devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【蓝桥杯】第十五届蓝桥杯大赛软件赛省赛（Java研究生组）个人解题思路及代码分享_现在给出一局小蓝的游戏记录文件,log.txt 中记录了n 条记录,每条记录有三个字段,

作者：我家小花儿 | 2024-05-14 04:43:09

赞

踩

现在给出一局小蓝的游戏记录文件,log.txt 中记录了n 条记录,每条记录有三个字段,

文章目录

试题A：劲舞团

【问题描述】
小蓝最近迷上了一款名为“劲舞团”的游戏，具体来说，只要按照游戏中给出的键位提示依次按出对应的键位，游戏人物便可以跟随节奏跳舞。对于连续的K 次正确敲击，如果任意连续的两次敲击间间隔时间都小于等于1s，那么我们称这是一次K 连击。现在给出一局小蓝的游戏记录文件，log.txt 中记录了N 条记录，每条记录有三个字段，依次为正确的敲击字符、小蓝打出的字符、打出字符的时间对应的毫秒时间戳。现在请你计算下最长的K 连击是多少，你只需要输出K 的值。

【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

【解题思路】
整体不难，但是需要注意一些细节：

  1. 连击中断分两种情况。第一种情况是，间隔时间太长，该情况下只需要下次敲击正确并且在间隔时间内，就直接算是2连。第二种情况是敲错，这种情况下，即使下次敲击正确并且在间隔时间内，也只是“1连”。

【Java代码】

import java.util.*;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.lang.*;

