第十二届蓝桥杯国赛JavaB组题解

最新推荐文章于 2024-03-27 15:12:30 发布
最新推荐文章于 2024-03-27 15:12:30 发布
阅读量1.2k 收藏 5
点赞数 1
分类专栏： 算法学习 文章标签： 蓝桥杯 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51624761/article/details/130958502
版权

A. 整数范围

在这里插入图片描述
思路：

签到题。答案： 255 255 255

B. 纯质数

在这里插入图片描述
思路：

先用筛法筛出所有的质数，再根据题意判断，模板参考AcWing 数学知识。

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Main {
	
	static final int N = 20211000;
	static int[] p = new int[N];
	static boolean[] st = new boolean[N];
	static int cnt;
	
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	static StreamTokenizer in = new StreamTokenizer(br);

	public static int nextInt() throws IOException {
		in.nextToken();
		return (int) in.nval;
	}
	
	public static boolean check(int x) {
		if (st[x]) return false;
		while (x != 0) {
			if (st[x % 10]) return false;
			x /= 10;
		}
		return true;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		st[0] = st[1] = true;
		for (int i = 2; i <= 20210605; i++) {
			if (!st[i]) p[cnt++] = i;
			for (int j = 0; p[j] * i <= 20210605; j++) {
				st[p[j] * i] = true;
				if (i % p[j] == 0) break;
			}
		}
		
		int ans = 0;
		for (int i = 1; i <= 20210605; i++) {
			if (check(i)) ans++;
		}
		out.println(ans);
		out.flush();
	}
}

C. 完全日期

在这里插入图片描述
思路：

使用Java自带的 LocalDate 类，简化日期计算。

代码：

import java.time.LocalDate;

public class Main {
	
	static LocalDate start = LocalDate.of(2001, 1, 1);
	static LocalDate end = LocalDate.of(2021, 12, 31);
	
	public static boolean check(LocalDate date) {
		String dt = date.toString();
		int res = 0;
		
		for (int i = 0; i < dt.length(); i++) {
			if (Character.isDigit(dt.charAt(i))) {
				res += dt.charAt(i) - '0';
			}
		}
		
		int a = (int) Math.sqrt(res);
		
		return a * a == res;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int ans = 0;
		while (start.compareTo(end) <= 0) {
			if (check(start)) ans++;
			start = start.plusDays(1);
		}
		System.out.println(ans);
	}

}

D. 最小权值

在这里插入图片描述
思路：
这个题现在看起来就是一个动态规划的题目，但是当时做的时候没意识到，最后错了。可以用记忆化搜索或者动态规划求。

记忆化搜索：

注意空子树权值为0，所以初始化为0；

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Main {
	
	static final int N = 2030;
	static long[] dp = new long[N];
	
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	static StreamTokenizer in = new StreamTokenizer(br);
	
	public static long dfs(int size) {
		if (dp[size] != 0 || size == 0) return dp[size];
		
		long res = 0x3f3f3f3f3f3f3fl;
		for (int i = 0; i < size; i++) {
			int j = size - 1 - i;
			res = Math.min(res, 1 + 2 * dfs(i) + 3 * dfs(j) + (long)i * i * j);
		}
		
		return dp[size] = res;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(dfs(2021));
	}
}

