A的计数

package 第十三届蓝桥杯省赛模拟赛; /**
 * @author Wcy
 * @Date 2022/3/24 18:14
 */

/**
 * AAAAAAABABBAABABABAAAAAAA
 * 　　ABBBBBABBAABBBBBABABBBBBA
 * 　　ABAAABABBBABAABBBBABAAABA
 * 　　ABAAABABBBBBAABAABABAAABA
 * 　　ABAAABABBABABBABABABAAABA
 * 　　ABBBBBABBBABAABBBBABBBBBA
 * 　　AAAAAAABABABABABABAAAAAAA
 * 　　BBBBBBBBABAABABBBBBBBBBBB
 * 　　AABAABABBAAABBAAABABBBBBA
 * 　　ABBABABBBABBAAAABBBBAAAAB
 * 　　BBBBAAABABAABABAABBBAABBA
 * 　　BBAABABABAAAABBBAABBAAAAA
 * 　　ABABBBABAABAABABABABBBBBA
 * 　　AAAABBBBBABBBBAAABBBABBAB
 * 　　AABAABAAABAAABAABABABAAAA
 * 　　ABBBBBBBBABABBBBABAABBABA
 * 　　ABBBAAABAAABBBAAAAAAABAAB
 * 　　BBBBBBBBABBAAABAABBBABBAB
 * 　　AAAAAAABBAAABBBBABABAABBA
 * 　　ABBBBBABBAABABAAABBBABBAA
 * 　　ABAAABABABBBAAAAAAAAAABAA
 * 　　ABAAABABABABBBABBAABBABAA
 * 　　ABAAABABBABBABABAABAABAAA
 * 　　ABBBBBABABBBBBABBAAAABAAA
 * 　　AAAAAAABAABBBAABABABBABBA
 * 　请问在这个矩阵中有多少个字母A？
 */
public class Count_A {
    public static void main(String[] args) {
        String str="AAAAAAABABBAABABABAAAAAAA\n" +
                "　　ABBBBBABBAABBBBBABABBBBBA\n" +
                "　　ABAAABABBBABAABBBBABAAABA\n" +
                "　　ABAAABABBBBBAABAABABAAABA\n" +
                "　　ABAAABABBABABBABABABAAABA\n" +
                "　　ABBBBBABBBABAABBBBABBBBBA\n" +
                "　　AAAAAAABABABABABABAAAAAAA\n" +
                "　　BBBBBBBBABAABABBBBBBBBBBB\n" +
                "　　AABAABABBAAABBAAABABBBBBA\n" +
                "　　ABBABABBBABBAAAABBBBAAAAB\n" +
                "　　BBBBAAABABAABABAABBBAABBA\n" +
                "　　BBAABABABAAAABBBAABBAAAAA\n" +
                "　　ABABBBABAABAABABABABBBBBA\n" +
                "　　AAAABBBBBABBBBAAABBBABBAB\n" +
                "　　AABAABAAABAAABAABABABAAAA\n" +
                "　　ABBBBBBBBABABBBBABAABBABA\n" +
                "　　ABBBAAABAAABBBAAAAAAABAAB\n" +
                "　　BBBBBBBBABBAAABAABBBABBAB\n" +
                "　　AAAAAAABBAAABBBBABABAABBA\n" +
                "　　ABBBBBABBAABABAAABBBABBAA\n" +
                "　　ABAAABABABBBAAAAAAAAAABAA\n" +
                "　　ABAAABABABABBBABBAABBABAA\n" +
                "　　ABAAABABBABBABABAABAABAAA\n" +
                "　　ABBBBBABABBBBBABBAAAABAAA\n" +
                "　　AAAAAAABAABBBAABABABBABBA";
        int total=0;
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)=='A')
                total++;
        }
        System.out.println(total);
    }

}

和尚挑水

package 第十三届蓝桥杯省赛模拟赛; /**
 * @author Wcy
 * @Date 2022/3/24 19:57
 */

import java.util.Scanner;

/**
 * 问题描述
 * 　　一个和尚要挑水，每次最多能挑 a 千克，水缸最多能装 t 千克，开始时水缸为空。
 * 　　请问这个和尚最少要挑多少次可以将水缸装满？
 * 输入格式
 * 　　输入一行包含两个整数 a, t，用一个空格分隔。
 * 输出格式
 * 　　输出一行包含一个整数，表示答案。
 * 样例输入
 * 20 2021
 * 样例输出
 * 102
 * 评测用例规模与约定
 * 　　对于所有评测用例，1 <= a <= 100，1 <= t <= 10000。
 */
