2019第十届蓝桥杯JAVA C组题解

蓝桥杯历年真题及解析.

package JC2019;
//正确

//试题 A: 求和
//本题总分:5 分
//【问题描述】
//小明对数位中含有 2、0、1、9 的数字很感兴趣,在 1 到 40 中这样的数包
//括 1、2、9、10 至 32、39 和 40,共 28 个,他们的和是 574。
//请问,在 1 到 2019 中,所有这样的数的和是多少?
//【答案提交】
//这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一
//个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
public class A {
     
	public static boolean check(int i){
     
		int x;
		while(i>0){
     
			x=i%10;
			i/=10;
			if(x==2||x==0||x==1||x==9){
     
				return true;
			}
		}
		return false;
	}
	public static void main(String[] args) {
     
		long sum=0;
		for(int i=0;i<=2019;i++){
     
			if(check(i)){
     
				sum+=i;
			}
		}
		System.out.println(sum);
	}
}

package JC2019;
//正确

//试题 B: 矩形切割
//本题总分:5 分
//【问题描述】
//小明有一些矩形的材料,他要从这些矩形材料中切割出一些正方形。
//当他面对一块矩形材料时,他总是从中间切割一刀,切出一块最大的正方
//形,剩下一块矩形,然后再切割剩下的矩形材料,直到全部切为正方形为止。
//例如,对于一块两边分别为 5 和 3 的材料(记为 5 × 3),小明会依次切出
//3 × 3、2 × 2、1 × 1、1 × 1 共 4 个正方形。
//现在小明有一块矩形的材料,两边长分别是 2019 和 324。请问小明最终会
//切出多少个正方形?
//【答案提交】
//这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一
//个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
public class B {
     
	public static int count=0;
	public static void f(int w,int h){
     
		if(w==0||h==0){
     
			return;
		}
		if(w>=h){
     
			count++;
			f(w-h,h);
		}
		else if(w<h){
     
			count++;
			f(w,h-w);
		}
	}
	public static void main(String[] args) {
     
		f(2019,324);
		System.out.println(count);
	}
}

package JC2019;
//正确
import java.util.HashSet;
//试题 C: 不同子串
//本题总分:10 分
//【问题描述】
//一个字符串的非空子串是指字符串中长度至少为 1 的连续的一段字符组成
//的串。例如,字符串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab,一共 7 个。
//注意在计算时,只算本质不同的串的个数。
//请问,字符串0100110001010001 有多少个不同的非空子串?
//【答案提交】
//这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一
//个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
public class C {
     
	public static void main(String[] args) {
     
		String s="0100110001010001";
		HashSet<String> set=new HashSet<String>();
		for(int i=0;i<=s.length();i++){
     
			for(int j=i;j<=s.length();j++){
     
				String ss=s.substring(i,j);
				set.add(ss);
			}
		}
		System.out.println(set.size()-1);
	}
}

package JC2019;
//正确

//试题 D: 质数
//本题总分:10 分
//【问题描述】
//我们知道第一个质数是 2、第二个质数是 3、第三个质数是 5……请你计算
//第 2019 个质数是多少?
//【答案提交】
//这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一
//个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
public class D {
     
	public static boolean check(int n){
     
		for(int i=2;i<=Math.sqrt(n);i++){
     
			if((n/i)*i==n){
     
				return false;
			}
		}
		return true;
	}
	public static void main(String[] args) {
     
		int arr[]=new int [2019];
		boolean is[]=new boolean[100000];
		int p=0;
		for(int i=2;i<is.length;i++){
     
			if(is[i])continue;
			else if(check(i)){
     
				arr[p]=i;
				p++;
				if(p==2019)break;
				for(int j=i;j<is.length;j+=i){
     
					is[j]=true;
				}
			}
		}
		System.out.println(arr[2018]);
	}
}

package JC2019;
//正确