动态规划：
易知状态转移方程为：
d p ( i ) = { 0 i = 0 1 + 2 ∗ d p ( l ) + 3 ∗ d p ( r ) + l ∗ l ∗ r 1 + l + r = i , 0 ≤ l , 0 ≤ r dp(i) = \begin{cases} 0 & i = 0 \\ 1 + 2 * dp(l) + 3 * dp(r) + l * l * r & 1 + l + r = i, 0 \le l, 0 \le r \end{cases} dp(i)={01+2∗dp(l)+3∗dp(r)+l∗l∗r​i=01+l+r=i,0≤l,0≤r​

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Main {
	
	static final int N = 2030;
	static long[] dp = new long[N];
	
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	static StreamTokenizer in = new StreamTokenizer(br);

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		for (int i = 1; i <= 2021; i++) {
			dp[i] = 0x3f3f3f3f3f3f3f3fl;
			for (int j = 0; j < i; j++) {
				int k = i - 1 - j;
				dp[i] = Math.min(dp[i], 1 + 2 * dp[j] + 3 * dp[k] + (long) j * j * k);
			}
		}
		System.out.println(dp[2021]);
	}

}

E. 大写

在这里插入图片描述
思路：
模拟题，String.toUpperCase()

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

public class Main {
	
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		String s = br.readLine();
		out.println(s.toUpperCase());
		out.flush();
	}
}

F. 123

在这里插入图片描述
思路：

找规律，我们将数段分割为若干段单调递增的序列，第 i i i 段序列的长度为 i i i，则前 i i i 段序列的总长为 i ∗ ( i + 1 ) / 2 i * (i + 1) / 2 i∗(i+1)/2，先用二分处理出询问的 l l l ， r r r 的前面一段序列（也可能就是当前的序列）。

数据范围为 1 0 12 10^{12} 1012，根据前面的分析知二分的区间范围不会超过 2 × 1 0 12 \sqrt{2 ×10^{12}} 2×1012 ​，这里取右边界 r = 1500000 r = 1500000 r=1500000，二分求法如下：

int l = 0, r = 1500000;
while (l < r) {
	int mid = l + r + 1 >> 1;
	if ((long)mid * (mid + 1) / 2 <= left) l = mid;
	else r = mid - 1;
}

由于我们二分的是的 l l l ， r r r 的前面一段序列（也可能就是当前的序列），如果 l l l 和 r r r 在二分的序列之后，就要算下在当前序列的和，姑且称作 l l l 和 r r r 的余项和。方法是找到 l l l ， r r r 在当前元素的位置：

int lrem = (int) (left - (long)l * (l + 1) / 2);
int rrem = (int) (right - (long)l * (l + 1) / 2);

接着算 l l l 和 r r r 的余项和，

long lsum = (long)lrem * (lrem + 1) / 2;
long rsum = (long)rrem * (rrem + 1) / 2;

因为要求 l l l ， r r r 之间一段序列的和， l l l 也包括在其中，所以要算出当前值，如果当前元素在第0号位置，也就相当于他在这一段序列的末尾，值为序列的长度

long lval = lrem == 0 ? l : lrem;

接着我们用二分好的答案算出两端序列之间的和，可以先预处理前缀和：

for (int i = 1; i < N; i++) {
	sum[i] = (long)i * (i + 1) / 2+ sum[i - 1];
}

两端序列之间的和加上 r r r 的余项和，减去 l l l 的余项和，再减去位置为 l l l 的元素值，即为所求。

res += sum[rr] - sum[ll] - lsum + rsum + lval;

时间复杂度分析，预处理的时间复杂度为 O ( 2 ∗ 1 0 12 ) O(\sqrt{2 * 10^{12}}) O(2∗1012 ​)，有 T T T 次询问，每次询问的时间复杂度为 O ( l o g ( 2 ∗ 1 0 12 ) ) O(log(\sqrt{2 * 10^{12}})) O(log(2∗1012 ​))，一个很小的常数，大概 20 20 20 左右，所以总的时间复杂度数量级为 1 0 6 10^6 106，完全够用。

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Main {
    
    static final int N = 1414214;
    static long[] sum = new long[N];
    
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
    static StreamTokenizer in = new StreamTokenizer(br);

    public static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }
    
    public static long nextLong() throws IOException {
        in.nextToken();
        return (long) in.nval;
    }
    
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        
        for (int i = 1; i < N; i++) {
            sum[i] = (long)i * (i + 1) / 2 + sum[i - 1];
        }
        
        int t = nextInt();
        while (t-- != 0) {
            long l = nextLong();
            long r = nextLong();
            out.println(figure(l, r));
        }
        out.flush();
    }
    
    public static long figure(long left, long right) {
        long res = 0;
        int ll = 0, rr = 0;
        
        int l = 0, r = 1500000;
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if ((long)mid * (mid + 1) / 2 <= left) l = mid;
            else r = mid - 1;
        }
        ll = l;
        
        int lrem = (int) (left - (long)l * (l + 1) / 2);
        long lsum = (long)lrem * (lrem + 1) / 2;
        long lval = lrem == 0 ? l : lrem;

        l = 0;
        r = 1500000;
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if ((long)mid * (mid + 1) / 2 <= right) l = mid;
            else r = mid - 1;
        }
        rr = l;

        int rrem = (int) (right - (long)l * (l + 1) / 2);
        long rsum = (long)rrem * (rrem + 1) / 2;
        
        res += sum[rr] - sum[ll] - lsum + rsum + lval; 
        return res;
    }

}