public class 和尚挑水 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int a=scanner.nextInt();
        int b=scanner.nextInt();
        int aa=b%a;
        System.out.println(Integer.parseInt(String.valueOf((b-aa)/a+1)));
    }
}

增加逗号

package 第十三届蓝桥杯省赛模拟赛; /**
 * @author Wcy
 * @Date 2022/3/24 20:02
 */

import java.util.Scanner;

/**
 * 问题描述
 * 　　在金融领域，通常将金额的百位和千位之间、十万位和百万位之间增加逗号（千分位分隔符），以方便阅读。一般从个位开始，每三位之前增加一个逗号。
 * 　　例如：1234567890.00 通常写成 1,234,567,890.00。
 * 　　注意小数点后固定保留 2 位。
 * 　　给定一个包含千分位分隔符的数值，请读入后输出对应的不含千分位的数值，小数点仍然保留 2 位。
 * 输入格式
 * 　　输入一行包含一个由千分位分隔符的数值，恰好有 2 位小数。
 * 输出格式
 * 　　输出不含千分位分隔符的数值，保留 2 位小数。
 * 样例输入
 * 1,234,567,890.00
 * 样例输出
 * 1234567890.00
 * 评测用例规模与约定
 * 　　对于所有评测用例，给定的数值整数部分不超过12位。
 */
public class 增加逗号 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str=scanner.nextLine();
        str=str.replace(",","");
        System.out.println(str);
    }
}

插头问题

package 第十三届蓝桥杯省赛模拟赛; /**
 * @author Wcy
 * @Date 2022/3/24 20:18
 */

import java.util.Scanner;

/**
 * 问题描述
 * 　　小蓝有一个插板，形状用一个 n * m 的01矩阵表示，0 表示板面，1 表示插孔。
 * 　　小蓝还有一个插头，形状用一个 r * c 的01矩阵表示，0 表示没有伸出的部分，1 表示伸出的部分。插头伸出的部分必须插在插孔里面。
 * 　　为了安全，插头插到面板上不能有任何部分超过插板边界（包括没有伸出的部分）。
 * 　　插头和插板都不能旋转，也不能翻转。请求出插头插入插板的合理位置。
 * 输入格式
 * 　　输入的第一行包含两个整数 n, m。
 * 　　接下来 n 行，每行一个长度为 m 的01串，表示插板的形状。
 * 　　接下来一行包含两个整数 r, c。
 * 　　接下来 r 行，每行一个长度为 c 的01串，表示插头的形状。
 * 输出格式
 * 　　如果插头没办法安全插入插板中，输出“NO”。否则输出两个数 a, b，表示插头的第 1 行第 1 列对应插板的第 a 行第 b 列。如果有多种情况满足要求，输出 a 最小的方案，如果 a 最小的方案有多个，输出在 a 最小的前提下 b 最小的方案。
 * 样例输入
 * 3 4
 * 0 1 1 0
 * 0 0 0 0
 * 0 0 0 0
 * 3 3
 * 0 0 0
 * 0 1 0
 * 0 0 0
 * 样例输出
 * NO
 * 样例说明
 * 　　在插头不超出范围的前提下无法插入。
 * 样例输入
 * 4 7
 * 1 1 1 0 1 0 0
 * 1 1 0 1 1 1 1
 * 0 0 0 1 1 1 1
 * 0 0 0 0 0 1 1
 * 2 3
 * 1 1 1
 * 0 1 1
 * 样例输出
 * 2 4
 * 评测用例规模与约定
 * 　　对于 50% 的评测用例，2 <= n, m, r, c <= 20。
 * 　　对于所有评测用例，2 <= n, m, r, c <= 100。
 */
public class 插头问题 {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int[][] cb = new int[a][b];
        for (int i = 0; i < a; i++)
            for (int j = 0; j < b; j++)
                cb[i][j] = scanner.nextInt();

