2017年题目列表:
- 外星日历
- 兴趣小组
- 纸牌三角形
- 承压计算
- 杨辉三角
- 最大公共子串
- Excel地址
- 拉马车
- 青蛙跳杯子(未做)
- 图形排版 (未做)
一、外星日历
Answer: G
题目描述:
某星系深处发现了文明遗迹。
他们的计数也是用十进制。
他们的文明也有日历。日历只有天数,没有年、月的概念。
有趣的是,他们也使用了类似“星期”的概念,
只不过他们的一个星期包含了9天,
为了方便,这里分别记为: A,B,C…H,I
从一些资料上看到,
他们的23日是星期E
他们的190日是星期A
他们的343251日是星期I
令人兴奋的是,他们居然也预见了“世界末日”的那天,
当然是一个很大很大的数字
651764141421415346185
请你计算一下,这遥远的一天是该文明的星期几?
你需要提交的是一个大写字母,表示该文明的星期几,
不要填写任何多余的内容。
思路:
尽管题目给出的数字是非常大的,但是在Java中也存在对应得大数类计算的一些方法,比如BigInteger,还有就是可以使用更大范围的double存储,然后进求出他们的余数就可以了
代码块:
解法一:
import java.math.*;
public class _1外星日历 {
public static void main(String[] args){
BigInteger a = new BigInteger("651764141421415346185");
BigInteger mod = a.mod(BigInteger.valueOf(9));
System.out.println(mod);//mod = 7(G)
}
}
解法二:
double d = 651764141421415346185f;
while(d > 9){
d%=9;
}
System.out.println(d);
二、兴趣小组
Answer: 20
为丰富同学们的业余文化生活,某高校学生会创办了3个兴趣小组
(以下称A组,B组,C组)。
每个小组的学生名单分别在【A.txt】,【B.txt】和【C.txt】中。
每个文件中存储的是学生的学号。
由于工作需要,我们现在想知道:
既参加了A组,又参加了B组,但是没有参加C组的同学一共有多少人?
请你统计该数字并通过浏览器提交答案。
注意:答案是一个整数,不要提交任何多余的内容。
笨笨有话说:
哇塞!数字好多啊!一眼望过去就能发现相同的,好像没什么指望。
不过,可以排序啊,要是每个文件都是有序的,那就好多了。
歪歪有话说:
排什么序啊,这么几行数字对计算机不是太轻松了吗?
我看着需求怎么和中学学过的集合很像啊…
思路:把文件A、B、C中的学号都存储在数组中,在把每个数组中以0开头的数字清掉最前面的零,否者会报错,然后定义一个范围,分别判断既在A组又在B组中的学号有哪些,然后判断不在C组的有哪些,最后相减即可得到答案。(我这个方法效率有点低,所以仅供参考)
代码块 :
public class _2兴趣小组 {
public static void main(String[] args){
long start = System.currentTimeMillis();
int[]a = {12894792, 92774113, 59529208, 22962224, 2991600, 83340521, 87365045,
40818286, 16400628, 39475245, 55933381, 76940287, 61366748, 95631228,
17102313, 50682833, 61562613, 87002524, 83062019, 51743442, 61977890,
32010762, 69680621, 87179571, 81761697, 32364296, 7833271, 36198035,
26588918, 84046668, 43059468, 73191775, 56794101, 454780, 11141030,
10008994, 35072237, 44945158, 53959980, 75758119, 18560273, 35801494,
42102550, 22496415, 3981786, 34593672, 13074905, 7733442, 42374678,
23452507, 98586743, 30771281, 17703080, 52123562, 5898131, 56698981,
90758589, 18238802, 18217979, 4511837, 75682969, 31135682, 55379006,
42224598, 98263070, 40228312, 28924663, 11580163, 25686441, 45944028,
96731602, 53675990, 3854194, 14858183, 16866794, 40677007, 73141512,
32317341, 56641725, 43123040, 15201174, 62389950, 72887083, 76860787,
61046319, 6923746, 17874548, 46028629, 10577743, 48747364, 5328780,
59855415, 60965266, 20592606, 14471207, 70896866, 46938647, 33575820,
53426294, 56093931, 51326542, 94050481, 80114017, 33010503, 72971538,
22407422, 17305672, 78974338, 93209260, 83461794, 41247821, 26118061,
10657376, 42198057, 15338224, 50284714, 32232841, 26716521, 76048344,
23676625, 62897700, 69296551, 59653393, 38704390, 48481614, 69782897,
26850668, 37471053, 88720989, 51010849, 94951571, 60024611, 29808329,
70377786, 13899299, 9683688, 58218284, 46792829, 97221709, 45286643,
48158629, 57367208, 26903401, 76900414, 87927040, 9926730, 1508757,
15101101, 62491840, 43802529};
int[]b = {44894050, 34662733, 44141729, 92774113, 99208727, 91919833, 23727681,
10003409, 55933381, 54443275, 13584702, 96523685, 50682833, 61562613,
62380975, 20311684, 93200452, 23101945, 42192880, 28992561, 18460278,
19186537, 58465301, 01111066, 62680429, 23721241, 20277631, 91708977,
57514737, 3981786, 81541612, 07346443, 93154608, 19709455, 37446968,
17703080, 72378958, 66200696, 30610382, 89586343, 33152171, 67040930,
35696683, 63242065, 99948221, 96233367, 52593493, 98263070, 1418023,
74816705, 89375940, 58405334, 96731602, 84089545, 16866794, 94737626,
1673442, 70548494, 13638168, 8163691, 11106566, 64375392, 40267902,
897705, 56447313, 54532235, 94738425, 66642634, 83219544, 40546096,
66924991, 20592606, 96037590, 73434467, 70896866, 91025618, 57892091,
8487641, 32500082, 84412833, 23311447, 38380409, 79957822, 72971538,
69645784, 91863314, 73099909, 93209260, 83461794, 81378487, 30423273,
22233715, 32232841, 26716521, 03511221, 29196547, 58263562, 56233305,
52547525, 55812835, 87253244, 52484232, 80837360, 94098464, 52028151,
53267501, 66381929, 84381316, 59788467, 9683688, 67082008, 71605255,
80654064, 21434307, 45286643, 76556656, 82465821, 57367208, 79218980,
48460468, 59170479, 46046391, 43043164, 96544490, 83340521, 70837892,
18926791, 40818286, 28936302, 11489524, 51031183, 73860337, 13241219,
9025448, 10718828, 76360986, 26031606, 76558053, 97726139, 46473415,
48406387, 23625539, 86756012, 35164187, 49161302, 78082834, 35072237,
8602486, 29815841, 56562216, 77684187, 81751704, 20160464, 50407962,
27786415, 19893526, 934129, 37759498, 52636463, 25666982, 43262852,
38393436, 2581136, 29323250, 56950657, 5898131, 95286262, 75574581,
54057961, 6703896, 90758589, 57782642, 34492535, 41919697, 6395464,
10993500, 81212949, 34017532, 69569396, 99009936, 57129610, 67401593,
71044018, 62076698, 29533873, 71936325, 86874388, 26545032, 35695544,
30433724, 53127345, 72887083, 25390873, 63711546, 6923746, 27783723,
33199575, 35929698, 16491251, 18276792, 62744775, 92096155, 06336570,
56141974, 73007273, 31416832, 00171057, 64176982, 46938647, 58460388,
69972026, 73724304, 27435484, 51568616, 15531822, 47788699, 11818851,
41594694, 83561325, 43107163, 56965375, 10557343, 26118061, 74650126,
90076467, 10657376, 49901436, 03425162, 61164599, 15797769, 5427896,
14444084, 36795868, 18079449, 59653393, 72942548, 6763077, 33895610,
94892653, 12085268, 65174140, 79567366, 23020126, 74290047, 13498869,
21696323, 27724594, 54941003, 38229841, 7050068};
int[]c = {13404901, 39952424, 47847739, 94939581, 13809950, 70966043, 11161555,
17102313, 47079425, 50682833, 74154313, 61562613, 93200452, 37103342,
18479435, 32502597, 36198035, 54210010, 73191775, 48358178, 85544503,
5996766, 54651623, 52113220, 27465181, 23871783, 22496415, 54107041,
65899605, 56528700, 82671109, 61176034, 42374678, 51612628, 63329997,
56591652, 04552733, 12789324, 89586343, 51935014, 38611966, 43916409,
70996050, 98263070, 1418023, 65345049, 21734275, 76846198, 71506230,
833171, 67128139, 41367555, 64769510, 44010700, 16475199, 93164325,
9386162, 95324041, 80688223, 67629139, 79552617, 76219736, 50368644,
45096021, 54972488, 63779011, 28862942, 73145521, 74078605, 66924991,
12806850, 02171001, 70896866, 73434467, 8487641, 44415025, 32500082,
84412833, 83896188, 52243759, 49191410, 38744339, 48079796, 44937032,
06267501, 81866886, 38575984, 25978688, 78974338, 41247821, 12356966,
64842303, 79127158, 2366944, 68000570, 12426275, 96409230, 705972,
8266503, 83820884, 8831807, 43273308, 23216105, 29196547, 95160161,
05553537, 52182214, 32641346, 91553427, 24436506, 77433749, 1979664,
52028151, 88985343, 1761499, 76203088, 63237368, 23405334, 59788467,
9683688, 67755443, 29946533, 12053603, 437479, 15200030, 45286643,
93537527, 82465821, 57367208, 53899751, 15354933, 97760830, 68933762,
80220545, 1892750, 39868288, 21524323, 69716610, 65083815, 78048499,
3227391, 83340521, 87365045, 71720254, 51031183, 89168555, 8503028,
37086236, 25103057, 87002524, 22808816, 80928090, 90741678, 15993372,
99117082, 49938176, 21755083, 86903426, 87830263, 53959980, 75758119,
59781354, 58679691, 25666982, 56307643, 47180521, 62776522, 78136608,
44882734, 90758589, 8075999, 66303819, 23480347, 11580163, 87080118,
18329165, 92514163, 89404632, 92377859, 3912329, 17499963, 59699979,
79876366, 63894807, 37857001, 86003935, 90087123, 29433345, 80298948,
61531153, 61046319, 37839841, 19421134, 48747364, 35196916, 62484573,
59907079, 36845702, 21631642, 72739317, 26283700, 80114017, 76639390,
29154110, 35159758, 47788699, 11818851, 56520669, 36396767, 36031167,
83817428, 10657376, 90076467, 14676452, 11024560, 16327605, 76048344,
14444084, 95452011, 99612346, 65172562, 84813675, 88618282, 38704390,
27998014, 63859011, 33787505, 60024611, 16229880, 13899299, 35240335,
29173227, 45036451, 66177893, 82658333, 43100730, 44520187, 74290047,
85013538, 9926730, 27724594, 95148523, 20503000, 64390907, 26006953,
98116293, 97457666, 29017396, 4634371, 70791589};
//既参加了A组,又参加了B组,但是没有参加C组的同学一共有多少人?
//System.out.println(a.length+" "+b.length+" "+c.length);//150 250 150
int[]d = new int[30];
int index = 0;
int cnt = 0;
for(int k = 100000; k <= 99999999; k++){
for(int i = 0; i < 150; i++){
if(a[i] == k){
for(int j = 0; j < 250; j++){
if(b[j] == k){
d[index] = k;
cnt++;
index++;
System.out.println(k);
//System.out.println("cnt:"+cnt);
}
}
}
}
}
int ct = 0;
for(int i = 0; i < 250; i++){
for(int j = 0; j < 30; j++){
if(c[i] == d[j]){
ct++;
}
}
}
System.out.println("ct:"+ct);
System.out.println("cnt:"+cnt);
//既在A组又在B组的有30,其中在C组的有10个人,所以答案:20;
System.out.println((System.currentTimeMillis() - start)+"ms");
}
}
三、纸牌三角形
Answer: 144
题目描述:
A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形(A按1计算)。要求每个边的和相等。
下图就是一种排法(如有对齐问题,参看p1.png)。
这样的排法可能会有很多。
如果考虑旋转、镜像后相同的算同一种,一共有多少种不同的排法呢?
请你计算并提交该数字。
注意:需要提交的是一个整数,不要提交任何多余内容。
笨笨有话说:
感觉可以暴力破解哦。
麻烦的是,对每个排法还要算出它的旋转、镜像排法,看看有没有和历史重复。
歪歪有话说:
人家又不让你把所有情况都打印出来,只是要算种类数。
对于每个基本局面,通过旋转、镜像能造出来的新局面数目不是固定的吗?
思路:
这题我用的是暴力破解法,通过暴力破解,求出符合条件的答案,然后在把最终答案除以6。
因为题目也说了旋转、镜像后相同的算同一种,例如:
每种情况可以旋转三次,每次可以左右对称分为两次,故3×2=6,所以就需要把结果除以一个6,用来排除重复的情况拉
代码块:
public class _3纸牌三角形 {
public static void main(String[] args){
int cnt = 0;
for(int a = 1; a <= 9; a++)//1
for(int b = 1; b <= 9; b++)//2
if(a!=b)
for(int c = 1; c <= 9; c++)//3
if(c != a && c!=b)
for(int d = 1; d <= 9; d++)//4
if(d!=a&&d!=b&&d!=c)
for(int e = 1; e <=9; e++)//5
if(e!=a&&e!=b&&e!=c&&e!=d)
for(int f = 1; f <= 9; f++)//6
if(f!=a&&f!=b&&f!=c&&f!=d&&f!=e)
for(int g = 1; g <= 9; g++)//7
if(g!=a&&g!=b&&g!=c&&g!=d&&g!=e&&g!=f)
for(int h = 1; h <= 9; h++)//8
if(h!=a&&h!=b&&h!=c&&h!=d&&h!=e&&h!=f&&h!=g)
for(int i = 1; i <= 9; i++)//9
if(i!=a&&i!=b&&i!=c&&i!=d&&i!=e&&i!=f&&i!=g&&i!=h){
if(a+b+c+d == d+e+f+g && g+h+i+a == d+e+f+g && a+b+c+d == g+h+i+a){
System.out.println(a+" "+b+" "+c+" "+d+" "+e+" "+f+" "+g+" "+h+" "+i);
cnt++;
}
}
System.out.println(cnt/6);
}
}
四、承压计算
Answer: 72,665,192,664
题目描述:
X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。
每块金属原料的外形、尺寸完全一致,但重量不同。
金属材料被严格地堆放成金字塔形。
其中的数字代表金属块的重量(计量单位较大)。
最下一层的X代表30台极高精度的电子秤。
假设每块原料的重量都十分精确地平均落在下方的两个金属块上,
最后,所有的金属块的重量都严格精确地平分落在最底层的电子秤上。
电子秤的计量单位很小,所以显示的数字很大。
工作人员发现,其中读数最小的电子秤的示数为:2086458231
请你推算出:读数最大的电子秤的示数为多少?
注意:需要提交的是一个整数,不要填写任何多余的内容。
笨笨有话说:
不断的除2,加到下面,除2,加到下面,… 不会浮点精度溢出吧?
歪歪有话说:
怕除不开还不好办, 把每个数字扩大一定的倍数不就好了。
思路:
考虑到需要前29层的数字不断地除2,有不想出现整数,那么我们可以考虑把每个数字都乘以2的30次方,这样不管怎么除,最后的结果都是一个整数,解决了整数问题后,我们再把除2后的数字分别加在下面一层对应的两个数字上,最后输出数组中第三十行(下标为29)的数据,可以排序输出,也可以只输出最大和最小值,因为题目给出了最小值,求最大值。
求出来后,再通过求出的最小值和题目给出的最小值的关系推出题目需要的最大值。
代码块:
import java.util.Scanner;
public class _4承压计算 {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
//求出2的30次方
long Fa = 1;
for(int i = 0; i < 30; i++){
Fa*=2;
}
//接收题目中的数据,并将每个数字都乘以一个2的三十次方,保证每次除二后不会有小数产生
long[][]arr = new long[30][30];
for(int i = 0; i < 29; i++){
for(int j = 0; j <= i; j++){
arr[i][j] = sc.nextLong();
arr[i][j] *= Fa;
}
}
//把每层的数字都加上上一层的数字的一半
for(int i = 0; i < 29; i++){
for(int j = 0; j <= i; j++){
long half = arr[i][j]/2;
arr[i+1][j] += half;
arr[i+1][j+1] += half;
}
}
//求出最后一层的最大值和最小值
long max = arr[29][0];
long min = arr[29][0];
for(int i = 0; i < 30; i++){
if(arr[29][i] > max){
max = arr[29][i];
}
if(arr[29][i] < min){
min = arr[29][i];
}
//System.out.print(arr[29][i]+" ");
}
//打印最大值和最小值
System.out.println(max+" "+min);
}
}
五、杨辉三角
Answer: int q = p-1; q >= 1; q–
题目描述:
杨辉三角也叫帕斯卡三角,在很多数量关系中可以看到,十分重要。
第0行: 1
第1行: 1 1
第2行: 1 2 1
第3行: 1 3 3 1
第4行: 1 4 6 4 1
…
两边的元素都是1, 中间的元素是左上角的元素与右上角的元素和。
我们约定,行号,列号都从0计数。
所以: 第6行的第2个元素是15,第3个元素是20
直观地看,需要开辟一个二维数组,其实一维数组也可以胜任。
如下程序就是用一维数组“腾挪”的解法。
public class A
{
// 杨辉三角形的第row行第col列
static long f(int row, int col){
if(row<2) return 1;
if(col==0) return 1;
if(col==row) return 1;
long[] a = new long[row+1];
a[0]=1;
a[1]=1;
int p = 2;
while(p<=row){
a[p] = 1;
for( __________________ ) a[q] = a[q] + a[q-1];
p++;
}
return a[col];
}
public static void main(String[] args){
System.out.println(f(6,2));
System.out.println(f(6,3));
}
}
请仔细分析源码,并完成划线部分缺少的代码。
注意:只提交缺少的代码,不要提交已有的代码和符号。也不要提交说明性文字。
思路:对于一维数组的“腾挪”,一般都是考虑从右往左进行覆盖
六、最大公共子串
Answer: a[i][j] = a[i-1][j-1]+1;
题目描述:
最大公共子串就是求两个串的所有子串中能够匹配上的最大长度是多少。
比如:“abcdkkk” 和 “baabcdadabc”,
可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
下面的程序是采用矩阵法进行求解的,这对串的规模不大的情况还是比较有效的解法。
请分析该解法的思路,并补全划线部分缺失的代码。
public class A
{
static int f(String s1, String s2)
{
char[] c1 = s1.toCharArray();
char[] c2 = s2.toCharArray();
int[][] a = new int[c1.length+1][c2.length+1];
int max = 0;
for(int i=1; i<a.length; i++){
for(int j=1; j<a[i].length; j++){
if(c1[i-1]==c2[j-1]) {
a[i][j] = _______________________ ; //填空
if(a[i][j] > max) max = a[i][j];
}
}
}
return max;
}
public static void main(String[] args){
int n = f("abcdkkk", "baabcdadabc");
System.out.println(n);
}
}
注意:只提交缺少的代码,不要提交已有的代码和符号。也不要提交说明性文字。
思路:通过填空所在的两个for循环,可以直到,外层循环控制的是层数,内层控制的是列数。
七、 Excel地址
题目描述:
Excel单元格的地址表示很有趣,它使用字母来表示列号。
比如,
A表示第1列,
B表示第2列,
Z表示第26列,
AA表示第27列,
AB表示第28列,
BA表示第53列,
…
当然Excel的最大列号是有限度的,所以转换起来不难。
如果我们想把这种表示法一般化,可以把很大的数字转换为很长的字母序列呢?
本题目既是要求对输入的数字, 输出其对应的Excel地址表示方式。
例如,
输入:
26
则程序应该输出:
Z
再例如,
输入:
2054
则程序应该输出:
BZZ
我们约定,输入的整数范围[1,2147483647]
资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗 < 1000ms
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是:Main,否则按无效代码处理。
笨笨有话说:
这有点像进制关系,又不完全是。好像末2位是以1当26,末3位是以1当26*26
歪歪有话说:
要是从字母序列转数字还好点,倒过来有点麻烦,不过计算机跑得快啊。
思路:
使用得是类似进制的转换方法,即满26进位
分两种情况讨论:
1)如果用户输入的数字可以被26整除,那么特殊处理,即把26作为余数;那么再下一次循环的时候,商减一
2)如果不能被26整除,那么求每次除以26的余数
最后,每次操作之后,都存储在一个数组中,然后输出数组中的数字即可(转化为字符后输出)
代码块:
import java.util.Scanner;
public class _7Excel地址 {
static long[]ans = new long[1000];
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
long n = sc.nextLong();
//存储转换后字母的位数
int cnt = 0;
while(n!=0){
//如果n可以被26整除(特殊处理)
if(n%26 == 0){
//能除尽得情况下,把26作为余数
ans[cnt] = 26;
//更新n(商减一)
n = n/26-1;
//如果n不能被26整除
}else{
//将余数记录再数组ans中
ans[cnt] = n%26;
//更新n
n /= 26;
}
cnt++;
//System.out.println(n);
}
//打印存储再数组ans中的数据(转化为字符)
for(int i = cnt-1; i >= 0; i--){
System.out.print((char)('A'+(ans[i]-1)));
}
}
}
八、拉马车
题目描述:
小的时候,你玩过纸牌游戏吗?
有一种叫做“拉马车”的游戏,规则很简单,却很吸引小朋友。
其规则简述如下:
假设参加游戏的小朋友是A和B,游戏开始的时候,他们得到的随机的纸牌序列如下:
A方:[K, 8, X, K, A, 2, A, 9, 5, A]
B方:[2, 7, K, 5, J, 5, Q, 6, K, 4]
其中的X表示“10”,我们忽略了纸牌的花色。
从A方开始,A、B双方轮流出牌。
当轮到某一方出牌时,他从自己的纸牌队列的头部拿走一张,放到桌上,并且压在最上面一张纸牌上(如果有的话)。
此例中,游戏过程:
A出K,B出2,A出8,B出7,A出X,此时桌上的序列为:
K,2,8,7,X
当轮到B出牌时,他的牌K与桌上的纸牌序列中的K相同,则把包括K在内的以及两个K之间的纸牌都赢回来,放入自己牌的队尾。注意:为了操作方便,放入牌的顺序是与桌上的顺序相反的。
此时,A、B双方的手里牌为:
A方:[K, A, 2, A, 9, 5, A]
B方:[5, J, 5, Q, 6, K, 4, K, X, 7, 8, 2, K]
赢牌的一方继续出牌。也就是B接着出5,A出K,B出J,A出A,B出5,又赢牌了。
5,K,J,A,5
此时双方手里牌:
A方:[2, A, 9, 5, A]
B方:[Q, 6, K, 4, K, X, 7, 8, 2, K, 5, A, J, K, 5]
注意:更多的时候赢牌的一方并不能把桌上的牌都赢走,而是拿走相同牌点及其中间的部分。但无论如何,都是赢牌的一方继续出牌,有的时候刚一出牌又赢了,也是允许的。
当某一方出掉手里最后一张牌,但无法从桌面上赢取牌时,游戏立即结束。
对于本例的初始手牌情况下,最后A会输掉,而B最后的手里牌为:
9K2A62KAX58K57KJ5
本题的任务就是已知双方初始牌序,计算游戏结束时,赢的一方手里的牌序。当游戏无法结束时,输出-1。
输入为2行,2个串,分别表示A、B双方初始手里的牌序列。
输出为1行,1个串,表示A先出牌,最后赢的一方手里的牌序。
例如,
输入:
96J5A898QA
6278A7Q973
则程序应该输出:
2J9A7QA6Q6889977
再比如,
输入:
25663K6X7448
J88A5KJXX45A
则程序应该输出:
6KAJ458KXAX885XJ645
我们约定,输入的串的长度不超过30
资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗 < 1000ms
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是:Main,否则按无效代码处理。
笨笨有话说:
不断删除前边的,又要后边添加… 如果用数组,需要开一个大点的,请佛祖保佑在游戏结束前,不会用到数组的边缘。
歪歪有话说:
反正串也不长,不如每次操作都返回一个新的串。
默默有话说:
我一般都不吱声,这是典型的队列结构,动态数组最好,没有?自己造一个呗!
代码块:
import java.util.Scanner;
public class _8拉马车 {
static StringBuilder A;//A的牌
static StringBuilder B;//B的牌
static StringBuilder C = new StringBuilder();//桌上的牌
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
//接收用户输入的两个字符串,并转化为StringBuilder
String a = sc.nextLine();
String b = sc.nextLine();
A = new StringBuilder(a);
B = new StringBuilder(b);
//使用两个变量flagA和flagB判断A和B谁在出牌
boolean flagA = true;//A能出牌的标志
boolean flagB = false;//A能出牌的标志
//循环判断A和B,直到其中一个人的牌数为零为止
while(true){
//判断A是否能出牌
if(flagA){
flagA = op(A, C);
if(A.length() == 0){
System.out.println(B);
break;
}
flagB = !flagA;
}
//判断B是否能出牌
if(flagB){
flagB = op(B, C);
if(B.length() == 0){
System.out.println(A);
break;
}
flagA = !flagB;
}
}
}
//x:正在操作的玩家手中的牌
//z:桌面上的牌
static boolean op(StringBuilder x, StringBuilder z){
//如果传入的字符串长度(玩家手中的牌数)为零,那么直接放回false
if(x.length() == 0)return false;
//返回值ans,判断玩家是否可以出牌
boolean ans = true;
//获取第一个字符
char front = x.charAt(0);
//查找字符在z中的位置
int k = z.indexOf(front+"");
//桌上相同的牌
//将这张牌插入x的尾部,并且将左上0~k之间的牌一次插入x的尾部
if(k != -1){
x.append(front);
for(int i = 0; i <= k; i++){
x.append(z.charAt(i));
}
//从桌面上移除这些牌
z.delete(0, k+1);
}else{
//将这张牌放在桌面上(下标为0)
z.insert(0, front);
ans = false;
}
//删除第一个字符
x.deleteCharAt(0);
return ans;
}
}
九、青蛙跳杯子
X星球的流行宠物是青蛙,一般有两种颜色:白色和黑色。
X星球的居民喜欢把它们放在一排茶杯里,这样可以观察它们跳来跳去。
如下图,有一排杯子,左边的一个是空着的,右边的杯子,每个里边有一只青蛙。
*WWWBBB
其中,W字母表示白色青蛙,B表示黑色青蛙,*表示空杯子。
X星的青蛙很有些癖好,它们只做3个动作之一:
1. 跳到相邻的空杯子里。
2. 隔着1只其它的青蛙(随便什么颜色)跳到空杯子里。
3. 隔着2只其它的青蛙(随便什么颜色)跳到空杯子里。
对于上图的局面,只要1步,就可跳成下图局面:
WWW*BBB
本题的任务就是已知初始局面,询问至少需要几步,才能跳成另一个目标局面。
输入为2行,2个串,表示初始局面和目标局面。
输出要求为一个整数,表示至少需要多少步的青蛙跳。
例如:
输入:
WWBB
WWBB
则程序应该输出:
2
再例如,
输入:
WWWBBB
BBBWWW
则程序应该输出:
10
我们约定,输入的串的长度不超过15
资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗 < 1000ms
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是:Main,否则按无效代码处理。
笨笨有话说:
我梦见自己是一棵大树,
青蛙跳跃,
我就发出新的枝条,
春风拂动那第 5 层的新枝,
哦,我已是枝繁叶茂。
十、图形排版
小明需要在一篇文档中加入 N 张图片,其中第 i 张图片的宽度是 Wi,高度是 Hi。
假设纸张的宽度是 M,小明使用的文档编辑工具会用以下方式对图片进行自动排版:
- 该工具会按照图片顺序,在宽度 M 以内,将尽可能多的图片排在一行。该行的高度是行内最高的图片的高度。例如在 M=10 的纸张上依次打印 3x4, 2x2, 3x3 三张图片,则效果如下图所示,这一行高度为4。(分割线以上为列标尺,分割线以下为排版区域;数字组成的矩形为第x张图片占用的版面)
0123456789
111
111 333
11122333
11122333
- 如果当前行剩余宽度大于0,并且小于下一张图片,则下一张图片会按比例缩放到宽度为当前行剩余宽度(高度向上取整),然后放入当前行。例如再放入一张4x9的图片,由于剩余宽度是2,这张图片会被压缩到2x5,再被放入第一行的末尾。此时该行高度为5:
0123456789
44
111 44
111 33344
1112233344
1112233344
- 如果当前行剩余宽度为0,该工具会从下一行开始继续对剩余的图片进行排版,直到所有图片都处理完毕。此时所有行的总高度和就是这 N 张图片的排版高度。例如再放入11x1, 5x5, 3x4 的图片后,效果如下图所示,总高度为11:
0123456789
44
111 44
111 33344
1112233344
1112233344
5555555555
66666
66666777
66666777
66666777
66666777
现在由于排版高度过高,图片的先后顺序也不能改变,小明只好从 N 张图片中选择一张删除掉以降低总高度。他希望剩余N-1张图片按原顺序的排版高度最低,你能求出最低高度是多少么?
输入:
第一行包含两个整数 M 和 N,分别表示纸张宽度和图片的数量。
接下来 N 行,每行2个整数Wi, Hi,表示第 i 个图大小为 Wi*Hi。
对于30%的数据,满足1<=N<=1000
对于100%的数据,满足1<=N<=100000,1<=M, Wi, Hi<=100
输出:
一个整数,表示在删除掉某一张图片之后,排版高度最少能是多少。
样例输入:
4 3
2 2
2 3
2 2
样例输出:
2
另一个示例,
样例输入:
2 10
4 4
4 3
1 3
4 5
2 1
2 3
5 4
5 3
1 5
2 4
样例输出:
17
资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗 < 2000ms
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是:Main,否则按无效代码处理。