2017年第八届蓝桥杯国赛试题及详解（Java B组）

忘是亡心i 2022-11-22 10:28 120阅读 0赞

*  结果填空 (满分17分)
 *  结果填空 (满分45分)
 *  代码填空 (满分23分)
 *  程序设计（满分43分）
 *  程序设计（满分71分）
 *  程序设计（满分101分）

### 1. 标题：平方十位数 ###

由0~9这10个数字不重复、不遗漏，可以组成很多10位数字。

这其中也有很多恰好是平方数（是某个数的平方）。

比如：1026753849，就是其中最小的一个平方数。

请你找出其中最大的一个平方数是多少？

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

**答案解析**

答案：9814072356

如果直接从 9876543210 遍历到 1026753849，未免太暴力了。可以遍历平方根，然后再平方判断是否有重复的数位。

public class Main { 
    
        public static void main(String[] args) { 
            // TODO Auto-generated method stub
            boolean[] vis = new boolean[10];
            long maxx = (int) Math.sqrt(9876543210.0);
            for (long i=maxx;i>=32043;i--) { 
                long k = i*i;
                int flag = 1;
                for (int j=0;j<=9;j++) { 
                    vis[j] = false;
                }
                while(k>0) { 
                    int temp = (int) (k%10);
                    if (vis[temp]) { 
                        flag = 0;
                        break;
                    }
                    else { 
                        vis[temp] = true;
                    }
                    k/=10;
                }
                if(flag==1) { 
                    System.out.println(i);
                    System.out.println(i*i);
                    break;
                }
            }
        }
    }

### 2. 标题：生命游戏 ###

康威生命游戏是英国数学家约翰·何顿·康威在1970年发明的细胞自动机。  
这个游戏在一个无限大的2D网格上进行。

初始时，每个小方格中居住着一个活着或死了的细胞。  
下一时刻每个细胞的状态都由它周围八个格子的细胞状态决定。

具体来说：

1.  当前细胞为存活状态时，当周围低于2个（不包含2个）存活细胞时， 该细胞变成死亡状态。（模拟生命数量稀少）
2.  当前细胞为存活状态时，当周围有2个或3个存活细胞时， 该细胞保持原样。
3.  当前细胞为存活状态时，当周围有3个以上的存活细胞时，该细胞变成死亡状态。（模拟生命数量过多）
4.  当前细胞为死亡状态时，当周围有3个存活细胞时，该细胞变成存活状态。 （模拟繁殖）

当前代所有细胞同时被以上规则处理后, 可以得到下一代细胞图。按规则继续处理这一代的细胞图，可以得到再下一代的细胞图，周而复始。

例如假设初始是:(X代表活细胞，.代表死细胞)

.....
    .....
    .XXX.
    .....

下一代会变为:

.....
    ..X..
    ..X..
    ..X..
    .....

康威生命游戏中会出现一些有趣的模式。例如稳定不变的模式：

....
    .XX.
    .XX.
    ....

还有会循环的模式：

......      ......       ......
    .XX...      .XX...       .XX...
    .XX...      .X....       .XX...
    ...XX.   -> ....X.  ->   ...XX.
    ...XX.      ...XX.       ...XX.
    ......      ......       ......

本题中我们要讨论的是一个非常特殊的模式，被称作"Gosper glider gun"：

......................................
    .........................X............
    .......................X.X............
    .............XX......XX............XX.
    ............X...X....XX............XX.
    .XX........X.....X...XX...............
    .XX........X...X.XX....X.X............
    ...........X.....X.......X............
    ............X...X.....................
    .............XX.......................
    ......................................

假设以上初始状态是第0代，请问第1000000000(十亿)代一共有多少活着的细胞？

注意：我们假定细胞机在无限的2D网格上推演，并非只有题目中画出的那点空间。  
当然，对于遥远的位置，其初始状态一概为死细胞。

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

**答案解析**

不会。

### 4.标题：小计算器 ###

模拟程序型计算器，依次输入指令，可能包含的指令有

