2020蓝桥杯 校内模拟赛 JAVA题解

1~2019有多少个9?

在1至2019中，有多少个数的数位中包含数字9？
注意，有的数中的数位中包含多个9，这个数只算一次。例如，1999这个数包含数字9，在计算只是算一个数

public class Main {
    public static void main(String[] args) {
        int sum=0;
        for (int i=1;i<=2019;i++){
            String x=String.valueOf(i);
            if (x.indexOf('9')>=0)
            {
                sum++;
                System.out.println(x);
            }
        }
        System.out.println(sum);
    }
}

递增三元组中心

问题描述
　　在数列 a[1], a[2], …, a[n] 中，如果对于下标 i, j, k 满足 0 　　给定一个数列，请问数列中有多少个元素可能是递增三元组的中心。
输入格式
　　输入的第一行包含一个整数 n。
　　第二行包含 n 个整数 a[1], a[2], …, a[n]，相邻的整数间用空格分隔，表示给定的数列。
输出格式
　　输出一行包含一个整数，表示答案。
样例输入
5
1 2 5 3 5
样例输出
2
样例说明
　　a[2] 和 a[4] 可能是三元组的中心。
评测用例规模与约定
　　对于 50% 的评测用例，2 <= n <= 100，0 <= 数列中的数 <= 1000。
　　对于所有评测用例，2 <= n <= 1000，0 <= 数列中的数 <= 10000。

import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        int[] a=new int[n+1];
        for (int i=1;i<=n;i++){
            a[i]=sc.nextInt();
        }
        Set<Integer> set = new TreeSet<>();
        for (int i=1;i<=n-2;i++){
            for (int j=i+1;j<=n-1;j++){
                if(a[j]>a[i]&&!set.contains(a[j])){
                    for (int k=j+1;k<=n;k++){
                        if(a[k]>a[j]){
                            set.add(a[j]);
                            break;
                        }
                    }
                }
            }
        }
        System.out.println(set.size());
    }
}

数位递增数

问题描述
　　一个正整数如果任何一个数位不大于右边相邻的数位，则称为一个数位递增的数，例如1135是一个数位递增的数，而1024不是一个数位递增的数。
　　给定正整数 n，请问在整数 1 至 n 中有多少个数位递增的数？
输入格式
　　输入的第一行包含一个整数 n。
输出格式
　　输出一行包含一个整数，表示答案。
样例输入
30
样例输出
26
评测用例规模与约定
　　对于 40% 的评测用例，1 <= n <= 1000。
　　对于 80% 的评测用例，1 <= n <= 100000。
　　对于所有评测用例，1 <= n <= 1000000。

import java.util.Scanner;

class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        int sum=0;
        for (int i=1;i<=n;i++){
            if(check(i)){
                sum++;
            }
        }
        System.out.println(sum);
    }
    public static Boolean check(int n){
        String s=String.valueOf(n);
        if(s.length()==1) return true;
        int[] res=new int[s.length()];
        for (int i=0;i<s.length();i++){
            res[i]=Integer.valueOf(s.charAt(i));
            if(i>0&&res[i]<res[i-1]) return false;
        }
        return true;
    }
}

四段字母

这里考虑情况: 辅元辅元辅元—“no”

小明对类似于 hello
这种单词非常感兴趣，这种单词可以正好分为四段，第一段由一个或多个辅音字母组成，第二段由一个或多个元音字母组成，第三段由一个或多个辅音字母组成，第四段由一个或多个元音字母组成。
　　给定一个单词，请判断这个单词是否也是这种单词，如果是请输出yes，否则请输出no。
　　元音字母包括 a, e, i, o, u，共五个，其他均为辅音字母。
输入格式
　　输入一行，包含一个单词，单词中只包含小写英文字母。
输出格式
　　输出答案，或者为yes，或者为no。
样例输入
lanqiao
样例输出
yes
样例输入
world
样例输出
no
评测用例规模与约定
　　对于所有评测用例，单词中的字母个数不超过100。

import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String word=sc.next();
        Set<Character> set = new TreeSet<>();
        set.add('a');
        set.add('e');
        set.add('i');
        set.add('o');
        set.add('u');
        if(set.contains(word.charAt(0))){
            System.out.println("no");
            return;
        }
        int key=1;
        int curr=0;
        while (curr!=word.length()&&key<=4){
            if(key==1||key==3&&curr<word.length()){
                while (curr<word.length()&&!set.contains(word.charAt(curr))){
                    curr++;
                }
                key++;
            }
            if (key==2||key==4&&curr<word.length()){
                while (curr<word.length()&&set.contains(word.charAt(curr))){
                    curr++;
                }
                key++;
            }
        }
        if(key==5&&curr==word.length()) System.out.println("yes");
        else System.out.println("no");
    }
}

满足序列的数量

问题描述
　　小明想知道，满足以下条件的正整数序列的数量：
　　1. 第一项为 n；
　　2. 第二项不超过 n；
　　3. 从第三项开始，每一项小于前两项的差的绝对值。
　　请计算，对于给定的 n，有多少种满足条件的序列。
输入格式
　　输入一行包含一个整数 n。
输出格式
　　输出一个整数，表示答案。答案可能很大，请输出答案除以10000的余数。
样例输入
4
样例输出
7
样例说明
　　以下是满足条件的序列：
　　4 1
　　4 1 1
　　4 1 2
　　4 2
　　4 2 1
　　4 3
　　4 4
评测用例规模与约定
　　对于 20% 的评测用例，1 <= n <= 5；
　　对于 50% 的评测用例，1 <= n <= 10；
　　对于 80% 的评测用例，1 <= n <= 100；
　　对于所有评测用例，1 <= n <= 1000。

