第十一届蓝桥杯国赛Java大学B组

最新推荐文章于 2023-01-09 23:53:50 发布
最新推荐文章于 2023-01-09 23:53:50 发布
阅读量183 收藏 2
点赞数 1
分类专栏： 赛题题解 文章标签： 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54409739/article/details/125113636
版权

最近在做真题，顺便发发题解，最近没空，很忙。

一、美丽的2

1.问题：

 

2.源代码：

package 蓝桥杯补题;
import java.util.*;
import java.io.*;
public class 国赛真题A_2020年 {
	static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner cin = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
		int ans = 0;
		for(int i = 1;i<=2020;i++) {
			String p = String.valueOf(i);
			if(p.contains("2")) {
				ans++;
			}
		}
		pw.println(ans);//563
		pw.flush();
    }

}

二、扩散

1.问题：

2.源代码：

package 蓝桥杯补题;
import java.util.*;
import java.io.*;
public class 国赛真题B_2020年 {
	static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	static class stu{
		int x;
		int y;
		int t;
		public stu(int x,int y,int t) {
			this.x = x;
			this.y = y;
			this.t = t;
		}
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner cin = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
		long ans = 0;
		int time = 2020;
		int xy[][] = {{1,0},{0,1},{-1,0},{0,-1}};
		boolean mp[][] = new boolean[7000][7000];
		LinkedList<stu> Q = new LinkedList<>();
		Q.add(new stu(2500,2500,0));
		Q.add(new stu(4520,2511,0));
		Q.add(new stu(2511,2514,0));
		Q.add(new stu(4500,4500,0));
		int answer = 0;
		while(!Q.isEmpty()) {
			stu now = Q.poll();
			if(now.t == 2021) {
				continue;
			}
			if(mp[now.x][now.y]) {
				continue;
			}
			mp[now.x][now.y] = true;
			answer++;
			for(int i = 0;i<4;i++) {
				int nx = now.x + xy[i][0];
				int ny = now.y + xy[i][1];
				if(!mp[nx][ny])
				Q.add(new stu(nx,ny,now.t+1));
			}
		}
		pw.println(answer);//20312088
		pw.flush();
	}

}

三、阶乘约数

1.问题：

 

2.源代码：

package 蓝桥杯补题;
import java.util.*;
import java.io.*;
import java.math.*;
public class 国赛真题C_2020年 {
	private static BigInteger one =  new BigInteger("1");
	private static BigInteger two =  new BigInteger("2");
	static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	private static BigInteger find(BigInteger num) {
		BigInteger ans = one;
		for(BigInteger i = two; i.multiply(i).compareTo(num)<=0; i = i.add(one)) {
			BigInteger j = one;
			while(num.mod(i).equals(BigInteger.ZERO)) {
				j = j.add(one);
				num = num.divide(i);
			}
			if(j.compareTo(one) > 0)
			ans = ans.multiply(j);
		}
		if(num.compareTo(one) > 0) {
			return ans.multiply(two);
		}
		else {
			return ans;
		}
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner cin = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
		BigInteger ans = one;
		for(int i = 1;i<=100;i++) {
			ans = ans.multiply(new BigInteger(String.valueOf(i)));
		}
		BigInteger answer = find(ans);
		pw.print(answer);//39001250856960000
		pw.flush();
	}

}

四、本质上升序列

1.问题：

 

2.源代码：

package 蓝桥杯补题;
import java.util.*;
import java.io.*;
import java.math.*;
public class 国赛真题D_2020年 {
	private static class stu{
		char str;
		int pi;
		public stu(char str, int pi) {
			this.str = str;
			this.pi = pi;
		}
	}
	static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner cin = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
		String s = cin.next();
		int n = s.length();
		long mp[] = new long [n];
		boolean ans[] = new boolean[1006];
		for(int i = n-1;i >= 0;i--) {
			mp[i] = 1;
			Arrays.fill(ans, false);
			for(int j = i+1; j< n;j++) {
				if(s.charAt(j) > s.charAt(i) && ans[s.charAt(j)] == false) {
					mp[i]+=mp[j];
					ans[s.charAt(j)] = true;
				}
			}
		}
		long answer = 0;
		Arrays.fill(ans, false);
		for(int i = 0;i<n;i++) {
			if(!ans[s.charAt(i)]) {
				answer+=mp[i];
				ans[s.charAt(i)] = true;
			}
		}
		pw.println(answer);//3616159
		pw.flush();
	}