1.  数字：‘NUM X’，X为一个只包含大写字母和数字的字符串，表示一个当前进制的数
2.  运算指令：‘ADD’,‘SUB’,‘MUL’,‘DIV’,‘MOD’，分别表示加减乘，除法取商，除法取余
3.  进制转换指令：‘CHANGE K’，将当前进制转换为K进制(2≤K≤36)
4.  输出指令：‘EQUAL’，以当前进制输出结果
5.  重置指令：‘CLEAR’，清除当前数字

指令按照以下规则给出：  
数字，运算指令不会连续给出，进制转换指令，输出指令，重置指令有可能连续给出  
运算指令后出现的第一个数字，表示参与运算的数字。且在该运算指令和该数字中间不会出现运算指令和输出指令  
重置指令后出现的第一个数字，表示基础值。且在重置指令和第一个数字中间不会出现运算指令和输出指令  
进制转换指令可能出现在任何地方

运算过程中中间变量均为非负整数，且小于2^63。  
以大写的’A’ ~ ‘Z’ 表示10 ~ 35

**\[输入格式\]**

第1行：1个n，表示指令数量

第2…n+1行：每行给出一条指令。指令序列一定以’CLEAR’作为开始，并且满足指令规则

**\[输出格式\]**

依次给出每一次’EQUAL’得到的结果

**\[样例输入\]**

7  
CLEAR  
NUM 1024  
CHANGE 2  
ADD  
NUM 100000  
CHANGE 8  
EQUAL

**\[样例输出\]**

2040

补充说明：

1.  n 值范围: 1<= n < 50000
2.  初始默认的进制是十进制

资源约定：  
峰值内存消耗 < 256M  
CPU消耗 < 1000ms

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。  
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。  
注意：主类的名字必须是：Main，否则按无效代码处理。

**答案解析：**

模拟题，重点在于进制转换，Long.valueOf()这个函数可以把指定字符串转换为想要的进制。

import java.util.Scanner;
    public class Main { 
    
        static int n, k = 10;
        static long num, temp;
        static String op = "";
    
        static void operation(String str) { 
            String[] ss = str.split(" ");
            if ("ADD".equals(ss[0])) { 
                op = ss[0];
            } 
            else if ("SUB".equals(ss[0])) { 
                op = ss[0];
            }
            else if ("MUL".equals(ss[0])) { 
                op = ss[0];
            }
            else if ("DIV".equals(ss[0])) { 
                op = ss[0];
            }
            else if ("MOD".equals(ss[0])) { 
                op = ss[0];
            }
            else if ("CHANGE".equals(ss[0])) { 
                k = Integer.parseInt(ss[1]);
            }
            else if ("EQUAL".equals(ss[0])) {  
                System.out.println(Long.toString(num, k).toUpperCase());
            } 
            else if ("CLEAR".equals(ss[0])) { 
                num = 0;
                temp = 0;
                k = 10;
                op = "";
            }
            else if ("NUM".equals(ss[0])) { 
                if ("".equals(op)) { 
                    num = Long.valueOf(ss[1], k);
                }
                else { 
                    temp = Long.valueOf(ss[1], k);
                    num =  calcute(op);
                    temp = 0;
                    op = "";
                }
            }
        }
    
        static long calcute(String str) { 
            // TODO Auto-generated method stub
            long ans = 0;
            if ("ADD".equals(str)) { 
                ans = num + temp;
            } 
            else if ("SUB".equals(str)) { 
                ans = num - temp;
            }
            else if ("MUL".equals(str)) { 
                ans = num * temp;
            }
            else if ("DIV".equals(str)) { 
                ans = num / temp;
            }
            else if ("MOD".equals(str)) { 
                ans = num % temp;
            }
            return ans;
        }
    
        public static void main(String[] args) { 
            // TODO Auto-generated method stub
            Scanner sc = new Scanner(System.in);
            n = sc.nextInt();
            sc.nextLine();
            for (int i = 1; i <= n; i++) { 
                String str = sc.nextLine();
                operation(str);
            }
        }
    }