G. 和与乘积

在这里插入图片描述
思路：
要求一段区间和和与乘积相等的话， 1 1 1 在里面 是很重要的，所以我们通过一些列的关于1的处理来解决这个问题。

首先我们只存储非 1 1 1 的数，统计每一个非 1 1 1 的数前连续的1的个数，以及前缀和。

num[i] 表示第i个非1的数
onecnt[i] 第i个非1的数前连续的1的个数
s[i] 包含第i个非1元素的前缀和

进行处理后，上述三个数组的有效长度都是 n − 1 n - 1 n−1，随后求出所有数字的和。然后从第一个非 1 1 1 的数开始枚举，计算当前数字和它后面非 1 1 1 的数的乘积，在计算的过程中，每乘一个数都要判断是否可以构成一组解：

如果说当前的乘积已经大于所有数的和，那一定找不到对应的一组累加和，直接退出即可。

对于乘积小于所有数的和的情况，首先计算出乘积与和的差值 d d d，如果 d = 0 d=0 d=0，则构成一组解，如果说乘积大于差值 ，并且差值小于等于当前区间左右两边相邻的连续的 1 1 1 的和，那此时通过加上左右两边的1也可以构成解。

最后的解就是原序列的长度+符合上述分析的解的个数。

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class Main {
	
	static final int N = 200010;
	static long[] s = new long[N];
	static int[] num = new int[N], onecnt = new int[N];
	static int n = 1, k;
	
	static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Reader reader = new Reader(System.in);
		k = reader.nextInt();
		for (int i = 1; i <= k; i++) {
			int tmp = reader.nextInt();
			if (tmp == 1) {
				s[n]++;
				onecnt[n]++;
			} else {
				s[n] += s[n - 1] + tmp;
				num[n] = tmp;
				n++;
			}
		}
		
		// 最后一个非1的数后面可能还有一串1
		long res = s[n - 1] + onecnt[n];
		long ans = k;
		
		for (int i = 1; i < n; i++) {
			long p = num[i];
			for (int j = i + 1; j < n; j++) {
				p *= num[j];
				if (p > res) break;
				/**
				 *  s[j]为包含第j个非1元素的前缀和
				 *  s[i - 1]为包含第i - 1个非1元素的前缀和
				 *  第i个非1元素前1的个数为onecnt[i]
				 *  则从第i个非1元素和第j个非1元素的和为s[j] - s[i - 1] - onecnt[i]
				 */
				long d = p - s[j] + s[i - 1] + onecnt[i];
				if (d == 0) ans++;
				else if (onecnt[i] + onecnt[j + 1] >= d && d > 0) {
					long left = Math.min(d, onecnt[i]);
					long right = Math.min(d, onecnt[j + 1]);
					ans += left + right - d + 1;
				}
			}
		}
		
		out.println(ans);
		out.flush();
	}
	
	static class Reader {//自定义快读 Read

	    public BufferedReader reader;
	    public StringTokenizer tokenizer;

	    public Reader(InputStream stream) {
	        reader = new BufferedReader(new InputStreamReader(stream), 32768);
	        tokenizer = null;
	    }

	    public String next() {
	        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
	            try {
	                tokenizer = new StringTokenizer(reader.readLine());
	            } catch (IOException e) {
	                throw new RuntimeException(e);
	            }
	        }
	        return tokenizer.nextToken();
	    }

	    public String nextLine() {
	        String str = null;
	        try {
	            str = reader.readLine();
	        } catch (IOException e) {
	            // TODO 自动生成的 catch 块
	            e.printStackTrace();
	        }
	        return str;
	    }

	    public int nextInt() {
	        return Integer.parseInt(next());
	    }

	    public long nextLong() {
	        return Long.parseLong(next());
	    }

	    public Double nextDouble() {
	        return Double.parseDouble(next());
	    }

	    public BigInteger nextBigInteger() {
	        return new BigInteger(next());
	    }
	}
}

