第八届蓝桥杯Java C组决赛试题

最新推荐文章于 2022-11-13 12:51:52 发布
最新推荐文章于 2022-11-13 12:51:52 发布
阅读量1k 收藏 8
点赞数 1
分类专栏： 蓝桥杯 文章标签： 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38905818/article/details/80206483
版权
1.标题：数位和


数学家高斯很小的时候就天分过人。一次老师指定的算数题目是：1+2+...+100。
高斯立即做出答案：5050!


这次你的任务是类似的。但并非是把一个个的数字加起来，而是对该数字的每一个数位作累加。
这样从1加到100的“和”是：901


从10加到15是：21，也就是：1+0+1+1+1+2+1+3+1+4+1+5，这个口算都可以出结果的。


按这样的“加法”，从1加到1000是多少呢？ 请通过浏览器提交该结果。


当然，我们并不期望你能像高斯一样，发现数字背后深奥的秘密，只要请计算机帮忙，一切都easy!


注意：你需要提交的是一个整数，不要填写任何多余的内容（比如：说明性文字）

答案：13501

import java.util.*;
public class Main {

    public static int f(int num)
    {
        String str=String.valueOf(num);
        int res=0;
        for(int i=0;i<str.length();i++)
        {
            res+=str.charAt(i)-'0';
        }
        return res;
    }
    public static void main(String[] args) {
        int count=0;
        for(int i=0;i<=1000;i++)
        {
            count+=f(i);
        }
        System.out.println(count);
    }
}
2.标题：数字划分


w星球的长老交给小明一个任务：
1,2,3...16 这16个数字分为两组。
要求：
这两组数字的和相同，
并且，两组数字的平方和也相同，
并且，两组数字的立方和也相同。


请你利用计算机的强大搜索能力解决这个问题。
并提交1所在的那个分组的所有数字。


这些数字要从小到大排列，两个数字间用一个空格分开。
即类似：1 4 5 8 ...  这样的答案。


注意，只提交这一组数字，不要填写任何多余的内容。


----------------------------------------
笨笨有话说：
    只要一个组的成员确定了，另一个组的成员也就确定了。枚举一个组的成员就可以了。
凭直觉，两个组的成员数目不会差太多吧。
歪歪有话说：
    既然求 1 所在的那个组，那只要枚举剩余的成员就可以了。

貌似都是8个成员的可能性很大啊。

思路：根据题目的暗示数组长度为8，写个排列即可。

答案：[1, 4, 6, 7, 10, 11, 13, 16]

import java.util.*;
public class Main {

    static ArrayList<Integer> tmpArr = new ArrayList<>();
    public static boolean test(ArrayList<Integer> a)
    {
        for(int k=1;k<=3;k++) {
            int num1 = 0;
            int num2 = 0;
            for (int i = 1; i <= 16; i++) {
                if(a.contains(i))
                {
                    num1+=Math.pow(i,k);
                }
                else
                {
                    num2+=Math.pow(i,k);
                }
            }
            if (num1 != num2) {
                return false;
            }
        }
        return true;
    }
    public static void combine(int index,int k,int []arr) {
        if(k == 1){
            for (int i = index; i < arr.length; i++) {
                tmpArr.add(arr[i]);
                if(test(tmpArr))
                    System.out.print(tmpArr.toString()+" ");
                tmpArr.remove((Object)arr[i]);
            }
        }else if(k > 1){
            for (int i = index; i <= arr.length - k; i++) {
                tmpArr.add(arr[i]); //tmpArr都是临时性存储一下
                combine(i + 1,k - 1, arr); //索引右移，内部循环，自然排除已经选择的元素
                tmpArr.remove((Object)arr[i]); //tmpArr因为是临时存储的，上一个组合找出后就该释放空间，存储下一个元素继续拼接组合了
            }
        }else{
            return ;
        }
    }
    public static void main(String[] args) {
        int a[]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
        combine(0,8,a);
    }
}


3.标题：树形显示


对于分类结构可以用树形来形象地表示。比如：文件系统就是典型的例子。


树中的结点具有父子关系。我们在显示的时候，把子项向右缩进（用空格，不是tab），并添加必要的连接线，以使其层次关系更醒目。


下面的代码就是为了这个目的的，请仔细阅读源码，并填写划线部分缺少的代码。