//试题 E: 最大降雨量
//本题总分:15 分
//【问题描述】
//由于沙之国长年干旱,法师小明准备施展自己的一个神秘法术来求雨。
//这个法术需要用到他手中的 49 张法术符,上面分别写着 1 至 49 这 49 个
//数字。法术一共持续 7 周,每天小明都要使用一张法术符,法术符不能重复使
//用。
//每周,小明施展法术产生的能量为这周 7 张法术符上数字的中位数。法术
//施展完 7 周后,求雨将获得成功,降雨量为 7 周能量的中位数。
//由于干旱太久,小明希望这次求雨的降雨量尽可能大,请大最大值是多少?
//【答案提交】
//这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一
//个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
public class E {
     
	public static void main(String[] args) {
     
		//建立7*7二维数组
		//使从左到右严格递增
		//使每行中位数从上到下严格递增
		//得出该二维数组中位数右下角均为比它大的数
		//则中位数最大值为49-16+1
		System.out.println(49-16+1);
	}
}

package JC2019;
//正确
import java.util.Scanner;
//试题 F: 旋转
//时间限制: 1.0s 内存限制: 512.0MB 本题总分:15 分
//【问题描述】
//图片旋转是对图片最简单的处理方式之一,在本题中,你需要对图片顺时
//针旋转 90 度。
//我们用一个 n × m 的二维数组来表示一个图片,例如下面给出一个 3 × 4 的
//图片的例子:
//1 3 5 7
//9 8 7 6
//3 5 9 7
//这个图片顺时针旋转 90 度后的图片如下:
//3 9 1
//5 8 3
//9 7 5
//7 6 7
//给定初始图片,请计算旋转后的图片。
//【输入格式】
//输入的第一行包含两个整数 n 和 m,分别表示行数和列数。
//接下来 n 行,每行 m 个整数,表示给定的图片。图片中的每个元素(像
//素)为一个值为 0 至 255 之间的整数(包含 0 和 255)。
//【输出格式】
//输出 m 行 n 列,表示旋转后的图片。
//试题F: 旋转 7
//第十届蓝桥杯大赛软件类省赛 Java 大学 C 组
//【样例输入】
//3 4
//1 3 5 7
//9 8 7 6
//3 5 9 7
//【样例输出】
//3 9 1
//5 8 3
//9 7 5
//7 6 7
//【评测用例规模与约定】
//对于 30% 的评测用例,1 ≤ n, m ≤ 10。
//对于 60% 的评测用例,1 ≤ n, m ≤ 30。
//对于所有评测用例,1 ≤ n, m ≤ 100。
public class F {
     
	public static void main(String[] args) {
     
		Scanner sc=new Scanner (System.in);
		int n=sc.nextInt(),m=sc.nextInt();
		int tran[][]=new int[m][n];
		for(int i=n-1;i>=0;i--){
     
			for(int j=0;j<m;j++){
     
				tran[j][i]=sc.nextInt();
			}
		}
		for(int i=0;i<m;i++){
     
			for(int j=0;j<n;j++){
     
				System.out.print(tran[i][j]+" ");
			}
			System.out.println();
		}
	}
}

package JC2019;
//正确
import java.util.Scanner;
/*试题 G: 外卖店优先级
时间限制: 1.0s 内存限制: 512.0MB 本题总分:20 分
 * */
public class G {
     
	public static void main(String[] args) {
     
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), m = sc.nextInt(), t = sc.nextInt();
		int arr[][] = new int[t + 1][n + 1];
		for (int i = 0; i < m; i++) {
     
			arr[sc.nextInt()][sc.nextInt()]++;
		}
		int cur[] = new int[n + 1];
		for (int i = 1; i < t + 1; i++) {
     
			for (int j = 1; j < n + 1; j++) {
     
				if (arr[i][j] > 0) {
     
					arr[i][j] = arr[i - 1][j] + arr[i][j] * 2;
					if (arr[i][j] > 5)
						cur[j] = 1;
				} else {
     
					if (arr[i - 1][j] > 0) {
     
						arr[i][j] = arr[i - 1][j] - 1;
						if (arr[i][j] < 4)
							cur[j] = 0;
					}
				}
			}
		}
		int ans = 0;
		for (int i = 0; i < cur.length; i++) {
     
			ans += cur[i];
		}
		System.out.println(ans);
	}
}