//tocyjkdzcieoiodfpbgcncsrjbhmugdnojjddhllnofawllbhfiadgdcdjstemphmnjihecoapdjjrprrqnhgccevdarufmliqijgihhfgdcmxvicfauachlifhafpdccfseflcdgjncadfclvfmadvrnaaahahndsikzssoywakgnfjjaihtniptwoulxbaeqkqhfwl
}

五、玩具蛇

1.问题：

2.源代码：

package 蓝桥杯补题;
import java.util.*;
import java.io.*;
import java.math.*;
public class 国赛真题E_2020年 {
	static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	static int answer = 0;
	static boolean mp[][] = new boolean[5][5];
	static int xy[][] = {{1,0},{0,1},{-1,0},{0,-1}};
	private static void dfs(int x,int y,int value) {
		if(value == 16) {
			answer++;
			return;
		}
		for(int i = 0;i<4;i++) {
			int nx = x + xy[i][0];
			int ny = y + xy[i][1];
			if(nx >= 1 && nx <= 4 && ny >= 1 && ny <= 4 && !mp[nx][ny] ) {
				mp[nx][ny] = true;
				dfs(nx,ny,value+1);
				mp[nx][ny] = false;
			}
		}
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner cin = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
		
		for(int i = 1;i<=4;i++) {
			for(int j = 1;j<=4;j++) {
				for(boolean as[] : mp) {
					Arrays.fill(as, false);
				}
				mp[i][j] = true;
				dfs(i,j,1);
			}
		}
		pw.println(answer);//552
		pw.flush();
		
	}

}

六、蓝肽子序列

1.问题：

 

 

2.源代码：

package 蓝桥杯补题;
import java.util.*;
import java.io.*;
import java.math.*;
public class 国赛真题F_2020 {
	static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner cin = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
		String p1 = cin.next();
		String p2 = cin.next();
		String s1[] = new String[1001];
		String s2[] = new String[1001];
		Arrays.fill(s1, "");
		Arrays.fill(s2, "");
		int pi1 = 0;
		for(int i = 0;i<p1.length();) {
			pi1++;
			if(p1.charAt(i) <= 'Z' && p1.charAt(i) >= 'A') {
				s1[pi1]+=p1.charAt(i);
				i++;
				while(i<p1.length() && p1.charAt(i) <= 'z' && p1.charAt(i) >= 'a') {
					s1[pi1]+=p1.charAt(i);
					i++;
				}
			}
			
		}
		int pi2 = 0;
		for(int i = 0;i<p2.length();) {
			pi2++;
			if(p2.charAt(i) <= 'Z' && p2.charAt(i) >= 'A') {
				s2[pi2]+=p2.charAt(i);
				i++;
				while(i<p2.length() && p2.charAt(i) <= 'z' && p2.charAt(i) >= 'a') {
					s2[pi2]+=p2.charAt(i);
					i++;
				}
			}
			
		}
		int mp[][] = new int[pi1+1][pi2+1];
		for(int i = 1;i<=pi1;i++) {
			for(int j = 1;j<=pi2;j++) {
				if(s1[i].equals(s2[j])) {
					mp[i][j] = mp[i-1][j-1]+1; 
				}
				else {
					mp[i][j] = Math.max(mp[i][j-1],mp[i-1][j]);
				}
			}
		}
		pw.print(mp[pi1][pi2]);
		pw.flush();
	}
}

 

七、皮亚诺曲线距离

1.问题：

 

 

2.源代码：

package 蓝桥杯补题;
import java.util.*;
import java.io.*;
import java.math.*;
public class 国赛真题G_2020年 {
	static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	static BigInteger mp[] = new BigInteger[301];
	static BigInteger one = new BigInteger("1");
	static BigInteger three = new BigInteger("3");
	static BigInteger two = new BigInteger("2");
	