[java]  view plain  copy
  1. import java.util.*;  
  2.   
  3. class MyTree  
  4. {  
  5.     private Map<String, List<String>>  map_ch = new HashMap<String, List<String>>();  
  6.     private Map<String,String> map_pa = new HashMap<String,String>();  
  7.       
  8.     public void add(String parent, String child)  
  9.     {  
  10.         map_pa.put(child, parent);  
  11.           
  12.         List<String> lst = map_ch.get(parent);  
  13.         if(lst==null){  
  14.             lst = new ArrayList<String>();  
  15.             map_ch.put(parent, lst);  
  16.         }  
  17.         lst.add(child);  
  18.     }  
  19.       
  20.     public String get_parent(String me){  
  21.         return map_pa.get(me);  
  22.     }  
  23.       
  24.     public List<String> get_child(String me){  
  25.         return map_ch.get(me);  
  26.     }  
  27.       
  28.     private String space(int n)  
  29.     {  
  30.         String s = "";  
  31.         for(int i=0; i<n; i++) s += ' ';  
  32.         return s;  
  33.     }  
  34.       
  35.     private boolean last_child(String x){  
  36.         String pa = map_pa.get(x);  
  37.         if(pa==null) return true;  
  38.           
  39.         List<String> lst = map_ch.get(pa);  
  40.         return lst.get(lst.size()-1).equals(x);  
  41.     }  
  42.       
  43.     public void show(String x){  
  44.           
  45.         String s = "+--" + x;  
  46.           
  47.         String pa = x;  
  48.         while(true){  
  49.             pa = map_pa.get(pa);  
  50.             if(pa==null) break;  
  51.             s = ___________________________________ ;  // 填空  
  52.         }  
  53.           
  54.         System.out.println(s);  
  55.     }  
  56.       
  57.     public void dfs(String x){  
  58.         show(x);  
  59.           
  60.         List<String> lst = map_ch.get(x);  
  61.         if(lst==null) return;  
  62.                   
  63.         for(String it: lst){  
  64.             dfs(it);  
  65.         }  
  66.     }  
  67. }  
  68.   
  69. public class TreeView  
  70. {  
  71.     public static void main(String[] args)  
  72.     {  
  73.         MyTree tree = new MyTree();  
  74.         tree.add("root", "dog");  
  75.         tree.add("root", "cat");  
  76.         tree.add("root", "duck");  
  77.         tree.add("dog", "AAdog");  
  78.         tree.add("dog", "BBdog");  
  79.         tree.add("dog", "CCdog");  
  80.         tree.add("AAdog", "AAdog01");  
  81.         tree.add("AAdog", "AAdog02");  
  82.         tree.add("cat", "XXcat");  
  83.         tree.add("cat", "YYcat");  
  84.         tree.add("XXcat","XXcat-oo");  
  85.         tree.add("XXcat","XXcat-qq");  
  86.         tree.add("XXcat-qq", "XXcat-qq-hahah");  
  87.         tree.add("duck", "TTduck");  
  88.         tree.add("TTduck", "TTduck-001");  
  89.         tree.add("TTduck", "TTduck-002");  
  90.         tree.add("TTduck", "TTduck-003");  
  91.         tree.add("YYcat","YYcat.hello");  
  92.         tree.add("YYcat","YYcat.yes");  
  93.         tree.add("YYcat","YYcat.me");         
  94.           
  95.         tree.dfs("root");  
  96.     }  
  97. }  
对于题目中的测试数据，输出结果:
+--root
     +--dog
     |    +--AAdog
     |    |    +--AAdog01
     |    |    +--AAdog02
     |    +--BBdog
     |    +--CCdog
     +--cat
     |    +--XXcat
     |    |    +--XXcat-oo
     |    |    +--XXcat-qq
     |    |         +--XXcat-qq-hahah
     |    +--YYcat
     |         +--YYcat.hello
     |         +--YYcat.yes
     |         +--YYcat.me
     +--duck
          +--TTduck
               +--TTduck-001
               +--TTduck-002
               +--TTduck-003
   

如有平字体对齐问题，可以参见图【p1.png】


注意，只填写划线部分缺少的代码，不要抄写已有的代码或符号。


答案：

[java]  view plain  copy
  1. s=last_child(pa)? "     " + s: "|    " + s;  

思路：一看show函数就想到是问怎么打印，先试下s=""，发现逐行打印，那么问题就很简单了，只要在根节点前面加“|       "，子节点加"        "就行了。


4.标题： 小数第n位


我们知道，整数做除法时，有时得到有限小数，有时得到无限循环小数。
如果我们把有限小数的末尾加上无限多个0，它们就有了统一的形式。


本题的任务是：在上面的约定下，求整数除法小数点后的第n位开始的3位数。