        int c = scanner.nextInt();
        int d = scanner.nextInt();
        int[][] ct = new int[c][d];
        if (c > a || d > b) {
            System.out.println("NO");
            return;
        }
        for (int i = 0; i < c; i++)
            for (int j = 0; j < d; j++)
                ct[i][j] = scanner.nextInt();
        //暴力匹配
        int de = c * d;
        int add = 0;
        String str = "NO";
        for (int i = 0; i < a; i++) {
            if (a - i < c) break;
            for (int j = 0; j < b; j++) {
                if (b - j < d) break;

                if (ct[0][0] == cb[i][j]) {

                    for (int z = 0; z < c; z++)
                        for (int n = 0; n < d; n++) {

                            if (ct[z][n] == cb[i + z][j + n] || (ct[z][n] == 0 && cb[i + z][j + n] == 1)) {
                                add++;
                                if (add == de) {
                                    str = i + " " + j;
                                }

                            } else {
                                break;
                            }
                        }
                }
                add=0;

            }

        }
        System.out.println(str);
    }
}

最2数字

package 第十三届蓝桥杯省赛模拟赛; /**
 * @author Wcy
 * @Date 2022/3/24 18:18
 */

/**
 * 问题描述
 * 　　如果一个整数的某个数位包含 2 ，则称这个数为一个“最2数字”。例如：102、2021 都是最2数字。
 * 　　请问在 1（含） 到 2021（含） 中，有多少个最2数字。
 * 答案提交
 * 　　这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
 */
public class 最2数字 {
    public static void main(String[] args) {
        int total=0;
        for(int i=1;i<2022;i++){
            String str=String.valueOf(i);
            for(int j=0;j<str.length();j++){
                if(str.charAt(j)=='2'){
                    total++;
                    break;
                }

            }
        }
        System.out.println(total);
    }
}

最少操作

package 第十三届蓝桥杯省赛模拟赛; /**
 * @author Wcy
 * @Date 2022/3/24 18:22
 */

/**
 * 问题描述
 * 　　有一个整数 A=2021，每一次，可以将这个数加 1 、减 1 或除以 2，其中除以 2 必须在数是偶数的时候才允许。
 * 　　例如，2021 经过一次操作可以变成 2020、2022。
 * 　　再如，2022 经过一次操作可以变成 2021、2023 或 1011。
 * 　　请问，2021 最少经过多少次操作可以变成 1。
 * 答案提交
 * 　　这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
 */
public class 最少操作 {
    public static void main(String[] args) {
        System.out.println(totalNum(2021,0));
    }

    public static int  totalNum(int a,int num){
        if(a==1){
            System.out.println(a+" "+num);
            return num;
        }
        if(a%2==0) {
            System.out.println(a+" "+num);
            num++;
            return totalNum(a / 2, num);
        }{
            System.out.println(a+" "+num);
            num++;
            return totalNum(a-1,num);
        }

    }
}

约数统计

package 第十三届蓝桥杯省赛模拟赛; /**
 * @author Wcy
 * @Date 2022/3/24 21:12
 */

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;

/**
 * 问题描述
 * 　　给定正整数 a, b, c，请问有多少个正整数，是其中至少两个数的约数。
 * 输入格式
 * 　　输入一行包含三个正整数 a, b, c。
 * 输出格式
 * 　　输出一行包含一个整数，表示答案。
 * 样例输入
 * 30 70 35
 * 样例输出
 * 6
 * 样例说明
 * 　　1、2、5、7、10、35满足条件。
 * 评测用例规模与约定
 * 　　对于 50% 的评测用例，1 <= a, b, c <= 1000000。
 * 　　对于所有评测用例，a, b, c 不超过 10**12（10的12次方）。
 */
public class 约数统计 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a, b, c;
        a = scanner.nextInt();
        b = scanner.nextInt();
        c = scanner.nextInt();
        List<Integer> result = new ArrayList<>();
        result.addAll(yue(a, b));
        result.addAll(yue(a, c));
        result.addAll(yue(c, b));
        HashSet<Integer> set=new HashSet<>(result);
//        System.out.println(set.toString());
        System.out.println(set.size());
    }

    public static List<Integer> yue(int a, int b) {
        List<Integer> list = new ArrayList<>();
        int min = Math.min(a, b);
        for (int i = 1; i <=min; i++) {
            if (a % i == 0 && b % i == 0)
                list.add(i);
        }
        return list;

    }
}

螺旋矩阵

package 第十三届蓝桥杯省赛模拟赛; /**
 * @author Wcy
 * @Date 2022/3/24 18:29
 */