H. 巧克力

在这里插入图片描述
思路：

贪心问题的难点就在于如何选择贪心策略，如果按照正常思路，从第一天开始就选择能吃的巧克力，前面几天选择的范围比较大，到了后面几天就相对比较难选了，而且前面的选择会直接影响最后是否会有解以及解的大小，但是前面在选的时候根本无法对其造成的影响进行估计，举个例子：如果从前面开始选，一开始会面临很多种选择，通常会选择最优策略，也就是说保质期能满足当前这一天，并且价格最便宜，但如果存在这样一种巧克力，保质期最长，价格也是最低的，在一开始就把它给用了，到了后面就不能用了，也就是说它原本可以在很多天之后吃就行，现在却在前几天就吃了，吃的时候保质期还有很长的一段事件，到了后面可供选择的巧克力保质期就会越来越短，很可能会出现得不到一个可行方案的情况，对于这种情况，其实把前后选择的巧克力对调一下就能解决，把前面选的保质期长，价格低的巧克力放在后面吃，把后面价格高，保质期短的放在前面吃，通过这样一通分析，我们可以惊奇地发现，正着来不行，我们从后面来貌似就比较合理，这也就引申出了我们的正确的策略：

将所有种类的巧克力按保质期从长到短排序，然后我们从后面几天开始选择吃哪块巧克力，对于第 i i i 天，将所有保质期满足能在第 i i i 天吃的巧克力都找出来，然后对它们按价格从小到大排序，选择价格最低的在第 i i i 天吃，并记录一下这种巧克力已经用掉了几块，如果全部都用掉了，那就不能再用了，这里用到了优先队列来动态维护当天能吃的各种巧克力，当前巧克力吃完就弹出。

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;
import java.util.PriorityQueue;

public class Main {

	static final int N = 100010;
	static int[] cnt = new int[N];
	static Node[] chos = new Node[N];
	static int n, x;

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	static StreamTokenizer in = new StreamTokenizer(br);

	static class Node implements Comparable<Node> {
		int a, b, c;

		public Node(int a, int b, int c) {
			this.a = a;
			this.b = b;
			this.c = c;
		}

		@Override
		public int compareTo(Node o) {
			// TODO Auto-generated method stub
			return o.b - this.b;
		}
	}

	public static int nextInt() throws IOException {
		in.nextToken();
		return (int) in.nval;
	}

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		x = nextInt();
		n = nextInt();

		for (int i = 1; i <= n; i++) {
			int a = nextInt();
			int b = nextInt();
			int c = nextInt();
			chos[i] = new Node(a, b, c);
		}

		Arrays.sort(chos, 1, n + 1);
		
		PriorityQueue<Node> heap = new PriorityQueue<Node>((o1, o2) -> {
			return o1.a - o2.a;
		});
		
		int t = 1;
		long cost = 0;
		boolean flag = true;
		