输入：
 一行三个整数：a b n，用空格分开。a是被除数，b是除数，n是所求的小数后位置（0<a,b,n<1000000000）
输出：
一行3位数字，表示：a除以b，小数后第n位开始的3位数字。


比如：
输入：
1 8 1


程序应该输出：
125


再比如：
输入：
1 8 3


程序应该输出：
500


再比如：
输入：
282866 999000 6


程序应该输出：
914


资源约定：
峰值内存消耗 < 256M
CPU消耗  < 1000ms




请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。


所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。

注意：主类的名字必须是：Main，否则按无效代码处理。

思路：难点在于判断循环小数段

import java.util.*;
public class Main {
    public static void main(String[] args) {
            Scanner in=new Scanner(System.in);

            double a,b,n;
            double sa,sn,count;

            a=in.nextInt();
            b=in.nextInt();
            n=in.nextInt();

            sn = n;
            sa = a % b;    // 此时的sa*10对b取余后得到小数点后第一位
            count = 0;

            while(sn>0)
            {
                if(sa == b)  //取余之后会等于零
                    break;
                if(sa < b)
                {
                    sa = sa * 10;
                }
                else
                {
                    //除法法则，逐步运算
                    sa = sa % b;
                    sa = sa * 10;
                    if(sa==0)
                        break;  //后面都是零则直接跳出循环

                }
                count++;
                if(sa % b == a % b) // 减掉循环的数
                {
                    sn = n % count;
                }
                sn--;
            }
            if(sa==0)
            {
                System.out.print("000");
            }
            else
            {
                int i = 3;
                while(i>0)
                {
                    System.out.print((int)(sa / b));//逐步输出n后三位的每一位
                    sa = sa % b;
                    sa = sa * 10;
                    i--;
                }
            }

    }
}
5.标题：分考场


n个人参加某项特殊考试。
为了公平，要求任何两个认识的人不能分在同一个考场。
求是少需要分几个考场才能满足条件。


输入格式：
第一行，一个整数n(1<n<100)，表示参加考试的人数。
第二行，一个整数m，表示接下来有m行数据
以下m行每行的格式为：两个整数a，b，用空格分开 (1<=a,b<=n)  表示第a个人与第b个人认识。


输出格式：
一行一个整数，表示最少分几个考场。


例如：
输入：
5
8
1 2
1 3
1 4
2 3
2 4
2 5
3 4
4 5


程序应该输出：
4


再比如：
输入：
5
10
1 2
1 3
1 4
1 5
2 3
2 4
2 5
3 4
3 5
4 5


则程序应该输出：
5


资源约定：
峰值内存消耗 < 256M
CPU消耗  < 1000ms




请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。


所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。

注意：主类的名字必须是：Main，否则按无效代码处理。

思路：如果某个人与教室里任意人认识，则寻找下一个教室，如果不存在能进入的教室则新开一个教室。

import java.util.*;
public class Main {

    static ArrayList<ArrayList<Integer>> list = null;
    static HashSet<Integer>[] map;

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int m = input.nextInt();

        map = new HashSet[n + 1];

        for (int i = 0; i < m; i++) {
            int key = input.nextInt();
            int value = input.nextInt();

            if (map[key] == null) {
                map[key] = new HashSet<Integer>();
            }

            if (map[value] == null) {
                map[value] = new HashSet<Integer>();
            }
            map[key].add(value);
            map[value].add(key);
        }

        list = new ArrayList<ArrayList<Integer>>();

        for (int i = 1; i <= n; i++) {

            if (list.size() == 0) {
                ArrayList<Integer> child = new ArrayList<Integer>();
                child.add(i);
                list.add(child);
            } else {
                boolean find = false;
                for (int j = 0; j < list.size(); j++) {
                    if (isBo(j, i)) {
                        list.get(j).add(i);
                        find = true;
                        break;
                    }
                }
                if (find == false) {// 没找到哦
                    ArrayList<Integer> child = new ArrayList<Integer>();
                    child.add(i);
                    list.add(child);
                }

            }

        }

        System.out.println(list.size());

    }
    public static boolean isBo(int school, int num) {
        ArrayList<Integer> child = list.get(school);
        HashSet<Integer> set = map[num];

        if (set == null)
            return true;

        for (int i = 0; i < child.size(); i++) {
            Integer stu = child.get(i);
            if (set.contains(stu)) {
                return false;
            }
        }
        return true;
    }

}

6.标题：合根植物