/**
 * 问题描述
 * 　　对于一个 n 行 m 列的表格，我们可以使用螺旋的方式给表格依次填上正整数，我们称填好的表格为一个螺旋矩阵。
 * 　　例如，一个 4 行 5 列的螺旋矩阵如下：
 * 　　1  2  3  4    5              1  2   3  4
 * 　　14 15 16 17   6              12 13  14 5
 * 　　13 20 19 18   7              11 16  15 6
 * 　　12 11 10 9    8              10 9   8  7
 * 　　请问，一个 30 行 30 列的螺旋矩阵，第 20 行第 20 列的值是多少？
 */
public class 螺旋矩阵 {
    public static void main(String[] args) {
        int[][] a=new int[30][30];
        a=init(30,a,1);
        sout(init(30,a,1));
        System.out.println(a[19][19]);
    }
    //四行四列： 4 3 3 2 2 1 1                   1234 567 8910 1112 1314 15 16
    // 30 29 29 28 28 27 27 26 26
    public static void sout(int[][] a){
        for(int i=0;i<a.length;i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j] + " ");
            }
            System.out.println();
        }
    }
    //右下左上
    public static int[][] init(int n,int[][] a,int init){
       for(int i=0;i<n;i++){
           //向右移动n
           for(int j=0;j<n-i;j++){
               a[i][j]=init;
               init++;
           }
           //向下移动n-1
           for(int j=i+1;j<n-i;j++){
               a[j][n-i-1]=init;
               init++;
           }
           //向左移动n-1
           for(int j=n-i-2;j>=i;j--){
               a[n-i-1][j]=init;
               init++;
           }
           //向上移动n-2
           for(int j=n-i-2;j>i;j--){
               a[j][i]=init;
               init++;
           }
//          sout(a);
//          System.out.println();
       }
       return a;
    }

}

下面两题就是我考试没做出来的：先空着

二叉树

package 第十三届蓝桥杯省赛模拟赛; /**
 * @author Wcy
 * @Date 2022/3/24 19:56
 */

/**
 * 问题描述
 * 　　一棵二叉树有2021个结点。该树满足任意结点的左子树结点个数和右子树的结点个数之差最多为1。
 * 　　定义根结点的深度为0，子结点的深度比父结点深度多1。
 * 　　请问，树中深度最大的结点的深度最大可能是多少？
 */
public class 二叉树 {
    public static void main(String[] args) {

    }
}

汉诺塔

package 第十三届蓝桥杯省赛模拟赛; /**
 * @author Wcy
 * @Date 2022/3/24 21:28
 */

import java.util.Scanner;

/**
 * 问题描述
 * 　　小蓝很喜欢玩汉诺塔游戏。
 * 　　游戏中有三根柱子，开始时第一根柱子上有 n 个圆盘，从上到下圆盘的大小依次为 1 到 n。
 * 　　每次，可以将一个盘子从一根柱子上移动到另一根柱子上，这个盘子必须是柱子最上方的盘子，而且移到的柱子上的盘子必须比这个盘子大。
 * 　　小蓝的目标是将所有的盘子移动到第三根柱子上。
 * 　　汉诺塔是个经典问题，当盘子数量为 n 时，最少需要移动 2**n-1 步，其中 2**n 表示 2 的 n 次方。
 * 　　小蓝已经玩了一会儿（不一定按最优方案玩），他想知道，对于他目前的局面，最少还需要多少步可以到达目标。
 * 输入格式
 * 　　输入的第一行包含三个非负整数 a, b, c，分别表示目前每根柱子上的盘子数。在本题中，n=a+b+c。
 * 　　第二行包含 a 个整数，相邻的整数之间使用一个空格分隔，表示第一根柱子上的盘子，盘子按从上到下（从小到大）的顺序给出。
 * 　　第三行包含 b 个整数，相邻的整数之间使用一个空格分隔，表示第二根柱子上的盘子，盘子按从上到下（从小到大）的顺序给出。
 * 　　第四行包含 c 个整数，相邻的整数之间使用一个空格分隔，表示第三根柱子上的盘子，盘子按从上到下（从小到大）的顺序给出。
 * 输出格式
 * 　　输出一行包含一个整数，表示答案。
 * 样例输入
 * 1 2 3
 * 1
 * 2 3
 * 4 5 6
 * 样例输出
 * 7
 * 评测用例规模与约定
 * 　　对于 30% 的评测用例，2 <= n <= 5。
 * 　　对于所有评测用例，2 <= n <= 60。
 */
public class 汉诺塔 {


}
最后修改：2022 年 03 月 30 日
© 允许规范转载
如果觉得我的文章对你有用，请随意赞赏