	private static void init() {
		mp[0] = one;
		for(int i = 1;i<=200;i++) {
			mp[i] = mp[i-1].multiply(three);
		}
	}
	private static BigInteger find(int n,BigInteger x,BigInteger y) {
		if(n == 0) {
			return one;
		}
		BigInteger num = mp[n];
		BigInteger add = mp[n*2].divide(new BigInteger("9"));
		if(x.compareTo(num.divide(three))<0) {
			if(y.compareTo(num.divide(three)) < 0) {
				return find(n-1,x,y);
			}
			if(y.compareTo(num.multiply(two).divide(three)) < 0) {
				return add.add(find(n-1,num.divide(three).subtract(x).subtract(one),y.subtract(num.divide(three))));
			}
			else {
				return add.multiply(two).add(find(n-1,x,y.subtract(num.multiply(two).divide(three))));
			}
		}
		else if(x.compareTo(num.multiply(two).divide(three)) < 0) {
			if(y.compareTo(num.divide(three)) < 0) {
				return add.multiply(new BigInteger("5")).add(find(n-1,x.subtract(num.divide(three)),num.divide(three).subtract(y).subtract(one)));
			}
			else if(y.compareTo(num.multiply(two).divide(three)) < 0) {
				return add.multiply(new BigInteger("4")).add(find(n-1,num.multiply(two).divide(three).subtract(one).subtract(x),num.multiply(two).divide(three).subtract(one).subtract(y)));
						
			}
			else {
				return add.multiply(three).add(find(n-1,x.subtract(num.divide(three)),num.subtract(y).subtract(one)));
			}
		}
		else {
			if(y.compareTo(num.divide(three)) < 0) {
				return add.multiply(new BigInteger("6")).add(find(n-1,x.subtract(num.multiply(two).divide(three)),y));
			}
			else if(y.compareTo(num.multiply(two).divide(three)) < 0) {
				return add.multiply(new BigInteger("7")).add(find(n-1,num.subtract(x).subtract(one),y.subtract(num.divide(three))));
			}
			else {
				return add.multiply(new BigInteger("8")).add(find(n-1,x.subtract(num.multiply(two).divide(three)),y.subtract(num.multiply(two).divide(three))));
			}
		}
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner cin = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
		init();
		BigInteger niu = cin.nextBigInteger();
		int k = Integer.parseInt(niu.toString());
		BigInteger x1 = cin.nextBigInteger();
		BigInteger y1 = cin.nextBigInteger();
		BigInteger x2 = cin.nextBigInteger();
		BigInteger y2 = cin.nextBigInteger();
		BigInteger ans1 = find(k,x1,y1);
		BigInteger ans2 = find(k,x2,y2);
		pw.println(ans2.subtract(ans1).abs());
		pw.flush();
	}
}

 

八、画廊

1.问题：

 

 

2.源代码：

package 蓝桥杯补题;
import java.util.*;
import java.io.*;
import java.math.*;
public class 国赛真题H_2020年 {
	private static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	private static double find(double x1,double y1,double x2,double y2) {
		return Math.sqrt((x1 - x2)*(x1 - x2)+(y1 - y2)*(y1 - y2));
	}
	private static int L,R,len,wid;
	public static void main(String[] args) {
		Scanner cin = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
		L = cin.nextInt();
		R = cin.nextInt();
		int left[] = new int[L+1];
		int right[] = new int[R+1];
		len = cin.nextInt();
		wid = cin.nextInt();
		double dp[][][] = new double[L+1][R+1][2];//L左边已经搞好的，R右边已经搞好的，2种状态，左、右
		for(double as[][] : dp) {
			for(double aa[] : as)
			Arrays.fill(aa, 99999999);
		}
		for(int i = 1;i<=L;i++) {
			left[i] = cin.nextInt();
		}
		for(int i = 1;i<=R;i++) {
			right[i] = cin.nextInt();
		}
		double mid = wid*1.0/2;
		dp[1][0][0] = find(mid,0,0,left[1]);
		dp[0][1][1] = find(mid,0,wid,right[1]);
		for(int i = 2;i<=L;i++) {
			dp[i][0][0] = dp[i-1][0][0] + left[i] - left[i-1];
		}
		for(int i = 2;i<=R;i++) {
			dp[0][i][1] = dp[0][i-1][1] + right[i] - right[i-1];
		}
		dp[1][1][0] = dp[0][1][1] + find(0,left[1],wid,right[1]);
		dp[1][1][1] = dp[1][0][0] + find(0,left[1],wid,right[1]);
		for(int i = 1;i<=L;i++) {
			for(int j = 1;j<=R;j++) {
				if(i == 1 && j == 1) {
					continue;
				}
				for(int k = 1;k>=0;k--) {
					if(k == 0) {
						dp[i][j][0] = Math.min(dp[i-1][j][0] + left[i] - left[i-1], dp[i-1][j][1]+find(0,left[i],wid,right[j]));
					}
					else {
						dp[i][j][1] = Math.min(dp[i][j-1][0] +find(0,left[i],wid,right[j]), dp[i][j-1][1]+right[j] - right[j-1]);
					}
				}
;			}
		}
		double ans1 = dp[L][R][0] + find(0,left[L],mid,len);
		double ans2 = dp[L][R][1] + find(wid,right[R],mid,len);
		pw.printf("%.2f",Math.min(ans1, ans2));
		pw.flush();
	}

}

 