w星球的一个种植园，被分成 m * n 个小格子（东西方向m行，南北方向n列）。每个格子里种了一株合根植物。
这种植物有个特点，它的根可能会沿着南北或东西方向伸展，从而与另一个格子的植物合成为一体。


如果我们告诉你哪些小格子间出现了连根现象，你能说出这个园中一共有多少株合根植物吗？


输入格式：
第一行，两个整数m，n，用空格分开，表示格子的行数、列数（1<m,n<1000）。
接下来一行，一个整数k，表示下面还有k行数据(0<k<100000)
接下来k行，第行两个整数a，b，表示编号为a的小格子和编号为b的小格子合根了。


格子的编号一行一行，从上到下，从左到右编号。
比如：5 * 4 的小格子，编号：
1  2  3  4
5  6  7  8
9  10 11 12
13 14 15 16
17 18 19 20


样例输入：
5 4
16
2 3
1 5
5 9
4 8
7 8
9 10
10 11
11 12
10 14
12 16
14 18
17 18
15 19
19 20
9 13
13 17


样例输出：
5


其合根情况参考图[p1.png]


资源约定：
峰值内存消耗 < 256M
CPU消耗  < 2000ms



请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。


所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。

注意：主类的名字必须是：Main，否则按无效代码处理。

思路：并查集

import java.util.HashSet;  
import java.util.Scanner;  
import java.util.Set;  
  
class Main{  
    static int []head;  
    public static void main(String[] args) {  
        //并查集  
        Scanner s=new Scanner(System.in);  
        int m=s.nextInt();  
        int n=s.nextInt();  
        int k=s.nextInt();  
        head=new int [m*n];  
        for(int i=0;i<m*n;i++)  
            head[i]=i;  
          
        int a,b;  
        for(int i=0;i<k;i++)  
        {  
            a=s.nextInt()-1;  
            b=s.nextInt()-1;  
            u(a,b);  
              
        }  
          
        Set<Integer> set=new HashSet<Integer>();  
        for(int i=0;i<m*n;i++)  
        {  
            set.add(f(i));  
        }  
          
        System.out.println(set.size());  
          
    }   
      
    private static void u(int a, int b) {  
          
        if(f(a)==f(b))  
            return;  
          
        head[f(a)]=f(b);  
          
    }  
  
    private static int f(int i)  
    {  
        if(head[i]==i)  
            return i;  
          
        return head[i]=f(head[i]);  
    }  
}