		for (int i = x; i >= 1; i--) {
			
			while(t <= n && chos[t].b >= i) {
				heap.add(chos[t]);
				t++;
			}
			if (heap.isEmpty()) {
				flag = false;
				break;
			}
			
			Node peek = heap.peek();
			peek.c--;
			cost += peek.a;
			if (peek.c == 0) heap.poll();
		}
		
		if (!flag) cost = -1;
		out.println(cost);
		out.flush();
	}

}
理想-
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第十三届蓝桥杯省赛JavaB组题目
04-09
第十三届蓝桥杯省赛JavaB组题目
2023年第十四届蓝桥杯JavaB组省赛真题及解析
Narnat的博客
05-14 2万+
本次比赛我只能说真是技不如人，本以为精通暴力算法就能狠狠拿下蓝桥杯的我，真的是被狠狠军训了😭。虽然最后也是拿了二等安慰奖，但是内心根本没有多开心，因为自己这几个月学的算法，几乎没有在本次比赛发挥作用，而且一直处于被题目吊打的局面。但这不能说明刷题没用，只能说我的水平还有待提高。重心态，重思维。想想也是如果单纯以算法衡量能否在蓝桥杯取得好成绩是不妥当的。毕竟大一，大二乃至大三都可以参加，单纯以刷题就能取得好成绩的话，对大一刚接触编程的新生来说太不利了，所以侧重思维就相对来说更公平。
蓝桥杯JavaB组真题解析A~E
m0_57248981的博客
03-09 1257
蓝桥杯JavaB组解析
第十二届蓝桥杯JavaB组省赛真题 - 卡片
最新发布
qq_61504864的博客
03-27 181
发现如果有 k 种卡片，那么对应的最大人数是 k * ( k + 1 ) / 2，然后比较 n 和 sum 的大小即可。
第十三届蓝桥杯省赛 JAVA B组（真题解析+个人体会）（已更新完G题）
奶味蓝呀的博客
05-01 2万+
试题 A: 星期计算【填空题】 题目： 答案：7 解析： 这题可以直接用double来做，考的时候我还在想会不会爆精度，后来发现答案也是对的。 此题直接对7求余即可。 public class Main { public static void main(String[] args) { double res = Math.pow(20, 22); res %= 7; System.out.println(res + 6);
2023第十四届蓝桥杯Java B组个人题解
小宇的修炼之路
04-08 1万+
本文是2023年第十四届蓝桥杯Java B组个人题解，有详细的思路分析和Java代码实现，期待和大家一起交流！
蓝桥杯真题及答案JavaB组（第七届~第十一届）
jizaichun的博客
05-01 6059
花点时间整理了近几年的蓝桥杯真题，友友们加油呀！
2020年第十一届蓝桥杯大赛国赛JavaB组题目.rar
11-14
2020年第十一届蓝桥杯大赛国赛Java大学B组题目 试题 A: 美丽的2 试题 B: 扩散 试题 C: 阶乘约数 试题 D: 本质上升序列 试题 E: 玩具蛇 试题 F: 蓝肽子序列 试题 G: 皮亚诺曲线距离 试题 H: 画廊 试题 I: 补给 试题 J...
2018年第九届蓝桥杯JAVAB组题目
04-02
2018年4月1日第九届蓝桥杯JAVA组B组题目！2018年4月1日第九届蓝桥杯JAVA组B组题目！
2020 第十一届蓝桥杯Java国赛B组
11-14
蓝桥杯全国软件和信息技术专业人才大赛由工业和信息化部人才交流中心主办,包括北大、清华等在内的全国31个省市自治区1200多所院校参加,每年参赛人数超过30000人。
第14届蓝桥杯省赛、国赛(B).pdf
06-07
第14届蓝桥杯省赛、国赛(B).pdf
2022年第十三届蓝桥杯比赛Java B组 【全部真题答案解析-第一部分】
kndjg的博客
11-10 3万+
最近回顾了Java B组的试题，深有感触：脑子长时间不用会锈住，很可怕。 兄弟们，都给我从被窝里爬起来，赶紧开始卷！！！
【22年蓝桥杯】十三届蓝桥杯真题JavaB组解析+代码（带你复习知识点）（一）
Jing_Hua
03-25 3192
直接取余的话可以使用java自带的Math.pow(数，次方),或者使用BigInteger（BigInteger和int的区别就是前者范围没有限制，所以可以直接使用）。实现代码：方法一：使用BigInteger解方法二：直接使用Math.pow()
2022年第十三届蓝桥杯省赛真题及部分答案解析(Java B组)
热门推荐
MysticalDream的博客
04-09 5万+
2022年第十三届蓝桥杯省赛javaB组真题及解析 试题 B: 山 【问题描述】 这天小明正在学数数。他突然发现有些正整数的形状像一座“山”，比如 123565321 、 145541 ，它们左右对称（回文）且数位上的数字先单调不减，后单调不增。 小明数了很久也没有数完，他想让你告诉他在区间[2022,2022222022]中有多少个数的形状像一座“山”。这是一道结果填空的题，你只需要算出结果后提交即可。本题的结
2022第十三届蓝桥杯国赛真题javaB组
qq_33891264的博客
06-19 6423
2022年第十三届蓝桥杯大赛软件赛决赛，Java 大学B 组真题个人题解。
第十四届蓝桥杯省赛真题解析 Java （B组），代码经过测试平台验证，均正确
weixin_73936404的博客
06-16 6817
第十四届蓝桥杯省赛 Java （B组）Java实现，思路详解和算法实现
第十届蓝桥杯Java b组省赛真题解析（附有详细代码，个人题解）
m0_58941767的博客
03-27 2301
为了大家可以更清楚地看到题目，我特意去找了当时的比赛文档，希望大家可以有更好的体验。 试题A：组队 组队这一题是签到题目，很简单这里不在赘述。 答案：490（填空题，直接写答案即可） 试题B：不同字串 代码如下： import java.util.*; /* 第十届第二题：不同字串 */ public class 不同字串{ public static void main(String[] args) { Scanner s...
蓝桥杯2021年第十二届Java/B组真题部分题解
qq_64431576的博客
09-30 1363
已知大写字母 A 的 ASCII 码为 65，请问大写字母 L 的 ASCII 码是多少？第一题一般都是签到题，就算很简单也要细心，一定不能出错，就算能看出答案，也建议还是用程序计算，毕竟人是容易出错的。
2023年第十四届蓝桥杯JavaB组省赛真题（题目+全部完整题解）
冷兮雪的博客
04-08 2万+
A、阶乘求和【问题描述】令S= 1!+ 2!+ 3!...，求S的末尾9位数字。提示：答案首位不为0。
蓝桥杯javab组真题合集
12-14
很高兴为您解答。以下是蓝桥杯Java B组历年真题的合集： 引用:2022年第十三届蓝桥杯Java B组(第一部分 A~F题)。 引用:以下是A~F前6道题的真题解析，如果对您有帮助，欢迎点赞、收藏、分享！ 引用:2021年第十二届蓝桥杯Java B组真题及答案解析。 引用:2020年第十一届蓝桥杯Java B组真题及答案解析。 引用:2019年第十届蓝桥杯Java B组真题及答案解析。 引用:2018年第九届蓝桥杯Java B组真题及答案解析。 引用:2017年第八届蓝桥杯Java B组真题及答案解析。 引用:2016年第七届蓝桥杯Java B组真题及答案解析。 引用:2015年第六届蓝桥杯Java B组真题及答案解析。 引用[10]:2014年第五届蓝桥杯Java B组真题及答案解析。 引用[11]:2013年第四届蓝桥杯Java B组真题及答案解析。 引用[12]:2012年第三届蓝桥杯Java B组真题及答案解析。 引用[13]:2011年第二届蓝桥杯Java B组真题及答案解析。 引用[14]:2010年第一届蓝桥杯Java B组真题及答案解析。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值