九、补给

1.问题：

 

 

2.源代码：

package 蓝桥杯补题;
import java.util.*;
import java.io.*;
import java.math.*;
public class 国赛真题I_2020年 {
	private static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	private static class point {
		int x;
		int y;
		public point(int x,int y) {
			this.x = x;
			this.y = y;
		}
	}
	private static double find(point o1,point o2) {
		return Math.sqrt((o1.x - o2.x)*(o1.x - o2.x)+(o1.y - o2.y)*(o1.y - o2.y));
	}
	private static double inf = 1e9;
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner cin = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
		int n,m;
		n = cin.nextInt();
		m = cin.nextInt();
		point mp[] = new point[n];
		double floyd[][] = new double[n][n];
		double dp[][] = new double[1<<n][n];
		for(int i = 0;i < n ;i++) {
			mp[i] = new point(cin.nextInt(),cin.nextInt());
		}
		for(int i = 0 ;i< n ;i++) {
			for(int j = 0;j < n;j++) {
				floyd[i][j] = find(mp[i],mp[j]);
				if(floyd[i][j] > m) {
					floyd[i][j] = inf;
				}
			}
		}
		for(int k = 0;k<n;k++) {
			for(int i = 0;i<n;i++) {
				for(int j = 0;j<n;j++) {
					floyd[i][j] = Math.min(floyd[i][j], floyd[i][k] + floyd[k][j]);
				}
			}
		}
		for(double as[] : dp) {
			Arrays.fill(as, inf);
		}
		dp[1][0] = 0;
		for(int i = 0;i<(1<<n);i++) {
			for(int j = 0;j<n;j++) {
				if(((i >> j)&1) > 0) {
					for(int k = 0;k<n;k++) {
						if((((i - (1<<j))>>k)&1)>0) {
							dp[i][j] = Math.min(dp[i][j],dp[i - (1<<j)][k]+floyd[k][j]);
						}
					}
				}
			}
		}
		double ans = inf;
		for(int i = 1;i<n;i++) {
			ans = Math.min(ans, floyd[i][0] + dp[(1<<n)-1][i]);
		}
		pw.printf("%.2f",ans);
		pw.flush();
	}

}

十、质数行者 

1.问题：

  

2.源代码：

