【蓝桥杯】第六届蓝桥杯大赛个人赛省赛（软件类） Java大学C组 -题目与答案

第六届蓝桥杯大赛个人赛省赛（软件类）

Java大学C组 -题目与答案

1、结果填空（满分3分）	2、结果填空（满分5分）	3、结果填空（满分9分）	4、代码填空（满分11分）	5、代码填空（满分15分）
15	36	1085
6、结果填空（满分17分）	7、结果填空（满分21分）	8、程序设计（满分13分）	9、程序设计（满分25分）	9、程序设计（满分25分）

具体解析：

1、隔行变色

Excel表的格子很多，为了避免把某行的数据和相邻行混淆，可以采用隔行变色的样式。

小明设计的样式为：第1行蓝色，第2行白色，第3行蓝色，第4行白色，....

现在小明想知道，从第21行到第50行一共包含了多少个蓝色的行。

请你直接提交这个整数，千万不要填写任何多余的内容。

public static void main(String[] args) {

//隔行变色

int i,count=0;

for(i=1;i<=50;i++){

if(i>=21&&i%2==1){

count++;

}

System.out.println(count);

}

答案：15

2、立方尾不变

有些数字的立方的末尾正好是该数字本身。

比如：1,4,5,6,9,24,25,....

请你计算一下，在10000以内的数字中（指该数字，并非它立方后的数值），符合这个特征的正整数一共有多少个。

请提交该整数，不要填写任何多余的内容。

public static void main(String[] args) {//2、立方尾不变

//注意使用long型，int型超出范围计算错误

int count = 0;//统计

for (long i = 1; i < 10000; ++i) {

if (i < 10) {

if (i * i * i % 10 == i) count++;

} else if (i < 100) {

if (i * i * i % 100 == i) count++;

} else if (i < 1000) {

if (i * i * i % 1000 == i) count++;

} else if (i < 10000) {

if (i * i * i % 10000 == i) count++;

}

System.out.println(count);

}

答案：36

3、三羊献瑞

观察下面的加法算式：

祥瑞生辉

+ 三羊献瑞

-------------------

三羊生瑞气

(如果有对齐问题，可以参看【图1.jpg】)

其中，相同的汉字代表相同的数字，不同的汉字代表不同的数字。

请你填写“三羊献瑞”所代表的4位数字（答案唯一），不要填写任何多余内容。

答案：1085

解析：

首先通过数学分析，得出“三”是：1

假设：祥:A 瑞:B 生:C 辉:D 三:E 羊:F 献:G 气:H

A B C D

+ 1 F G H

_____________________

1 F C B H

暴力破解：

public static void main(String[] args) {//三羊献瑞

int a1,a2,a3,a4,a5,a6,a7;

for(a1=1;a1<10;a1++){

for(a2=0;a2<10;a2++){

for(a3=0;a3<10;a3++){

for(a4=0;a4<10;a4++){

for(a5=0;a5<10;a5++){

for(a6=0;a6<10;a6++){

for(a7=0;a7<10;a7++){

long temp1= a1*1000+a2*100+a3*10+a4;

long temp2= 1000+a5*100+a6*10+a2;

long result= 10000+a5*1000+a3*100+a2*10+a7;

if(a1==a2||a1==a3||a1==a4||a1==a5||a1==a6||a1==a7||a2==a3||a2==a4

||a2==a3||a2==a4||a2==a5||a2==a6||a2==a7||a3==a4||a3==a5||a3==a6

||a3==a4||a3==a5||a3==a6||a3==a7||a4==a5||a4==a6||a4==a7||a5==a6

||a5==a6||a5==a7||a6==a7||a7==1){

continue;

}

if(temp1+temp2==result){

System.out.printf("%d+%d=%d\n",temp1,temp2,result);

}

4、格子中输出

StringInGrid函数会在一个指定大小的格子中打印指定的字符串。

要求字符串在水平、垂直两个方向上都居中。

如果字符串太长，就截断。

如果不能恰好居中，可以稍稍偏左或者偏上一点。

下面的程序实现这个逻辑，请填写划线部分缺少的代码。

#include <stdio.h>

#include <string.h>

void StringInGrid(int width, int height, const char* s)

{

int i,k;

char buf[1000];

strcpy(buf, s);

if(strlen(s)>width-2) buf[width-2]=0;

printf("+");

for(i=0;i<width-2;i++) printf("-");

printf("+\n");

for(k=1; k<(height-1)/2;k++){

printf("|");

for(i=0;i<width-2;i++) printf(" ");

printf("|\n");

}

printf("|");

printf("%*s%s%*s",_____________________________________________); //填空

printf("|\n");

for(k=(height-1)/2+1; k<height-1; k++){

printf("|");

for(i=0;i<width-2;i++) printf(" ");

printf("|\n");

}

printf("+");

for(i=0;i<width-2;i++) printf("-");

printf("+\n");

}

int main()

{

StringInGrid(20,6,"abcd1234");

return 0;

}

对于题目中数据，应该输出：

+------------------+

| |

| abcd1234 |

| |

+------------------+

（如果出现对齐问题，参看【图1.jpg】）

注意：只填写缺少的内容，不要书写任何题面已有代码或说明性文字。

答案："%" + (width - 2 - s.length()) / 2 + "s%s%" + (width - 2 - s.length()

//4、格子中输出

//主方法

public static void main(String[] args) {

stringInGrid(20,6,"abcd1234");

}

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 = _______________________________________________________; //填空

String ff = "%" + (width - 2 - s.length()) / 2 + "s%s%" + (width - 2 - s.length() - (width - 2 - s.length()) / 2) + "s"; //填空

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("+");

}

5、串逐位和

给定一个由数字组成的字符串，我们希望得到它的各个数位的和。

比如：“368” 的诸位和是：17

这本来很容易，但为了充分发挥计算机多核的优势，小明设计了如下的方案：

int f(char s[], int begin, int end)

{

int mid;

if(end-begin==1) return s[begin] - '0';

mid = (end+begin) / 2;

return ____________________________________; //填空

}

int main()

{

char s[] = "4725873285783245723";

printf("%d\n",f(s,0,strlen(s)));

return 0;

}

你能读懂他的思路吗？请填写划线部分缺失的代码。

注意：只填写缺少的部分，不要填写已有代码或任何多余内容。

答案：return f(s, begin,mid)+f(s,mid,end);

6、奇妙的数字

小明发现了一个奇妙的数字。它的平方和立方正好把0~9的10个数字每个用且只用了一次。

你能猜出这个数字是多少吗？

请填写该数字，不要填写任何多余的内容。

//6、奇妙的数字

public static void main(String[] args) {

for (int i = 1; i <= 100000; i++) {

// 求平方和立方合成一个字符串

String s = (i * i) + "" + (i * i * i);

// 调用方法

if (check(s)) {

System.out.println("这个数是："+i);

System.out.println("这个数平方是："+i*i);

System.out.println("这个数立方是："+i*i*i);

}

private static boolean check(String s) {

// 字符串的长度刚好是10

if (s.length() != 10)

return false;

Set<Character> set = new HashSet<Character>();

// 判断刚好是10各数字组成的

for (int i = 0; i < s.length(); i++) {

set.add(s.charAt(i));

}

return set.size() == 10;

}

答案：69

7、加法变乘法

我们都知道：1+2+3+ ... + 49 = 1225

现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015

比如：

1+2+3+...+10*11+12+...+27*28+29+...+49 = 2015

就是符合要求的答案。

请你寻找另外一个可能的答案，并把位置靠前的那个乘号左边的数字提交（对于示例，就是提交10）。

注意：需要你提交的是一个整数，不要填写任何多余的内容。

//7、加法变乘法

public static void main(String[] args) {

for (int i = 1; i <= 30; i++) {

for (int j = i + 2; j <= 30; j++) {

if (1225 - 2 * i - 1 - 2 * j - 1 + j*(j + 1) + i*(i + 1) == 2015)

System.out.println(i);

}

答案：16

8、饮料换购

乐羊羊饮料厂正在举办一次促销优惠活动。乐羊羊C型饮料，凭3个瓶盖可以再换一瓶C型饮料，并且可以一直循环下去(但不允许暂借或赊账)。

请你计算一下，如果小明不浪费瓶盖，尽量地参加活动，那么，对于他初始买入的n瓶饮料，最后他一共能喝到多少瓶饮料。

输入：一个整数n，表示开始购买的饮料数量（0<n<10000）

输出：一个整数，表示实际得到的饮料数

例如：

用户输入：

100

程序应该输出：

149

用户输入：

101

程序应该输出：

151

资源约定：

峰值内存消耗 < 256M

CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

注意: main函数需要返回0

注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。

注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>，不能通过工程设置而省略常用头文件。

import java.util.Scanner;

//8、饮料换购

public class Main {

static int m;// 购买数量

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

m = in.nextInt();// 购买数量

DFS(m, 0); // 递归

}

/**

* @param n 购买数量

* @param sum 兑换数量

public static void DFS(int n, int sum) {

if (n - 3 < 0) {// 当m不足3的时候就不能兑换饮料了

System.out.println(sum + m);

return;// 实际数量=购买数量+兑换数

}

DFS(n - 2, sum + 1); // 购买数>个数大于3

}

提交时，注意选择所期望的编译器类型。

9、打印大X

小明希望用星号拼凑，打印出一个大X，他要求能够控制笔画的宽度和整个字的高度。

为了便于比对空格，所有的空白位置都以句点符来代替。

要求输入两个整数m n，表示笔的宽度，X的高度。用空格分开(0<m<n, 3<n<1000, 保证n是奇数)

要求输出一个大X

例如，用户输入：

3 9

程序应该输出：

***.....***

.***...***.

..***.***..

...*****...

....***....

...*****...

..***.***..

.***...***.

***.....***

（如有对齐问题，参看【图1.jpg】）

再例如，用户输入：

4 21

程序应该输出

****................****

.****..............****.

..****............****..

...****..........****...

....****........****....

.....****......****.....

......****....****......

.......****..****.......

........********........

.........******.........

..........****..........

.........******.........

........********........

.......****..****.......

......****....****......

.....****......****.....

....****........****....

...****..........****...

..****............****..

.****..............****.

****................****

（如有对齐问题，参看【图2.jpg】）

资源约定：

峰值内存消耗 < 256M

CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

注意: main函数需要返回0

注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。

注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>，不能通过工程设置而省略常用头文件。

提交时，注意选择所期望的编译器类型。

import java.util.Scanner;

打印大X

public class Main {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

int m = sc.nextInt();// 宽度

int n = sc.nextInt();// 高度

int w = m + (n / 2) * 2;

int g[][] = new int[n][w];

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

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

g[j][i] = '.';

}

// 从左上往右下

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

for (int k = 0; k < m; ++k) {

g[i][i + k] = '*';

}

// 从右上到左下

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

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

g[l][w - 1 - l - i] = '*';

}

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

for (int j = 0; j < w; ++j) {

System.out.printf("%c", g[i][j]);

}

System.out.printf("\n");

}

10、垒骰子

赌圣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

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

注意: main函数需要返回0

注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。

注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>，不能通过工程设置而省略常用头文件。

public class Main {//10、垒骰子

static int ym[] = new int[7];

private static int n;

private static int m;

private static final long MOD = 1000000007;

static void init() {

ym[1] = 4;

ym[4] = 1;

ym[2] = 5;

ym[5] = 2;

ym[3] = 6;

ym[6] = 3;

}

public static void main(String[] args) {

init();

Scanner sc = new Scanner(System.in);

n = sc.nextInt();

m = sc.nextInt();

long cf[][] = new long[6][6];

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

for (int j = 0; j < 6; j++) {

cf[i][j]=1;

}

//建立冲突矩阵

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

int a = sc.nextInt();

int b = sc.nextInt();

cf[ym[a] - 1][b - 1] = 0;

cf[ym[b] - 1][a - 1] = 0;

}

// 求冲突矩阵的n-1次方

long[][] mPow_n_1 = mPow(cf, 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 * power(4, n) % MOD);

}

提交时，注意选择所期望的编译器类型。

public static long power(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;

}

/*矩阵的快速幂*/

public static long[][] mPow(long[][] cf, int n) {

long[][] e = new long[6][6];

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

for (int j = 0; j < 6; j++) {

if (i == j) e[i][j] = 1;

else e[i][j] = 0;

}

while (n != 0) {

if ((n & 1) == 1) {

e = mMul(e, cf);

}

cf = mMul(cf, cf);

n >>= 1;

}

return e;

}

public 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;

}