Slayer_Zhao
关注
专栏目录
2019年 第10届 蓝桥杯 Java B组 决赛真题详解及小结
upward
10-31 2027
一、试题 A: 递增序列（本题总分：5 分）——答案： 二、试题 B: 平方拆分（本题总分：5 分）——答案： 三、试题 C: 切割（本题总分：10 分）——答案： 四、试题 D: 最优旅行（本题总分：10 分）——答案： 五、试题 E: 序列求和（本题总分：15 分）——答案： 六、试题 F: 最长子序列（本题总分：15 分） 七、试题 G: 数正方形（本题总分：20 分） 八、试题 H: 大胖子走迷宫（本题总分：20 分） 九、试题 I: 估计人数（本题总分：25 分） 十、试题 J: 分考场
2021年 第12届 蓝桥杯 Java B组 决赛真题详解及小结【2021.06.05】
upward
01-29 4212
2021年 第12届 蓝桥杯 Java B组 决赛真题详解及小结【2021.06.05】
蓝桥杯Java语言C组真题
07-22
蓝桥杯Java语言C组真题，题目文件与参赛时一模一样形式。每一道题一个文件。
第八届蓝桥杯决赛试题： 对局匹配
KeBo's Blog
05-13 855
题目: 标题：对局匹配 小明喜欢在一个围棋网站上找别人在线对弈。这个网站上所有注册用户都有一个积分，代表他的围棋水平。 小明发现网站的自动对局系统在匹配对手时，只会将积分差恰好是K的两名用户匹配在一起。如果两人分差小于或大于K，系统都不会将他们匹配。 现在小明知道这个网站总共有N名用户，以及他们的积分分别是A1, A2, ... AN。 小明想了解最多可能有多少名用户同时在线寻找对手，但是系...
第四届蓝桥杯javaC组真题
u011917813的博客
03-14 656
买不到的数目 小明开了一家糖果店。他别出心裁：把水果糖包成4颗一包和7颗一包的两种。糖果不能 拆包卖。 小朋友来买糖的时候，他就用这两种包装来组合。当然有些糖果数目是无法组合出来的 ，比如要买 10 颗糖。 你可以用计算机测试一下，在这种包装情况下，最大不能买到的数量是17。大于17的任 何数字都可以用4和7组合出来。 本题的要求就是在已知两个包装的数量时，求最大不能组合出的数字。 * ...
第十三届蓝桥杯 2022年省赛真题（Java 大学C组）
二两清酒.的博客
04-28 8706
第十三届蓝桥杯 2022年省赛真题（Java 大学C组）
第八届蓝桥杯国赛Java b组 第三题
lixiaomu2的博客
05-31 816
标题：树形显示 对于分类结构可以用树形来形象地表示。比如：文件系统就是典型的例子。 树中的结点具有父子关系。我们在显示的时候，把子项向右缩进（用空格，不是tab），并添加必要的连接线，以使其层次关系更醒目。 下面的代码就是为了这个目的的，请仔细阅读源码，并填写划线部分缺少的代码。 import java.util.*; class MyTr
2017年第八届蓝桥杯省赛 Java A 组真题
Code-CHAN的博客
04-07 276
2017年第八届蓝桥杯省赛 Java A组 第一题 import java.util.Arrays; import java.util.Scanner; public class Q1 { static char[][] mp = new char[10][10]; static boolean[][] vis = new boolean[10][10]; static int ans = 0; public static void main(String[] args) { Scan
第十三届蓝桥杯Java C 组真题
qq_52252193的博客
04-10 965
十三届蓝桥杯Java C 组
第八届蓝桥杯大赛个人赛决赛（软件类）真题
11-12
"第八届蓝桥杯大赛个人赛决赛（软件类）真题"是一场针对大学生和编程爱好者的编程竞赛，旨在测试参赛者在C/C++、Java、Python等编程语言中的技能和解决问题的能力。作为历届蓝桥杯大赛的一部分，这个资源包含了A、B...
蓝桥杯第九届c组Java题目及答案
05-24
蓝桥杯第九届 2018年第九届，c组，Java题目及答案代码。
历届蓝桥杯真题汇总_题目（第一到第八届省赛和国赛）
11-08
历届蓝桥杯真题汇总（第一到第八届省赛和国赛），比较齐全，适合赛前训练突破。 压缩包含以下组别类型的试题： 1、C/C++程序设计（本科A组、本科B组、高职高专组） 2、Java软件开发（本科A组、本科B组、高职高专组）
2015年蓝桥杯C组试题及答案
08-13
2015年蓝桥杯C组试题及答案，
蓝桥杯历年真题
04-10
第四届（2013）到第九届（2018）真题.包含了C,JAVA比赛的A,B,C组所有题目.
第十二届蓝桥杯大赛软件赛决赛 Java 大学 C 组.pdf
06-05
综上所述，本次蓝桥杯大赛软件赛决赛的Java大学C组赛题不仅考察了选手的编程技能，还对选手的问题解决能力、编程习惯和比赛规则的遵守提出了明确的要求。对于参赛者而言，这不仅是展示自身技术实力的机会，也是一个...
2022年第十三届蓝桥杯大赛软件类决赛C/C++/Java/Python真题
sumangguoguo的博客
06-28 2110
2022年第十三届蓝桥杯大赛软件类决赛C/C++/Java/Python真题
蓝桥杯第八届C组第一题
SK.韩
02-23 232
题目： 标题：外星日历 某星系深处发现了文明遗迹。 他们的计数也是用十进制。 他们的文明也有日历。日历只有天数，没有年、月的概念。 有趣的是，他们也使用了类似“星期”的概念， 只不过他们的一个星期包含了9天， 为了方便，这里分别记为: A,B,C…H,I 从一些资料上看到， 他们的23日是星期E 他们的190日是星期A 他们的343251日是星期I 令人兴奋的是，他们居然也预见了“世界末日”的那天...
【十三届蓝桥杯省赛解析javaC组】
最新发布
DypBellwether的博客
11-13 2806
蓝桥杯十三届省赛
第八届蓝桥杯决赛JAVA语言 C组题解_题 2 数字划分
NanyouqiaoMu_的博客
03-30 554
JAVA语言决赛 C组题解_题 2 数字划分题目解题思路 题目 问题描述 w星球的长老交给小明一个任务： 1,2,3…16 这16个数字分为两组。 要求： 这两组数字的和相同， 并且，两组数字的平方和也相同， 并且，两组数字的立方和也相同。 请你利用计算机的强大搜索能力解决这个问题。 并提交1所在的那个分组的所有数字。 这些数字要从小到大排列，两个数字间用一个空格分开。 即类似：1 4 5 8 …...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值