package 蓝桥杯补题;
import java.util.*;
import java.io.*;
import java.math.*;
public class 国赛真题J_2020年 {
	private static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	private static int n,m,w,r1,h1,t1,r2,h2,t2,ans = 0,mod;
	private static boolean is[];
	private static void init() {
		mod = 1000000007;
		is = new boolean[1001];
		is[1] = true;
		is[0] = true;
		for(int i = 2;i<=1000;i++) {
			if(!is[i]) {
				for(int j = 2;i*j<=1000;j++) {
					is[i*j] = true;
				}
			}
		}
	}
	private static void dfs(int x,int y,int t) {
		if(x == n && y == m && t == w) {
			ans++;
			return ;
		}
		if(x == r1 && y == h1 && t == t1 || x == r2 && y == h2 && t == t2 ) {
			return ;
		}
		if(x > n || y > m || t > w) {
			return ;
		}
		int nx = x,ny = y,nt = t;
		for(int i = 0;i<n;i++) {
			if(!is[i]) {
				dfs(x+i,y,t);
			}
		}
		for(int i = 0;i<m;i++) {
			if(!is[i]) {
				dfs(x,y+i,t);
			}
		}
		for(int i = 0;i<w;i++) {
			if(!is[i]) {
				dfs(x,y,t+i);
			}
		}
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner cin = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
		init();
		n = cin.nextInt();
		m = cin.nextInt();
		w = cin.nextInt();
		r1 = cin.nextInt();
		h1 = cin.nextInt();
		t1 = cin.nextInt();
		r2 = cin.nextInt();
		h2 = cin.nextInt();
		t2 = cin.nextInt();
//		dfs(1,1,1); //嘎嘎超时
		int Max = Math.max(n, Math.max(m,w));
		int dp[][][] = new int[300][300][300];
		dp[1][1][1] = 1;
		for(int i = 1;i<=n;i++) {
			for(int j = 1;j<=m;j++) {
				for(int k = 1;k<=w;k++) {
					if(i == r1 && j == h1 && k == t1 || i == r2 && j == h2 && k == t2) {
						dp[i][j][k] = 0;
					}
					for(int add = 2;add<= Max;add++) {
						if(!is[add]) {
							if(i+add<=n) {
								dp[i+add][j][k] = (dp[i+add][j][k]%mod + dp[i][j][k]%mod)%mod;
							}
							if(j+add<=m) {
								dp[i][j+add][k] = (dp[i][j+add][k]%mod + dp[i][j][k]%mod)%mod;
							}
							if(k+add<=w) {
								dp[i][j][k+add] = (dp[i][j][k+add]%mod + dp[i][j][k]%mod)%mod;
							}
						}
					}
				}
			}
		}
		ans = dp[n][m][w];
		pw.println(ans);
		pw.flush();
	}

}

用DP只有40分，没啥想法 

