zoukankan      html  css  js  c++  java
  • Java实现 第十一届 蓝桥杯 (高职专科组)省内模拟赛

    有错误的或者有问题的欢迎评论

    十六进制数1949对应的十进制数
    19000互质的数的个数
    70044与113148的最大公约数
    第十层的二叉树
    洁净数
    递增序列
    最大的元素距离
    元音字母辅音字母的数量
    梅花桩
    小明的城堡

    十六进制数1949对应的十进制数

    问题描述
      请问十六进制数1949对应的十进制数是多少?请特别注意给定的是十六进制,求的是十进制。
    答案提交
      这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    package 蓝桥杯省模拟赛_高职组;
    
    public class 进制转换 {
        public static void main(String[] args) {//6473
            System.out.println(Integer.parseInt("1949",16));
        }
    }
    
    

    19000互质的数的个数

    问题描述
      不超过19000的正整数中,与19000互质的数的个数是多少?
    答案提交
      这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    因为19000的因子为2 5 19 所以只需要判断最大公约数没有这些的就可以

    package 蓝桥杯省模拟赛_高职组;
    
    public class 互质数 {//7200
        public static void main(String[] args) {
            int count=0;
            for (int i=1;i<=19000;i++){
                if(i%2!=0&&i%5!=0&&i%19!=0){
                    count++;
                }
            }
            System.out.println(count);
        }
    }
    
    

    70044与113148的最大公约数

    问题描述
      70044与113148的最大公约数是多少?
    答案提交
      这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    package 蓝桥杯省模拟赛_高职组;
    
    public class 最大公约数 {//5388
        public static void main(String[] args) {
            int max=0;
            for(int i=1;i<=70044;i++){
                if(70044%i==0&&113148%i==0){
                    max=i;
                }
            }
            System.out.println(max);
        }
    }
    
    

    第十层的二叉树

    一棵10层的二叉树,最多包含多少个结点?
      注意当一棵二叉树只有一个结点时为一层。
    答案提交
      这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    package 蓝桥杯省模拟赛_高职组;
    
    public class 二叉树 {//1023
        public static void main(String[] args) {
            int sum=1;
            int num=1;
            for (int i=1;i<=9;i++){
                num*=2;
                sum+=num;
            }
            System.out.println(sum);
        }
    }
    
    

    洁净数

    小明非常不喜欢数字 2,包括那些数位上包含数字 2 的数。如果一个数的数位不包含数字 2,小明将它称为洁净数。
      请问在整数 1 至 n 中,洁净数有多少个?
    输入格式
      输入的第一行包含一个整数 n。
    输出格式
      输出一行包含一个整数,表示答案。
    样例输入
    30
    样例输出
    18
    评测用例规模与约定
      对于 40% 的评测用例,1 <= n <= 10000。
      对于 80% 的评测用例,1 <= n <= 100000。
      对于所有评测用例,1 <= n <= 1000000。

    package 蓝桥杯省模拟赛_高职组;
    
    import java.util.Scanner;
    
    public class 洁净数 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();
            sc.close();
            int count=0;
          A:  for (int i=1;i<=n;i++){
                int a = i;
                while(a!=0){
                    int b=a%10;
                    if(b==2){
                        continue A;
                    }
                    a/=10;
                }
                count++;
            }
            System.out.println(count);
        }
    }
    
    

    递增序列

    问题描述
      在数列 a[1], a[2], …, a[n] 中,如果 a[i] < a[i+1] < a[i+2] < … < a[j],则称 a[i] 至 a[j] 为一段递增序列,长度为 j-i+1。
      给定一个数列,请问数列中最长的递增序列有多长。
    输入格式
      输入的第一行包含一个整数 n。
      第二行包含 n 个整数 a[1], a[2], …, a[n],相邻的整数间用空格分隔,表示给定的数列。
    输出格式
      输出一行包含一个整数,表示答案。
    样例输入
    7
    5 2 4 1 3 7 2
    样例输出
    3

    package 蓝桥杯省模拟赛_高职组;
    
    import java.util.Scanner;
    
    public class 递增序列 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();
            int[] num = new int[n];
            int temp=-1;
            int count=0;
            int max=0;
            for (int i=0;i<n;i++){
                num[i]=sc.nextInt();
                if(count==0){
                    temp=num[i];
                    count++;
                }
                if(temp<num[i]){
                    temp=num[i];
                    count++;
                }
                else{
                    temp=num[i];
                    max=Math.max(count,max);
                    count=1;
                }
    
            }
            System.out.println(max);
        }
    }
    
    

    最大的元素距离

    在数列 a_1, a_2, …, a_n中,定义两个元素 a_i 和 a_j 的距离为 |i-j|+|a_i-a_j|,即元素下标的距离加上元素值的差的绝对值,其中 |x| 表示 x 的绝对值。
      给定一个数列,请问找出元素之间最大的元素距离。
    输入格式
      输入的第一行包含一个整数 n。
      第二行包含 n 个整数 a_1, a_2, …, a_n,相邻的整数间用空格分隔,表示给定的数列。
    输出格式
      输出一行包含一个整数,表示答案。
    样例输入
    5
    9 4 2 4 7
    9

    package 蓝桥杯省模拟赛_高职组;
    
    import java.util.Scanner;
    
    public class 元素距离 {
        public static void main(String[] args) {
            Scanner sc=new Scanner(System.in);
            int n=sc.nextInt();
            int[] num=new int[n];
            int max=0;
            for (int i = 0; i < num.length; i++) {
                num[i]=sc.nextInt();
            }
            sc.close();
            int b=0;
            for (int i = 0; i < num.length-1; i++) {
                for (int j = i+1; j < num.length; j++) {
                      b=Math.abs(i-j)+Math.abs(num[i]-num[j]);
                    max=Math.max(max,b);
                }
            }
            System.out.println(max);
        }
    }
    
    

    元音字母辅音字母的数量

    给定一个单词,请计算这个单词中有多少个元音字母,多少个辅音字母。
      元音字母包括 a, e, i, o, u,共五个,其他均为辅音字母。
    输入格式
      输入一行,包含一个单词,单词中只包含小写英文字母。
    输出格式
      输出两行,第一行包含一个整数,表示元音字母的数量。
      第二行包含一个整数,表示辅音字母的数量。
    样例输入
    lanqiao
    样例输出
    4
    3
    评测用例规模与约定
      对于所有评测用例,单词中的字母个数不超过100。

    package 蓝桥杯省模拟赛_高职组;
    
    import java.util.Scanner;
    
    public class 元音字母辅音字母的数量 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            String s = sc.nextLine();
            sc.close();;
            char[] num = s.toCharArray();
            int count_yuan=0,count_fu=0;
            for (int i=0;i<s.length();i++){
                if(num[i]=='a' ||num[i]=='e' ||num[i]=='i' ||num[i]=='o' ||num[i]=='u' ){
                    count_yuan++;
                }
                else{
                    count_fu++;
                }
            }
            System.out.println(count_yuan);
            System.out.println(count_fu);
        }
    }
    
    

    梅花桩

    小明每天都要练功,练功中的重要一项是梅花桩。
      小明练功的梅花桩排列成 n 行 m 列,相邻两行的距离为 1,相邻两列的距离也为 1。
      小明站在第 1 行第 1 列上,他要走到第 n 行第 m 列上。小明已经练了一段时间,他现在可以一步移动不超过 d 的距离(直线距离)。
      小明想知道,在不掉下梅花桩的情况下,自己最少要多少步可以移动到目标。
    输入格式
      输入的第一行包含两个整数 n, m,分别表示梅花桩的行数和列数。
      第二行包含一个实数 d(最多包含一位小数),表示小明一步可以移动的距离。
    输出格式
      输出一个整数,表示小明最少多少步可以到达目标。
    样例输入
    3 4
    1.5
    样例输出
    3

    10评测用例规模与约定
      对于 30% 的评测用例,2 <= n, m <= 20,1 <= d <= 20。
      对于 60% 的评测用例,2 <= n, m <= 100,1 <= d <= 100。
      对于所有评测用例,2 <= n, m <= 1000,1 <= d <= 100。

    PS:
    这里的搜索肯定是找半径搜索,肯定是半径搜索的最右下面的,
    下面那个图,看一下,我的y2是最靠下的位置,x2++,如果超出了半径范围,
    那么y2就往上走,x2++的范围继续搜索,如果没有超过半径范围,x2++就继续向右面找
    然后在超过半径,就y2–往上走,知道y2<y1,
    因为他是右下走,所以你只需要考虑右下方向的路径
    不好意思,实在是不清楚怎么把他转过来
    在这里插入图片描述

    在这里插入图片描述

    package 蓝桥杯省模拟赛_高职组;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Scanner;
    
    public class 梅花桩 {
        public static void main(String[] args) {
            List<Integer> list_y = new ArrayList<Integer>();
            List<Integer> list_x = new ArrayList<Integer>();
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();
            int m = sc.nextInt();
            double d = sc.nextDouble();
            sc.close();
            int[][] map = new int[n+1][m+1];
            list_x.add(1);
            list_y.add(1);
            while (list_x.size()!=0){
                int x1 =list_x.remove(0);
                int y1=list_y.remove(0);
                int x2=x1;
                int y2=y1+(int)d;
                if((n-x1)*(n-x1) + (m-y1)*(m-y1) <= d*d)
                {
                    map[n][m] = map[x1][y1] + 1;
                    break;
                }
                while (x2 <= n && y2 >= y1 && y2 <= m){
                    if((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1) <= d * d && map[x2][y2] == 0)
                    {
                        list_x.add(x2);
                        list_y.add(y2);
                        map[x2][y2] = map[x1][y1] + 1;
                        x2 ++;
                    }
                    else y2 --;
                }
            }
            System.out.println(map[n][m]);
        }
    }
    
    

    小明的城堡

    小明用积木搭了一个城堡。
      为了方便,小明在搭的时候用的是一样大小的正方体积本,搭在了一个 n 行 m 列的方格图上,每个积木正好占据方格图的一个小方格。
      当然,小明的城堡并不是平面的,而是立体的。小明可以将积木垒在别的积木上面。当一个方格上的积木垒得比较高时,就是一个高塔,
    当一个方格上没有积木时,就是一块平地。
      小明的城堡可以用每个方格上垒的积木层数来表示。例如,下面就表示一个城堡。
      9 3 3 1
      3 3 3 0
      0 0 0 0
      这个城堡南面和东面都有空地,西北面有一个大房子,在西北角还有一个高塔,东北角有一个车库。
      现在,格格巫要来破坏小明的城堡,他施了魔法水淹小明的城堡。
      如果水的高度为1,则紧贴地面的那些积木要被水淹,在上面的例子中,有7块积木要被水淹。
      如果水的高度为2,则更多积木要被水淹,在上面的例子中,有13块积木要被水淹。
      给定小明的城堡图,请问,水的高度依次为1, 2, 3, …, H 时,有多少块积木要被水淹。
    输入格式
      输入的第一行包含两个整数 n, m。
      接下来 n 行,每行 m 个整数,表示小明的城堡中每个位置积木的层数。
      接下来包含一个整数 H,表示水高度的上限。
    输出格式
      输出 H 行,每行一个整数。第 i 的整数表示水的高度为 i 时被水淹的积木数量。
    样例输入
    3 4
    9 3 3 1
    3 3 3 0
    0 0 0 0
    10
    样例输出
    7
    13
    19
    20
    21
    22
    23
    24
    25
    25
    评测用例规模与约定
      对于 40% 的评测用例,1 <= n, m <= 100,1 <= H <= 100,积木层数不超过100;
      对于 70% 的评测用例,1 <= n, m <= 1000,1 <= H <= 1000,积木层数不超过1000;
      对于所有评测用例,1 <= n, m <= 1000,1 <= H <= 100000,积木层数不超过1000000000。

    package 蓝桥杯省模拟赛_高职组;
    
    import java.util.Arrays;
    import java.util.Scanner;
    
    public class 小明的城堡 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();
            int m = sc.nextInt();
            long[] map = new long[n * m];
            for (int i = 0; i < map.length; i++) {
                map[i] = sc.nextLong();
            }
            int h = sc.nextInt();
            Arrays.sort(map);
            sc.close();
            long[] num = new long[h];
            for (int i = 0; i < num.length; i++) {
                long y = 0;
                A:
                for (int j = map.length - 1; j >= 0; j--) {
                    if (map[j] == 0) {
                        break A;
                    }
                    y++;
                    map[j]--;
                }
                if (i > 0) {
                    num[i] = y + num[i - 1];
                } else {
                    num[i] = y;
                }
    
            }
            for (int i = 0; i < num.length; i++) {
                System.out.println(num[i]);
            }
        }
    }
    
    
  • 相关阅读:
    《算法导论》读书笔记(五)
    《算法导论》读书笔记(四)
    《算法导论》读书笔记(三)
    《算法导论》读书笔记(二)
    《算法导论》读书笔记(一)
    Posix消息队列
    管道和FIFO
    linux内核数据结构之kfifo
    linux内核数据结构之链表
    Mybatis XML 映射配置文件 -- 熟悉配置
  • 原文地址:https://www.cnblogs.com/a1439775520/p/13074634.html
Copyright © 2011-2022 走看看