package JC2019;
 
import java.util.Scanner;
import java.util.Vector;
 
public class H {
     
	static boolean jiancha(char C){
     
		if ((C>='a'&&C<='z')||(C>='A'&&C<='Z')) {
     
			return false;
		}
		return true;
	}
	public static void main(String[] args) {
     
		Vector<Integer> vectora = new Vector<Integer>();
		Vector<Integer> vectorb = new Vector<Integer>();
		int n;
		String string;
		Scanner scanner = new Scanner(System.in);
		n = scanner.nextInt();
 
		string = scanner.nextLine();
		string = scanner.nextLine();
		for (int i = 0; i+5 <= string.length(); i++) {
     
			if ((i==0 || jiancha(string.charAt(i-1)) == true) && (i+5==string.length() || jiancha(string.charAt(i+5)) == true)) {
     
		
				if (string.substring(i, i+5).equals("Alice")) {
     
					vectora.add(i);
				}
			}
		}
		for (int i = 0; i+3 <= string.length(); i++) {
     
			if ((i==0 || jiancha(string.charAt(i-1)) == true) && (i+3==string.length() || jiancha(string.charAt(i+3)) == true)) {
     
				if (string.substring(i, i+3).equals("Bob")) {
     
					vectorb.add(i);
				}
			}
		}
		int ans = 0;
		for (int i = 0; i < vectora.size(); i++) {
     
			int l  =0,r=-1;
			while(r+1 < vectorb.size() && vectora.get(i) > vectorb.get(r+1)  ) {
     
				r++;
			}
			while (l<=r && vectora.get(i) >vectorb.get(l)+n+3  ) {
     
				l++;
			}
			ans += r-l+1;
		}
		
		for (int i = 0; i < vectorb.size(); i++) {
     
			int l  =0,r=-1;
			while(r+1 < vectora.size() && vectorb.get(i) > vectora.get(r+1)  ) {
     
				r++;
			}
			while (l<=r && vectorb.get(i) >vectora.get(l)+n+5  ) {
     
				l++;
			}
			ans += r-l+1;
		}
		System.out.println(ans);
	
	}
}

package JC2019;

import java.util.Arrays;
import java.util.Scanner;

public class I {
     
	public static void main(String[] args) {
     
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int arr[]=new int[n];
		for(int i=0;i<n;i++){
     
			arr[i]=sc.nextInt();
		}
		Arrays.sort(arr);
		int set[]=new int[n-1];
		for(int i=0;i<n-1;i++){
     
			set[i]=arr[i+1]-arr[i];
		}
		Arrays.sort(set);
		System.out.println((arr[n-1]-arr[0])/set[0]+1);
	}
}

package JC2019;
//写的深搜,前四个测试数据都能出来,后边时间超限,或者栈溢出
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
 
public class J {
     
	public static int n;
	public static int arr[];
	public static int ans=Integer.MAX_VALUE;
	public static void main(String[] args) {
     
		Scanner sc=new Scanner (System.in);
		n=sc.nextInt();
		int k=sc.nextInt();
		arr=new int[k+1];
		for(int i=1;i<=k;i++){
     
			arr[i]=sc.nextInt();
		}
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
		dfs(1,0,0);
		System.out.println((ans-1)*2);
	}
	public static void dfs(int k,int max,int up){
     
		if(k==1){
     
			dfs(k+1,0,arr[1]);
		}
		else if(k==arr.length){
     
			max=max>(up+n-arr[k-1])?max:(up+n-arr[k-1]);
			ans=max>ans?ans:max;
		}
		else {
     
			if(arr[k]-arr[k-1]==0){
     
				dfs(k+1,max,up);
			}else
			for(int i=0;i<(arr[k]-arr[k-1]);i++){
     
				dfs(k+1,max>(up+i)?max:(up+i),arr[k]-arr[k-1]-i);
			}
		}
	}
}

你可能感兴趣的:(蓝桥杯,蓝桥杯,Java,第十届蓝桥杯,蓝桥省赛,算法题解)