stu_kk
关注
专栏目录
第十一届蓝桥杯大赛软件类决赛（2020javaB国赛）
weixin_41736581的博客
11-16 837
第十一届蓝桥杯大赛软件类决赛 Java 大 学 B 组 试题 A: 美丽的 2 5 分 【问题描述】 小蓝特别喜欢 2，今年是公元 2020 年，他特别高兴。 他很好奇，在公元 1 年到公元 2020 年（包含）中，有多少个年份的数位中包含数字 2？ 【答案提交】 这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。 试题 B: 扩散 本题总分：5 分 【问题描述】 小蓝在一张无限大的特殊画布上作画。 这张画布可以看成一个方格
2020年第十一届蓝桥杯国赛Java大学B组真题及解析
imreal_的博客
03-01 6744
你们可爱的呆毛又回来啦~~~这次给大家带来国赛的解析orz(瑟瑟发抖)，请尽情食用吧！(各位看官看完以后如果觉得有帮助的话请不要吝惜手中的赞哦，大家的鼓励是我更新文章的最大动力) 目录 试题A：美丽的2 试题B：扩散 试题C：阶乘约数 试题D：本质上升序列 试题F：蓝肽子序列 试题G：皮亚诺曲线距离 试题H：画廊 试题I：补给 试题J：质数行者 试题A：美丽的2 解析：水题一道，直接枚举就行，从1枚举到2020，然后转换为字符串，判断是否有2，代码： public cla
第十一届蓝桥杯大赛软件类国赛Java大学B组真题-重复字符串
一个双子座的Java攻城狮
01-09 477
如果一个字符串 S 恰好可以由某个字符串重复 K 次得到，我们就称 S 是 K 次重复字符串。例如 abcabcabc 可以看作是 abc 重复 3 次得到，所以 abcabcabc 是 3 次重复字符串。2、将字符串等分后，遍历每个子字符串，修改子字符串不同的位置，修改为所有字串中当前位置，存的最多的那个字母。现在给定一个字符串 S，请你计算最少要修改其中几个字符，可以使 S 变为一个 K 次字符串？同理 aaaaaa 既是 2 次重复字符串、又是 3 次重复字符串和 6次重复字符串。
2020 第十一届蓝桥杯Java国赛B组
11-14
蓝桥杯全国软件和信息技术专业人才大赛由工业和信息化部人才交流中心主办,包括北大、清华等在内的全国31个省市自治区1200多所院校参加,每年参赛人数超过30000人。
蓝桥杯第十一届国赛JavaB组部分题解
weixin_43664907的博客
11-15 640
前言 本分的题解都是博主在经过跟伙伴一定的讨论，初步认为无误的，博主是JavaB国二。所以也是菜鸡一个，大家互相学习罢了。如果有错误或者感觉有疑问。欢迎评论区"开战"。 题目文件 题目文件我用百度网盘分享给大家 连接链接：https://pan.baidu.com/s/1pZk9GZ7Mc-zxmv7z373W7w 提取码：ovj8 目录 试题A:美丽的2 试题D:本质上的升序列 美丽的2 问题描述 小蓝特别喜欢 2，今年是公元 2020 年，他特别高兴。 他很好奇，在公元 1 年到公元 2020 年（包含
第十一届蓝桥杯 2020年国赛真题及解析 (Java 大学B组)
田埂、の技术博客
06-02 2655
第十一届蓝桥杯 2020年国赛真题 Java 大学B组 A 美丽的 2 B 扩散 C 阶乘约数 D 本质上升序列 E 玩具蛇 F 蓝肽子序列 ​G 皮亚诺曲线距离 H 画廊 I 补给 J 质数行者
第十五届蓝桥杯Java A组参赛总结
最新发布
04-14
### 第十五届蓝桥杯Java A组参赛总结 #### 知识点一：比赛规则与流程 - **考试流程**：参赛者需首先下载题目，使用官方提供的解压密码解压试题包。整个考试时长为4小时。 - **提交方式**： - 在考试过程中，参赛...
第十三届蓝桥杯Java C组试题
04-09
【标题】"第十三届蓝桥杯Java C组试题"涵盖了两个主要编程语言——Java和C，在这个竞赛中，参赛者需要展示他们在编程、算法设计和问题解决上的技能。蓝桥杯是一项全国性的软件和信息技术专业人才大赛，旨在促进高校...
2020年第十一届蓝桥杯大赛国赛JavaB组题目.rar
11-14
2020年第十一届蓝桥杯大赛国赛Java大学B组题目 试题 A: 美丽的2 试题 B: 扩散 试题 C: 阶乘约数 试题 D: 本质上升序列 试题 E: 玩具蛇 试题 F: 蓝肽子序列 试题 G: 皮亚诺曲线距离 试题 H: 画廊 试题 I: 补给 试题 J...
第十一届蓝桥杯大赛软件类省赛Java大学B组（第一场）
qq_53261858的博客
03-10 1387
分析： 方法一：手算，五个五个写，慢点写 方法二：上机写代码 代码： import java.util.Scanner; public class Main{ public static void main(String[] args) { String str = "EaFnjISplhFviDhwFbEjRjfIBBkRyY"; // 加密后的字符 String s1 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; /...
第十一届蓝桥杯大赛软件类省赛第二场 Java 大学 B 组 题目PDF压缩包无密码
10-17
第十一届蓝桥杯大赛软件类省赛第二场 Java 大学 B 组 题目PDF压缩包 第十一届蓝桥杯大赛软件类省赛第二场 Java 大学 B 组 题目PDF压缩包 第十一届蓝桥杯大赛软件类省赛第二场 Java 大学 B 组 题目PDF压缩包
2020年第十一届蓝桥杯javaB组国赛
衣点QIAO的博客
11-28 2734
2020年第十一届蓝桥杯java B组国赛 + 心得体会试题 A: 美丽的 2试题 B: 扩散试题 C: 阶乘约数试题 D: 本质上升序列试题 E: 玩具蛇试题 F: 蓝肽子序列试题 G: 皮亚诺曲线距离试题 H: 画廊试题 I: 补给试题 J: 质数行者心得体会 试题 A: 美丽的 2 本题总分：5 分 【问题描述】 小蓝特别喜欢 2，今年是公元 2020 年，他特别高兴。 他很好奇，在公元 1 年到公元 2020 年（包含）中，有多少个年份的数位中包含数字 2？ 【答案提交】 这是一道结果填空
2020年第十一届蓝桥杯省赛及国赛心得（Java B组）
360°顺滑
11-10 4455
省赛 今年省赛五道结果填空题，五道程序设计题。结果填空前三道比较简单，都对了。最后两道结果填空题有点难，就直接跳过去做程序设计题。前两道送分题，第三道深搜，第四道时间来不及，我直接暴力过50%样例。最后一道直接提交样例答案，不知道能混个两分吗？后面回头想去做结果填空题来不及了，最后一道填空题应该是可以做出来的。总的来说，六道半是对的吧！ 比赛后有点失落，因为感觉省一有点悬！加上没怎么准备省赛，靠啃老本，所以对于能不能进决赛也是不怎么抱希望！ 成绩公布后，居然省一了。有点开心，也有点失望，因为疫情北京去不成.
第十一届蓝桥杯决赛JavaC组真题——详细答案对照(完整版)
红目香薰
03-12 4000
目录 A、美丽的 2 B、合数个数 C、扩散 D、阶乘约数 E、本质上升序列 F、天干地支 G、皮亚诺曲线距离 H、蓝肽子序列 I、画廊 E、答疑 A、美丽的 2 本题总分：5 分 问题描述   小蓝特别喜欢 2 ，今年是公元 2020 年，他特别高兴。   他很好奇，在公元 1 年到公元 2020 年（包含）中，有多少个年份的数位中包含数字 2 ？ 答案提交   这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写
第十一届蓝桥杯 2020年国赛真题 (Java 大学A组)
NOW I GOT ONE WAY
03-27 3151
蓝桥杯 2020年国赛真题（Java 大学 A 组 ）
第十一届蓝桥杯JavaB组省赛(题目及AC题解)
03-17 2668
第十一届蓝桥杯JavaB组省赛(题目及AC题解)
第十一届蓝桥杯大赛决赛试题Java A组(试题解析)
Learning_xzj的博客
05-08 6039
## 试题 **A:** 合数个数 **👀问题描述** 一个数如果除了 1 和自己还有其他约数，则称为一个合数。 例如：1, 2, 3 不是合数，4, 6 是合数。请问从 1 到 2020 一共有多少个合数。 ✏️**思路解析** 在1-2020这些数中，构成有3部分：质数、合数、既非质数亦非合数，既非质数亦非合数只有数字"1"。 ✨**参考代码**
2020年第十一届蓝桥杯javaB组省赛
热门推荐
衣点QIAO的博客
01-17 1万+
文章目录试题 A: 门牌制作试题 B: 寻找 2020试题 C: 蛇形填数试题 D: 七段码试题 E: 排序试题 F: 成绩分析试题 G: 单词分析试题 H: 数字三角形试题 I: 子串分值和试题 J: 装饰珠 以下均为个人想法和解题思路，如有错误或不足，欢迎指正。 试题 A: 门牌制作 本题总分：5 分 【问题描述】 小蓝要为一条街的住户制作门牌号。 这条街一共有 2020 位住户，门牌号从 1 到 2020 编号。 小蓝制作门牌的方法是先制作 0 到 9 这几个数字字符，最后根据需要将字 符
最新 2020年 第十一届 蓝桥杯 软件类Java B组 决赛 （国赛） 题目 + 个人答案
davies
11-14 5352
目录 试题 A: 美丽的 2 试题 A: 美丽的 2 本题总分:5 分 【问题描述】 小蓝特别喜欢 2,今年是公元 2020 年,他特别高兴。 他很好奇,在公元 1 年到公元 2020 年(包含)中,有多少个年份的数位中包含数字 2? 【答案提交】 这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。 答案：563 代码： // 试题 A: 美丽的 2 import java.util.*; ...
蓝桥杯国赛java b组历年题目
09-17
蓝桥杯国赛Java B组历年题目主要着重于Java编程语言的运用和理解。这些题目旨在考察参赛者对于Java语法、数据结构和算法的掌握程度，以及解决实际问题的能力。 历年题目涵盖了各个领域的知识点，如字符串处理、数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

stu_kk

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值