public class Problem1 {
	public static void main(String[] args) throws Exception {
		BufferedReader bufferedReader = new BufferedReader(new FileReader("D:\\WSKH\\MyData\\Master\\比赛或项目\\研1\\第十五届蓝桥杯"
				+ "\\LQSP2024_JG\\LQSP2024_JG\\log.txt"));
		String lineString = null;
		int maxRes = 0;
		int tempRes = 0;
		long lastTime = 0;
		while((lineString = bufferedReader.readLine()) != null) {
			String[] splitStrings = lineString.split(" ");
			if(splitStrings[0].equals(splitStrings[1])) {
				// 正确敲击
				long curTime = Long.parseLong(splitStrings[2]);
				if(curTime - lastTime <= 1000) {
					// 正确敲击且在1秒内
					tempRes++;
					if(tempRes >= 2) {
						maxRes = Math.max(maxRes, tempRes);
					}
				}else {
					// 正确敲击却在1秒外，当前敲击就是第一次，下一次正确敲击就可以触发2连
					tempRes = 1;
				}
				lastTime = curTime;
			}else {
				// 不正确敲击，就直接归零
				tempRes = 0;
				lastTime = 0;
			}
		}
		bufferedReader.close();
		System.out.println(maxRes); // 9
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

试题B：召唤数字精灵

【问题描述】
数学家们发现了两种用于召唤强大的数学精灵的仪式，这两种仪式分别被称为累加法仪式A(n) 和累乘法仪式B(n)。

累加法仪式A(n) 是将从1 到n 的所有数字进行累加求和，即：A(n) =1 + 2 + …+ n 。
累乘法仪式B(n) 则是将从1 到n 的所有数字进行累乘求积，即：B(n) =1 * 2 * … * n 。

据说，当某个数字i 满足A(i) - B(i) 能被100 整除时，数学精灵就会被召唤出来。

现在，请你寻找在1 到 2024041331404202 之间有多少个数字 i，能够成功召唤出强大的数学精灵。

【答案提交】
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

【解题思路】
这题数字 2024041331404202 太大了，程序求解应该是求不出。所以，这题应该是数学题或找规律题。我从小的数开始调试，于是发现了如下规律：

传入 2024041331404202，答案是 40480826628084
传入 202404133140420，答案是 4048082662808
传入 20240413314042，答案是 404808266281
传入 2024041331404，答案是 40480826628
传入 202404133140，答案是 4048082663
传入 20240413314，答案是 404808266
传入 2024041331，答案是 40480827
传入 202404133，答案是 4048083
传入 20240413，答案是 404808
传入 2024041，答案是 40481
传入 202404，答案是 4048
传入 20240，答案是 405
传入 2024，答案是 40
传入 202，答案是 4

写到这大家应该大致都感受出一些规律了。下面直接看代码吧。

【Java代码】

import java.util.*;
import java.lang.*;

public class Problem2 {
	public static long solve(long num) {
		num *= 2;
		num /= 10;
		if(num % 10 >= 5) {
			num += 10;
		}
		return num / 10;
	}
	
	public static void main(String[] args) {
		// 2024041331404202L
		System.out.println(solve(2024041331404202L)); // 40480826628084
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

试题C：封闭图形的个数

【问题描述】
在蓝桥王国，数字的大小不仅仅取决于它们的数值大小，还取决于它们所形成的“封闭图形”的个数。

封闭图形是指数字中完全封闭的空间，例如数字1、2、3、5、7 都没有形成封闭图形，而数字0、4、6、9 分别形成了1 个封闭图形，数字8 则形成了2个封闭图形。值得注意的是，封闭图形的个数是可以累加的。例如，对于数字68，由于6 形成了1 个封闭图形，而8 形成了2 个，所以68 形成的封闭图形的个数总共为3。

在比较两个数的大小时，如果它们的封闭图形个数不同，那么封闭图形个数较多的数更大。例如，数字41 和数字18，它们对应的封闭图形的个数分别为1 和2，因此数字41 小于数组18。如果两个数的封闭图形个数相同，那么数值较大的数更大。例如，数字14 和数字41，它们的封闭图形的个数都是1，但14 < 41，所以数字14 小于数字41。如果两个数字的封闭图形个数和数值都相同，那么这两个数字被认为是相等的。

小蓝对蓝桥王国的数字大小规则十分感兴趣。现在，他将给定你n 个数a1，a2，…，an，请你按照蓝桥王国的数字大小规则，将这 n 个数从小到大排序，并输出排序后结果。

【输入格式】
输入的第一行包含一个整数n ，表示给定的数字个数。

第二行包含n 个整数a1，a2，…，an ，相邻整数之间使用一个空格分隔，表示待排序的数字。

【输出格式】
输出一行包含n 个整数，相邻整数之间使用一个空格分隔，表示按照蓝桥王国的数字大小规则从小到大排序后的结果。

在这里插入图片描述

【解题思路】
根据题目给的规则，写一个Comparator，然后传给Java内置的排序算法进行排序即可。

【Java代码】

import java.util.*;
import java.lang.*;

public class Problem3 {
	
	public static int f(int n, int[] data) {
		int res = 0;
		while(n > 0) {
			res += data[n % 10];
			n /= 10;
		}
		return res;
	}
	
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		Integer[] arr = new Integer[scanner.nextInt()];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = scanner.nextInt();
		}
		int[] data = new int[] {1,0,0,0,1,0,1,0,2,1};
		Arrays.sort(arr,new Comparator<Integer>() {
			public int compare(Integer o1, Integer o2) {
				int a = f(o1, data);
				int b = f(o2, data);
				if(a == b) {
					return Integer.compare(o1, o2);
				}
				return Integer.compare(a, b);
			}
		});
		for (int i = 0; i < arr.length; i++) {
			if(i == arr.length - 1) {
				System.out.print(arr[i]);
			}else {
				System.out.print(arr[i]+" ");
			}
		}
		scanner.close();
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

试题D：商品库存管理

【问题描述】
在库存管理系统中，跟踪和调节商品库存量是关键任务之一。小蓝经营的仓库中存有多种商品，这些商品根据类别和规格被有序地分类并编号，编号范围从1 至n。初始时，每种商品的库存量均为0。

为了高效地监控和调整库存量，小蓝的管理团队设计了m 个操作，每个操作涉及到一个特定的商品区间，即一段连续的商品编号范围（例如区间[L，R]）。执行这些操作时，区间内每种商品的库存量都将增加1。然而，在某些情况下，管理团队可能会决定不执行某些操作，使得这些操作涉及的商品区间内的库存量不会发生改变，维持原有的状态。

现在，管理团队需要一个评估机制，来确定如果某个操作未被执行，那么最终会有多少种商品的库存量为0。对此，请你为管理团队计算出，对于每个操作，如果不执行该操作而执行其它操作，库存量为0 的商品的种类数。

【输入格式】
输入的第一行包含两个整数n 和m，分别表示商品的种类数和操作的个数。

接下来的m 行，每行包含两个整数L 和R，表示一个操作涉及的商品区间。

【输出格式】
输出m 行，每行一个整数，第i 行的整数表示如果不执行第i 个操作，则最终库存量为0 的商品种类数。

【样例输入】
5 3
1 2
2 4
3 5

【样例输出】
1
0
1

在这里插入图片描述

【解题思路】
我是直接暴力求解的

【Java代码】

import java.util.*;
import java.lang.*;

public class Problem4 {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);

		int n = scanner.nextInt();
		int m = scanner.nextInt();

		int[][] data = new int[m][2];

		for (int i = 0; i < data.length; i++) {
			data[i][0] = scanner.nextInt() - 1;
			data[i][1] = scanner.nextInt() - 1;
		}

		// 暴力求解
		int[] res = new int[n];
		for (int i = 0; i < data.length; i++) {
			for (int j = data[i][0]; j <= data[i][1]; j++) {
				res[j]++;
			}
		}
		
		for (int i = 0; i < data.length; i++) {
			int ans = 0;
			for (int j = data[i][0]; j <= data[i][1]; j++) {
				if(res[j] <= 1) {
					ans++;
				}
			}
			System.out.println(ans);
		}
		
		scanner.close();
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

试题E：砍柴

【问题描述】
小蓝和小乔正在森林里砍柴，它们有T 根长度分别为n1，n2，…， nT 的木头。对于每个初始长度为n 的木头，小蓝和小乔准备进行交替砍柴，小蓝先出手。每次砍柴时，若当前木头长度为x ，需要砍下一截长度为p 的木头，然后换另一个人继续砍，其中2 ≤ p ≤ x 且p 必须为质数。当轮到某一方时x = 1 或x = 0 ，它就没法继续砍柴，它就输了。它们会使用最优策略进行砍柴。请对每根木头判断是小蓝赢还是小乔赢，如果小蓝赢请输出1 （数字1），如果小乔赢请输出0 （数字0）。

【输入格式】
输入的第一行包含一个正整数T，
接下来T 行，每行包含一个正整数，其中第i 的整数为ni 。

【输出格式】
输出T 行，每行包含一个整数，依次表示对于每一根木头的答案。

【样例输入】
3
1
2
6

【样例输出】
0
1
1

在这里插入图片描述

【解题思路】
双表的动态规划

【Java代码】

import java.util.*;
import java.lang.*;

public class Problem5 {
	
	public static boolean isZhiNumber(int num) {
		if(isZhiDp[num] != null) {
			return isZhiDp[num];
		}
		for (int i = 2; i < num; i++) {
			if(num % i == 0) {
				isZhiDp[num] = false;
				return false;
			}
		}
		isZhiDp[num] = true;
		return true;
	}
	
	public static List<Integer> getAllZhiNumber(int n) {
		List<Integer> list = new LinkedList<>();
		for (int i = 2; i <= n; i++) {
			if(isZhiNumber(i)) {
				list.add(i);
			}
		}
		return list;
	}
	
	public static boolean solve(int n,boolean isLan) {
		if(isLan) {
			if(dp1[n] != null) {
				return dp1[n];
			}
		}else {
			if(dp2[n] != null) {
				return dp2[n];
			}
		}
		boolean b = false;
		if(n > 1) {
			// 遍历所有可以切的数
			if(lists[n] == null) {
				lists[n] = getAllZhiNumber(n);
			}
			for(Integer qieNumInteger : lists[n]) {
				boolean tempB = !solve(n-qieNumInteger, !isLan);
				if(tempB) {
					b = true;
					break;
				}
			}
		}
		if(isLan) {
			dp1[n] = b;
		}else {
			dp2[n] = b;
		}
		return b;
	}
	
	static List<Integer>[] lists;
	static Boolean[] isZhiDp;
	static Boolean[] dp1;
	static Boolean[] dp2;
	
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		int t = scanner.nextInt();
		int[] ns = new int[t];
		int maxN = 0;
		for (int i = 0; i < ns.length; i++) {
			ns[i] = scanner.nextInt();
			maxN = Math.max(maxN, ns[i]);
		}
		
		lists = new List[maxN+1];
		dp1 = new Boolean[maxN + 1];
		dp2 = new Boolean[maxN + 1];
		isZhiDp = new Boolean[maxN + 1];
		
		// 初始化 isZhiDp
		isZhiDp[1] = true;
		isZhiDp[2] = true;
		for (int i = 2; i <= maxN; i++) {
			for (int j = i + 1; j <= maxN; i++) {
				int y = i * j;
				if (y <= maxN && y >= 0) {
					isZhiDp[y] = false;
				}else {
					break;
				}
			}
		}
		
		for (int i = 0; i < ns.length; i++) {
			dp1[ns[i]] = solve(ns[i], true);
		}
		
		for (int i = 0; i < ns.length; i++) {
			System.out.println(dp1[ns[i]] ? 1 : 0);
		}
		
		scanner.close();
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107

试题F：回文字符串

【问题描述】
小蓝最近迷上了回文字符串，他有一个只包含小写字母的字符串S ，小蓝可以往字符串S 的开头处加入任意数目个指定字符：l、q、b （ASCII 码分别为：108、113、98）。小蓝想要知道他是否能通过这种方式把字符串S 转化为一个回文字符串。

【输入格式】
输入的第一行包含一个整数T，表示每次输入包含T 组数据。接下来依次描述T 组数据。
每组数据一行包含一个字符串S 。

【输出格式】
输出T 行，每行包含一个字符串，依次表示每组数据的答案。如果可以将S 转化为一个回文字符串输出Yes，否则输出No 。

【样例输入】
3
gmgqlq
pdlbll
aaa

【样例输出】
Yes
No
Yes

在这里插入图片描述

【解题思路】
暴力求解

【Java代码】

import java.util.*;
import java.lang.*;

public class Problem6 {

	public static boolean isHuiWen(String str, boolean b) {
		int n = str.length();
		for (int i = 0; i < n; i++) {
			if (str.charAt(i) != str.charAt(n - i - 1)) {
				if (b) {
					return isHuiWen2(str);
				} else {
					return false;
				}
			}
		}
		return true;
	}

	public static boolean isHuiWen2(String str) {
		int n = str.length();
		String tempString = "";
		for (int i = 0; i < n; i++) {
			char c = str.charAt(n - i - 1);
			if (c == 'l' || c == 'q' || c == 'b') {
				tempString += c;
				if (isHuiWen(tempString + str, false)) {
					return true;
				}
			} else {
				break;
			}
		}
		return false;
	}

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();

		boolean[] res = new boolean[n];

		for (int i = 0; i < n; i++) {

			String str = scanner.next();

			res[i] = isHuiWen(str, true);

		}

		for (int i = 0; i < res.length; i++) {
			System.out.println(res[i] ? "Yes" : "No");
		}

		scanner.close();
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57

试题G：最大异或节点

【问题描述】
小蓝有一棵树，树中包含N 个结点，编号为0; 1; 2; … ; N - 1 ，其中每个结点上都有一个整数Xi 。他可以从树中任意选择两个不直接相连的结点a 、b并获得分数Xa ^ Xb ，其中 ^ 表示按位异或操作。请问小蓝可以获得的最大分数是多少？

【输入格式】
输入的第一行包含一个整数N ，表示有N 个结点。
第二行包含N 个整数X1; X2; … ; XN ，相邻整数之间使用一个空格分隔。
第三行包含N 个整数F1; F2; … ; FN ，相邻整数之间使用一个空格分隔，
其中第i 个整数表示i 的父结点编号，Fi = -1 表示结点 i 没有父结点。

【输出格式】
输出一行包含一个整数表示答案。

【样例输入】
51
0 5 3 4
-1 0 1 0 1

【样例输出】
7

【样例说明】
选择编号为3 和4 的结点，x3 = 3 ，x4 = 4 ，他们的值异或后的结果为3 ^ 4 = 7 。

在这里插入图片描述

【解题思路】
暴力求解

【Java代码】

import java.util.*;
import java.lang.*;

public class Problem7 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		int n = scanner.nextInt();
		
		int[] data = new int[n];
		for (int i = 0; i < data.length; i++) {
			data[i] = scanner.nextInt();
		}
		
		int[] fathers = new int[n];
		for (int i = 0; i < fathers.length; i++) {
			fathers[i] = scanner.nextInt();
		}
		
		// 暴力求解
		int res = -1;
		for (int i = 0; i < n; i++) {
			for (int j = i + 1; j < n; j++) {
				if(fathers[i] != j && fathers[j] != i) {
					res = Math.max(res, i ^ j);
				}
			}
		}
		
		System.out.println(res);
		
		scanner.close();
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

试题H：植物生命力

【问题描述】
小蓝是一位资深的植物学家，他专注于研究植物的相互关系和生命力。在他所照料的森林中，每个品种的植物都拥有独特的生命力，彼此之间互不相同。

植物的生命力会影响其下级品种的生长。具体地，如果下级品种的生命力数值无法被上级品种的生命力数值整除，或者下级品种的生命力数值大于上级品种的生命力数值时，它们便会受到压制，无法茁壮成长。

为了深入研究和定量分析这一现象，小蓝构建了一种模型。他将森林中的植物品种关系抽象成了一棵包含n 个结点的树，结点的编号从1 到n，代表不同的植物品种。其中，树的根结点编号为s，结点i（1 < i < n）的生命力表示为ai。

现在，小蓝想要对于每个结点i，统计其子树（以i 为根的子树）中同时满足以下两个条件的子结点的数量：

  1. 子结点的生命力小于结点i 的生命力ai。
  2. 子结点的生命力无法被结点i 的生命力ai 整除。

请你帮助小蓝计算出所有子树中满足条件的结点个数的总和。

【输入格式】
输入的第一行包含两个整数n 和s，分别表示结点的数量和根结点的编号。

第二行包含n 个互不相同的整数a1; a2; … ; an，相邻整数之间使用一个空格分隔，其中ai 表示编号为i 的结点的生命力。

接下来的n - 1 行，每行包含两个整数u 和v ，用一个空格分隔，表示编号为u 和v 的结点之间存在一条边。

【输出格式】
输出一行包含一个整数，表示所有子树中满足条件的结点个数的总和。

【样例输入】
6 1
6 5 3 2 4 1
1 2
1 3
2 4
2 5
3 6

【样例输出】
4

在这里插入图片描述

【解题思路】
暴力求解

【Java代码】

import java.util.*;
import java.lang.*;

public class Problem8 {
	
	static class Node{
		int num;
		LinkedList<Node> nodeList = new LinkedList<>();
		// 构造函数
		public Node(int num) {
			this.num = num;
		}
	}
	
	public static int dfs(int rootNodeNum, Node node) {
		int tempRes = 0;
		for(Node childNode : node.nodeList) {
			if(childNode.num < rootNodeNum && rootNodeNum % childNode.num != 0) {
				tempRes ++;
			}
			tempRes += dfs(rootNodeNum, childNode);
		}
		return tempRes;
	}
	
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		int n = scanner.nextInt();
		int rootIndex = scanner.nextInt()-1;
		
		Node[] nodes = new Node[n];
		for (int i = 0; i < nodes.length; i++) {
			nodes[i] = new Node(scanner.nextInt());
		}
		
		for (int i = 0; i < nodes.length - 1; i++) {
			nodes[scanner.nextInt()-1].nodeList.add(nodes[scanner.nextInt()-1]);
		}
		
		
		int res = 0;
		for (int i = 0; i < nodes.length; i++) {
			res += dfs(nodes[i].num, nodes[i]);
		}
		
		System.out.println(res);
		
		scanner.close();
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/567351
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号