JavaC组蓝桥杯 107道历年真题
2013年JavaC组————蓝桥杯第四届
猜年龄 暴力法 or Set集合
【问题描述】美国数学家维纳(N.Wiener)智力早熟，11岁就上了大学。他曾在1935~1936年应邀来中国清华大学讲学。 一次，他参加某个重要会议，年轻的脸孔引人注目。于是有人询问他的年龄，他回答说： “我年龄的立方是个4位数。我年龄的4次方是个6位数。这10个数字正好包含了从0到9这10个数字，每个都恰好出现1次。” 请你推算一下，他当时到底有多年轻。
通过浏览器，直接提交他那时的年龄数字。
注意：不要提交解答过程，或其它的说明文字。
【答案】18
【暴力法代码】
public static void main(String[] args) {
for (int age = 11; age < 20; age++) {
System.out.println("年龄"+age+":"+Math.pow(age, 3) +" "+ Math.pow(age, 4));
}
}
【输出】
年龄11:1331.0 14641.0
年龄12:1728.0 20736.0
年龄13:2197.0 28561.0
年龄14:2744.0 38416.0
年龄15:3375.0 50625.0
年龄16:4096.0 65536.0
年龄17:4913.0 83521.0
年龄18:5832.0 104976.0
年龄19:6859.0 130321.0
【Set集合代码】
public static void main(String[] args) {
for(int i=10;i<100;i++) {
int i1=i*i*i;
int i2=i1*i;
String s1 = i1+"";
String s2 = i2+"";
if(s1.length()==4&&s2.length()==6&&Check(s1+s2)) {
System.out.println(i);
break;
}
}
}
public static boolean Check(String s) {
Set<Character> set=new HashSet<Character>(); // 不允许出现重复元素
for(int i=0;i<s.length();i++) {
set.add(s.charAt(i));
}
return set.size()==10; // 等于10 正好0~9都存入Set集合中
}
组元素 暴力法or递归全排列
【问题描述】素数就是不能再进行等分的数。比如：2 3 5 7 11 等。9 = 3 * 3 说明它可以3等分，因而不是素数。
我们国家在1949年建国。如果只给你 1 9 4 9 这4个数字卡片，可以随意摆放它们的先后顺序（但卡片不能倒着摆放啊，我们不是在脑筋急转弯！），那么，你能组成多少个4位的素数呢？
比如：1949，4919 都符合要求。
【答案】6
【暴力法代码】
public static boolean isPrime(int num) { // 判断是否为素数
if (num == 1 || num % 2 == 0 && num != 2) {
return false;
} else {
for (int i = 3; i < Math.sqrt(num); i += 2) {
if (num % i == 0) {
return false;
}
}
}
return true;
}
public static void main(String[] args) {
//暴力破解
int[] a = new int[] {1949,1499,1994,9149,9194,9491,9419,9914,9941,4199,4919,4991}; // 手动全排列
int count = 0;
for(int i:a) {
if(isPrime(i)) {
count++;
}
}
System.out.println(count);
}
【递归全排列代码】
public static Set<Integer> set; // 用set集合排除两个9交换的特殊情况
public static void main(String[] args) {
int a[] = { 1, 9, 4, 9 };
set = new HashSet<Integer>();
perm(a,0,3);
System.out.println(set.size());
}
public static void perm(int a[], int start, int end) { // 递归全排列
if (start == end) {
String str = "";
for (int j = 0; j < a.length; j++) {
str = str + a[j];
}
isPrime(Integer.valueOf(str));
} else {
for (int i = start; i <= end; i++) {
swap(a, start, i);
perm(a, start + 1, end);
swap(a, start, i);
}
}
}
public static void swap(int a[], int i, int j) { // 交换
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
public static boolean isPrime(int num) { // 判断是否为素数
if (num == 1 || num % 2 == 0 && num != 2) {
return false;
} else {
for (int i = 3; i <= Math.sqrt(num); i += 2) {
if (num % i == 0) {
return false;
}
}
}
set.add(num);
return true;
}
马虎的算式 暴力法or递归全排列法
【问题描述】
小明是个急性子，上小学的时候经常把老师写在黑板上的题目抄错了。
有一次，老师出的题目是：36 x 495 = ?
他却给抄成了：396 x 45 = ?
但结果却很戏剧性，他的答案竟然是对的！！
因为 36 * 495 = 396 * 45 = 17820
类似这样的巧合情况可能还有很多，比如：27 * 594 = 297 * 54
假设 a b c d e 代表1~9不同的5个数字（注意是各不相同的数字，且不含0）
能满足形如： ab * cde = adb * ce 这样的算式一共有多少种呢？
请你利用计算机的优势寻找所有的可能，并回答不同算式的种类数。
满足乘法交换律的算式计为不同的种类，所以答案肯定是个偶数。
答案直接通过浏览器提交。
注意：只提交一个表示最终统计种类数的数字，不要提交解答过程或其它多余的内容。
【答案】142
【暴力破解法】 for循环套的有点迷
public static void main(String[] args) {
int count = 0;
for(int a=1;a<=9;a++) {
for(int b=1;b<=9;b++) {
if(b==a)
continue;
for(int c=1;c<=9;c++) {
if(c==a||c==b)
continue;
for(int d=1;d<=9;d++) {
if(d==a||d==b||d==c) {
continue;
}
for(int e=1;e<=9;e++) {
if(e==a||e==b||e==c||e==d) {
continue;
}
if ((10*a+b)*(100*c+10*d+e)==(100*a+10*d+b)*(10*c+e)) {
count++;
}
}
}
}
}
}
System.out.println(count);//142
}
【递归全排列法】 解法和上一题差不多
public static Set<String> set; // 算式的个数
public static void main(String[] args) {
int a[] = {1,2,3,4,5,6,7,8,9};
set = new HashSet<String>();
perm(a,0,8);
System.out.println(set.size());
}
public static void perm(int a[], int start, int end) { // 递归全排列
if (start == end) {
fun(a[0],a[1],a[2],a[3],a[4]);
} else {
for (int i = start; i <= end; i++) {
swap(a, start, i);
perm(a, start + 1, end);
swap(a, start, i);
}
}
}
public static void swap(int a[], int i, int j) { // 交换
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
public static void fun(int a,int b,int c,int d,int e) {
if((a*10+b)*(c*100+d*10+e)==(a*100+d*10+b)*(c*10+e)) {
set.add(""+a+b+c+d+e);
}
}
第39级台阶 递归(dfs深搜)
【问题描述】
小明刚刚看完电影《第39级台阶》，离开电影院的时候，他数了数礼堂前的台阶数，恰好是39级!
站在台阶前，他突然又想着一个问题：
如果我每一步只能迈上1个或2个台阶。先迈左脚，然后左右交替，最后一步是迈右脚，也就是说一共要走偶数步。那么，上完39级台阶，有多少种不同的上法呢？
请你利用计算机的优势，帮助小明寻找答案。
要求提交的是一个整数。
注意：不要提交解答过程，或其它的辅助说明文字。
【答案】51167078
【代码】
public static void main(String[] args) {
System.out.println(f(0));//51167078
}
public static int f(int x) {
if(x==39) { //
return 1;
}
if(x>39) // 抛弃
return 0;
return f(x+2)+2*f(x+3)+f(x+4); //1步
}
// (左脚 右脚) (左脚 右脚) ........ (左脚 右脚)->39
// 一个组合可能有四种走法 2步 3步 3步 4步
// 抛弃大于39
// 得到正好走到39
有理数类
【问题描述】
有理数就是可以表示为两个整数的比值的数字。一般情况下，我们用近似的小数表示。但有些时候，不允许出现误差，必须用两个整数来表示一个有理数。
这时，我们可以建立一个“有理数类”，下面的代码初步实现了这个目标。为了简明，它只提供了加法和乘法运算。
class Rational
{
private long ra;
private long rb;
private long gcd(long a, long b){
if(b==0) return a;
return gcd(b,a%b);
}
public Rational(long a, long b){
ra = a;
rb = b;
long k = gcd(ra,rb);
if(k>1){ //需要约分
ra /= k;
rb /= k;
}
}
// 加法
public Rational add(Rational x){
return ________________________________________; //填空位置
}
// 乘法
public Rational mul(Rational x){
return new Rational(ra*x.ra, rb*x.rb);
}
public String toString(){
if(rb==1) return "" + ra;
return ra + "/" + rb;
}
}
使用该类的示例：
Rational a = new Rational(1,3);
Rational b = new Rational(1,6);
Rational c = a.add(b);
System.out.println(a + "+" + b + "=" + c);
请分析代码逻辑，并推测划线处的代码，通过网页提交
注意：仅把缺少的代码作为答案，千万不要填写多余的代码、符号或说明文字！！
【答案】new Rational(rax.rb+x.rarb,rb*x.rb)
参照乘法
逆波兰表达式
【问题描述】
正常的表达式称为中缀表达式，运算符在中间，主要是给人阅读的，机器求解并不方便。
例如：3 + 5 * (2 + 6) - 1
而且，常常需要用括号来改变运算次序。
相反，如果使用逆波兰表达式（前缀表达式）表示，上面的算式则表示为：
- + 3 * 5 + 2 6 1
不再需要括号，机器可以用递归的方法很方便地求解。
为了简便，我们假设：
1. 只有 + - * 三种运算符
2. 每个运算数都是一个小于10的非负整数
下面的程序对一个逆波兰表示串进行求值。
其返回值为一个数组：其中第一元素表示求值结果，第二个元素表示它已解析的字符数。
static int[] evaluate(String x)
{
if(x.length()==0) return new int[] {0,0};
char c = x.charAt(0);
if(c>='0' && c<='9') return new int[] {c-'0',1};
int[] v1 = evaluate(x.substring(1));
int[] v2 = __________________________________________; //填空位置
int v = Integer.MAX_VALUE;
if(c=='+') v = v1[0] + v2[0];
if(c=='*') v = v1[0] * v2[0];
if(c=='-') v = v1[0] - v2[0];
return new int[] {v,1+v1[1]+v2[1]};
}
请分析代码逻辑，并推测划线处的代码，通过网页提交。
注意：仅把缺少的代码作为答案，千万不要填写多余的代码、符号或说明文字！！
【答案】 evaluate(x.substring(v1[1]+1))
核桃的数量 最小公倍数
【问题描述】
小张是软件项目经理，他带领3个开发组。工期紧，今天都在加班呢。为鼓舞士气，小张打算给每个组发一袋核桃（据传言能补脑）。他的要求是：
1. 各组的核桃数量必须相同
2. 各组内必须能平分核桃（当然是不能打碎的）
3. 尽量提供满足1,2条件的最小数量（节约闹革命嘛）
程序从标准输入读入：
a b c
a,b,c都是正整数，表示每个组正在加班的人数，用空格分开（a,b,c<30）
程序输出：
一个正整数，表示每袋核桃的数量。
例如：
用户输入：
2 4 5
程序输出：
20
再例如：
用户输入：
3 1 1
程序输出：
3
资源约定：
峰值内存消耗（含虚拟机） < 64M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.6及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
【代码】
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int a = scan.nextInt();
int b = scan.nextInt();
int c = scan.nextInt();
for(int i=1;i<=a*b*c;i++) {
if(i%a==0&&i%b==0&&i%c==0) {
System.out.println(i);
break;
}
}
}
打印十字图 递归重拟矩阵坐标系
【问题描述】
小明为某机构设计了一个十字型的徽标（并非红十字会啊），如下所示(可参见p1.jpg)
$$$$$$$$$$$$$
$ $
$$$ $$$$$$$$$ $$$
$ $ $ $
$ $$$ $$$$$ $$$ $
$ $ $ $ $ $
$ $ $$$ $ $$$ $ $
$ $ $ $ $ $ $
$ $ $ $$$$$ $ $ $
$ $ $ $ $ $ $
$ $ $$$ $ $$$ $ $
$ $ $ $ $ $
$ $$$ $$$$$ $$$ $
$ $ $ $
$$$ $$$$$$$$$ $$$
$ $
$$$$$$$$$$$$$
对方同时也需要在电脑dos窗口中以字符的形式输出该标志，并能任意控制层数。
为了能准确比对空白的数量，程序要求对行中的空白以句点（.）代替。
输入格式：
一个正整数 n (n<30) 表示要求打印图形的层数
输出：
对应包围层数的该标志。
例如：
用户输入：
1
程序应该输出：
..$$$$$..
..$...$..
$$$.$.$$$
$...$...$
$.$$$$$.$
$...$...$
$$$.$.$$$
..$...$..
..$$$$$..
再例如：
用户输入：
3
程序应该输出：
..$$$$$$$$$$$$$..
..$...........$..
$$$.$$$$$$$$$.$$$
$...$.......$...$
$.$$$.$$$$$.$$$.$
$.$...$...$...$.$
$.$.$$$.$.$$$.$.$
$.$.$...$...$.$.$
$.$.$.$$$$$.$.$.$
$.$.$...$...$.$.$
$.$.$$$.$.$$$.$.$
$.$...$...$...$.$
$.$$$.$$$$$.$$$.$
$...$.......$...$
$$$.$$$$$$$$$.$$$
..$...........$..
..$$$$$$$$$$$$$..
请仔细观察样例，尤其要注意句点的数量和输出位置。
资源约定：
峰值内存消耗（含虚拟机） < 64M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.6及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
【代码】
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int num = n * 4 + 5;
char[][] img = new char[num][num];
for (int i = 0; i < img.length; i++) {
for (int j = 0; j < img[i].length; j++) {
img[i][j] = '.';
}
}
fun(img, n,0,num-1);
for (int i = 0; i < img.length; i++) {
for (int j = 0; j < img[i].length; j++) {
System.out.print(img[i][j]);
}
System.out.println();
}
}
// 第0层 8个点 上(0,2) 下（6，2） 左（2，0）右（2，6） 左上拐角（2，2）右上拐角（2，2）左下拐角（2，2）右下拐角（2，2）
// 第1层 8个点 上(0，2) 下（8，2）左（2，0） 右（2，8） 左上拐角（2，2）右上拐角 （2，6）左下拐角（6，2）右下拐角（6，6）
// 第2层 8个点 上（0，2） 下（12，2）左（2，0）右（2，12）左上拐角（2，2）右上拐角（2，10）左下拐角 （10，2）右下拐角（10，10）
public static void fun(char img[][], int n,int start,int end) { // start end 重拟矩阵坐标系范围
int nextN = n-1;
int nextStart = start+2;
int nextEnd = end-2;
if(n<0) {
return;
}else {
for(int i=0;i<n*4+1;i++) {
img[start][start+2+i] = '$'; //上
img[end][start+2+i]='$'; // 下
img[start+2+i][start]='$'; // 左
img[start+2+i][end]='$'; // 右
}
// 左上拐角
img[start+2][start+2] = '$';
img[start+2-1][start+2] = '$';
img[start+2][start+2-1] = '$';
// 右上拐角
img[start+2][end-2] = '$';
img[start+2-1][end-2] = '$';
img[start+2][end-2+1] = '$';
// 左下拐角
img[end-2][start+2] = '$';
img[end-2+1][start+2] = '$';
img[end-2][start+2-1] = '$';
// 右下拐角
img[end-2][end-2] = '$';
img[end-2+1][end-2] = '$';
img[end-2][end-2+1] = '$';
// 递归
fun(img,nextN,nextStart,nextEnd);
}
}
买不到的数目
【问题描述】
小明开了一家糖果店。他别出心裁：把水果糖包成4颗一包和7颗一包的两种。糖果不能拆包卖。
小朋友来买糖的时候，他就用这两种包装来组合。当然有些糖果数目是无法组合出来的，比如要买 10 颗糖。
你可以用计算机测试一下，在这种包装情况下，最大不能买到的数量是17。大于17的任何数字都可以用4和7组合出来。
本题的要求就是在已知两个包装的数量时，求最大不能组合出的数字。
输入：
两个正整数，表示每种包装中糖的颗数(都不多于1000)
要求输出：
一个正整数，表示最大不能买到的糖数
例如：
用户输入：
4 7
程序应该输出：
17
再例如：
用户输入：
3 5
程序应该输出：
7
资源约定：
峰值内存消耗（含虚拟机） < 64M
CPU消耗 < 3000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.6及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
【代码】
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int a = scan.nextInt();
int b = scan.nextInt();
for (int i = a * b; i >= (a > b ? a : b); i--) {
if (fun(a, b, i)) {
System.out.println(i);
break;
}
}
}
public static boolean fun(int a, int b, int a_and_b) {
for (int i = 0; i <= b; i++) {
for (int j = 0; j <= a; j++) {
if (a * i + b * j == a_and_b) {
return false;
}
}
}
return true;
}
剪格子 dfs剪枝回溯
【问题描述】
如图p1.jpg所示，3 x 3 的格子中填写了一些整数。
我们沿着图中的红色线剪开，得到两个部分，每个部分的数字和都是60。
本题的要求就是请你编程判定：对给定的m x n 的格子中的整数，是否可以分割为两个部分，使得这两个区域的数字和相等。
如果存在多种解答，请输出包含左上角格子的那个区域包含的格子的最小数目。
如果无法分割，则输出 0
程序输入输出格式要求：
程序先读入两个整数 m n 用空格分割 (m,n<10)
表示表格的宽度和高度
接下来是n行，每行m个正整数，用空格分开。每个整数不大于10000
程序输出：在所有解中，包含左上角的分割区可能包含的最小的格子数目。
例如：
用户输入：
3 3
10 1 52
20 30 1
1 2 3
则程序输出：
3
再例如：
用户输入：
4 3
1 1 1 1
1 30 80 2
1 1 1 100
则程序输出：
10
(参见p2.jpg)
资源约定：
峰值内存消耗（含虚拟机） < 64M
CPU消耗 < 5000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.6及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
【代码】
public static int[][] g,vis;
private static int n, m,total;
private static int ans = Integer.MAX_VALUE;
static void dfs(int i, int j, int steps, int sum) {
if (i < 0 || i == n || j < 0 || j == m||vis[i][j]==1) {
return;
}
if(sum==total/2) {
ans = Math.min(ans,steps-1);
return;
}if(sum>total/2) {
return;
}
vis[i][j] = 1;
dfs(i - 1, j, steps + 1, sum + g[i][j]); // down
dfs(i + 1, j, steps + 1, sum + g[i][j]); // up
dfs(i, j - 1, steps + 1, sum + g[i][j]); // left
dfs(i, j + 1, steps + 1, sum + g[i][j]); // left
vis[i][j] = 0;
}
public static void main(String[] args) {
// 试探 —— 解的搜索 1、深搜2、宽搜3、二分搜索
// dfs 剪枝 回溯
Scanner scan = new Scanner(System.in);
m = scan.nextInt();
n = scan.nextInt();
g = new int[n][m];
vis = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
g[i][j] = scan.nextInt();
total = total + g[i][j];
}
}
// =完成输入=
dfs(0, 0, 0, 0);
System.out.println(ans);
}
2014年JavaC组————蓝桥杯第五届
猜年龄 暴力破解
【问题描述】
小明带两个妹妹参加元宵灯会。别人问她们多大了，她们调皮地说：“我们俩的年龄之积是年龄之和的6倍”。小明又补充说：“她们可不是双胞胎，年龄差肯定也不超过8岁啊。”
请你写出：小明的较小的妹妹的年龄。
注意： 只写一个人的年龄数字，请通过浏览器提交答案。不要书写任何多余的内容。
【答案】10
【代码】
public static void main(String[] args) {
for(int i=1;i<=100;i++) {
for(int j=i+1;j<=100;j++) {
if(i*j==6*(i+j)&&(j-i)<=8){
System.out.println(i);
}
}
}
// 10岁
}
等额本金 暴力破解
【问题描述】
小明从银行贷款3万元。约定分24个月，以等额本金方式还款。
这种还款方式就是把贷款额度等分到24个月。每个月除了要还固定的本金外，还要还贷款余额在一个月中产生的利息。
假设月利率是：0.005，即：千分之五。那么，
第一个月，小明要还本金 1250, 还要还利息：30000 * 0.005，总计 1400
第二个月，本金仍然要还 1250, 但利息为：(30000-1250) * 0.005 总计 1393.75
请问：小明在第15个月，应该还款多少（本金和利息的总和）？
请把答案金额四舍五入后，保留两位小数。注意：32.5，一定要写为：32.50
通过浏览器提交答案，这是一个含有小数点和两位小数的浮点数字。不要写多余内容（例如：多写了“元”或添加说明文字）
【答案】1312.50
【代码】
System.out.println(1250 + ((30000-1250*14)*0.005));
猜字母 局部思维or暴力破解
【问题描述】
把abcd...s共19个字母组成的序列重复拼接106次，得到长度为2014的串。
接下来删除第1个字母（即开头的字母a），以及第3个，第5个等所有奇数位置的字母。
得到的新串再进行删除奇数位置字母的动作。如此下去，最后只剩下一个字母，请写出该字母。
答案是一个小写字母，请通过浏览器提交答案。不要填写任何多余的内容。
【答案】q
【代码】
public static void main(String[] args) {
// 方法1 全局——>局部
// 106个串 缩小为 2个串
// "abcdefghijklmnopqrsabcdefghijklmnopqrs";
// 去奇数 最后剩q
// 方法2
char[] a = new char[2014];
int index = 0;
for(int i=0;i<106;i++) {
for(int j=0;j<19;j++) {
a[index++] = (char)('a'+j);
}
}
int len = 2014;
while(len!=1) {
int k = 0;
for(int i=1;i<len;i+=2) {
a[k++] = a[i];
}
len = k;
}
System.out.println(a[0]);
}
大衍数列
【问题描述】
中国古代文献中，曾记载过“大衍数列”, 主要用于解释中国传统文化中的太极衍生原理。
它的前几项是：0、2、4、8、12、18、24、32、40、50 ...
其规律是：对偶数项，是序号平方再除2，奇数项，是序号平方减1再除2。
以下的代码打印出了大衍数列的前 100 项。
for(int i=1; i<100; i++)
{
if(________________) //填空
System.out.println(ii/2);
else
System.out.println((ii-1)/2);
}
请填写划线部分缺失的代码。通过浏览器提交答案。
注意：不要填写题面已有的内容，也不要填写任何说明、解释文字。
【答案】i%2==0
写日志
【问题描述】
写日志是程序的常见任务。现在要求在 t1.log, t2.log, t3.log 三个文件间轮流写入日志。也就是说第一次写入t1.log，第二次写入t2.log，... 第四次仍然写入t1.log，如此反复。
下面的代码模拟了这种轮流写入不同日志文件的逻辑。
public class A
{
private static int n = 1;
public static void write(String msg)
{
String filename = "t" + n + ".log";
n = ____________;
System.out.println("write to file: " + filename + " " + msg);
}
}
请填写划线部分缺失的代码。通过浏览器提交答案。
注意：不要填写题面已有的内容，也不要填写任何说明、解释文字。
【答案】 n%3+1
李白打酒 递归(凑方案)
【问题描述】
话说大诗人李白，一生好饮。幸好他从不开车。
一天，他提着酒壶，从家里出来，酒壶中有酒2斗。他边走边唱：
无事街上走，提壶去打酒。
逢店加一倍，遇花喝一斗。
这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。
请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b。则：babaabbabbabbbb 就是合理的次序。像这样的答案一共有多少呢？请你计算出所有可能方案的个数（包含题目给出的）。
注意：通过浏览器提交答案。答案是个整数。不要书写任何多余的内容。
【代码】
public static int ans = 0;
public static void main(String[] args) {
fun(0,0,2);
System.out.println(ans);
}
public static void fun(int a,int b,int wine) {
if(wine==1&&a==5&&b==9) {
ans++;
return;
}
if(a>5||b>9) {
return;
}
fun(a+1,b,wine*2); // 遇见店
fun(a,b+1,wine-1); // 遇见花
}
奇怪的分式 递归(最大公约数)
【问题描述】
上小学的时候，小明经常自己发明新算法。一次，老师出的题目是：
1/4 乘以 8/5
小明居然把分子拼接在一起，分母拼接在一起，答案是：18/45 （参见图1.png）
老师刚想批评他，转念一想，这个答案凑巧也对啊，真是见鬼！
对于分子、分母都是 1~9 中的一位数的情况，还有哪些算式可以这样计算呢？
请写出所有不同算式的个数（包括题中举例的）。
显然，交换分子分母后，例如：4/1 乘以 5/8 是满足要求的，这算做不同的算式。
但对于分子分母相同的情况，2/2 乘以 3/3 这样的类型太多了，不在计数之列!
注意：答案是个整数（考虑对称性，肯定是偶数）。请通过浏览器提交。不要书写多余的内容。
【代码】
public static void main(String[] args) {
int ans = 0;
for(int a=1;a<=9;a++) {
for(int b=1;b<=9;b++) {
if(a==b) {
continue;
}
for(int c=1;c<=9;c++) {
for(int d=1;d<=9;d++) {
if(c==d) {
continue;
}
int gcd1 = gcd(a*c,b*d);
int gcd2 = gcd(a*10+c,b*10+d);
if((a*c)/gcd1==(a*10+c)/gcd2&&(b*d)/gcd1==(b*10+d)/gcd2) {
ans++;
}
}
}
}
}
System.out.println(ans);
}
// 最大公约数
public static int gcd(int a,int b) {
if(b==0)return a;
return gcd(b,a%b);
}
兰顿蚂蚁 递归(模拟)
【问题描述】
兰顿蚂蚁，是于1986年，由克里斯·兰顿提出来的，属于细胞自动机的一种。
平面上的正方形格子被填上黑色或白色。在其中一格正方形内有一只“蚂蚁”。
蚂蚁的头部朝向为：上下左右其中一方。
蚂蚁的移动规则十分简单：
若蚂蚁在黑格，右转90度，将该格改为白格，并向前移一格；
若蚂蚁在白格，左转90度，将该格改为黑格，并向前移一格。
规则虽然简单，蚂蚁的行为却十分复杂。刚刚开始时留下的路线都会有接近对称，像是会重复，但不论起始状态如何，蚂蚁经过漫长的混乱活动后，会开辟出一条规则的“高速公路”。
蚂蚁的路线是很难事先预测的。
你的任务是根据初始状态，用计算机模拟兰顿蚂蚁在第n步行走后所处的位置。
【数据格式】
输入数据的第一行是 m n 两个整数（3 < m, n < 100），表示正方形格子的行数和列数。
接下来是 m 行数据。
每行数据为 n 个被空格分开的数字。0 表示白格，1 表示黑格。
接下来是一行数据：x y s k, 其中x y为整数，表示蚂蚁所在行号和列号（行号从上到下增长，列号从
左到右增长，都是从0开始编号）。s 是一个大写字母，表示蚂蚁头的朝向，我们约定：上下左右分别用：UDLR表示。k 表示蚂蚁走的步数。
输出数据为两个空格分开的整数 p q, 分别表示蚂蚁在k步后，所处格子的行号和列号。
例如, 输入：
5 6
0 0 0 0 0 0
0 0 0 0 0 0
0 0 1 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
2 3 L 5
程序应该输出：
1 3
再例如, 输入：
3 3
0 0 0
1 1 1
1 1 1
1 1 U 6
程序应该输出：
0 0
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
【代码】
static int m, n;
static int X,Y;
static String s;
static int img[][];
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
m = scan.nextInt();
n = scan.nextInt();
img = new int[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
img[i][j] = scan.nextInt();
}
}
int x = scan.nextInt();
int y = scan.nextInt();
String s = scan.next();
int k = scan.nextInt();
fun(x, y, s, k);
System.out.println(X + " " + Y);
}
public static void fun(int x, int y, String s, int k) {
if (k == 0) {
X = x;
Y = y;
return;
}
if (img[x][y] == 1) { // 黑格
img[x][y] = 0;
if (s.equals("U")) {
fun(x, y + 1, "R", k - 1);// 右走
} else if (s.equals("R")) {
fun(x + 1, y, "D", k - 1);// 下走
} else if (s.equals("D")) {
fun(x, y - 1, "L", k - 1);// 左走
} else if (s.equals("L")) {
fun(x - 1, y, "U", k - 1);// 上走
}
} else { // 白格
img[x][y] = 1;
if (s.equals("U")) {
fun(x, y - 1, "L", k - 1); // 左走
} else if (s.equals("R")) {
fun(x - 1, y, "U", k - 1); // 上走
} else if (s.equals("D")) {
fun(x, y + 1, "R", k - 1); // 右走
} else if (s.equals("L")) {
fun(x + 1, y, "D", k - 1); // 下走
}
}
}
地宫取宝 递归(dfs深搜)
【问题描述】
X 国王有一个地宫宝库。是 n x m 个格子的矩阵。每个格子放一件宝贝。每个宝贝贴着价值标签。
地宫的入口在左上角，出口在右下角。
小明被带到地宫的入口，国王要求他只能向右或向下行走。
走过某个格子时，如果那个格子中的宝贝价值比小明手中任意宝贝价值都大，小明就可以拿起它（当然，也可以不拿）。
当小明走到出口时，如果他手中的宝贝恰好是k件，则这些宝贝就可以送给小明。
请你帮小明算一算，在给定的局面下，他有多少种不同的行动方案能获得这k件宝贝。
【数据格式】
输入一行3个整数，用空格分开：n m k (1<=n,m<=50, 1<=k<=12)
接下来有 n 行数据，每行有 m 个整数 Ci (0<=Ci<=12)代表这个格子上的宝物的价值
要求输出一个整数，表示正好取k个宝贝的行动方案数。该数字可能很大，输出它对 1000000007 取模的结果。
例如，输入：
2 2 2
1 2
2 1
程序应该输出：
2
再例如，输入：
2 3 2
1 2 3
2 1 5
程序应该输出：
14
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 2000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
【代码】
static int n,m,k;
static int ans;
static int img[][];
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
n = scan.nextInt();// 行
m = scan.nextInt();// 列
k = scan.nextInt();// k个宝贝
img = new int[n][m];
// 初始化
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
img[i][j] = scan.nextInt();
}
}
// 坐标 宝贝数
fun(0,0,0,-1);
System.out.println(ans%1000000007);
}
public static void fun(int i,int j,int realK,int maxValue) {
if(i==n-1&&j==m-1) { // 到出口时
if(realK==k) { // 正好拿够两个
ans++;
return;
}else if(realK==k-1&&img[i][j]>maxValue){ // 缺一个并且出口宝贝大于最大价值
ans++;
return;
}
return;
}
if(i==n||j==m||realK>k) {
return;
}
if(img[i][j]>maxValue) {
fun(i+1,j,realK+1,img[i][j]);// 向下走 拿宝贝
fun(i,j+1,realK+1,img[i][j]);// 向右走 拿宝贝
fun(i+1,j,realK,maxValue);// 向下走 不拿宝贝
fun(i,j+1,realK,maxValue);// 向右走 不拿宝贝
}else {
fun(i+1,j,realK,maxValue);// 向下走 不拿宝贝
fun(i,j+1,realK,maxValue);// 向右走 不拿宝贝
}
}
矩阵翻硬币
小明先把硬币摆成了一个 n 行 m 列的矩阵。
随后，小明对每一个硬币分别进行一次 Q 操作。
对第x行第y列的硬币进行 Q 操作的定义：将所有第 i*x 行，第 j*y 列的硬币进行翻转。
其中i和j为任意使操作可行的正整数，行号和列号都是从1开始。
当小明对所有硬币都进行了一次 Q 操作后，他发现了一个奇迹——所有硬币均为正面朝上。
小明想知道最开始有多少枚硬币是反面朝上的。于是，他向他的好朋友小M寻求帮助。
聪明的小M告诉小明，只需要对所有硬币再进行一次Q操作，即可恢复到最开始的状态。然而小明很懒，不愿意照做。于是小明希望你给出他更好的方法。帮他计算出答案。
【数据格式】
输入数据包含一行，两个正整数 n m，含义见题目描述。
输出一个正整数，表示最开始有多少枚硬币是反面朝上的。
【样例输入】
2 3
【样例输出】
1
【数据规模】
对于10%的数据，n、m <= 10^3；
对于20%的数据，n、m <= 10^7；
对于40%的数据，n、m <= 10^15；
对于10%的数据，n、m <= 10^1000（10的1000次方）。
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 2000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
【代码】
static int n, m;
static int img[][];
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
n = scan.nextInt();
m = scan.nextInt();
img = new int[n+1][m+1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
img[i][j] = 1; // 初始化 1代表正面
}
}
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= m; y++) {
Q(x, y); // 对所有硬币Q操作
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (img[i][j] == 0) {
ans++;
}
}
}
System.out.println(ans);
}
public static void Q(int x, int y) {
for(int i=1;i<=n;i++) {
for(int j=1;j<=m;j++) {
if(i*x<=n&&j*y<=m) {
if(img[i*x][j*y]==1) {
img[i*x][j*y] = 0;
}else {
img[i*x][j*y] = 1;
}
}
}
}
}
2015年JavaC组 蓝桥杯校内选拔
杨辉三角
【问题描述】
二项式的系数规律，我国数学家很早就发现了。
如【图1.png】，我国南宋数学家杨辉1261年所著的《详解九章算法》一书里就出现了。
其排列规律：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
如下的程序，用来建立N行的杨辉三角形。请填写划线部分缺少的代码。
注意：只填写划线部分的代码，不要填写任何多余的内容。
public class A
{
public static void main(String[] args)
{
int N = 8;
int[][] a = new int[N][N] ;
for(int i=0; i<N; i++){
a[i][0] = 1;
a[i][i] = 1;
}
for(int i=1; i<N; i++){
for(int j=1; j<i; j++) _____________________________; //填空
}
for(int i=0; i<N; i++){
for(int j=0; j<=i; j++) System.out.print(String.format("%-5d", a[i][j]));
System.out.println();
}
}
}
【答案】a[i][j]=a[i-1][j-1]+a[i-1][j]
调和级数
【问题描述】
1/1 + 1/2 + 1/3 + 1/4 + ... 在数学上称为调和级数。
它是发散的，也就是说，只要加上足够多的项，就可以得到任意大的数字。
但是，它发散的很慢：
前1项和达到 1.0
前4项和才超过 2.0
前83项的和才超过 5.0
那么，请你计算一下，要加多少项，才能使得和达到或超过 15.0 呢？
请填写这个整数。
注意：只需要填写一个整数，不要填写任何多余的内容。比如说明文字。
【答案】1835421
【代码】
public static void main(String[] args) {
double sum = 0;
int ans = 0;
for (int i = 1;; i++) {
sum = sum + (double)1/i;
ans++;
if (sum >= 15) {
break;
}
}
System.out.println(ans);
}
回文素数
【问题描述】
10301是个5位的素数。它有个特点，把数字倒过来还是它本身，具有这样特征的素数，我们称之为：回文素数。
10501
10601
11311
这些都是5位的回文素数。
请你计算一下，像这样的5位数的回文素数，一共有多少个？
请填写这个表示个数的整数，注意不要写任何其它多余的内容，比如说明或解释文字，也不要列出所有的回文素数。
【答案】93
【代码】
public static void main(String[] args) {
int ans = 0;
for (int i = 10001; i <= 100000; i++) {
if (perm(i)) {
StringBuffer sb = new StringBuffer(String.valueOf(i));
if (sb.toString().equals(sb.reverse().toString())) {
ans++;
}
}
}
System.out.println(ans);
}
public static boolean perm(int num) {
if (num == 1 || num % 2 == 0 && num != 2) {
return false;
} else {
for (int i = 3; i <= Math.sqrt(num); i += 2) {
if (num % i == 0) {
return false;
}
}
}
return true;
}
让我怎能过大年
【问题描述】
有如下的加法算式。其中每个汉字代表一个数字。
（如存在对齐问题，可参见【图1.png】）
年
大年
过大年
能过大年
怎能过大年
我怎能过大年
- 让我怎能过大年
能能能能能能能
请填写“让我怎能过大年” 所代表的整数。
所有数字连在一起，中间不要空格。例如："3125697"。当然，这个不是正确的答案。
注意：只填写一个整数，不要填写任何多余的内容。
【答案】1572836 or 2072836
【代码】
public static void main(String[] args) {
int a[] = new int[7];
int sum = 0;
String str = "";
char temp;
for (long i = 1000000; i <= 9999999; i++) {
sum = 0;
for (int j = 0; j < 7; j++) {
a[j] = (int) (i % Math.pow(10, j + 1));
sum = sum + a[j];
}
temp = String.valueOf(i).charAt(3);
str = "" + temp + temp + temp + temp + temp + temp + temp;
if (sum == Integer.valueOf(str)) {
System.out.println(i);
}
}
}
位平方和
【问题描述】
把一个整数的每个数位都平方后求和，又得到一个整数，我们称这个整数为：位平方和。
对新得到的整数仍然可以继续这一运算过程。
比如，给定整数为4，则一系列的运算结果为：
16,37,58,89,....
本题的要求是，已知一个整数x，求第n步的运算结果。
【数据格式要求】
输入，两个整数x n，中间以空格分开。表示求x的第n步位平方和。其中，x，n都大于0，且小于100000。
输出，一个整数，表示所求结果。
例如，
【输入】
4 3
则程序应该输出：
58
【输入】
1314 10
则程序应该输出：
20
【资源约定】
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
【代码】
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int x = scan.nextInt();
int n = scan.nextInt();
int sum = 0;
while (n > 0) {
sum = 0;
String temp = String.valueOf(x);
for (int i = 0; i < temp.length(); i++) {
sum = sum + (int) Math.pow(temp.charAt(i)-'0', 2);
}
x = sum;
n--;
}
System.out.println(x);
}
单位分数
【问题描述】
形如：1/a 的分数称为单位分数。
可以把1分解为若干个互不相同的单位分数之和。
例如：
1 = 1/2 + 1/3 + 1/9 + 1/18
1 = 1/2 + 1/3 + 1/10 + 1/15
1 = 1/3 + 1/5 + 1/7 + 1/9 + 1/11 + 1/15 + 1/35 + 1/45 + 1/231
等等，类似这样的分解无穷无尽。
我们增加一个约束条件：最大的分母必须不超过30
请你求出分解为n项时的所有不同分解法。
数据格式要求：
输入一个整数n，表示要分解为n项（n<12）
输出分解后的单位分数项，中间用一个空格分开。
每种分解法占用一行，行间的顺序按照分母从小到大排序。
【输入】
4
【输出】
1/2 1/3 1/8 1/24
1/2 1/3 1/9 1/18
1/2 1/3 1/10 1/15
1/2 1/4 1/5 1/20
1/2 1/4 1/6 1/12
【输入】
5
【输出】
1/2 1/3 1/12 1/21 1/28
1/2 1/4 1/6 1/21 1/28
1/2 1/4 1/7 1/14 1/28
1/2 1/4 1/8 1/12 1/24
1/2 1/4 1/9 1/12 1/18
1/2 1/4 1/10 1/12 1/15
1/2 1/5 1/6 1/12 1/20
1/3 1/4 1/5 1/6 1/20
【资源约定】
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 2000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
【代码】
static long tmp = 2329089562800l;
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
while (input.hasNext()) {
int n = input.nextInt();
int arr[] = new int[n];
f2(arr, 0, 0, 0);
return;
}
}
public static void f2(int arr[], int k, int t, long res) {
if (k == arr.length) {
long sum = 0;
if (res == tmp) {
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.println("1/" + arr[i]);
} else {
System.out.print("1/" + arr[i] + " ");
}
}
}
return;
}
if (k==arr.length-3) {//在这个位置检查前面的项数和是否超过了1
if (res>tmp) {
return;
}
}
for (int i=t+1;i<30;i++) {//题目应该是分母不能超过30
arr[k]=i;
f2(arr,k+1,i,res+tmp / i);
}
}
上下楼梯
【问题描述】
有n级台阶。从地面（第0级）出发，首先连续的上台阶，上到不超过第n级的某一个位置后再连续的下台阶，直到回到地面。若每次上下台阶只允许走1级或2级，请问可能的上下台阶的方案数是多少？
特别地，在0级站着不动也算一种方案。
数据格式：
输入一行包含两个正整数n和m。
输出一个整数，表示n级台阶有多少种合法的走楼梯方案，答案对m取余。
例如：输入：
2 10007
程序应该输出
6
【样例说明1】
共有6种方案(其中+表示上台阶，-表示下台阶)：
(1) 原地不动
(2) +1 -1
(3) +2 -2
(4) +2 -1 -1
(5) +1 +1 -2
(6) +1 +1 -1 -1
再例如，输入：
3 14
程序应该输出：
1
【样例说明2】
共有15种方案，对14取余后得1。
【数据规模】
对于30%的数据，n<=10000；
对于100%的数据，n<=1017，m<=2*109。
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
【代码】
static int n;
static int god;
static int ans;
static int sum;
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
n = scan.nextInt();
god = scan.nextInt();
for(int i=0;i<=n;i++) {
ans = 0;
fun(i,0);
sum = sum + ans*ans;
}
System.out.println(sum%god);
}
public static void fun(int i,int now) { // i目标楼梯 k现在楼梯
if(now==i) {
ans++;
return;
}
if(now>i) {
return;
}
fun(i,now+1); // 上一阶楼梯
fun(i,now+2); // 上两阶楼梯
}
2015年JavaC组 ————蓝桥杯第六届
隔行变色
Excel表的格子很多，为了避免把某行的数据和相邻行混淆，可以采用隔行变色的样式。
小明设计的样式为：第1行蓝色，第2行白色，第3行蓝色，第4行白色，....
现在小明想知道，从第21行到第50行一共包含了多少个蓝色的行。
请你直接提交这个整数，千万不要填写任何多余的内容。
【答案】15
【代码】
public static void main(String[] args) {
int ans = 0;
for (int i = 21; i <= 50; i++) {
if (i % 2 != 0) {
ans++;
}
}
System.out.println(ans);
}
立方尾不变
有些数字的立方的末尾正好是该数字本身。
比如：1,4,5,6,9,24,25,....
请你计算一下，在10000以内的数字中（指该数字，并非它立方后的数值），符合这个特征的正整数一共有多少个。
请提交该整数，不要填写任何多余的内容。
【答案】36
【代码】
public static void main(String[] args) {
int ans = 0;
for (int i = 1; i <= 10000; i++) {
if (fun(i)) {
ans++;
}
}
System.out.println(ans);
}
public static boolean fun(int i) {
String str1 = String.valueOf(i);
String str2 = String.valueOf((long) Math.pow(i, 3));
if (str1.equals(str2.substring(str2.length() - str1.length()))) {
System.out.println(str1);
return true;
}
return false;
}
无穷分数
无穷的分数，有时会趋向于固定的数字。
请计算【图1.jpg】所示的无穷分数，要求四舍五入，精确到小数点后5位，小数位不足的补0。
请填写该浮点数，不能填写任何多余的内容。
【答案】0.58198
【代码】
public static void main(String[] args) {
BigDecimal fn = new BigDecimal(BigInteger.ONE);
for(int i=2000;i>=1;i--) {
BigDecimal ii = new BigDecimal(BigInteger.valueOf(i));
fn = ii.divide(fn.add(ii),6,BigDecimal.ROUND_HALF_UP);
}
System.out.println(fn.toPlainString());
}
循环节长度 Debug找规律
两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。
比如，11/13=6=>0.846153846153..... 其循环节为[846153] 共有6位。
下面的方法，可以求出循环节的长度。
请仔细阅读代码，并填写划线部分缺少的代码。
public static int f(int n, int m)
{
n = n % m;
Vector v = new Vector();
for(;;)
{
v.add(n);
n *= 10;
n = n % m;
if(n==0) return 0;
if(v.indexOf(n)>=0) _________________________________ ; //填空
}
}
注意，只能填写缺少的部分，不要重复抄写已有代码。不要填写任何多余的文字。
【答案】return v.size()
格子中输出
stringInGrid方法会在一个指定大小的格子中打印指定的字符串。
要求字符串在水平、垂直两个方向上都居中。
如果字符串太长，就截断。
如果不能恰好居中，可以稍稍偏左或者偏上一点。
下面的程序实现这个逻辑，请填写划线部分缺少的代码。
public static void stringInGrid(int width, int height, String s)
{
if(s.length()>width-2) s = s.substring(0,width-2);
System.out.print("+");
for(int i=0;i<width-2;i++) System.out.print("-");
System.out.println("+");
for(int k=1; k<(height-1)/2;k++){
System.out.print("|");
for(int i=0;i<width-2;i++) System.out.print(" ");
System.out.println("|");
}
System.out.print("|");
String ff = _______________________________________________________; //填空
System.out.print(String.format(ff,"",s,""));
System.out.println("|");
for(int k=(height-1)/2+1; k<height-1; k++){
System.out.print("|");
for(int i=0;i<width-2;i++) System.out.print(" ");
System.out.println("|");
}
System.out.print("+");
for(int i=0;i<width-2;i++) System.out.print("-");
System.out.println("+");
}
对于题目中数据，应该输出：
+------------------+
| |
| abcd1234 |
| |
| |
+------------------+
（如果出现对齐问题，参看【图1.jpg】）
【答案】"%"+(width-2-s.length())/2+"s%s%"+(width-2-s.length()-(width-2-s.length())/2)+"s"
奇妙的数字
【问题描述】
奇妙的数字
小明发现了一个奇妙的数字。它的平方和立方正好把0~9的10个数字每个用且只用了一次。
你能猜出这个数字是多少吗？
请填写该数字，不要填写任何多余的内容。
【答案】69
【代码】
public static void main(String[] args) {
String str = "0123456789";
for (int i = 1;; i++) {
char temp[] = (String.valueOf((int) (Math.pow(i, 2))) + String.valueOf((int) (Math.pow(i, 3))))
.toCharArray();
if (temp.length == 10) {
Arrays.sort(temp);
String result = new String(temp);
if (result.equals(str)) {
System.out.println(i);
break;
}
}
}
}
加法变乘法
【问题描述】
我们都知道：1+2+3+ ... + 49 = 1225
现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015
比如：
1+2+3+...+1011+12+...+2728+29+...+49 = 2015
就是符合要求的答案。
请你寻找另外一个可能的答案，并把位置靠前的那个乘号左边的数字提交（对于示例，就是提交10）。
注意：需要你提交的是一个整数，不要填写任何多余的内容。
【答案】16
【代码】
public static void main(String[] args) {
for (int i = 1; i <= 46; i++) {
for(int j=i+2;j<=48;j++) {
if(i*(i+1)-(i+i+1)+j*(j+1)-(j+j+1)==2015-1225) {
System.out.println(i+" "+j);
}
}
}
}
移动的距离
【问题描述】
X星球居民小区的楼房全是一样的，并且按矩阵样式排列。其楼房的编号为1,2,3...
当排满一行时，从下一行相邻的楼往反方向排号。
比如：当小区排号宽度为6时，开始情形如下：
1 2 3 4 5 6
12 11 10 9 8 7
13 14 15 .....
我们的问题是：已知了两个楼号m和n，需要求出它们之间的最短移动距离（不能斜线方向移动）
输入为3个整数w m n，空格分开，都在1到10000范围内
要求输出一个整数，表示m n 两楼间最短移动距离。
例如：
用户输入：
6 8 2
则，程序应该输出：
4
再例如：
用户输入：
4 7 20
则，程序应该输出：
5
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
【代码】
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int w = scan.nextInt();
int m = scan.nextInt();
int n = scan.nextInt();
System.out.println(fun(w, m, n));
}
public static int fun(int w, int m, int n) {
int d1 = (int) Math.ceil((double)m / w); // m 的楼层
int d2 = (int) Math.ceil((double)n / w); // n 的楼层
int right1 = 0;
int right2 = 0;
if (d1 % 2 == 0) {
right1 = (d1-1) * w + 1;
}else {
right1 = d1 * w;
}
if (d2 % 2 == 0) {
right2 = (d2-1) * w + 1;
}else {
right2 = d2 * w;
}
return (int) Math.abs(d1 - d2) + (int) Math.abs(Math.abs(right1-m) - Math.abs(right2-n));
}
打印大X
【问题描述】
小明希望用星号拼凑，打印出一个大X，他要求能够控制笔画的宽度和整个字的高度。
为了便于比对空格，所有的空白位置都以句点符来代替。
要求输入两个整数m n，表示笔的宽度，X的高度。用空格分开(0<m<n, 3<n<1000, 保证n是奇数)
要求输出一个大X
例如，用户输入：
3 9
程序应该输出：
.....
.....
.....
......
........
......
.....
.....
.....
（如有对齐问题，参看【图1.jpg】）
再例如，用户输入：
4 21
程序应该输出
................
................
................
................
................
................
................
................
........**........
..................
....................
..................
........***........
................
................
................
................
................
................
................
................
（如有对齐问题，参看【图2.jpg】）
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
【代码】
static char img[][];
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int m = scan.nextInt();
int n = scan.nextInt();
img = new char[n][n-1+m];
fun(m,n);
}
public static void fun(int m,int n) {
for(int i=0;i<=(n-1)/2;i++) {
for(int j=0;j<i;j++) {
img[i][j] = '.';
}
for(int j=i;j<m+i;j++) {
img[i][j] = '*';
}
for(int j=i+m;j<(n-1)-i;j++) {
img[i][j] = '.';
}
for(int j=(n-1)-i;j<(n-1)+m-i;j++) {
img[i][j] = '*';
}
for(int j=(n-1)+m-i;j<(n-1)+m;j++) {
img[i][j] = '.';
}
}
// copy下半部分
for(int i=0;i<n-(n-1)/2;i++) {
for(int j=0;j<n-1+m;j++) {
img[n-i-1][j] = img[i][j];
}
}
// 打印
for(int i=0;i<img.length;i++) {
for(int j =0 ;j<img[i].length;j++) {
System.out.print(img[i][j]);
}
System.out.println();
}
}
垒骰子
【问题描述】
赌圣atm晚年迷恋上了垒骰子，就是把骰子一个垒在另一个上边，不能歪歪扭扭，要垒成方柱体。
经过长期观察，atm 发现了稳定骰子的奥秘：有些数字的面贴着会互相排斥！
我们先来规范一下骰子：1 的对面是 4，2 的对面是 5，3 的对面是 6。
假设有 m 组互斥现象，每组中的那两个数字的面紧贴在一起，骰子就不能稳定的垒起来。 atm想计算一下有多少种不同的可能的垒骰子方式。
两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同。
由于方案数可能过多，请输出模 10^9 + 7 的结果。
不要小看了 atm 的骰子数量哦～
「输入格式」
第一行两个整数 n m
n表示骰子数目
接下来 m 行，每行两个整数 a b ，表示 a 和 b 不能紧贴在一起。
「输出格式」
一行一个数，表示答案模 10^9 + 7 的结果。
「样例输入」
2 1
1 2
「样例输出」
544
「数据范围」
对于 30% 的数据：n <= 5
对于 60% 的数据：n <= 100
对于 100% 的数据：0 < n <= 10^9, m <= 36
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 2000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
【代码】
static int op[] = new int[7];
private static int n;
private static int m;
private static final Long mod = 1000000007L;
static void init(){
op[1]=4;
op[4]=1;
op[2]=5;
op[5]=2;
op[3]=6;
op[6]=3;
}
public static void main(String[] args) {
init();
Scanner sc = new Scanner(System.in);
n = sc.nextInt();//骰子数
m = sc.nextInt();//组合数
long conflict[][] = new long[6][6];
for (int i=0;i<6;i++){
for (int j=0;j<6;j++){
conflict[i][j]=1;
}
}
//建立冲突矩阵
for (int i=0;i<m;i++){
int a = sc.nextInt();
int b = sc.nextInt();
conflict[op[a]-1][b-1]=0;
conflict[op[b]-1][a-1]=0;
}
//求冲突矩阵的n-1次方
long[][] mPow_n_1 = mPow(conflict,n-1);
//累加矩阵的每个元素
long ans = 0;
for (int i=0;i<6;i++){
for (int j=0;j<6;j++){
ans = (ans+mPow_n_1[i][j])%mod;
}
}
System.out.println((ans*(pow(4,n)))%mod);
}
private static long pow(long i, int n) {
long ans = 1;
while (n!=0){
if ((n&1)==1){
ans = (ans*i)%mod;
}
i = i*i%mod;
n >>=1;
}
return ans;
}
private static long[][] mPow(long[][] conflict, int n) {
//建立单位矩阵
long[][] ans = new long[6][6];
for (int i=0;i<6;i++){
for (int j=0;j<6;j++){
if (i==j){
ans[i][j]=1;
}else {
ans[i][j]=0;
}
}
}
while (n!=0){
if ((n&1)==1){
ans = mMul(ans,conflict);
}
conflict = mMul(conflict,conflict);
//向右移一位
n>>=1;
}
return ans;
}
private static long[][] mMul(long[][] a, long[][] b) {
long[][] ans = new long[6][6];
for (int i=0;i<6;i++){
for (int j=0;j<6;j++){
for (int k=0;k<6;k++){
ans[i][j] = (ans[i][j]+a[i][k]*b[k][j])%mod;
}
}
}
return ans;
}
2016年JavaC组————蓝桥杯第七届
有奖猜谜
【问题描述】
小明很喜欢猜谜语。
最近，他被邀请参加了X星球的猜谜活动。
每位选手开始的时候都被发给777个电子币。
规则是：猜对了，手里的电子币数目翻倍，
猜错了，扣除555个电子币, 扣完为止。
小明一共猜了15条谜语。
战果为：vxvxvxvxvxvxvvx
其中v表示猜对了，x表示猜错了。
请你计算一下，小明最后手里的电子币数目是多少。
请填写表示最后电子币数目的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
【答案】58497
【代码】
public static void main(String[] args) {
String string = "vxvxvxvxvxvxvvx";
int maney = 777;
for(int i=0;i<string.length();i++) {
if(string.charAt(i)=='v') {
maney = maney * 2;
}else {
maney = maney - 555;
}
}
System.out.println(maney);
}
煤球的数目
【问题描述】
有一堆煤球，堆成三角棱锥形。具体：
第一层放1个，
第二层3个（排列成三角形），
第三层6个（排列成三角形），
第四层10个（排列成三角形），
....
如果一共有100层，共有多少个煤球？
请填表示煤球总数目的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
【答案】171700
【代码】
public static void main(String[] args) {
int down = 0;
int sum = 0;
for(int i=1;i<=100;i++) {
down = (int)Math.pow(i,2) - down;
sum = sum + down;
}
System.out.println(sum);
}
平方怪圈
【问题描述】
如果把一个正整数的每一位都平方后再求和，得到一个新的正整数。
对新产生的正整数再做同样的处理。
如此一来，你会发现，不管开始取的是什么数字，
最终如果不是落入1，就是落入同一个循环圈。
请写出这个循环圈中最大的那个数字。
请填写该最大数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
【答案】145
【代码】
public static void main(String[] args) {
String init;
int m = 66;
for(int i=1;i<=100;i++) {
init = String.valueOf(m);
m = 0;
System.out.println(init);
for(int j=0;j<init.length();j++) {
m = m + (int)Math.pow(Integer.parseInt(String.valueOf(init.charAt(j))),2);
}
}
//145
}
骰子游戏
【问题描述】
我们来玩一个游戏。
同时掷出3个普通骰子（6个面上的数字分别是1~6）。
如果其中一个骰子上的数字等于另外两个的和，你就赢了。
下面的程序计算出你能获胜的精确概率（以既约分数表示）
public class Main
{
public static int gcd(int a, int b)
{
if(b==0) return a;
return gcd(b,a%b);
}
public static void main(String[] args)
{
int n = 0;
for(int i=0; i<6; i++)
for(int j=0; j<6; j++)
for(int k=0; k<6; k++){
if(________________________________) n++; //填空位置
}
int m = gcd(n,6*6*6);
System.out.println(n/m + "/" + 6*6*6/m);
}
}
仔细阅读代码，填写划线部分缺少的内容。
注意：不要填写任何已有内容或说明性文字。
【答案】i+j+2k+1||i+k+2j+1||j+k+2==i+1
分小组 全排列
【问题描述】
9名运动员参加比赛，需要分3组进行预赛。
有哪些分组的方案呢？
我们标记运动员为 A,B,C,... I
下面的程序列出了所有的分组方法。
该程序的正常输出为：
ABC DEF GHI
ABC DEG FHI
ABC DEH FGI
ABC DEI FGH
ABC DFG EHI
ABC DFH EGI
ABC DFI EGH
ABC DGH EFI
ABC DGI EFH
ABC DHI EFG
ABC EFG DHI
ABC EFH DGI
ABC EFI DGH
ABC EGH DFI
ABC EGI DFH
ABC EHI DFG
ABC FGH DEI
ABC FGI DEH
ABC FHI DEG
ABC GHI DEF
ABD CEF GHI
ABD CEG FHI
ABD CEH FGI
ABD CEI FGH
ABD CFG EHI
ABD CFH EGI
ABD CFI EGH
ABD CGH EFI
ABD CGI EFH
ABD CHI EFG
ABD EFG CHI
..... (以下省略，总共560行)。
public class A
{
public static String remain(int[] a)
{
String s = "";
for(int i=0; i<a.length; i++){
if(a[i] == 0) s += (char)(i+'A');
}
return s;
}
public static void f(String s, int[] a)
{
for(int i=0; i<a.length; i++){
if(a[i]==1) continue;
a[i] = 1;
for(int j=i+1; j<a.length; j++){
if(a[j]==1) continue;
a[j]=1;
for(int k=j+1; k<a.length; k++){
if(a[k]==1) continue;
a[k]=1;
System.out.println(__________________________________); //填空位置
a[k]=0;
}
a[j]=0;
}
a[i] = 0;
}
}
public static void main(String[] args)
{
int[] a = new int[9];
a[0] = 1;
for(int b=1; b<a.length; b++){
a[b] = 1;
for(int c=b+1; c<a.length; c++){
a[c] = 1;
String s = "A" + (char)(b+'A') + (char)(c+'A');
f(s,a);
a[c] = 0;
}
a[b] = 0;
}
}
}
仔细阅读代码，填写划线部分缺少的内容。
注意：不要填写任何已有内容或说明性文字。
【答案】s+" "+(char)(i+'A')+(char)(j+'A')+(char)(k+'A')+" "+remain(a)
凑算式 递归全排列
【问题描述】
B DEF
A + --- + ------- = 10
C GHI
（如果显示有问题，可以参见【图1.jpg】）
这个算式中AI代表19的数字，不同的字母代表不同的数字。
比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。
这个算式一共有多少种解法？
注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。
【答案】29
【代码】
static int ans = 0;
public static void main(String[] args) {
int a[] = {1,2,3,4,5,6,7,8,9};
fun(a,0,a.length-1);
System.out.println(ans);
}
public static void fun(int a[],int start,int end) {
if(start==end) {
double A = a[0];
double B = a[1];
double C = a[2];
double DEF = a[3]*100+a[4]*10+a[5];
double GHI = a[6]*100+a[7]*10+a[8];
if((A*GHI*C+B*GHI+DEF*C)/(GHI*C)==10) {
ans++;
}
}else {
for(int i=start;i<=end;i++) {
swap(a,start,i);
fun(a,start+1,end);
swap(a,start,i);
}
}
}
public static void swap(int a[],int n,int m) {
int temp = a[n];
a[n] = a[m];
a[m] = temp;
}
搭积木 递归全排列
【问题描述】
小明最近喜欢搭数字积木，
一共有10块积木，每个积木上有一个数字，0~9。
搭积木规则：
每个积木放到其它两个积木的上面，并且一定比下面的两个积木数字小。
最后搭成4层的金字塔形，必须用完所有的积木。
下面是两种合格的搭法：
0
1 2
3 4 5
6 7 8 9
0
3 1
7 5 2
9 8 6 4
请你计算这样的搭法一共有多少种？
请填表示总数目的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
【答案】768
【代码】
static int ans = 0;
public static void main(String[] args) {
int a[] = {0,1,2,3,4,5,6,7,8,9};
fun(a,1,a.length-1);
System.out.println(ans);
}
public static void fun(int a[],int start,int end) {
if(start==end) {
if(a[1]>a[0]&&a[2]>a[0]&&a[3]>a[1]&&a[4]>a[1]&&a[4]>a[2]&&a[5]>a[2]&&a[6]>a[3]&&a[7]>a[3]&&a[7]>a[4]&&a[8]>a[4]&&a[8]>a[5]&&a[9]>a[5]) {
ans++;
}
}else {
for(int i=start;i<=end;i++) {
swap(a,start,i);
fun(a,start+1,end);
swap(a,start,i);
}
}
}
public static void swap(int a[],int n,int m) {
int temp = a[n];
a[n] = a[m];
a[m] = temp;
}
冰雹数
【问题描述】
任意给定一个正整数N，
如果是偶数，执行： N / 2
如果是奇数，执行： N * 3 + 1
生成的新的数字再执行同样的动作，循环往复。
通过观察发现，这个数字会一会儿上升到很高，
一会儿又降落下来。
就这样起起落落的，但最终必会落到“1”
这有点像小冰雹粒子在冰雹云中翻滚增长的样子。
比如N=9
9,28,14,7,22,11,34,17,52,26,13,40,20,10,5,16,8,4,2,1
可以看到，N=9的时候，这个“小冰雹”最高冲到了52这个高度。
输入格式：
一个正整数N（N<1000000）
输出格式：
一个正整数，表示不大于N的数字，经过冰雹数变换过程中，最高冲到了多少。
例如，输入：
10
程序应该输出：
52
再例如，输入：
100
程序应该输出：
9232
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
【代码】
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int max = 1;
for(int i=1;i<=N;i++) {
if(max<f(i)) {
max = f(i);
}
}
System.out.println(max);
}
public static int f(int N) {
int max = 1 ;
while(true) {
if(N == 1) {
break;
}
if(N%2==0) {
N = N/2;
}else {
N = N*3+1;
}
if(max<N) {
max = N;
}
}
return max;
}
四平方和
【问题描述】
四平方和定理，又称为拉格朗日定理：
每个正整数都可以表示为至多4个正整数的平方和。
如果把0包括进去，就正好可以表示为4个数的平方和。
比如：
5 = 0^2 + 0^2 + 1^2 + 2^2
7 = 1^2 + 1^2 + 1^2 + 2^2
（^符号表示乘方的意思）
对于一个给定的正整数，可能存在多种平方和的表示法。
要求你对4个数排序：
0 <= a <= b <= c <= d
并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法
程序输入为一个正整数N (N<5000000)
要求输出4个非负整数，按从小到大排序，中间用空格分开
例如，输入：
5
则程序应该输出：
0 0 1 2
再例如，输入：
12
则程序应该输出：
0 2 2 2
再例如，输入：
773535
则程序应该输出：
1 1 267 838
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 3000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
【代码】
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
for (int i = 0; i < Math.sqrt(n); i++) {
for (int j = i; j < Math.sqrt(n); j++) {
for (int k = j; k < Math.sqrt(n); k++) {
for (int m = k; m < Math.sqrt(n); m++) {
if (i * i + j * j + k * k + m * m == n) {
System.out.println(i + " " + j + " " + k + " " + m);
return;
}
}
}
}
}
}
密码脱落 dfs
【问题描述】
X星球的考古学家发现了一批古代留下来的密码。
这些密码是由A、B、C、D 四种植物的种子串成的序列。
仔细分析发现，这些密码串当初应该是前后对称的（也就是我们说的镜像串）。
由于年代久远，其中许多种子脱落了，因而可能会失去镜像的特征。
你的任务是：
给定一个现在看到的密码串，计算一下从当初的状态，它要至少脱落多少个种子，才可能会变成现在的样子。
输入一行，表示现在看到的密码串（长度不大于1000）
要求输出一个正整数，表示至少脱落了多少个种子。
例如，输入：
ABCBA
则程序应该输出：
0
再例如，输入：
ABDCDCBABC
则程序应该输出：
3
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 3000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
【代码】
static String string;
static int ans1 = 0;
static int ans2 = 0;
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
string = scan.next();
fun1(0, string.length() - 1);
fun2(0, string.length() - 1);
if (ans1 >= ans2) {
System.out.println(ans2);
}else {
System.out.println(ans1);
}
}
// 左补
public static void fun1(int start, int end) {
if (start >= end) {
return;
}
if (string.charAt(start) != string.charAt(end)) {
fun1(start, end - 1);
ans1++;
} else {
fun1(start + 1, end - 1);
}
}
// 右补
public static void fun2(int start, int end) {
if (start >= end) {
return;
}
if (string.charAt(start) != string.charAt(end)) {
fun2(start + 1, end);
ans2++;
} else {
fun2(start + 1, end - 1);
}
}
2017年JavaC组————第八届蓝桥杯
外形日历
【问题描述】
某星系深处发现了文明遗迹。
他们的计数也是用十进制。
他们的文明也有日历。日历只有天数，没有年、月的概念。
有趣的是，他们也使用了类似“星期”的概念，
只不过他们的一个星期包含了9天，
为了方便，这里分别记为: A,B,C....H,I
从一些资料上看到，
他们的23日是星期E
他们的190日是星期A
他们的343251日是星期I
令人兴奋的是，他们居然也预见了“世界末日”的那天，
当然是一个很大很大的数字
651764141421415346185
请你计算一下，这遥远的一天是该文明的星期几？
你需要提交的是一个大写字母，表示该文明的星期几，
不要填写任何多余的内容。
【答案】G
【代码】
public static void main(String[] args) {
String string = "ABCDEFGHI";
BigInteger b1 = new BigInteger("651764141421415346185");
BigInteger b2 = new BigInteger("9");
System.out.println(string.charAt(b1.mod(b2).intValue()-1));
}
兴趣小组
【问题描述】
为丰富同学们的业余文化生活，某高校学生会创办了3个兴趣小组
(以下称A组，B组，C组)。
每个小组的学生名单分别在【A.txt】,【B.txt】和【C.txt】中。
每个文件中存储的是学生的学号。
由于工作需要，我们现在想知道：
既参加了A组，又参加了B组，但是没有参加C组的同学一共有多少人？
请你统计该数字并通过浏览器提交答案。
注意：答案是一个整数，不要提交任何多余的内容。
笨笨有话说：
哇塞！数字好多啊！一眼望过去就能发现相同的，好像没什么指望。
不过，可以排序啊，要是每个文件都是有序的，那就好多了。
歪歪有话说：
排什么序啊，这么几行数字对计算机不是太轻松了吗？
我看着需求怎么和中学学过的集合很像啊.....
【答案】20
【代码】
public static void main(String[] args) throws IOException {
Set<String> A = new HashSet<String>();
Set<String> B = new HashSet<String>();
Set<String> C = new HashSet<String>();
read(A, "files/A.txt");
read(B, "files/B.txt");
read(C, "files/C.txt");
int ans = 0;
for (String a : A) {
if (B.contains(a) && !C.contains(a))
ans++;
}
System.out.println(ans);
}
public static void read(Set<String> set, String path) throws IOException {
BufferedReader reader = new BufferedReader(new FileReader(path));
String line = "";
while (true) {
line = reader.readLine();
if (line == null)
break;
String[] split = line.split(",");
for (String s : split) {
String trim = s.trim();
if (trim.length() > 0)
set.add(s.trim());
}
}
reader.close();
}
纸牌三角形 递归全排列
【问题描述】
A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。
下图就是一种排法（如有对齐问题，参看p1.png）。
A
9 6
4 8
3 7 5 2
这样的排法可能会有很多。
如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？
请你计算并提交该数字。
注意：需要提交的是一个整数，不要提交任何多余内容。
笨笨有话说：
感觉可以暴力破解哦。
麻烦的是，对每个排法还要算出它的旋转、镜像排法，看看有没有和历史重复。
歪歪有话说：
人家又不让你把所有情况都打印出来，只是要算种类数。
对于每个基本局面，通过旋转、镜像能造出来的新局面数目不是固定的吗？
【答案】144
【代码】
static int ans=0;
public static void main(String[] args) {
int a[] = {1,2,3,4,5,6,7,8,9};
fun(a,0,a.length-1);
System.out.println(ans/6);
}
public static void fun(int a[],int start,int end) {
if(start==end) {
int l1 = a[0]+a[1]+a[2]+a[3];
int l2 = a[3]+a[4]+a[5]+a[6];
int l3 = a[6]+a[7]+a[8]+a[0];
if(l1==l2&&l2==l3) {
ans++;
}
}else {
for(int i=start;i<=end;i++) {
swap(a,start,i);
fun(a,start+1,end);
swap(a,start,i);
}
}
}
public static void swap(int a[],int m,int n) {
int temp = a[m];
a[m] = a[n];
a[n] = temp;
}
承压计算
【问题描述】
X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。
每块金属原料的外形、尺寸完全一致，但重量不同。
金属材料被严格地堆放成金字塔形。
7
5 8
7 8 8
9 2 7 2
8 1 4 9 1
8 1 8 8 4 1
7 9 6 1 4 5 4
5 6 5 5 6 9 5 6
5 5 4 7 9 3 5 5 1
7 5 7 9 7 4 7 3 3 1
4 6 4 5 5 8 8 3 2 4 3
1 1 3 3 1 6 6 5 5 4 4 2
9 9 9 2 1 9 1 9 2 9 5 7 9
4 3 3 7 7 9 3 6 1 3 8 8 3 7
3 6 8 1 5 3 9 5 8 3 8 1 8 3 3
8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9
8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4
2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9
7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6
9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3
5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9
6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4
2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4
7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6
1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3
2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8
7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9
7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6
5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1
X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X
其中的数字代表金属块的重量（计量单位较大）。
最下一层的X代表30台极高精度的电子秤。
假设每块原料的重量都十分精确地平均落在下方的两个金属块上，
最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。
电子秤的计量单位很小，所以显示的数字很大。
工作人员发现，其中读数最小的电子秤的示数为：2086458231
请你推算出：读数最大的电子秤的示数为多少？
注意：需要提交的是一个整数，不要填写任何多余的内容。
笨笨有话说：
不断的除2，加到下面，除2,加到下面,.... 不会浮点精度溢出吧？
歪歪有话说：
怕除不开还不好办， 把每个数字扩大一定的倍数不就好了。
【答案】72665192664
【代码】
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
double a[][] = new double[30][30];
for (int i = 0; i < a.length - 1; i++) {
for (int j = 0; j <= i; j++) {
a[i][j] = scan.nextDouble();
}
}
for (int i = 0; i < a.length - 1; i++) {
for (int j = 0; j <= i; j++) {
a[i + 1][j] = a[i + 1][j] + a[i][j] / 2;
a[i + 1][j + 1] = a[i + 1][j + 1] + a[i][j] / 2;
}
}
double minVal = Double.MAX_VALUE; //该值为常数，表示double能够表示的最大数
double maxVal = Double.MIN_VALUE;
for(int i=0;i<30;i++){
if(a[29][i]<minVal)
minVal = a[29][i];
if(a[29][i]>maxVal)
maxVal = a[29][i];
}
System.out.println((2086458231.0 * maxVal)/ minVal);
}
杨辉三角
【问题描述】
杨辉三角也叫帕斯卡三角，在很多数量关系中可以看到，十分重要。
第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(col0) return 1;
if(colrow) 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));
}
}
请仔细分析源码，并完成划线部分缺少的代码。
注意：只提交缺少的代码，不要提交已有的代码和符号。也不要提交说明性文字。
【答案】int q = p-1;q>=1;q--
最大公共子串
【问题描述】
最大公共子串就是求两个串的所有子串中能够匹配上的最大长度是多少。
比如："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);
}
}
注意：只提交缺少的代码，不要提交已有的代码和符号。也不要提交说明性文字。
【答案】a[i][j] = a[i-1][j-1] + 1
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
歪歪有话说：
要是从字母序列转数字还好点，倒过来有点麻烦，不过计算机跑得快啊。
【代码】
public static void main(String[] args) {
String string = "ZABCDEFGHIJKLMNOPQRSTUVWXY";
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
String result = "";
while (n!=0) {
result = string.charAt(n%26) + result;
if(n%26==0) {
n = n/26-1;
}else {
n = n/26;
}
}
System.out.println(result);
}
拉马车
【问题描述】
小的时候，你玩过纸牌游戏吗？
有一种叫做“拉马车”的游戏，规则很简单，却很吸引小朋友。
其规则简述如下：
假设参加游戏的小朋友是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，否则按无效代码处理。
笨笨有话说：
不断删除前边的，又要后边添加.... 如果用数组，需要开一个大点的，请佛祖保佑在游戏结束前，不会用到数组的边缘。
歪歪有话说：
反正串也不长，不如每次操作都返回一个新的串。
默默有话说：
我一般都不吱声，这是典型的队列结构，动态数组最好，没有？自己造一个呗！
【代码】
static StringBuilder A;
static StringBuilder B;
static StringBuilder C = new StringBuilder();
static boolean op(StringBuilder x,StringBuilder z) {
if(x.length()==0)return false;
boolean ans = true;
char front = x.charAt(0);
int i=z.indexOf(front+"");
if(i!=-1) {
x.append(front);
for(int j=0;j<=i;++j) {
x.append(z.charAt(j));
}
z.delete(0,i+1);
}else {
z.insert(0,front);
ans = false;
}
x.deleteCharAt(0);
return ans;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String a = sc.nextLine();
String b = sc.nextLine();
A = new StringBuilder(a);
B = new StringBuilder(b);
boolean flagA = true;
boolean flagB= false;
while(true) {
if(flagA) {
flagA = op(A,C);
if(A.length()==0) {
System.out.println(B);
break;
}
flagB = !flagA;
}
if(flagB) {
flagB = op(B,C);
if(B.length()==0) {
System.out.println(A);
break;
}
flagA= !flagB;
}
}
}
青蛙跳杯子 bfs广搜
【问题描述】
X星球的流行宠物是青蛙，一般有两种颜色：白色和黑色。
X星球的居民喜欢把它们放在一排茶杯里，这样可以观察它们跳来跳去。
如下图，有一排杯子，左边的一个是空着的，右边的杯子，每个里边有一只青蛙。
WWWBBB
其中，W字母表示白色青蛙，B表示黑色青蛙，表示空杯子。
X星的青蛙很有些癖好，它们只做3个动作之一：
1. 跳到相邻的空杯子里。
2. 隔着1只其它的青蛙（随便什么颜色）跳到空杯子里。
3. 隔着2只其它的青蛙（随便什么颜色）跳到空杯子里。
对于上图的局面，只要1步，就可跳成下图局面：
WWWBBB
本题的任务就是已知初始局面，询问至少需要几步，才能跳成另一个目标局面。
输入为2行，2个串，表示初始局面和目标局面。
输出要求为一个整数，表示至少需要多少步的青蛙跳。
例如：
输入：
WWBB
WWBB
则程序应该输出：
2
再例如，
输入：
WWWBBB
BBB*WWW
则程序应该输出：
10
我们约定，输入的串的长度不超过15
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
笨笨有话说：
我梦见自己是一棵大树，
青蛙跳跃，
我就发出新的枝条，
春风拂动那第 5 层的新枝,
哦，我已是枝繁叶茂。
【代码】
static String start, target;
static Set<String> allState = new HashSet<String>();
// 封装一个持有状态和层次的类
private static class StateAndLevel {
char[] state;
int level;
int pos; // (空杯子的位置)
public StateAndLevel(char[] state, int level, int pos) {
super();
this.state = state;
this.level = level;
this.pos = pos;
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
start = sc.nextLine();
target = sc.nextLine();
bfs();
}
private static void bfs() {
// 将初始状态加入队列
Queue<StateAndLevel> q = new LinkedList<StateAndLevel>();
q.add(new StateAndLevel(start.toCharArray(), 0, start.indexOf('*')));
allState.add(start);
// 不停弹出队首，一步演化成相邻状态，加入队列（判重）
while (!q.isEmpty()) {
StateAndLevel front = q.poll(); // 弹出头部
char[] state = front.state;
int level = front.level;
// 和目标值做比对
if(new String(state).equals(target)) {
System.out.println(level);
break;
}
int pos = front.pos;
// 可以演化出若干个相邻状态
for (int i = -3; i <= 3; i++) {
if (i == 0)
continue;
if (pos + i >= 0 && pos + i < state.length) {
char[] new_start = new String(state).toCharArray();
swap(new_start, pos, pos + i); // 交换达新状态
if(!allState.contains(new String(new_start))) {//判重
q.add(new StateAndLevel(new_start,level+1,pos+i));
}
}
}
}
}
private static void swap(char[] a, int i, int j) {
char temp = a[i];
a[i] = a[j];
a[j] = temp;
}
图形排版
【问题描述】
小明需要在一篇文档中加入 N 张图片，其中第 i 张图片的宽度是 Wi，高度是 Hi。
假设纸张的宽度是 M，小明使用的文档编辑工具会用以下方式对图片进行自动排版：
1. 该工具会按照图片顺序，在宽度 M 以内，将尽可能多的图片排在一行。该行的高度是行内最高的图片的高度。例如在 M=10 的纸张上依次打印 3x4, 2x2, 3x3 三张图片，则效果如下图所示，这一行高度为4。(分割线以上为列标尺，分割线以下为排版区域；数字组成的矩形为第x张图片占用的版面)
0123456789
111
111 333
11122333
11122333
2. 如果当前行剩余宽度大于0，并且小于下一张图片，则下一张图片会按比例缩放到宽度为当前行剩余宽度(高度向上取整)，然后放入当前行。例如再放入一张4x9的图片，由于剩余宽度是2，这张图片会被压缩到2x5，再被放入第一行的末尾。此时该行高度为5：
0123456789
44
111 44
111 33344
1112233344
1112233344
3. 如果当前行剩余宽度为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，否则按无效代码处理。
【代码】
public static void main(String[] arg) {
solve();
}
static StringTokenizer ST;
static BufferedReader BR;
static PrintWriter PW;
static String next() {
while(ST == null || !ST.hasMoreTokens()) {
try {
ST = new StringTokenizer(BR.readLine());
}catch (Exception e) {
// TODO: handle exception
throw new RuntimeException(e);
}
}
return ST.nextToken();
}
static int nextInt() {
return Integer.parseInt(next());
}
public static void solve() {
BR = new BufferedReader(new InputStreamReader(System.in));
PW = new PrintWriter(System.out);
int m = nextInt(), n = nextInt();
Pair a[] = new Pair[n + 10];
Triple cr[] = new Triple[n + 10];
cr[0] = new Triple();
//正向处理出加到第i块的状态，Triple记忆第i块右下坐标(x,y)和第i块缩放后的高度h
for(int i = 1; i <= n; i++) {
//创建
Triple tmp = new Triple(cr[i-1]);
//如果这一行装不下，就置零换行
if(tmp.x == m) tmp.x = tmp.h = 0;
//新建输入的宽高
a[i] = new Pair(nextInt(), nextInt());
cr[i] = new Triple();
Pair b = Change(a[i], m - tmp.x);
//保存当前的位置
cr[i].x = tmp.x + b.x;
cr[i].h = Math.max(tmp.h, b.y);
cr[i].y = cr[i].h + tmp.y - tmp.h;
}
Triple A[] = new Triple[m];
Triple B[] = new Triple[m];
for(int i = 0; i < m; i++) {
A[i] = new Triple();
B[i] = new Triple();
}
int ans = cr[n].y;
//把每一个都尝试一下
for(int i = n; i >= 1; i--) {
//处理删除第i块的答案ah
Triple pre = cr[i-1];
int ah;
if(pre.x == m) {
ah = pre.y + B[0].y;
} else {
ah = pre.y - pre.h + B[pre.x].y - B[pre.x].h + Math.max(pre.h, B[pre.x].h);
}
ans = Math.min(ans, ah);
//逆向DP，处理出第i至n块从(0,j)位置开始放置
for(int j = 0; j < m; j++) {
Pair b = Change(a[i], m - j);
Triple tmp;
//放完这个我就要换行
if(j + b.x == m) tmp = new Triple(0, B[0].y, 0);
//如果不换行，还是这个
else tmp = new Triple(B[j + b.x]);
A[j].h = Math.max(b.y, tmp.h);
A[j].y = A[j].h + tmp.y - tmp.h;
}
for(int j = 0; j < m; j++)
B[j] = new Triple(A[j]);
}
PW.print(ans);
PW.close();
}
//a的x小就返回a，否则返回
static Pair Change(Pair A, int x) {
if(A.x <= x) return new Pair(A);
return new Pair(x, (A.y * x + A.x - 1) / A.x);
}
}
class Pair implements Comparable<Pair> {
int x, y;
Pair() { }
Pair(Pair A) { x = A.x; y = A.y; }
Pair(int x, int y) {
this.x = x; this.y = y;
}
@Override
public int compareTo(Pair A) {
return x == A.x ? y - A.y : x - A.x;
}
}
class Triple {
int x, y, h;
Triple() {}
Triple(int x, int y, int h) {
this.x = x; this.y = y; this.h = h;
}
Triple(Triple A) {
x = A.x; y = A.y; h = A.h;
}
@Override
public String toString() {
return String.valueOf(x) + " " + String.valueOf(y) + " " + String.valueOf(h);
}
2018年JavaC组————蓝桥杯第九届
哪天返回
【问题描述】
小明被不明势力劫持。后被扔到x星站再无问津。小明得知每天都有飞船飞往地球，但需要108元的船票，而他却身无分文。
他决定在x星战打工。好心的老板答应包食宿，第1天给他1元钱。
并且，以后的每一天都比前一天多2元钱，直到他有足够的钱买票。
请计算一下，小明在第几天就能凑够108元，返回地球。
要求提交的是一个整数，表示第几天。请不要提交任何多余的内容。
【答案】11
【代码】
int day = 0;
int maney = 0;
for(int i=1;;i=i+2) {
maney = maney + i;
day++;
if(maney>=108) {
System.out.println(day);
break;
}
}
猴子分香蕉
【问题描述】
5只猴子是好朋友，在海边的椰子树上睡着了。这期间，有商船把一大堆香蕉忘记在沙滩上离去。
第1只猴子醒来，把香蕉均分成5堆，还剩下1个，就吃掉并把自己的一份藏起来继续睡觉。
第2只猴子醒来，重新把香蕉均分成5堆，还剩下2个，就吃掉并把自己的一份藏起来继续睡觉。
第3只猴子醒来，重新把香蕉均分成5堆，还剩下3个，就吃掉并把自己的一份藏起来继续睡觉。
第4只猴子醒来，重新把香蕉均分成5堆，还剩下4个，就吃掉并把自己的一份藏起来继续睡觉。
第5只猴子醒来，重新把香蕉均分成5堆，哈哈，正好不剩！
请计算一开始最少有多少个香蕉。
需要提交的是一个整数，不要填写任何多余的内容。
【答案】3141
【代码】
public static void main(String[] args) {
for(int i=5;;i++) {
int all = i;
int monkey1 = all%5; // 第一个猴子吃数量 1
if(monkey1!=1)continue;
all = all - (all-1)/5 - monkey1;
int monkey2 = all%5;// 第二个猴子吃数量 2
if(monkey2!=2)continue;
all = all - (all-2)/5 - monkey2;
int monkey3 = all%5;// 第三个猴子吃数量 3
if(monkey3!=3)continue;
all = all - (all-3)/5 - monkey3;
int monkey4 = all%5;// 第四个猴子吃数量 4
if(monkey4!=4)continue;
all = all - (all-4)/5 - monkey4;
if(all==0) continue;
int monkey5 = all%5;// 第五个猴子吃数量 0
if(monkey5==0) {
System.out.println(i);
break;
}
}
}
字母阵列 dfs深搜
【问题描述】
仔细寻找，会发现：在下面的8x8的方阵中，隐藏着字母序列："LANQIAO"。
SLANQIAO
ZOEXCCGB
MOAYWKHI
BCCIPLJQ
SLANQIAO
RSFWFNYA
XIFZVWAL
COAIQNAL
我们约定: 序列可以水平，垂直，或者是斜向；
并且走向不限（实际上就是有一共8种方向）。
上图中一共有4个满足要求的串。
下面有一个更大的（100x100）的字母方阵。
你能算出其中隐藏了多少个“LANQIAO”吗？
FOAIQNALWIKEGNICJWAOSXDHTHZPOLGYELORAUHOHCZIERPTOOJUITQJCFNIYYQHSBEABBQZPNGYQTCLSKZFCYWDGOAIADKLSNGJ
GSOZTQKCCSDWGUWAUOZKNILGVNLMCLXQVBJENIHIVLRPVVXXFTHQUXUAVZZOFFJHYLMGTLANQIAOQQILCDCJERJASNCTLYGRMHGF
TSDFYTLVIBHKLJVVJUDMKGJZGNNSTPVLCKTOFMUEUFSVQIAUVHNVFTGBDDARPKYNNCUOYUAZXQJNOEEYKLFRMOEMHUKJTPETHLES
FKVINSLWEVGAGMKVFVIUBMYOIAFHLVNKNTYKTZWVXQWRWIGPENFXYDTKRVPKRTHMGHVYOCLDCKMEKRLGEKBYUCLOLYPAKPFSOREH
KWPUOLOVMOFBIXYACWRDYBINTMPASPCEOKHXQIGBQQMCEOIVULIEOPFSCSIHENAJCVDPJDOIWIIULFDNOZOFVAMCABVGKAKCOZMG
XWMYRTAFGFOCNHLBGNGOXPJSTWLZUNNAGIRETGXFWAQSSJPFTQAXMTQWMZWYVEPQERKSWTSCHSQOOBGXAQTBCHOEGBDVKGWJIFTG
ZWWJEIISPLMXIMGHOOGDRZFTGNDDWDWMNUFWJYJGULPHNUFSAQNNIUVAAFZIAZKFXXNWCEABGJAUMGYEIEFVQXVHHHEDYUITRCQB
XZHDPZQTOBECJVBZLACVXACZEDYOGVAVQRNWEOWGRAQYUEUESTEDQTYJUTEFOOITSHDDZHONJGBRCWNEQLZUTBNQIADKNFIOMWZR
EBFKCVNLURZSNPOLTISRPDTNUMCDGKTYRGIOVEPTUTSBAWQKWWEUWIWHAANUZUADGZEATZOQICWFUJTWNZDBKLQNELWVTBNDLNFH
PESISEATZNCDFRMXBQUKBFTIGYSFCWVHPMSUSDKPSCOMVLDOHYQVFHAJKRDTAVLIMNZBZSMLMRTLRPSLAHXDBASDMWAAYBPYVJZF
SCCWYHLQOUKBMCEYENQNJXFOMOOJMTKDSHJJOHDKEGATFZHGWJJAZJROWHAZUFGEQKPYXLCAAXHHQBDALPYUDWZQHBASBBCFGQCQ
ZKNXUBRYZVSPQHOVLAEUAUITMPWXNXJQVIBJVBCSVXKWFAFRPRWOLYVSDVTGGOFFMNQJZOBUDJLFHJTCYMPNOBHQJHGKLIKLZMLA
POCKVEQXUAVHERIAQLGJHYOOVOMTXQFRTBFSETOZICPCHZHFBWNESVJJLSVSVOOGYYABFESWNWDNYBGBNAKRCFQMTCUMIFTESVIN
JCAULIQRYUMAMAOVVWSEUTMECXSDTONRMMROQUISYEURSAYNZUVOPXLIFBDOHPXMABBLEQZGLJXQJOEYYRRRCFTEZQAOIWKRJQDL
ZNUUDWZXZZURPMHGXQGNQBIQWWNERZWULSAPIBODBFFQQIHEQKCKLJYQNXQUTAAYGRBXSLLQNOQPZJEWHETQHPXJANMJFOHINWOW
KJGAWWFSVIZHFNUWBLWYVPIWAEICCAHOEIWRADSLOZGPSVGPUBUUQAVYCHOIGINKYKJABWAQCZCXOBKTNJZQRHLUFKQLACAAOIWJ
SIKWLXQHKDFJVGBVXWDWJKUSFRQRTDJYQMNFOQQALHRLMHSDMCFLAOVKDMTKMTPVTLAZLYJNJXZCFRHHSDIXYUUSVIMIICLUJHFW
JHWUSMCFYHPIXHAPBBSHYDQCKVGQFTENLVERFVOVDCLSTQFUSEPUMTFODLZLYQXDOXAEPONIQWTDWSAWBNSZYACGSJQSHAUMIKXT
MVBNFXMFNPAYSODPXEAYNRKTEZJWMUACSIUYPIORUFPMXAOZZJPJXPFLNSKNIAMETMOVULZPQIJJIRCSYQXOEVRHCNACSBRHKYNW
KGKBTBHGWKVJYZCOVNSKUREKZEIWVLOHAMUAYKLUGHEUESICBZAHURNTJAECTHRNKSIJQFIPVZANSZYSPJWHPKHCAPEYWNXUYQSD
RRRFYQFIQSWYRQTSNGNUFOBMSLGAFWPJGYEHGASFKTJCCZPXFIQLSXNKNWCYVTETOAPCOZJNHEWOCCAWVDEZUQCLLAVUQJJTQCKJ
NMBKMUENVGXXVMQCLXPJDQIQCFWYADIFDSGINGZDJYHPUPXVRMWDIPJRWPNRYOFGYYPEAVKDEMLYRRRMNCRQXPTDSQIVKKGJWDEF
SBAEKIFZCKDOMIQKBDWVQGBYWPDIBOLQUGAQRXLJDAZMXVZXYSNWEWTNZKYREMBEUHOTFOCKEJSXCMUBCKXNGQXTQJRCRCLWJTOI
YXBFBIBRAAFNPKBLTSMCFERZURZNWHMOEHIHNQTBWXNPJGIDYDPRGEWACCBULJRACOFLANQIAOIHMYCNQHVKXSIGAMWAHUSNBBTD
QDGPTRONXHAZWOUPNBFJFEWAMFZUQZFDKAPNJUBQPWBPYGPZHKUDZZDLCCWHGAUKJCSLLFWGPYJKJQBNLCZESOGXXSQCVVKVRVAW
NXPGQOUEFLUZHHSAODIWEPZLXVQLYGVOOVCCREDJZJOMCSCFFKEIEAVCTPUZOWNOLJHGBJHJFBFFORGXOXXFOCAGBWEFCIDEKDLB
PTXSUINQAJURNFQPMMSPLZTQAHCIOFJUEFFZGIHTSJNIEXQLLHRQUXXLLORJEHGQJOXSLIAVFPEJNGMMVAXDDMPXLOSTRLLFLYRM
JQNCLENGTROIKDWBMXRNJYPGZRQOREPJJPTXKVVKPYYZENEOIQKZOPXAYGFXORXRIDGATHMZFDJIOIOKVDJBHSXQMYCBYFGXWHLH
CITGTILGPGBHZMNWWHXEFPGDPJUVFBJKAQWACZHPRPJYCOLGZTBDCVHNRSUAJUQAWAPMQJDQIFPZQZEONWHIYKMXDZOMVETEFJRB
RDOTIDCFEESOKYPYCGQQKOGPMGJRITSVTKOKDSXLRLJRRHNFRFXCMDNQMCEGZFJWHZOAFBQXXPXNBSWTSUYPAWQRHAUGLNPBRSJT
HOWRIUGMOQTUYIHDWJRFBWWKWYKCICSVBVKTBIIWGFSVIFCTUKIHHUUISCOTEOYRWQXTAEBXQQOLLMOALNIYVCCHNSWIKHMYYNZO
OFRIYYXPPSRTPAYMUJSSDILKIZAYSEIOLANQIAOVKARDPGVFCSYBSNHAPGTIKLAWTTKOEADWRLAACAAFYTBTNSGFTYLYUHJXBMMA
NJFTMLUIBKDPWBXQOMBVQXCZOIREHRSZCSJOIVBXWQIBUTYBQNTZRVROHGOIZYAJWXLEATLOZJIKJMIHSLGSVTCXJWIOOGWSERRQ
DBQJNGBLRIYFIKHBEYOZQBOAGGNIZKFDHWXCFNJLBQXVLHIQNIBZSDLTTRERHNWCMLJCVBBGGAQTPUQHIRABXPQSYGSDVMBNNDFG
KPLFUYXHYGOCZPPXMWCZYNKCYBCRZVKFBHQXPGPBZFTTGEPQTJMOFHAYSQQZDMQECGXOXADYHNNXUKNBXZBYHBOULXNBJZKIZREF
LVHAMSNXJOCVRPVGJUWXFVOCUCLCZDXRPBBDRLRAVVNLOZWOHWMXYSNMXAKJYWYGILNGUJGIPKAUDVANZLFWKUWWUSQYBRCBVDIJ
QCXPLOTPPGXCUZOUSSTXHVMLHVMJTUSSOPLRKEBQSGWNGVHKANVZWYQHSHLIPWSYCPKTUKPMWPLVFLLAHXZQANFXHFNYHIQVIOYN
ZPTJJCBHXPSUPOMNRVCKXSUFCNRCRNCPTPGIDQOEQUDFNUNMJPOEKVIMUJAJZOUKMAFSLDWYMCHTSNJYUDJAHQOIXPYSRHVAFFCR
DCGMEEWXWMNOSSJNIZCINRHENPPPCYVFWYCONOPKXMFZXXIHNXIGAHAMHSBRESOETGVXWDNQLGCEOUDDJXHQIVCHRNKBFFEWILGY
SOAIQNALXRBSGAQIDQVMVDKVZCPMJNXKXRXPFZAUVQPBHHQKTPDSQROLQTUGMFQRWGVEWCYPDYDZGNNNUFKJUEHJKPLIQNRQYXHU
GKGWUCJXUKAEHLRLNDFUQPSJAZTVJRXWXQVBMRJXULEMJJPDCVTOWVFDBVLSBHZRRQUVMUQYKTJCLSGGHGCPHPHMWYAECLJIZUWV
QQNKPQRJMSOCEAYDNKPHVEGKAGCKAPDXTGVXULHUXHJPDXCSKQTCJENVTZTMRUENCSWHBEORALSREBWAJEMQDXMRKGHJGICDHKHY
YNSDSWDRLBBFUFVVICMGUCGBSVDLJNXGKXNFGVLKAVBJRRRUHKRXTPBJAKIEBAVMDIOJLIUDABCGNPNJIYBCXMOOWKRPHPYSWRDC
BORWTNBISSLTVKBRTLWKRNCEDCNEGCIYJIPDICFAVNOISYAHWBLGMNFKXZYTTWJOBEPNMSJEJMHXVPGOJOLQQQVXFGEULANQIAOD
OQETOJHCZXGTUKIWGMEVVMXCURISUOFQSAWZWDMZWVYHZMPEIMWKJDGERODVVUXYRTYLCRGYQQOIOFZSSZRAIESWBQOAIQNALJNR
HEYWHPLLPCUEOCBAOWGAYEJZQJHLVNMVQNSQQGGUBOIMDPFLOVSQGBLYAMBRYJDVOXOQINLJAVYALAKHPKOYNKGXIISSJNGKHYMS
IQVRYKXCUFIRNENEXFJTMOTJWYXSMTDHHPRHWIXETWVVIXZELKLLWRWQYGBCGJNYSUQEFCOUDNIJMLJNLAWSYJGULKBCFPYVSSMW
WQHGWRQFWFOTGPBBSJBDUKOMBXNRPIMCGPGVZFADWTBVIEMVTBXVAFQDDMJALCOMZTXUFFKBQQZDFAMTFWEXTHBKNWRLUVITQXLN
OPPJQKNGHWWPENVQIABJCQNKXNPWOWRFEOKQPQLANQIAORGGOLAYCEGZBHZVLPBERWYIJNJUNXKULUQOJLTNRDZDEYWEMYCHJLLB
LJISOAQLXJEFXVTOZSICOLQIJEXUANJWIFSIMGUQWHBXUDWOEILYFUZTGDZDSPLZPDPXBLFAXLEFQFEPDSJQWEQMXKKHCXHMSATM
UMUJENPBYKZLWAJAXJKDIYCBREBPOETQHMRHLKSEZUIPRGWIZDDQLSJAPKPBWMJMPZWLNFLFCQOCDBMLIHIYCXUJLFLPZVGWBKMY
WHZJLKEWUPETVUREKVKCLBNYFLWCERVIPUDINNWGQTUHWXCTDVTMYATYUZLMVLOHKBOGIZCQDOWFBCWJAVUXYUEVRKPOXCKHAWZC
RPLNLCUHJRADHJNSDPZXIKXGUKEJZCFJQASVUBSNLXCJXVCJZXGMRYRLOBCNGPDUJQVEFKMYHNZGZOAIQNALQDHTBWJXPKJLFXJY
MKCEZEDAFGSOCORWJGMOKWPVVBVDYZDZHPXFWJBDELHPGOQHMBAHUUUJMGXAEKZCTQTBXNVYUIQUVZGXSKQXJWRUPSFIJDYIAORC
GKFKQNXPJWOPPBTUKTHUBIROSYOVFEMJBRREWICJPCIOSTWPAUSKTRQULXPWRSXHSRYBCWYCYOTCTPFSQLDIILIGMEVZKYSOYRPH
SFDSCSMLLNARCCGCBJOGZAEQTGNGSFAQIXLPDBSWZDTYVASYYPVBRFBTIAGGWONGSVKCJDBBLYKAIOXUATGMALZXFOHZFTXALCFU
CUSSTLCRYPDTFSFJFENKJWTEBOBEPLSNXLALQWCKSLVMZQDJITHZKVCCQXTEXOSVAUFYAZXJUOAPPVEEWOIIMOSZZMCOQBRUXWKG
PDOFSCKKJJTRYRWGLEZODQTJSIMXIAOLNMLPHBAYLPTTLPYWILSEIIQVSXNHIJEORVCNJHYXRBIZZJTADGMRTSXVRXYGVQQNUEIC
IHNJOQXUXTXFPALCHOELNVMWDWQTEARUKPIFWXJSMWZLMNLAODUTKNZDYRFRLGBLIBGIBXJBOYMLYLANQIAORORYKSJPOOOAMVRN
IWIUHLYJKTQGVJBDPROSRGZUFITDIBCDPICNEFIGHWGSROWBYKUCLCQYLJXLHLXSCTJWKDLHHMLDBZCVDKPXYYASHUUMUJMVSXAD
GXOYXQFEBFIEJJLHBNGSYALOUXNQBXXZAAZJXENJJVVGFVHOTKSLEGLJVSJCQHSSZFEIOGBOGWSPIRENQAAWRQFBEFEXBKGMSTRC
PYIANSGMNKBCDPHWDUPKICQEUDNZPNGRUJYSZIRLXGXXITAFBCANGDLVAQLDPVTJNSAUZMBBNOBBOERSHQIOLBVTSPPJKVCMXUBS
IKMDIYSNCJZKJKJQMTIKEPRUNAHJUSWJHSLWIVWHYAYLOIOGSZVWKQWXZDBPHWZRAIPMXDJHBIISVJWVEVZAEGAKCYYMNZARBZPC
DLDFVQDFDMVHYVOWEKMFKWUXLTPWIVKPRZZXOLMDAPAIQEKJHCHYAGJDBOFWDGNEGQGOOKWSKLTLREMGGTVJFHAIBCQKNZVRCZYS
FBQASGNCCBBGNKJHCDBTGBIIWKMPHDABKEWDEPYEAVKNMPATUZZUOEHGUGAZNECSGUCIIJPMMRAMTVADMTCRJCBWDLWWFNFOWMVZ
XFJFBGDAVGGAIZHAUIYENDZTRUWHPQUFWCHOXNCWYNAWVPLBLNQKQDTKQQKXNFXCTBGRWUZFHNRBDNLNKQVOLLGBBJQIYOBCEIKO
CURAGWXMLYBSIZLAXFONZZMQMRNNSRQKRHQGFGZUTLONAYRKSSOWAMKZBSGOOYQDPTBHGPBNQEDCZHRTOXREOFJEKJVIZXZBCJPN
KGYBZTZRKOGBETJRUWRNUCIFKIMCZGYTZLCZYGCGKVZRJIFZQIQPTCPPUHYWIXBOFFGSGSAIMNGKKUUROAVNJUQQNSWJRZIZEHAF
DDAOBVCPOVODVJFLSNPJXHWQBHILWZAHQQMTQASNADZLZNXJLJMFCOUWOZJCMVVTYCKTUBABWLCEBNYWAMOLNBQQYBRUJCQCZALE
TVVRPMYFIKINHIUEJBDLTCUMMUWICIUVCZNIQIUEWVAHLANQIAONMEYJWPDAFXVNOSOFDOCESSLGZPTJINBUAFWWWMPTYALZIGVD
DCZGKILMBFXIQQFEKJBIUDEMIFCANVGNYZAYSQFMNNQFEPZFUUVGTBKSMDXITBLANQIAOQUKTPNYPOWSQQYWWMJHSDYVFDJYXBAF
VGYXAMDRRZWVIHNQPZZWRNWBTROOJOLNUGXBILZKQEGIQSYGKZGODPWBJSCMRRWSSQURUFIAFQGEZLGZNOEQMNQEYUKPEQPPVAMO
SYSFUAJFKIPUJVQSZRWQCJYAUMLDDNOKODDXIEQIFLANQIAOZFUNKUBVDBLMJOAUTVCZVLKJRQIORQPGAVCEYVNYUZHXILHERYEC
GJEKWEKIJNIWUXZNVIWIAANHIOSOLATSQFSSCTAKESUTSPPYFHEHLVLIBJZEEBCOWMNHFTZMAPKFUPNFLTFFJQRVJHAKDVMGGUIX
KAKXXNKSOAIQNALLWKWGVACYWBQEVTFSEUCYRORQTHWFUJFLQHONWZEKPLSNPRPBOMOFFCPMKXFZBKIERBKDYFKYUEYVYRPMOAQI
WNICDLQKZXGTKDLIEFBGELGJOAIQNALXZLGGDQIBVEULDPBWUJNTYOKFBPGMAWRRUJPPIGYCNYURNOSQRIRBAZAGWWDUHAAZQWPT
KFXZQXRMKSBUXWOUVVHSJWTLKZELGXMMAIDSJIWGCJPCBWZIEKMNUPUAFHTUMOZKJWVTIAQNOHELEMWGKJHKPNJVSRVHAUFXBUOU
XOWCZJYQLXJRUOOYSKDLDXKWTTJBYBTLKSWRUYPOYTPBGUJXBMRWNELBWADCSZDAEEFGPVRHNNLBFDDXNPDXLKQUSJAZDEUDBMBD
QIKYEKMVUHGGWZDKXFVQQNECZOAWCFUBHQMEPEPKEFSDBAYJQOSGAIHRBRAUKLQRANKMTTIOJDDXAEWTQHIYSGRRMEFTNNWCLZSI
ZFUQAQCSFNVUQMKUQWBWFQIEQVVXPOSVIDTUOBLLTGHQKEMSUWWHWRISLGRDPPQPZBANSGDWXKNYTKMWECPMPDYSCJZXPUKPWGYI
CNGVLBSCBHRLJARWSRENGHYYQDKRATERCPEAOPAJZUMOYIDHVPDMQPKKHCBAMRBGEIEXXJALMCXKPUGXYVINRORFYURXAMOJCBZQ
YJHHAWESCLMDIHVYMLAJZQSYTDEURWYPOLJCAKIKSATGVIALBLWPPKDEGSPMRLDBQNVPPCLQXKUQLQJERMYFGAETUATEBQZUMGUN
NBWUBVXYDFPLPJYLIDFVTVKKGFWMXVINLJUDUPABTSBJAJENZSXIMUJQWPEZTAVDMBBHFYTJKYFXIXQTBTTQIKQXQDPWYNMXRQDJ
OGWLZQUBJJHAQNPVRGHGPNMMJPIDGANYEEDWYPOLKLNEPYSRTQYCJLSWFRJRRGGSNSDHIXYYSNAKKBWQDDGYYMOGPUXQEUSAPSOU
CLLSELRVFZUFYVTJQKCQHNICMERWQFQNPVRPIIYKHZWJYJAFCLNSZXUHSPOZWQUMJHLKKYJENVZOCSWCTPYWIZONUUCLSUROGAYS
AZGNIMXPLPCEPULRRBHHQOBELHJZPUQAMWUASVKDXVEWAOFMAYSJFXHCNEUXUQWUESFBRUFZQLKKWHCHKOPLECCBYSLECAEZIMMI
TUUEOCEBAUKWLTSYJJPLZTIARAOZXKYYWIOXBBTZZCSAULKNEJWVQXIKUWBIWVHGNTHVBAWAVPGLHSDJDLPVHHHUNVSFKXARXLVQ
EMVDFSLANQIAOPTLFLFRKGNUZCTXWCAXHECTZFHWUFENRGQICHTYLSHZWIEGLNVDJZOMTKAAUWOHVOVOCTUKOSINSAYIAEUYORNA
VGPRMLCAQZIPRFQOZMEFTQZYVOTVFNVOIQSJCIPPQXQKJIXICUIGMHAJJMSXENCBQFIJHNZXIQMWACKDKQSEWWKMLOAUPFHAZGRY
SQWQMRSQBGGKYKGWEZYRIHWGNXRPOUMFSFGTYDLUDWPWAVQORTMQUXWKUQVNMDPWQFIZPOIHCJATODRQGZDMQXZVNXXVEJNGWZOM
PVBGZSQPCELDIWDHOQWAUHILGLPYRIICTLFSOYKQZYZOCIZPTECSWOODGGBDTSGIMYGMVPJPRPEVWOOKYFWRGXHWUCRQNYJEMSYL
XWOFXFVDXPTHYTCEGMODCILAHYBREZVVHOUPZKCNHUEVPMKHUBNRPFMWXVQACVZCALZLYMZSBLCEASPMIEFOTGKMPGWYQADSNDPR
QPHAVLZDZLKIEISFLLVWXAVBZLZIJRHGROUVGXRDLUJAXNHBBZYNCVERJGSKLWZEKGJBCWMSMLYIHZFFMIOGVIMZQBSRHQWAADYN
MNXEGTDXCDKIUDOISQXEUJWETPELKBCYFSDNJQWNNBPYMWBUPQBAAINMYZOYCEGNLFNNHZFEMSQVXJJGWBCRAVKZFWFBKMBRVBFD
HKACSZIUWUXLWKFPKOCUQJEPQDZCMUJFLVCLIOQQRVKSWFIAKNHMRLNJTKGVNTGLCVPVMBLJANOBCXUGVWBJYSIXZQVAVFWILWFB
QWNLTPMCYHRSKVHXLONRANWKWXUTHYQLIOFKGDBMSWDRCYRKVSAGGRJMWQYQFLMUIGGCLAUQAACTYLPZEOJBHMWRKHCRXGTGRMUP
CPQKJRBLYDNPUGHCRBVYBAIRVCAWLBWVWCMKNBIRKJOUGYQEBQRHDSTWXDIWGRVMLIJFBWHLHCDAAVUDLZSCGQNOUXVUIVIZZZMD
NMHGYPFUUDWKQGTAKKGCDFJFYJFNRZVXDPGZEAMWQVQZODKTXHIYFVKJSSAWVHYCUCZMLLBPXTILDYJQEMWDRUFKISOUVPUDTYPB
FDAQUBXHUJYTAYNWVIJNUSQDTQDEMUAPWXRYUWONTBDZCHZOUEGPMWEZTQWWSHAYOBWVTDIMZYNVNZKUHOFCQKPHJXWNRCGUJEKO
WSDAUGUTVWCVHEMOIRJJGTANUWTSAIXXEVZTBDHPGSRHHVWCDZVZYRJTLONIJVXEATHQXOUKBIGZONFRSZIOGWNTYAJYLQCGEOWY
请提交一个整数，不要填写任何多余的内容。
【答案】
【代码】
static final int N = 100;
static char[][] data = new char[N][N];
private static int ans;
static final char[] src = {'L','A','N','Q','I','A','O'};
static int dx[] = {1,1,0,-1,-1,-1,0,1};
static int dy[] = {0,1,1,1,0,-1,-1,-1};
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
for(int i=0;i<N;i++) {
data[i] = sc.nextLine().toCharArray();
}
for(int i=0;i<N;i++) {
for(int j=0;j<N;j++) {
if(data[i][j]=='L') {
for(int d = 0;d<8;d++) {
int _x = i+dx[d];
int _y = j+dy[d];
if(_x<N&&_x>=0&&_y<N&&_y>=0) {
dfs(_x,_y,1,d);
}
}
}
}
}
System.out.println(ans);
}
public static void dfs(int x,int y,int index,int d) {
if(data[x][y]!=src[index])return;
if(index == 6) {
ans++;
return;
}
int _x = x + dx[d];
int _y = y + dy[d];
if(_x<N&&_x>=0&&_y<N&&_y>=0)dfs(_x,_y,index+1,d);
}
第几个幸运数
【问题描述】
到x星球旅行的游客都被发给一个整数，作为游客编号。
x星的国王有个怪癖，他只喜欢数字3,5和7。
国王规定，游客的编号如果只含有因子：3,5,7,就可以获得一份奖品。
我们来看前10个幸运数字是：
3 5 7 9 15 21 25 27 35 45
因而第11个幸运数字是：49
小明领到了一个幸运数字 59084709587505，他去领奖的时候，人家要求他准确地说出这是第几个幸运数字，否则领不到奖品。
请你帮小明计算一下，59084709587505是第几个幸运数字。
需要提交的是一个整数，请不要填写任何多余内容。
【答案】1905
【代码】
public static void main(String[] args) {
long MAX = 59084709587505l;
int sum = 0;
for (long i = 0; Math.pow(3, i) < MAX; i++)
for (long j = 0; Math.pow(5, j) < MAX; j++)
for (long k = 0; Math.pow(7, k) < MAX; k++)
if (Math.pow(3, i) * Math.pow(5, j) * Math.pow(7, k) < MAX) {
sum++;
}
System.out.println(sum);
}
书号验证
【问题描述】
2004年起，国际ISBN中心出版了《13位国际标准书号指南》。
原有10位书号前加978作为商品分类标识；校验规则也改变。
校验位的加权算法与10位ISBN的算法不同，具体算法是：
用1分别乘ISBN的前12位中的奇数位（从左边开始数起），用3乘以偶数位，乘积之和以10为模，10与模值的差值再对10取模（即取个位的数字）即可得到校验位的值，其值范围应该为0~9。
下面的程序实现了该算法，请仔细阅读源码，填写缺失的部分。
public class A
{
static boolean f(String s){
int k=1;
int sum = 0;
for(int i=0; i<s.length(); i++){
char c = s.charAt(i);
if(c'-' || c' ') continue;
sum += ______________________________; //填空
k++;
if(k>12) break;
}
return s.charAt(s.length()-1)-'0' == (10-sum % 10)%10;
}
public static void main(String[] args){
System.out.println(f("978-7-301-04815-3"));
System.out.println(f("978-7-115-38821-6"));
}
}
注意：只提交空缺的代码，不要抄写已经存在的代码。
【答案】k%2!=0?(c-'0'):(c-'0')*3
打印大X debug
【问题描述】
如下的程序目的是在控制台打印输出大X。
可以控制两个参数：图形的高度，以及笔宽。
用程序中的测试数据输出效果：
(如果显示有问题，可以参看p1.png)
高度=15, 笔宽=3
*** ***
*** ***
*****
***
*****
*** ***
*** ***
高度=8, 笔宽=5
请仔细分析程序流程，填写缺失的代码。
public class A
{
static void f(int h, int w){
System.out.println(String.format("高度=%d, 笔宽=%d",h,w));
int a1 = 0;
int a2 = h - 1;
for(int k=0; k<h; k++){
int p = Math.min(a1,a2);
int q = Math.max(a1+w,a2+w);
for(int i=0; i<p; i++) System.out.print(" ");
if(q-p<w*2){
____________________________________________ ; //填空
}
else{
for(int i=0; i<w; i++) System.out.print("*");
for(int i=0; i<q-p-w*2; i++) System.out.print(" ");
for(int i=0; i<w; i++) System.out.print("*");
}
System.out.println();
a1++;
a2--;
}
}
public static void main(String[] args){
f(15,3);
f(8,5);
}
}
注意：只填写缺失的代码，不要拷贝已经存在的代码。
【答案】for(int i=0;i<q-p;i++)System.out.print("*")
缩位求和 递归
在电子计算机普及以前，人们经常用一个粗略的方法来验算四则运算是否正确。
比如：248 * 15 = 3720
把乘数和被乘数分别逐位求和，如果是多位数再逐位求和，直到是1位数，得
2 + 4 + 8 = 14 ==> 1 + 4 = 5;
1 + 5 = 6
5 * 6
而结果逐位求和为 3
5 * 6 的结果逐位求和与3符合，说明正确的可能性很大！！（不能排除错误）
请你写一个计算机程序，对给定的字符串逐位求和：
输入为一个由数字组成的串，表示n位数(n<1000);
输出为一位数，表示反复逐位求和的结果。
例如：
输入：
35379
程序应该输出：
9
再例如：
输入：
7583676109608471656473500295825
程序应该输出：
1
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
【代码】
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
fun(str,0);
}
public static void fun(String str,int sum) {
for(int i=0;i<str.length();i++) {
sum = sum + str.charAt(i)-'0';
}
if(sum>=10) {
str = String.valueOf(sum);
fun(str,0);
}else {
System.out.println(sum);
return;
}
}
等腰三角形 找规律
【问题描述】
本题目要求你在控制台输出一个由数字组成的等腰三角形。
具体的步骤是：
- 先用1,2,3，...的自然数拼一个足够长的串
- 用这个串填充三角形的三条边。从上方顶点开始，逆时针填充。
比如，当三角形高度是8时：
1
2 1
3 8
4 1
5 7
6 1
7 6
891011121314151
显示不正确时，参看：p1.png
输入，一个正整数n(3<n<300),表示三角形的高度
输出，用数字填充的等腰三角形。
为了便于测评，我们要求空格一律用"."代替。
例如：
输入：
5
程序应该输出：
....1
...2.1
..3...2
.4.....1
567891011
再例如：
输入：
10
程序应该输出：
.........1
........2.2
.......3...2
......4.....2
.....5.......1
....6.........2
...7...........0
..8.............2
.9...............9
1011121314151617181
再例如：
输入：
15
程序应该输出：
..............1
.............2.3
............3...2
...........4.....3
..........5.......1
.........6.........3
........7...........0
.......8.............3
......9...............9
.....1.................2
....0...................8
...1.....................2
..1.......................7
.1.........................2
21314151617181920212223242526
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
【代码】
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int h = sc.nextInt();
String str = "";
for (int i = 1;; i++) {
if (str.length() >= h * 2 - 2 + h * 2 - 1)
break;
str = str + i;
}
str = str.substring(0, h * 2 - 3 + h * 2 - 1)+"1";
for (int i = 1; i <h; i++) {
for (int j = i; j < h; j++) {
System.out.print('.');
}
System.out.print(str.charAt(i-1));
for (int j = 0; j < 2*(i-1)-1; j++) {
System.out.print('.');
}
if(i!=1) {
System.out.print(str.charAt(str.length()-i));
}
System.out.println();
}
for(int i=h-1;i<str.length()-h+1;i++) {
System.out.print(str.charAt(i));
}
}
小朋友崇拜圈
【问题描述】
班里N个小朋友，每个人都有自己最崇拜的一个小朋友（也可以是自己）。
在一个游戏中，需要小朋友坐一个圈，
每个小朋友都有自己最崇拜的小朋友在他的右手边。
求满足条件的圈最大多少人？
小朋友编号为1,2,3,...N
输入第一行，一个整数N（3<N<100000）
接下来一行N个整数，由空格分开。
要求输出一个整数，表示满足条件的最大圈的人数。
例如：
输入：
9
3 4 2 5 3 8 4 6 9
则程序应该输出：
4
解释：
如图p1.png所示，崇拜关系用箭头表示，红色表示不在圈中。
显然，最大圈是[2 4 5 3] 构成的圈
再例如：
输入：
30
22 28 16 6 27 21 30 1 29 10 9 14 24 11 7 2 8 5 26 4 12 3 25 18 20 19 23 17 13 15
程序应该输出：
16
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
【代码】
static int max = 0;
static int[] nums;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
nums = new int[n];
for (int i = 0; i < n; i++) {
nums[i] = sc.nextInt();
}
for (int i = 0; i < nums.length; i++)
{
ArrayList<Integer> list = new ArrayList<Integer>();
f(nums[i],list);
}
System.out.println(max);
}
static void f(int k,ArrayList<Integer> list)
{
int cnt = 0;
while (!list.contains(k))
{//集合中有没有第i个小朋友
System.out.print(k+" ");
list.add(k);//添加崇拜的人
k = nums[k - 1];//找到当前崇拜的人
cnt++;//崇拜人的人数
if (cnt > max)
{
max = cnt;//找出人数最多的
}
}
System.out.println();
}
耐摔指数 ？？？？
x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
为了减少测试次数，从每个厂家抽样3部手机参加测试。
如果已知了测试塔的高度，并且采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
输入数据，一个整数n（3<n<10000）,表示测试塔的高度。
输出一个整数，表示最多测试多少次。
例如：
输入：
3
程序应该输出：
2
解释：
手机a从2楼扔下去，坏了，就把b手机从1楼扔；否则a手机继续3层扔下
再例如：
输入：
7
程序应该输出：
3
解释：
a手机从4层扔，坏了，则下面有3层，b,c 两部手机2次足可以测出指数；
若是没坏，手机充足，上面5,6,7 三层2次也容易测出。
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
笨笨有话说：
我觉得3个手机太难了，要是2个手机还可以考虑一下。
歪歪有话说：
想什么呢，你！要是1部手机还用你编程啊？那样的话只好从下往上一层一层测。
【代码】
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt(); // 输入摔手机的层数
int[] arr = new int[1000];
int ans = 1; // 暂时保存摔的次数
for (int i = 0; ans < n; i++) { // 摔的次数小于输入的手机
ans = i+ans; // 慢慢累加着往上摔
arr[i]=ans; // 数组保存第一次摔坏的手机
}
ans = 1; // 初始值
int count=0; // 统计最后的最少摔坏手机次数
for (int i = 0; ans < n; i++) { // 摔的次数小于输入的手机
ans=arr[i]+ans; // 数组第一次摔坏的手机+再次往上摔坏的手机
count++; // 得出最优结果
}
System.out.println(count);
}
2019年JavaC组————蓝桥杯第十届
求和
【问题描述】
小明对数位中含有2、0、1、9的数字很感兴趣，在1到40中这样的数包括1、2、9、10至32、39、40，共28个，他们的和是574.请问，在1到2019中，所有这样的数的和是多少？
【答案】1905111
【代码】
public static void main(String[] args) {
String str = "2019";
int ans = 0;
int sum = 0;
for (int i = 1; i <= 2019; i++) {
String strI = String.valueOf(i);
for (int j = 0; j < strI.length(); j++) {
if (str.contains(String.valueOf(strI.charAt(j)))) {
ans++;
sum = sum + i;
break;
}
}
}
System.out.println(sum);
}
矩阵切割
【问题描述】
小明有一些矩形的材料，他要从这些矩形材料中切割出一些正方形。
当他面对一块矩形材料时，他总是从中间切割一刀，切出一块最大的正方
形，剩下一块矩形，然后再切割剩下的矩形材料，直到全部切为正方形为止。
例如，对于一块两边分别为5和3的材料（记为5×3)，小明会依次切出
3×3、2×2、1×1、1×1共4个正方形。
现在小明有一块矩形的材料，两边长分别是2019和324。请问小明最终会
切出多少个正方形?
【答案】21
【代码】
public static void main(String[] args) {
int l = 2019;
int w = 324;
int ans = 0;
while (true) {
if (l == 0 || w == 0) {
break;
}
if (l >= w) {
l = l - w;
ans++;
} else if (l < w) {
w = w - l;
ans++;
}
}
System.out.println(ans);
}
不同子串
【问题描述】
一个字符串的非空子串是指字符串中长度至少为1的连续的一段字符组成
的串。例如，字符串aaab有非空子串a,b,aa，ab,aaa,aab，aaab，一共7个。
注意在计算时，只算本质不同的串的个数。
请问，字符串0100110001010001有多少个不同的非空子串?
【答案】100
【代码】
public static void main(String[] args) {
String str="0100110001010001";
Set<String> set = new HashSet<String>();
for(int i=0;i<str.length();i++) {
String temp = str.charAt(i)+"";
set.add(temp);
for(int j=i+1;j<str.length();j++) {
temp = temp + str.charAt(j);
set.add(temp);
}
}
System.out.println(set.size());
}
质数 判断素数
【问题描述】
【问题描述】
我们知道第一个质数是2、第二个质数是3、第三个质数是5……请你计算
第2019个质数是多少?
【答案】17569
【代码】
static int ans = 0;
public static void main(String[] args) {
for(int i=2;;i++) {
fun(i);
if(ans==2019) {
System.out.println(i);
break;
}
}
}
public static boolean fun(int k) {
if(k==1||k%2==0&&k!=2) {
return false;
}else {
for(int i = 3;i<=Math.sqrt(k);i++) {
if(k%i==0) {
return false;
}
}
}
ans ++ ;
return true;
}
最大降雨量
【问题描述】
由于沙之国长年干旱，法师小明准备施展自己的一个神秘法术来求雨。
这个法术需要用到他手中的49张法术符，上面分别写着1至49这49个
数字。法术一共持续7周，每天小明都要使用一张法术符，法术符不能重复使
用。
每周，小明施展法术产生的能量为这周7张法术符上数字的中位数。法术
施展完7周后，求雨将获得成功，降雨量为7周能量的中位数。
由于干旱太久，小明希望这次求雨的降雨量尽可能大，请大最大值是多少?
【答案】34
27 28 29 30 31 32 33
20 21 22 23 24 25 26
13 14 15 16 17 18 19
10 11 12 34 35 36 37
7 8 9 38 39 40 41
4 5 6 42 43 44 45
1 2 3 46 47 48 49
旋转
【问题描述】
图片旋转是对图片最简单的处理方式之一，在本题中，你需要对图片顺时
针旋转90度。
我们用一个nxm的二维数组来表示一个图片，例如下面给出一个3×4的
图片的例子:
1357
9876
359 7
这个图片顺时针旋转90度后的图片如下:
39 1
583
975
767
给定初始图片，请计算旋转后的图片。
【输入格式】
输入的第一行包含两个整数n和m，分别表示行数和列数。
接下来n行，每行m个整数，表示给定的图片。图片中的每个元素（像
素）为一个值为0至255之间的整数（包含0和255）。
【输出格式】
输出m行n列，表示旋转后的图片。
试题F:旋转
7
【代码】
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int a[][] = new int[n][m];
int b[][] = new int[m][n];
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
a[i][j] = sc.nextInt();
}
}
for (int i = 0; i < b.length; i++) {
for (int j = 0; j < b[i].length; j++) {
b[i][j] = a[n-j-1][i];
}
}
for (int i = 0; i < b.length; i++) {
for (int j = 0; j < b[i].length; j++) {
System.out.print(b[i][j] + " ");
}
System.out.println();
}
}
//3 4
//1 3 5 7
//9 8 7 6
//3 5 9 7
外卖优先级
【问题描述】
“饱了么”外卖系统中维护着N家外卖店，编号1~N。每家外卖店都有
一个优先级，初始时{0时刻）优先级都为0。
每经过Ⅰ个时间单位，如果外卖店没有订单，则优先级会减少l，最低减
到U:而如果外卖店有订单，则优先级不减反加，每有一单优先缓加2。
如果某家外卖店某时刻优先级大于5，则会被系统加入优先缓存中;如果
优先级小于等于3，则会被沾除出优先缓存。
给定T时刻以内的M条订单信息，语你计算T时刻时有多少外卖在优
先缓存中..
【输入格式】
第行位含3个整数N、M和r。
以下M行每行包含两个整裂txs和id，表示tx时刻编号id 的外卖收到
一个订单..
【输出格式】
输出一个轻戮代表答案，
【样例输入】
266
ll
5 2
3 1
6 2
2 1
6 2
【代码】
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt(); // 店数
int M = sc.nextInt(); // 订单信息数
int T = sc.nextInt(); // T时刻
int a[][] = new int[M][2];
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
a[i][j] = sc.nextInt();
}
}
int b[] = new int[N + 1]; // 店铺优先级
int c[] = new int[N + 1]; // 是否是优先缓存
for (int t = 1; t <= T; t++) {
int flag[] = new int[N + 1]; // 标志 是否有订单
for (int j = 0; j < M; j++) {
if (a[j][0] == t) {
flag[a[j][1]] = flag[a[j][1]] + 1;
}
}
for (int j = 1; j < N + 1; j++) {
if (flag[j] != 0) {
b[j] = b[j] + flag[j] * 2;
} else {
if (b[j] > 0) {
b[j] = b[j] - 1;
}
}
}
for (int j = 1; j < N + 1; j++) {
if (b[j] > 5) {
c[j] = 1;
} else if (b[j] <= 3) {
c[j] = 0;
}
}
}
int youxian = 0;
for (int i : c) {
if (i == 1) {
youxian++;
}
}
System.out.println(youxian);
}
//2 6 6
//1 1
//5 2
//3 1
//6 2
//2 1
//6 2
人物相关性分析
【问题描述】
小明正在分析一本小说中的人物相关性。他想知道在小说中Alice和HBob
有多少次同时出现
更准确的说，小明定义Alice和 Bob“同时出现”的意思是:在小说文本
中Alice和 Bob之间不超过K个字符。
例如以下文本:
T'his is a story sbout.Alice and Hob.Alicc wanis to scnd a.privaLe: mcssag: to Hob.
假设K= 20，则Alicsc和 Hob lo时出现了2次，分别是”Alicc and Hob”
和"Bob.Alice"。前者Alice和 Bob 之间名5个字符，后首有2个字符。
注意:
1.Alicx:和Hot〉是大小写敏&的，:licx:或tob等并不计算在内。
2. Alicxc:和Hob应为单独的单词，前后可以有标点符号和空格，但是不能
有字母。例如Hobbi业不算出现了Hob。
【输入格式】
第一行包含一个们数K。
第二行包含一行字符串，只包含大小写字母、标点符号和空格。长度不超
过1000000。
【输出格式】
输出一个整数，表示Alice和Bob同时出现的次戮。
【样例输入】
20
This is a story about Alice and Bob. Alice wants to send a. private message to Bob.
【样例输出】
2
【评测用例规模与约定】
对于所有评测用例，1<K≤100000o。
【代码】
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int K = sc.nextInt();
sc.nextLine();
String english = sc.nextLine();
String a[] = english.split("\\s+|\\.");
// 找Alice——>Bob
int ans = 0;
for (int i = 0; i < a.length; i++) {
if (a[i].equals("Alice")) {
int k = 1;
for (int j = i + 1; j < a.length; j++) {
if (a[j].equals("Bob")) {
ans++;
}
k = k + a[j].length() + 1;
if (k > 20) {
break;
}
}
}
}
// 找Bob——>Alice
for (int i = 0; i < a.length; i++) {
if (a[i].equals("Bob")) {
int k = 1;
for (int j = i + 1; j < a.length; j++) {
if (a[j].equals("Alice")) {
ans++;
}
k = k + a[j].length() + 1;
if (k > 20) {
break;
}
}
}
}
System.out.println(ans);
}
等差数列
【问题描述】
数学老师给小明出了一道等差数列求和的题日。但是粗心的小明忘记了一
部分的数列，只记得其中N个整数。
现在给出这N个整数，小明想知道包含这Ⅳ个整裂的最短的等差数列有
几项?
【输入格式】
输入的第一行包含一个整数N。
第二行包含N个整划A1,A2,…- ,Av-(注意A~Ax并不一足是拟等杀瑕
列中的顺予给出)
【输出格式】
输H:个整数丧小答案。
【样例输入】
5
2 6 4 10 20
【样例输出】
10
【样例说明】
包含2、6、4、10、20的最短的等差数列是2、4、6、8、10、12、14、16、
18、20。
【评测用例规模与约定】
对于所有评测用例，2≤N≤100000，0≤A;≤10”
【代码】
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int a[] = new int[N];
for (int i = 0; i < a.length; i++) {
a[i] = sc.nextInt();
}
Arrays.sort(a);
int d = 1;
if (N > 2) { // 求出公差d
d = gcd(a[1] - a[0], a[2] - a[1]);
for (int i = 1; i < a.length - 1; i++) {
if (gcd(a[i] - a[i - 1], a[i + 1] - a[i]) < d) {
d = gcd(a[i] - a[i - 1], a[i + 1] - a[i]);
}
}
} else {
d = a[1] - a[0];
}
System.out.println((a[a.length-1]-a[0])/d+1);
}
public static int gcd(int p, int q) {
if (q == 0)
return p;
return gcd(q, p % q);
}
扫地机器人
【问题描述】
小明公司的办公区有一条长长的走廊，由N个方格区闻组成，如下图所
示。
走廊内部署了K台扫地机器人，其中第﹔台在第个方格区域中。
已知扫地机器人每分钟可以移动到左右相邻的方格中，并将该区域清扫干
净。
请你编写一个程序，计算每台机器人的清扫路线，使得
1.它们最终鄱返回出发方格，
2．每个方格区域部至少被清扫一遍，
3．从机器人开始行动到最后一台机器人归位花费的时间最少。
注意多台机器人可以同时清扫同一方块区域，它们不会互相影响。
输出最少花费的时间。
在上图所示的例子中，最少花费时间是6。第一台路线:2-1-2-3-4-2-2，清
扫了1、2、3、4号区域。第二台路线5-6-7-6-5，清扫了5、6、7。第三台路线
10-9-8-9-10，清扫了8、9和10.
【输入格式】
第一行包含两个整数N和K。
接下来K行，每行一个整数Ao
【输出格式】
输出一个整数表示答案。
【样例输入】
10 3
5
2
10
【样例输出】
6
【评测用例规模与约定】
对」30%的评测用例，l≤K<N<l0。
对于6%的评测用例，1≤K<N≤ 1000.
对于所有评测用例，1≤K<N≤100000，1≤;≤N.
【代码】
static int N;
static int K;
static int[] a = new int[1000000];
static int[] b = new int[1000000];
public static void main(String[] args) {
int i, L;
Scanner sc = new Scanner(System.in);
N = sc.nextInt();
K = sc.nextInt();
for (i = 1; i <= K; i++) {
a[i] = sc.nextInt();
b[a[i]] = 1;
}
L = fun();
System.out.println(2 * (L - 1));
}
public static boolean check1(int first_L, int L) { // 第一个区间长度为 first_L，之后区间长度都为 L
int i, j;
if (first_L + (K - 1) * L < N) {// 第一个区间再加上，其他的机器人和*这段的长度是不是能够够到总长
return false;
}
i = 1; // 第 i 个区间
j = 1; // 当前查看的方格位置
while (j <= N) {
if (b[j] == 1) { // 第 i 个区间内有机器人
j = first_L + (i - 1) * L + 1; // j 指向下一个区间起点
i++; // 下一个区间
} else {
j++;// 一直检查下一个方格，如果一直没有直到first_L和j相等后，表明真的没有机器人
if (j == first_L + (i - 1) * L + 1 || j == N + 1) { // 第 i 个区间内没有机器人
return false; // 因为L是不断变大的，first也一直变大，所以检查一直再往后扩展
}
}
}
return true;
}
public static boolean check(int L) {
int first_L; // 首区间的长度(取值范围：1~L)
for (first_L = L; first_L > 0; first_L--) {// 倒叙是因为，用大区间可以减少机器人的移动
if (check1(first_L, L)) {
return true;
}
}
return false;
}
public static int fun() {
int i, j, L;
for (L = N / K; L <= N; L++) {// 平均一下，
if (check(L)) {
return L;
}
}
return L;
}
2020第十一届校内第一次模拟真题高职组
15.125GB
【问题描述】
在计算机存储中，15.125GB是多少MB？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。
本题的结果为一个整数，在提交答案时只填写这个整数，
填写多余的内容将无法得分。
【答案】15488.0
【代码】
public static void main(String[] args) {
System.out.println(15.125*1024);
}
【输出】
15488
约数个数
【问题描述】
1200000有多少个约数（只计算正约数）。
【答案提交】
这是一道结果填空的题，
你只需要算出结果后提交即可。
本题的结果为一个整数，在提交答案时只填写这个整数，
填写多余的内容将无法得分。
【答案】96
【分析】
什么使约数?
约数，又称因数。整数a除以整数b(b≠0) 除得的商正好是整数而没有余数，我们就说a能被b整除，或b能整除a。a称为b的倍数，b称为a的约数。
4的正约数有：1、2、4。
6的正约数有：1、2、3、6。
10的正约数有：1、2、5、10。
12的正约数有：1、2、3、4、6、12。
15的正约数有：1、3、5、15。
【代码】
public static void main(String[] args) {
System.out.println(fun(1200000));
}
// 返回约束的个数
public static int fun(int num) {
int count=0;
for(int i=1;i<=num;i++) {
if(num%i==0) {
count++;
}
}
return count;
}
【输出】
96
叶结点数
【问题描述】一棵包含有2019个结点的二叉树，
最多包含多少个叶结点？
【答案提交】这是一道结果填空的题，
你只需要算出结果后提交即可。本题的结果为一个整数，
在提交答案时只填写这个整数，填写多余的内容将无法得分。
【答案】1010
【分析】
二叉树什么时候出现最多的叶结点的情况？
在完全二叉树的情况下可以得到最多的叶子节点。
叶子节点最多的个数与节点总数的奇偶有关，奇数个则有(n-1)/2+1个
偶数个则有n/2个。
【代码】
小编写的时候不知道这个公式，所以暴力破解
public static void main(String[] args) {
double sum = 0;
for(double i=0;i<2019;i++) {
if(sum>=2019) {
break;
}
sum = sum+ Math.pow(2,i);
System.out.println("该层有节点"+Math.pow(2,i)+"个---------------"+"树的层数"+(i+1)+"总计:"+sum);
}
System.out.println(1024-(2047-2019)/2);
}
【输出】
该层有节点1.0个---------------树的层数1.0总计:1.0
该层有节点2.0个---------------树的层数2.0总计:3.0
该层有节点4.0个---------------树的层数3.0总计:7.0
该层有节点8.0个---------------树的层数4.0总计:15.0
该层有节点16.0个---------------树的层数5.0总计:31.0
该层有节点32.0个---------------树的层数6.0总计:63.0
该层有节点64.0个---------------树的层数7.0总计:127.0
该层有节点128.0个---------------树的层数8.0总计:255.0
该层有节点256.0个---------------树的层数9.0总计:511.0
该层有节点512.0个---------------树的层数10.0总计:1023.0
该层有节点1024.0个---------------树的层数11.0总计:2047.0
1010
数字9
【问题描述】在1至2019中，有多少个数的数位中包含数字9？
注意，有的数中的数位中包含多个9，这个数只算一次。
例如，1999这个数包含数字9，在计算只是算一个数。
【答案提交】这是一道结果填空的题，你只需要算出结果后提交即可。
本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
【答案】544
【分析】
将整型转为字符串型，利用String api的indexOf()，当一个数中没有出现字符9，返回-1
【代码】
public static void main(String[] args) {
int count = 0;
for(int i=1;i<=2019;i++) {
if(String.valueOf(i).indexOf('9')!=-1) {
count++;
}
}
System.out.println(count);
}
【输出】544
位数递增的数
【问题描述】一个正整数如果任何一个数位不大于右边相邻的数位，则称为一个数位递增的数，例如1135是一个数位递增的数，而1024不是一个数位递增的数。
给定正整数 n，请问在整数 1 至 n 中有多少个数位递增的数？
【输入格式】输入的第一行包含一个整数 n。
【输出格式】输出一行包含一个整数，表示答案。
【样例输入】30【样例输出】26
【评测用例规模与约定】对于 40% 的评测用例，1 >= n >= 1000。对于 80% 的评测用例，1 >= n >= 100000。对于所有评测用例，1 >= n >= 1000000。
【分析】首先想到的是指针指向整数的第一位，第一位与后一位进行比较。后来又想到可以用递归的方法，没想出来，于是借鉴了别人的代码
【代码】
非递归
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
System.out.println(fun(n));
}
public static int fun(int n) {
int count = 0;
boolean flag = true;
for(int i=1;i<=n;i++) {
flag = true;
String numString = String.valueOf(i);
for(int j=0;j<numString.length()-1;j++) {
if(!(numString.charAt(j)<=numString.charAt(j+1))) {
flag = false;
break;
}
}
if(flag) {
count++;
}
}
return count;
}
递归
public static int n=0;
public static int count = 0;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
sc.close();
fun(0,1);
System.out.println(count-1);
}
public static int fun(int num,int temp) {
// num 这个数，temp是位数
if(num>n) {
return 0;
}else {
count++;
}
for(int i=temp;i<10;i++) {
fun(num*10+i,i);
}
return count;
}
递增三元组
【问题描述】
在数列 a[1], a[2], ..., a[n] 中， 如果对于下标 i, j, k 满足 0<i<j<k<n+1 且 a[i]<a[j]<a[k]，则称 a[i], a[j], a[k] 为一组递增三元组，a[j]为递增三元组的中心。
给定一个数列， 请问数列中有多少个元素可能是递增三元组的中心。
【输入格式】
输入的第一行包含一个整数 n。
第二行包含 n 个整数 a[1], a[2], ..., a[n]，相邻的整数间用空格分隔，表示给定的数列。
【输出格式】
输出一行包含一个整数，表示答案。
【样例输入】
5
1 2 5 3 5
【样例输出】
2
【样例说明】
a[2] 和 a[4] 可能是三元组的中心。
【评测用例规模与约定】
对于 50% 的评测用例， 2 <= n <= 100，0 <= 数列中的数 <= 1000。
对于所有评测用例， 2 <= n <= 1000，0 <= 数列中的数 <= 10000。
【代码】
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int a[] = new int[n];
for (int i = 0; i < a.length; i++) {
a[i] = scan.nextInt();
}
int num = fun(a);
System.out.println(num);
}
public static int fun(int a[]) {
int num = 0;
boolean flag = false;
for(int j = 1;j<a.length-1;j++) {
flag = false;
for(int i=0;i<j;i++) {
for(int k=j+1;k<a.length;k++) {
if(a[i]<a[j]&&a[j]<a[k]) {
num++;
flag = true;
break;
}
}
if(flag) {
break;
}
}
}
return num;
}
音节判断
【问题描述】
小明对类似于 hello 这种单词非常感兴趣，这种单词可以正好分为四段，第一段由一个或多个辅音字母组成，第二段由一个或多个元音字母组成，第三段由一个或多个辅音字母组成，第四段由一个或多个元音字母组成。
给定一个单词，请判断这个单词是否也是这种单词，如果是请输出yes，否则请输出no。
元音字母包括 a, e, i, o, u，共五个，其他均为辅音字母。
【输入格式】
输入一行，包含一个单词，单词中只包含小写英文字母。
【输出格式】
输出答案，或者为yes，或者为no。
【样例输入】
lanqiao
【样例输出】
yes
【样例输入】
world
【样例输出】
no
【评测用例规模与约定】
对于所有评测用例，单词中的字母个数不超过100。
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String str = scan.next();
if (fun(str)) {
System.out.println("yes");
} else {
System.out.println("no");
}
}
public static boolean fun(String str) {
char chs[] = str.toCharArray();
String yuanyin = "aeiou";
int flag = 0;
for (int i = 0; i < chs.length; i++) {
if (flag % 2 == 0 && !yuanyin.contains(String.valueOf(chs[i]))) {
flag++;
} else if (flag % 2 != 0 && yuanyin.contains(String.valueOf(chs[i]))) {
flag++;
}
}
if (flag == 4) {
return true;
}
return false;
}
长草
【问题描述】
小明有一块空地，他将这块空地划分为 n 行 m 列的小块，每行和每列的长度都为 1。
小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。
这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，这四小块空地都将变为有草的小块。
请告诉小明，k 个月后空地上哪些地方有草。
【输入格式】
输入的第一行包含两个整数 n, m。
接下来 n 行，每行包含 m 个字母，表示初始的空地状态，字母之间没有空格。如果为小数点，表示为空地，如果字母为 g，表示种了草。
接下来包含一个整数 k。
【输出格式】
输出 n 行，每行包含 m 个字母，表示 k 个月后空地的状态。如果为小数点，表示为空地，如果字母为 g，表示长了草。
【样例输入】
4 5
.g...
.....
..g..
.....
2
【样例输出】
gggg.
gggg.
ggggg
.ggg.
【评测用例规模与约定】
对于 30% 的评测用例，2 <= n, m <= 20。
对于 70% 的评测用例，2 <= n, m <= 100。
对于所有评测用例，2 <= n, m <= 1000，1 <= k <= 1000。
public static int[][] bool;
public static int k = 0, n = 0, m = 0;
public static char block[][];
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
n = scan.nextInt();
m = scan.nextInt();
bool = new int[n][m];
block = new char[n][m];
for (int i = 0; i < n; i++) {
char temp[] = scan.next().toCharArray();
for (int j = 0; j < m; j++) {
block[i][j] = temp[j];
}
}
k = scan.nextInt();
fun(block, k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
System.out.print(block[i][j]);
}
System.out.println();
}
}
public static void fun(char block[][], int k) {
while (k > 0) {
for (int i = 0; i < block.length; i++) {
for (int j = 0; j < block[i].length; j++) {
if (block[i][j] == 'g')
bool[i][j] = 1;
}
}
for (int i = 0; i < bool.length; i++) {
for (int j = 0; j < bool[i].length; j++) {
if (bool[i][j] == 1) {
if (i - 1 >= 0) {
block[i - 1][j] = 'g';
}
if (i + 1 < block.length) {
block[i + 1][j] = 'g';
}
if (j - 1 >= 0) {
block[i][j - 1] = 'g';
}
if (j + 1 < bool[i].length) {
block[i][j + 1] = 'g';
}
}
}
}
k--;
}
}
序列计数
【问题描述】
小明想知道，满足以下条件的正整数序列的数量：
- 第一项为 n；
- 第二项不超过 n；
- 从第三项开始，每一项小于前两项的差的绝对值。
请计算，对于给定的 n，有多少种满足条件的序列。
【输入格式】
输入一行包含一个整数 n。
【输出格式】
输出一个整数，表示答案。答案可能很大，请输出答案除以10000的余数。
【样例输入】
4
【样例输出】
7
【样例说明】
以下是满足条件的序列：
4 1
4 1 1
4 1 2
4 2
4 2 1
4 3
4 4
【评测用例规模与约定】
对于 20% 的评测用例，1 <= n <= 5；
对于 50% 的评测用例，1 <= n <= 10；
对于 80% 的评测用例，1 <= n <= 100；
对于所有评测用例，1 <= n <= 1000。
public static int n=0,count=0;
public static int [] []map ;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n =sc.nextInt();
sc.close();
map = new int [n+1][n+1];
for (int i = 1; i <=n; i++) {
map[i][i]=1;
map[i][0]=1;
map[0][i]=1;
}
for (int i = 1; i <=n; i++) {
count+=f(n,i);
count%=10000;
// System.out.println(count);
}
System.out.println(count);
// System.out.println(f(4,2));
}
public static int f(int x,int y){
if(map[x][y]!=0){
return map[x][y];
}
for (int i = Math.abs(x-y)-1; i>=0; i--) {
map[x][y]+=f(y,i);
}
map[x][y]%=10000;
// map[y][x]=map[x][y];
// System.out.println();
return map[x][y];
}
晚会节目单
【问题描述】
小明要组织一台晚会，总共准备了 n 个节目。然后晚会的时间有限，他只能最终选择其中的 m 个节目。
这 n 个节目是按照小明设想的顺序给定的，顺序不能改变。
小明发现，观众对于晚上的喜欢程度与前几个节目的好看程度有非常大的关系，他希望选出的第一个节目尽可能好看，在此前提下希望第二个节目尽可能好看，依次类推。
小明给每个节目定义了一个好看值，请你帮助小明选择出 m 个节目，满足他的要求。
【输入格式】
输入的第一行包含两个整数 n, m ，表示节目的数量和要选择的数量。
第二行包含 n 个整数，依次为每个节目的好看值。
【输出格式】
输出一行包含 m 个整数，为选出的节目的好看值。
【样例输入】
5 3
3 1 2 5 4
【样例输出】
3 5 4
【样例说明】
选择了第1, 4, 5个节目。
【评测用例规模与约定】
对于 30% 的评测用例，1 <= n <= 20；
对于 60% 的评测用例，1 <= n <= 100；
对于所有评测用例，1 <= n <= 100000，0 <= 节目的好看值 <= 100000。
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int[] num = new int[n];
int[] order = new int[n];
for (int i = 0; i < n; i++) {
num[i] = sc.nextInt();
order[i] = num[i];
}
sc.close();
Arrays.sort(order);
ArrayList<String> list = new ArrayList<String>();
for (int i = n - m; i < n; i++) {
list.add(order[i]+"");
}
StringBuilder sb = new StringBuilder("");
for (int i : num) {
if (list.contains(i+"")) {
list.remove(i+"");
sb.append(i + " ");
}
}
System.out.println(sb);
}
2020第十一届校内第二次模拟真题高职组
十六进制1949
【问题描述】
请问十六进制数1949对应的十进制数是多少？请特别注意给定的是十六进制，求的是十进制。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
【答案】6473
【代码】
public static void main(String[] args) {
System.out.println(Integer.valueOf("1949",16));
}
互质个数
【问题描述】
不超过19000的正整数中，与19000互质的数的个数是多少？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
【答案】7200
【代码】
public static void main(String[] args) {
int ans = 0;
for(int i=1;i<=19000;i++) {
if(gcd(i,19000)==1) {
ans ++ ;
}
}
System.out.println(ans);
}
public static int gcd(int a,int b) {
if(b==0) {
return a;
}
return gcd(b,a%b);
}
最大公约数
【问题描述】
70044与113148的最大公约数是多少？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
【答案】5388
【代码】
public static void main(String[] args) {
System.out.println(gcd(70044,113148));
}
public static int gcd(int a,int b) {
if(b==0) {
return a;
}
return gcd(b,a%b);
}
最多节点数
【问题描述】
一棵10层的二叉树，最多包含多少个结点？
注意当一棵二叉树只有一个结点时为一层。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
【答案】512
【代码】
public static void main(String[] args) {
System.out.println((int)Math.pow(2,9));
}
洁净数
【问题描述】
小明非常不喜欢数字 2，包括那些数位上包含数字 2 的数。如果一个数的数位不包含数字 2，小明将它称为洁净数。
请问在整数 1 至 n 中，洁净数有多少个？
【输入格式】
输入的第一行包含一个整数 n。
【输出格式】
输出一行包含一个整数，表示答案。
【样例输入】
30
【样例输出】
18
【评测用例规模与约定】
对于 40% 的评测用例，1 <= n <= 10000。
对于 80% 的评测用例，1 <= n <= 100000。
对于所有评测用例，1 <= n <= 1000000。
【代码】
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int ans = 0;
for(int i=1;i<=n;i++) {
if(!String.valueOf(i).contains("2")) {
ans++;
}
}
System.out.println(ans);
}
最大距离
【问题描述】
在数列 a_1, a_2, ..., a_n中，定义两个元素 a_i 和 a_j 的距离为 |i-j|+|a_i-a_j|，即元素下标的距离加上元素值的差的绝对值，其中 |x| 表示 x 的绝对值。
给定一个数列，请问找出元素之间最大的元素距离。
【输入格式】
输入的第一行包含一个整数 n。
第二行包含 n 个整数 a_1, a_2, ..., a_n，相邻的整数间用空格分隔，表示给定的数列。
【输出格式】
输出一行包含一个整数，表示答案。
【样例输入】
5
9 4 2 4 7
【样例输出】
9
【样例说明】
a_1 和 a_3 的距离为 |1-3|+|9-2|=9。
【评测用例规模与约定】
对于 50% 的评测用例，2 <= n <= 100，0 <= 数列中的数 <= 1000。
对于所有评测用例，2 <= n <= 1000，0 <= 数列中的数 <= 10000。
【代码】
public static void main(String[] args) {
Integer max = Integer.MIN_VALUE;
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a[] = new int[n];
for(int i=0;i<a.length;i++) {
a[i] = sc.nextInt();
}
for(int i=0;i<a.length-1;i++) {
for(int j=i+1;j<a.length;j++) {
int temp = Math.abs(i-j)+Math.abs(a[i]-a[j]);
if(temp>max) {
max = temp;
}
}
}
System.out.println(max);
}
最长递增
【问题描述】
在数列 a[1], a[2], ..., a[n] 中，如果 a[i] < a[i+1] < a[i+2] < ... < a[j]，则称 a[i] 至 a[j] 为一段递增序列，长度为 j-i+1。
给定一个数列，请问数列中最长的递增序列有多长。
【输入格式】
输入的第一行包含一个整数 n。
第二行包含 n 个整数 a[1], a[2], ..., a[n]，相邻的整数间用空格分隔，表示给定的数列。
【输出格式】
输出一行包含一个整数，表示答案。
【样例输入】
7
5 2 4 1 3 7 2
【样例输出】
3
【评测用例规模与约定】
对于 50% 的评测用例，2 <= n <= 100，0 <= 数列中的数 <= 1000。
对于所有评测用例，2 <= n <= 1000，0 <= 数列中的数 <= 10000。
【代码】
public static void main(String[] args) {
Integer max = Integer.MIN_VALUE;
int ans = 1;
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a[] = new int[n];
for(int i=0;i<a.length;i++) {
a[i] = sc.nextInt();
}
for(int i=0;i<a.length-1;i++) {
if(a[i+1]>a[i]) {
ans++;
}else {
if(ans>max) {
max = ans;
}
ans = 1;
}
}
if(ans>max) {
max = ans;
}
System.out.println(max);
}
字符计数
【问题描述】
给定一个单词，请计算这个单词中有多少个元音字母，多少个辅音字母。
元音字母包括 a, e, i, o, u，共五个，其他均为辅音字母。
【输入格式】
输入一行，包含一个单词，单词中只包含小写英文字母。
【输出格式】
输出两行，第一行包含一个整数，表示元音字母的数量。
第二行包含一个整数，表示辅音字母的数量。
【样例输入】
lanqiao
【样例输出】
4
3
【评测用例规模与约定】
对于所有评测用例，单词中的字母个数不超过100。
【代码】
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
char word[] = sc.nextLine().toCharArray();
String yuan = "aeiou";
int y = 0;
int f = 0;
for(char w:word) {
if(yuan.contains(""+w)) {
y++;
}else {
f++;
}
}
System.out.println(y);
System.out.println(f);
}
练功
【问题描述】
小明每天都要练功，练功中的重要一项是梅花桩。
小明练功的梅花桩排列成 n 行 m 列，相邻两行的距离为 1，相邻两列的距离也为 1。
小明站在第 1 行第 1 列上，他要走到第 n 行第 m 列上。小明已经练了一段时间，他现在可以一步移动不超过 d 的距离（直线距离）。
小明想知道，在不掉下梅花桩的情况下，自己最少要多少步可以移动到目标。
【输入格式】
输入的第一行包含两个整数 n, m，分别表示梅花桩的行数和列数。
第二行包含一个实数 d（最多包含一位小数），表示小明一步可以移动的距离。
【输出格式】
输出一个整数，表示小明最少多少步可以到达目标。
【样例输入】
3 4
1.5
【样例输出】
3
【评测用例规模与约定】
对于 30% 的评测用例，2 <= n, m <= 20，1 <= d <= 20。
对于 60% 的评测用例，2 <= n, m <= 100，1 <= d <= 100。
对于所有评测用例，2 <= n, m <= 1000，1 <= d <= 100。
【代码】
static int n;
static int m;
static double d;
static int aim_x; // 目标x
static int aim_y; // 目标y
static int step = 0;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
m = sc.nextInt();
d = sc.nextDouble();
fun(1,1);
System.out.println(step);
}
public static void fun(int x,int y) { // 递归
double L = Math.sqrt(Math.pow(n-x,2)+Math.pow(m-y,2));
if(L<=d) {
step++;
return;
}
double min = Double.MAX_VALUE;
for(int x_i=x;x_i<=n;x_i++) {
for(int y_j=y;y_j<=m;y_j++) {
L = Math.sqrt(Math.pow(x_i-x,2)+Math.pow(y_j-y,2));
if(d-L>=0&&d-L<min) {
min = d-L;
aim_x = x_i;
aim_y = y_j;
}
}
}
step++;
fun(aim_x,aim_y); // 移动到目标位置
}
积木
【问题描述】
小明用积木搭了一个城堡。
为了方便，小明在搭的时候用的是一样大小的正方体积本，搭在了一个 n 行 m 列的方格图上，每个积木正好占据方格图的一个小方格。
当然，小明的城堡并不是平面的，而是立体的。小明可以将积木垒在别的积木上面。当一个方格上的积木垒得比较高时，就是一个高塔，当一个方格上没有积木时，就是一块平地。
小明的城堡可以用每个方格上垒的积木层数来表示。例如，下面就表示一个城堡。
9 3 3 1
3 3 3 0
0 0 0 0
这个城堡南面和东面都有空地，西北面有一个大房子，在西北角还有一个高塔，东北角有一个车库。
现在，格格巫要来破坏小明的城堡，他施了魔法水淹小明的城堡。
如果水的高度为1，则紧贴地面的那些积木要被水淹，在上面的例子中，有7块积木要被水淹。
如果水的高度为2，则更多积木要被水淹，在上面的例子中，有13块积木要被水淹。
给定小明的城堡图，请问，水的高度依次为1, 2, 3, ...., H 时，有多少块积木要被水淹。
【输入格式】
输入的第一行包含两个整数 n, m。
接下来 n 行，每行 m 个整数，表示小明的城堡中每个位置积木的层数。
接下来包含一个整数 H，表示水高度的上限。
【输出格式】
输出 H 行，每行一个整数。第 i 的整数表示水的高度为 i 时被水淹的积木数量。
【样例输入】
3 4
9 3 3 1
3 3 3 0
0 0 0 0
10
【样例输出】
7
13
19
20
21
22
23
24
25
25
【评测用例规模与约定】
对于 40% 的评测用例，1 <= n, m <= 100，1 <= H <= 100，积木层数不超过100；
对于 70% 的评测用例，1 <= n, m <= 1000，1 <= H <= 1000，积木层数不超过1000；
对于所有评测用例，1 <= n, m <= 1000，1 <= H <= 100000，积木层数不超过1000000000。
【代码】
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
int[][] a = new int[n][m];
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++){
a[i][j] = sc.nextInt();
}
}
int h = sc.nextInt();
get(a,h);
}
public static void get(int a[][],int h){
int count = 0;
for(int H=1;H<=h;H++){
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++){
if(a[i][j]!=0){
count++;
a[i][j]--;
}
}
}
System.out.println(count);
}
}
2020年JavaC组————蓝桥杯第十一届
指数运算
【问题描述】
7 月 1 日是建党日，从 1921 年到 2020 年，中国***已经带领中国人民
走过了 99 年。
请计算：7
2020 mod 1921，其中 A mod B 表示 A 除以 B 的余数。
【答案提交】
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个
整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
【答案】
【代码】
public static void main(String[] args) {
int sum = 7;
for(int i=2;i<=2020;i++) {
sum = sum*7%1921;
}
System.out.println(sum);
}
解密
【问题描述】
小明设计了一种文章加密的方法：对于每个字母 c，将它变成某个另外的
字符 Tc。下表给出了字符变换的规则：
例如，将字符串 YeRi 加密可得字符串 EaFn。
小明有一个随机的字符串，加密后为
EaFnjISplhFviDhwFbEjRjfIBBkRyY
（由 30 个大小写英文字母组成，不包含换行符），请问原字符串是多少？
（如果你把以上字符串和表格复制到文本文件中，请务必检查复制的内容
是否与文档中的一致。在试题目录下有一个文件 str.txt，第一行为上面的字符
串，后面 52 行依次为表格中的内容。）
【答案提交】
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个
只包含 30 个大小写英文字母的字符串，在提交答案时只填写这个字符串，填写
多余的内容将无法得分。
【答案】YeRikGSunlRzgDlvRwYkXkrGWWhXaA
【代码】
public static void main(String[] args) throws IOException {
BufferedReader bs = new BufferedReader(new FileReader("files\\str.txt"));
String str = null;
Map<String,String> map = new HashMap<String, String>();
while((str = bs.readLine())!=null) {
map.put(str.split(" ")[1],str.split(" ")[0]);
}
String EaFn = "EaFnjISplhFviDhwFbEjRjfIBBkRyY";
for(int i=0;i<EaFn.length();i++) {
System.out.print(map.get(EaFn.charAt(i)+""));
}
}
跑步训练
【问题描述】
小明要做一个跑步训练。
初始时，小明充满体力，体力值计为 10000。如果小明跑步，每分钟损耗
600 的体力。如果小明休息，每分钟增加 300 的体力。体力的损耗和增加都是
均匀变化的。
小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如此循
环。如果某个时刻小明的体力到达 0，他就停止锻炼。
请问小明在多久后停止锻炼。为了使答案为整数，请以秒为单位输出答案。
答案中只填写数，不填写单位。
【答案提交】
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个
整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
【答案】3880
【代码】
public static void main(String[] args) {
int strength = 10000;
int loss = 600;
int add = 300;
int d = 0;
while(true) {
strength = strength - 300;
d = d + 2;
if(strength<loss) {
System.out.println(d*60+strength/(loss/60));
break;
}
}
}
合并检测
【问题描述】
新冠疫情由新冠病毒引起，最近在 A 国蔓延，为了尽快控制疫情，A 国准
备给大量民众进病毒核酸检测。
然而，用于检测的试剂盒紧缺。
为了解决这一困难，科学家想了一个办法：合并检测。即将从多个人（k
个）采集的标本放到同一个试剂盒中进行检测。如果结果为阴性，则说明这 k
个人都是阴性，用一个试剂盒完成了 k 个人的检测。如果结果为阳性，则说明
至少有一个人为阳性，需要将这 k 个人的样本全部重新独立检测（从理论上看，
如果检测前 k − 1 个人都是阴性可以推断出第 k 个人是阳性，但是在实际操作中
不会利用此推断，而是将 k 个人独立检测），加上最开始的合并检测，一共使用
了 k + 1 个试剂盒完成了 k 个人的检测。
A 国估计被测的民众的感染率大概是 1%，呈均匀分布。请问 k 取多少能
最节省试剂盒？
【答案提交】
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个
整数，在提交答案时只填写这个整数，填写多余的内容将无法得分
【答案】10
【思路1】
这题数学问题
设总人数为pop，感染率p，每次k人，总市级数sum
sum = ( [pop / k]+1 ) * ( 1+kp(k+1) )
这里的[ pop / k ] + 1，即pop/k向上取整
[pop/k] + 1 这里由于pop数量较大，所以这里向上取整的1可以忽略，这里直接取了pop/k，即
sum = ( pop / k ) * ( 1 + kp( k+1 ) )
将p代入sum = (pop/k)( 1+k0.01( k+1 ) )
sum求导 = ( pop/k ) ( 0.01k-1/k)
可得当k =10时，sum取最小值
所以K = 10。
【思路2】
假设A国有n个人，感染者有n/100
每k个人一组，共n/k组，共用n/k瓶试剂
按照最坏的情况，每多出一个感染者就多用k瓶试剂，
因此共用n/k+(n/100)k瓶试剂
n是定值，所以求(1/k+k/100)最小
由于a+b>=2√ab
当且仅当a = b时，取等号
即1/k=k/100时，取得最小值
解得k = 10
REPEAT程序
【问题描述】
附件 prog.txt 中是一个用某种语言写的程序。
其中 REPEAT k 表示一个次数为 k 的循环。循环控制的范围由缩进表达，
从次行开始连续的缩进比该行多的（前面的空白更长的）为循环包含的内容。
例如如下片段：
该片段中从 A = A + 4 所在的行到 A = A + 8 所在的行都在第一行的
循环两次中。
REPEAT 6: 所在的行到 A = A + 7 所在的行都在 REPEAT 5: 循环中。
A = A + 5 实际总共的循环次数是 2 × 5 × 6 = 60 次。
请问该程序执行完毕之后，A 的值是多少？
【答案提交】
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个
整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
【答案】403
【代码】
public static void main(String[] args) {
int a = 0, count = 1;
for (int i = 1; i <= 2; i++) {
a = a + 4;
for (int j = 1; j <= 5; j++) {
for (int k = 1; k <= 6; k++) {
a = a + 5;
}
a = a + 7;
}
a = a + 8;
}
a = a + 9;
System.out.println(a);
}
分类计数
【问题描述】
输入一个字符串，请输出这个字符串包含多少个大写字母，多少个小写字
母，多少个数字。
【输入格式】
输入一行包含一个字符串。
【输出格式】
输出三行，每行一个整数，分别表示大写字母、小写字母和数字的个数。
【样例输入】
1+a=Aab
【样例输出】
1
3
1
【评测用例规模与约定】
对于所有评测用例，字符串由可见字符组成，长度不超过 100。
【代码】
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String words = sc.nextLine();
int small = 0;
int big = 0;
int num = 0;
for (int i = 0; i < words.length(); i++) {
char temp = words.charAt(i);
if (temp <= 'z' && temp >= 'a')small++;
else if (temp <= 'Z' && temp >= 'A')big++;
else if (temp <= '9' && temp >= '0')num++;
}
System.err.println(big);
System.out.println(small);
System.err.println(num);
}
整除序列
【问题描述】
有一个序列，序列的第一个数是 n，后面的每个数是前一个数整除 2，请输
出这个序列中值为正数的项。
【输入格式】
输入一行包含一个整数 n。
【输出格式】
输出一行，包含多个整数，相邻的整数之间用一个空格分隔，表示答案。
【样例输入】
20
【样例输出】
20 10 5 2 1
【评测用例规模与约定】
对于 80% 的评测用例，1 ≤ n ≤ 109。
对于所有评测用例，1 ≤ n ≤ 1018。
【代码】
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
BigInteger n = sc.nextBigInteger();
while(true) {
System.out.print(n+" ");
if(n.equals(new BigInteger("1")))break;
n = n.divide(new BigInteger("2"));
}
}
走方格
【问题描述】
在平面上有一些二维的点阵。
这些点的编号就像二维数组的编号一样，从上到下依次为第 1 至第 n 行，
从左到右依次为第 1 至第 m 列，每一个点可以用行号和列号来表示。
现在有个人站在第 1 行第 1 列，要走到第 n 行第 m 列。只能向右或者向下
走。
注意，如果行号和列数都是偶数，不能走入这一格中。
问有多少种方案。
【输入格式】
输入一行包含两个整数 n, m。
【输出格式】
输出一个整数，表示答案。
【样例输入】
3 4
【样例输出】
2
【样例输入】
6 6
【样例输出】
0
【评测用例规模与约定】
对于所有评测用例，1 ≤ n ≤ 30, 1 ≤ m ≤ 30。
【代码1】
static int n, m;
static int ans;
static int img[][];
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
m = sc.nextInt();
if (n % 2 == 0 && m % 2 == 0) {
System.out.println(ans);
} else {
dfs(1, 1);
System.out.println(ans);
}
}
public static void dfs(int x, int y) {
if (x % 2 == 0 && y % 2 == 0) {
return;
}
if (x > n || y > m) {
return;
}
if (x == n && y == m) {
ans++;
return;
}
dfs(x + 1, y); // 向右走
dfs(x, y + 1); // 向下走
}
【代码1】
public static void main(String[] args) {
// 输入矩阵的宽高
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
long startTime = System.currentTimeMillis(); //获取开始时间
sc.close();
int[][] dp = new int[n][m];
dp[0][0] = 1;
// 这个规律是只能往右下走，也就是只能取左上的值
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
// 第一行一列无需处理
if (i == 0 && j == 0) {
continue;
}
// 只要不是第一行就可以取上面的
if (i > 0) {
dp[i][j] += dp[i - 1][j];
}
// 只要不是第一列就可以取左面的
if (j > 0) {
dp[i][j] += dp[i][j - 1];
}
// 如果是偶数行列不能取值，这里是奇数，因为我的是从0开始，所以偶数的就变成了奇数
if ((i & 1) == 1 && (j & 1) == 1) {
dp[i][j] = 0;
}
}
}
System.out.println(dp[n - 1][m - 1]);
}
字符串编码
【问题描述】
小明发明了一种给由全大写字母组成的字符串编码的方法。对于每一个大
写字母，小明将它转换成它在 26 个英文字母中序号，即 A → 1, B → 2, ... Z →
26。
这样一个字符串就能被转化成一个数字序列：
比如 ABCXYZ → 123242526。
现在给定一个转换后的数字序列，小明想还原出原本的字符串。当然这样
的还原有可能存在多个符合条件的字符串。小明希望找出其中字典序最大的字
符串。
【输入格式】
一个数字序列。
【输出格式】
一个只包含大写字母的字符串，代表答案
【样例输入】
123242526
【样例输出】
LCXYZ
【评测用例规模与约定】
对于 20% 的评测用例，输入的长度不超过 20。
对于所有评测用例，输入的长度不超过 200000。
【代码】
public static void main(String[] args) {
String words = " ABCDEFGHIJKLMNOPQRSTUVWXYZ";
Scanner sc = new Scanner(System.in);
String bianma = sc.nextLine();
int link1 = 0;
int link2 = 1;
while(link1<bianma.length()) {
int n;
if(link2<bianma.length()) {
n = (bianma.charAt(link1)-'0')*10+bianma.charAt(link2)-'0';
}else {
n = bianma.charAt(link1)-'0';
}
if(n<=26) {
System.out.print(words.charAt(n));
link1 = link1 + 2;
link2 = link2 + 2;
}else {
System.out.print(words.charAt(bianma.charAt(link1)-'0'));
link1 = link1 + 1;
link2 = link2 + 1;
}
}
}
整数小拼接
【问题描述】
给定义个长度为 n 的数组 A1, A2, · · · , An。你可以从中选出两个数 Ai 和 Aj
(i 不等于 j)，然后将 Ai 和 Aj 一前一后拼成一个新的整数。例如 12 和 345 可
以拼成 12345 或 34512 。注意交换 Ai 和 Aj 的顺序总是被视为 2 种拼法，即便
是 Ai = Aj 时。
请你计算有多少种拼法满足拼出的整数小于等于 K。
【输入格式】
第一行包含 2 个整数 n 和 K。
第二行包含 n 个整数 A1, A2, · · · , An。
【输出格式】
一个整数代表答案。
【样例输入】
4 33
1 2 3 4
【样例输出】
8
【评测用例规模与约定】
对于 30% 的评测用例，1 ≤ N ≤ 1000, 1 ≤ K ≤ 108
, 1 ≤ Ai ≤ 104。
对于所有评测用例，1 ≤ N ≤ 100000，1 ≤ K ≤ 1010，1 ≤ Ai ≤ 109。
【代码】
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int K = sc.nextInt();
int[] a = new int[n];
int ans = 0;
for(int i=0;i<a.length;i++) {
a[i] = sc.nextInt();
}
for(int i=0;i<a.length-1;i++) {
for(int j=i+1;j<a.length;j++) {
int num1 = Integer.valueOf(String.valueOf(a[i])+String.valueOf(a[j]));
int num2 = Integer.valueOf(String.valueOf(a[j])+String.valueOf(a[i]));
System.out.println(num1+" "+num2);
if(num1<K) {
ans++;
}
if(num2<K) {
ans++;
}
}
}
System.out.println(ans);
}
