蓝桥杯2015年真题
1.隔行变色
在Excel表格中存在大量单元格（cell），为了防止某一行的数据与其相邻的另一行产生混淆从而影响数据完整性与可读性，则可采用隔行着色的方法进行样式设置
根据上述设定的小明交错颜色方案，请问从第21到50号单元格之间包含了多少个深蓝色单元格？
请你直接提交这个整数，千万不要填写任何多余的内容。
public class A {
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);
}
}2.立方尾不变
有些数字的立方的末尾正好是该数字本身。
比如：1,4,5,6,9,24,25,…
请计算一下，在小于等于10000的数字范围内（指这个特定的数字不考虑其立方结果），有多少个这样的正整数。
请提交该整数，不要填写任何多余的内容。
答题思路：
_**1. 题目未做时间和内存限制要求的情况下，默认可采用穷举法这种简单直接的方式进行求解。
2. 穷举法是一种可行的方法，在这种情况下尤其适合解决范围较小的问题。
3. 因为这些数的立方结果通常较大（例如计算1到9999之间所有正整数的立方），所以为了存储这些较大的数值需要使用long long类型变量来存储结果）。
4. 比如说当计算出某个整数n的立方值时（例如计算25³得到的结果是15625），我们只需要提取这个数值的最后两位数字（即62），然后与原来的数字n进行比较是否相等即可满足题目的条件）。
5. 如果最后两位数字与n相等，则将该数值记录下来作为候选答案之一）。
public class A {
public static void main(String[] args) {
int count = 0;
int i;
for (i = 1; i <= 10000; i++) {
if (i < 10) {
if ((i*i*i) % 10 == i) {
//System.out.println(i+" ");
count++;
}
} else if (i < 100) {
// System.out.println("*****");
if ((i*i*i) % 100 == i){
//System.out.println(i+" ");
count++;}
} else if (i < 1000) {
//System.out.println("*****");
if ((i*i*i) % 1000 == i){
//System.out.println(i+" ");
count++;
}
} else if (i < 10000) {
if ((i*i*i) % 10000 == i){
//System.out.println(i+" ");
//System.out.println("*****");
count++;}
}
}
System.out.println(count);
}
}3.无穷分数
图1.jpg
无限延伸的分数可能会收敛至某个固定值。请计算如图所示的无限分数，请将结果四舍五入至第五位小数，并对不足的小数位进行零填充。
请填写该浮点数，不能填写任何多余的内容。
思路：
_由题可知,反复相除后最终会趋近于一个固定数值,并且需要保留至第五位小数,因此我们可以选取几个初始值进行计算,观察其收敛情况,进而确定收敛至哪一个稳定值
该式的实现方法可以通过递归算法来完成,同样适合使用迭代算法来处理,而本次实现采用了循环结构以简化运算流程
public class A{
public static void main(String[] args) {
//可以更改n来试验最后求出的固定值对不对
double n = 100;
//储存每一次计算的值
double sum = n + 2;
//倒着来算每一层的值，一直算到第一层
for (double i = n; i >= 0; i--) {
sum = i + (i + 1) / sum;
}
//格式化字符串，保留五位小数输出
System.out.println(String.format("%.5f", sum));
}
}4.循环节长度
进行整数除法运算时，可能会得到一个无限循环小数。其中的无限部分被称为"循环节"。例如，在计算 \frac{1}{7} 时会得到 0.\overline{142857} 其中的"142857"这一串数字就是该分数的一个典型循环节并包含了六位数字我们介绍一种方法来确定一个分数的其长度。
请仔细阅读代码，并填写划线部分缺少的代码。
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) _________________________________ ; //填空
}
}这个方法显著地表现出良好的效果。
思路：
向量在内存管理上与数组具有相似性，在内存起始位置开始分配存储空间并按顺序占据内存区域。其区别在于向量允许动态调整大小以适应插入或删除操作；向量提供了一种高效的查找功能：通过调用vector.indexOf(int n)方法可以在数据结构中快速定位特定数值n的位置；如果成功找到该数值，则返回其在向量中的索引位置；如果未找到，则返回-1表示不存在该数值。
import java.util.Vector;
public class A {
public static int f(int n, int m) {
n = n % m;
Vector<Integer> v = new Vector<Integer>();
for(; ;) {
v.add(n);
n *= 10;
n = n % m;
if(n == 0) {
return 0;
}
if(v.indexOf(n) >= 0) {
return v.size();
}
}
}
public static void main(String[] args) {
int a = A.f(11, 13);
System.out.println(a);
}
}5.格子中输出
该算法会将给定的字符串渲染到一个预先设计好的网格单元格内。
该字符串需在水平轴和垂直轴两个方向上实现精确居中显示。
若输入文本长度超过单元格容量，则会进行截断处理以避免溢出显示区域。
当无法完全居中时，默认允许文本向左或向上轻微偏移以满足显示需求。
下面的程序实现这个逻辑，请填写划线部分缺少的代码。
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("+");
}对于题目中数据，应该输出：
public class A{
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 = "%1$"+(width-s.length()-2)/2+"s%2$s%3$"+(width-s.length()-2)/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("+");
}
public static void main(String[] args) {
A fk = new A();
fk.stringInGrid(20, 6, "abcd1234");
}
}6.奇妙的数字
小明发现了令人惊叹的一个数字。它的平方与立方恰好把0至9的十个数字每个都用了一次。你能猜出这个数字是什么吗？
请填写该数字，不要填写任何多余的内容。
HashSet的基本概念是不允许在其对象中存储重复的数据项。然而，在实际操作中将元素添加至HashSet的过程并不遵循顺序原则（与List存在显著差异）。值得注意的是，在HashSet中元素并不以插入顺序保存（与List存在显著差异），而是基于哈希算法进行组织。因此，在执行检索操作同样是基于该键值得实现这一特点使得其内存访问效率得以提升
型 方法名 功能
boolean add(E e) 如果当前列表中不存在e， 则将e加入列表
void clear() 从列表中删除所有元素
boolean contains(Object j) 判断列表中是否有元素j
Iterator iterator() 得到当前列表的遍历器
boolean remove(Object j) 如果列表中存在元素j,则将其从列表中删除
int size（） 得到列表中元素的个数
import java.util.HashSet;
import java.util.Set;
public class A {
public static void main(String[] args) {
Set<Integer> set;
int n=0,p=0,l=0,count=0;
while(count!=10) {
n++;
set=new HashSet<Integer>();
p=n*n;
l=n*n*n;
while(p>0) {
set.add(p%10);
p/=10;
}
while(l>0) {
set.add(l%10);
l/=10;
}
count=set.size();
}
System.out.println(n);
}
}7.加法变乘法
我们都知道：1+2+3+ … + 49 = 1225
现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015
比如：
1+2+3+…+10 11+12+…+27 28+29+…+49 = 2015
就是符合要求的答案。
请为该问题寻找另一个可能的答案，并将其最前面的那个乘号左侧的数值提交（例如，在示例中就是10）。
注意：需要你提交的是一个整数，不要填写任何多余的内容。
public class A {
public static void main(String[] args) {
int a = 2015 - 1225;
for (int i = 1; i <= 48; i++) {
for (int j = 1; j <= 48; j++) {
if (i * (i + 1) + j * (j + 1) - i -
i - 1 - j -
j - 1 == a && i < j && i != 10) {
int min = (i > j) ? j : i;
System.out.println(min);
}
}
}
}
}8.移动距离
X星球小区的所有住宅建筑结构相同，并以矩阵形式分布。其楼号依次为1、2、3……
一旦一列填满后，则从下一层对应位置开始向相反的方向进行编号。
其中宽度设定为6个单位时的情况如下：
1 2 3 4 5 6
12 11 10 9 8 7
13 14 15 …
我们的题目是：知道了两个单元楼的编号m和n，请计算它们之间的最小间距（不允许水平或垂直方向移动）。
输入由三个整数w、m、n组成，在它们之间有空格分隔，并且每个数值都在1至10,000之间。请计算出m与n两楼之间的最短移动距离。
例如：
用户输入：
6 8 2
则，程序应该输出：
4
再例如：
用户输入：
4 7 20
则，程序应该输出：
5
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
将所有代码整合至一个源文件中进行开发。为了便于调试与管理，请确保整个项目的所有代码都位于同一个编译单位内。特别提示：请避免在源代码中导入任何包（package）语句，在实际编码过程中可能会因包管理不当导致运行时错误或性能问题。为了确保开发质量，请严格遵守以下规定：禁止在项目中应用 JDK 1.7及更高版本特有的功能特性或语法特性；建议将主类命名为‘Main’。
import java.util.Scanner;
//广度优先搜索
public class A {
public static void main(String[] args) {
@SuppressWarnings("unused")
int next[][]={{0,1},//向右走
{1,0},//向下走
{0,-1},//向左走
{-1,0}};
//初始化楼房
@SuppressWarnings("resource")
Scanner sr = new Scanner(System.in);
int c=sr.nextInt();
int f1=sr.nextInt();
int f2=sr.nextInt();
@SuppressWarnings("unused")
int k,count1=0;
int fb=1;
int g=1;
for(int i=1;;i++) {
if(i*c>(f2>f1?f2:f1))
{
k=i;
break;
}
}
@SuppressWarnings("unused")
int z=c*k;
int lf[][]= new int[k][c+1];
for(int i=0;i<k;i++) {
for(int j=0;j<c;j++) {
lf[i][j]=g++;
}
}
@SuppressWarnings("unused")
int qdx = 0,qdy = 0;
for(int i=0;i<k;i++) {
for(int j=0;j<c/2;j++) {
if(c-j-1>0&&fb==-1) {
int b=lf[i][c-j-1];
lf[i][c-j-1]=lf[i][j];
lf[i][j]=b;
}
}
fb*=-1;
}
int f1x = 0,f1y = 0,f2x = 0,f2y = 0;
for(int i=0;i<k;i++) {
for(int j=0;j<c;j++) {
if (lf[i][j]==f1){
f1x=i;
f1y=j;
}
if (lf[i][j]==f2){
f2x=i;
f2y=j;
}
System.out.print(lf[i][j]+"\t");
}
System.out.println();
}
int localx,localy;
localx=f1x-f2x;
localy=f1y-f2y;
if(localx<0)
localx*=-1;
if(localy<0)
localy*=-1;
System.out.println(localx+localy);
}
}9.打印大X
小明打算使用星号组装一个大X形图案，并要求能够调节线条粗细程度以及整体尺寸的高度。
在进行空格对比时,所有空白区域都被标记为句点符号。
请提供两个整数m和n（其中m < n），分别表示线条的宽度和高度（满足条件：m在0到n之间且n大于3小于1000，并且保证n为奇数）。要求以空格分隔输入数据，并生成相应的图形符号X
例如，用户输入：
3 9
程序应该输出：
再例如，用户输入：
4 21
程序应该输出
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
将所有代码整合到同一个源文件中进行编写，并在调试阶段完成整合过程。须确保程序运行测试无误后方可进行下一步操作。为了提高开发效率，请避免采用包结构以及不依赖于JDK 1.7及更高版本的特性。特别强调的是，在本项目中不允许任何外部库的支持，并且主类的名字必须是Main（大写字母），否则会导致项目无法正确编译或运行。
import java.util.Scanner;
public class A {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int m = sc.nextInt();
int n = sc.nextInt();
int width = m+n-1;
String arr[][] = new String[n][width];
for (int i = 0; i < n; i++) {
for (int j = 0; j < width; j++) {
arr[i][j] = ".";
}
}
for (int i = 0; i < n ; i++) {
for (int j = i; j < i+m; j++) {
arr[i][j] = "*";
}
}
for (int i = 0; i < n ; i++) {
for (int j = width-i-m; j < width-i; j++) {
arr[i][j] = "*";
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < width; j++) {
System.out.print(arr[i][j]);
}
System.out.println();
}
}}10.垒骰子
赌圣atm晚年对垒骰子产生了浓厚的兴趣。具体操作是将每个骰子叠放在前一个上面，并且不允许出现倾斜或倾斜状态以确保最终形成整齐稳定的方柱体结构。
通过长时间的观察分析发现影响稳定性的关键因素揭示出某些特定数字相邻放置会导致无法稳定摆放。
为了便于后续分析和计算我们首先规范明确各个面的位置关系即1↔4,2↔5,3↔6.
假设存在m组互斥关系其中任意一组中的两个数字相邻放置都会导致整体稳定性受到影响.
不要小看了 atm 的骰子数量哦～
开头一行包含两个数字 n 和 m
「输出格式」
一行一个数，表示答案模 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。如果不符合要求，则视为无效代码处理。
思路：
①假设骰子的堆放位置已经确定后，则每个骰子都可以围绕竖直轴线旋转四次不同的方向。因此总的摆放方法数应该是4^n乘以摆放位置的选择数目。
②动态规划算法的基本思想是通过逐步构建最优解来实现全局最优解的寻找过程。具体来说就是每次将一个新的骰子放置在已构建结构的顶部，并分析其与现有部分的关系从而建立递推公式。
③例如，在测试案例中，在第二层放置底面对应于数字1时计算得出各顶点的可能性数目为...；通过分析上下层之间的几何关系最终得到第二层完成后的顶点分布情况；接着在第三层重新开始计算并结合上下文信息得到完整的三维模型。
import java.util.Scanner;
public class A {
public static int mod = 10^9 + 7;//这个不知道怎么取余
public static int pow(int m,int n){
//一定要敲的很熟,一个一个的乘很复杂，但是可以一组一组的乘，而这种方法就是利用二进制进行分组
int ans = 1;
int base = m;//最开始的当然是m啦
while(n>0){
if((n&1) == 1) //如果最后一位的权值是1，就应该去乘
ans = ans * base;
base = base*base;//每次都要自己乘自己，以便于随时作出贡献，与下面的n>>1是一对
n = n>>1;//要取的是最后一位
}
return ans;
}
public static void main(String[] args){
Math.pow(1,4);
int[] back = {-100,4,5,6,1,2,3};
int[] pre = {0,1,1,1,1,1,1};//用滚动数组不是太好理解，所以有两个一维数组算了
int[] cur = new int[7];
boolean[][] conflict = new boolean[7][7];
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
for(int i=0;i<m;i++){
int x = sc.nextInt();
int y = sc.nextInt();
conflict[x][y] = conflict[y][x] = true;
}
for(int i=2;i<=n;i++){
for(int j=1;j<7;j++){
cur[j] = 0;//与下面的迭代是一起的组合，千万别忘了,清零这个事情千万别忘了
}
for(int j=1;j<7;j++){//对于当前第i个骰子的当前j面朝上
for(int k=1;k<7;k++){
if(conflict[back[j]][k] == false){//两层之间的限制条件
cur[j]+=pre[k];//顶上的面数为j的种数就等于上一个的选择性累加，一种有递推关系的
/* j //可取的原则就是还有可能互斥
* / /| |\ \
* 1 2 3 4 5 6
* */
}
}
}
for(int a=1;a<7;a++){
pre[a] = cur[a];
//cur[a] = 0;//进行pre与cur的迭代，不能再这里赋值0啊
}
}
int sum = 0;
for(int i=1;i<7;i++){
sum += cur[i];
}
System.out.println(sum*pow(4,n));
}
}