import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Scanner;

class Main{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        Queue<int[]> queue = new ArrayDeque<>();
        int sum=0;
        for (int i=1;i<=n;i++){
            int num[]={n,i};
            queue.add(num);
            sum++;
        }
        while (!queue.isEmpty()){
            int[] curr=queue.poll();
            int value=Math.abs(curr[0]-curr[1]);
            for (int i=1;i<=n;i++){
                if (i<value){
                    queue.add(new int[]{curr[1], i});
                    sum++;
                }else break;
            }
        }
        System.out.println(sum%10000);
    }
}

小明种草

一开始想用两个数组,但是被地址搞晕了,后来直接换了一种记录的方法:将’g’与其他字符循环交换,这样就可以在一个数组里操作.

问题描述
　　小明有一块空地，他将这块空地划分为 n 行 m 列的小块，每行和每列的长度都为 1。
　　小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。
　　这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，这四小块空地都将变为有草的小块。
　　请告诉小明，k 个月后空地上哪些地方有草。
输入格式
　　输入的第一行包含两个整数 n, m。
　　接下来 n 行，每行包含 m 个字母，表示初始的空地状态，字母之间没有空格。如果为小数点，表示为空地，如果字母为 g，表示种了草。
　　接下来包含一个整数 k。
输出格式
　　输出 n 行，每行包含 m 个字母，表示 k 个月后空地的状态。如果为小数点，表示为空地，如果字母为 g，表示长了草。
样例输入
4 5
.g…
…
…g…
…
2
样例输出
gggg.
gggg.
ggggg
.ggg.
评测用例规模与约定
　　对于 30% 的评测用例，2 <= n, m <= 20。
　　对于 70% 的评测用例，2 <= n, m <= 100。
　　对于所有评测用例，2 <= n, m <= 1000，1 <= k <= 1000。

import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

class Main{
    static char key;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        char[][] chars = new char[n][m];
        for (int i=0;i<n;i++){
            String s=sc.next();
            chars[i]=s.toCharArray();
        }
        key='g';
        int k=sc.nextInt();
        for (int i=1;i<=k;i++){
            for (int row=0;row<n;row++){
                for (int col=0;col<m;col++){
                    if(chars[row][col]==key){
                        helper(chars,row,col,n,m,key);
                    }
                }
            }
            key=key=='g'?'1':'g';
        }
        for (char[] i :
                chars) {
            for (char j :
                    i) {
                if (j == '1')
                    System.out.print('g');
                else System.out.print(j);
            }
            System.out.println();

        }
    }
    public static void helper(char[][] chars, int row, int col,int n,int m,char key){//上下左右搜索
        char curr=key;
        key = key == 'g' ? '1' : 'g';
        chars[row][col]=key;
        if (row>0&&chars[row-1][col]!=curr) chars[row-1][col]=key;
        if (row<n-1&&chars[row+1][col]!=curr) chars[row+1][col]=key;
        if (col>0&&chars[row][col-1]!=curr) chars[row][col-1]=key;
        if (col<m-1&&chars[row][col+1]!=curr) chars[row][col+1]=key;
        return;
    }
}

小明选节目

这道题我考虑了多种情况,5个节目选三个包括:①节目好看值全部相同,比如:2 2 2 2 2.输出:2 2 2
②节目好看值部分相同,比如:2 2 5 2 2.输出:2 2 5

问题描述
　　小明要组织一台晚会，总共准备了 n 个节目。然后晚会的时间有限，他只能最终选择其中的 m 个节目。
　　这 n 个节目是按照小明设想的顺序给定的，顺序不能改变。
　　小明发现，观众对于晚上的喜欢程度与前几个节目的好看程度有非常大的关系，他希望选出的第一个节目尽可能好看，在此前提下希望第二个节目尽可能好看，依次类推。
　　小明给每个节目定义了一个好看值，请你帮助小明选择出 m 个节目，满足他的要求。
输入格式
　　输入的第一行包含两个整数 n, m ，表示节目的数量和要选择的数量。
　　第二行包含 n 个整数，依次为每个节目的好看值。
输出格式
　　输出一行包含 m 个整数，为选出的节目的好看值。
样例输入
5 3
3 1 2 5 4
样例输出
3 5 4
样例说明
　　选择了第1, 4, 5个节目。
评测用例规模与约定
　　对于 30% 的评测用例，1 <= n <= 20；
　　对于 60% 的评测用例，1 <= n <= 100；
　　对于所有评测用例，1 <= n <= 100000，0 <= 节目的好看值 <= 100000。

import java.util.*;

class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();//节目的数量
        int m=sc.nextInt();//选择的数量
        int []nums=new int[n];
        for (int i=0;i<n;i++){
            nums[i] = sc.nextInt();
        }
        int[] res=nums.clone();
        Arrays.sort(nums);
        int min=nums[n-m-1];
        int last[]=new int[m];
        last[0]=min;
        int sum=1;
        for (int i=0;i<n;i++) {
            if (res[i]>nums[n-m-1]) {
                last[sum]=res[i];
                sum++;
            }
        }
        while (sum<m){
            System.out.print(min+" ");
            sum++;
        }
        int i=0;
        while (i<last.length&&last[i]!=0){
            System.out.print(last[i]+" ");
            i++;
        }
    }
}