2017蓝桥杯模拟赛高职组

Myth丶恋晨 2022-09-30 00:57 164阅读 0赞

标题: 1的个数  
  
  
  
  
请统计出下面的数据块中有多少个1？  
  
  
10111000100110010111110111000101100100011001100110  
00100101100010100101101000101011101000011010010001  
10010001101100010001001111101000011001011011010110  
01011101011110101110101111010100010001111100000000  
11101110101100101100100101010011101101111110100101  
10010111000000101111100010011100100101110100101000  
10010001000110101011000011111001110110101010111101  
01101000100000111010001110001101111101000001000011  
01001010001011100100110010111111100110111100010000  
10000001011000000011000110110101010111100011000000  
11010100101101110000000110110011111000100010011110  
10101101101001011101100011011111111101100100010000  
00101000100000000101000100101011001111000100111011  
10100111011101100010101000111111001010000100111111  
01111010100001100010011011100010111001111001010001  
01100011100111000010100000011101100001001000010001  
00000001111001000111010010001101101110110110100000  
00000001110111101010011111110000110101100001111101  
11100100111110100101100110010111100011111011111000  
10010101101111011011011111101000111011000010111001  
  
  
当然，我们不反对你一行一行地人工数出来，但这很容易出错啊。这么机械的事情为什么不交给计算机帮你呢？  
  
  
可以把这些数据做成一个常量串，然后逐一枚举每个字符，遇见是1的就计数吧！  
  
  
祝你好运！

注意：只需要填写一个整数，不要填写任何多余的内容。比如说明文字

497

\#include<iostream>  
\#include<algorithm>  
using namespace std;  
int main()  
\{  
char a\[\]="1011100010011001011111011100010110010001100110011000100101100010100101101000101011101000011010010001100100011011000100010011111010000110010110110101100101110101111010111010111101010001000111110000000011101110101100101100100101010011101101111110100101100101110000001011111000100111001001011101001010001001000100011010101100001111100111011010101011110101101000100000111010001110001101111101000001000011010010100010111001001100101111111001101111000100001000000101100000001100011011010101011110001100000011010100101101110000000110110011111000100010011110101011011010010111011000110111111111011001000100000010100010000000010100010010101100111100010011101110100111011101100010101000111111001010000100111111011110101000011000100110111000101110011110010100010110001110011100001010000001110110000100100001000100000001111001000111010010001101101110110110100000000000011101111010100111111100001101011000011111011110010011111010010110011001011110001111101111100010010101101111011011011111101000111011000010111001";  
int i,cnt=0;  
for (i=0; a\[i\]; i++)  
\{  
if (a\[i\] == '1')  
cnt++;  
\}  
cout<<cnt;  
return 0;  
 \}

地产大亨Q先生临终的遗愿是：拿出100万元给X社区的居民抽奖，以稍慰藉心中愧疚。  
麻烦的是，他有个很奇怪的要求：  
  
  
1. 100万元必须被正好分成若干份（不能剩余）。每份必须是7的若干次方元。  
   比如：1元, 7元，49元，343元，...  
  
  
2. 相同金额的份数不能超过5份。  
  
  
3. 在满足上述要求的情况下，分成的份数越多越好！  
  
  
请你帮忙计算一下，最多可以分为多少份？  
  
  
  
  
注意：只需要填写一个整数，就是分成的份数，不要填写任何多余的内容。比如说明文字。  
  
  
\-----------------------------  
  
  
剧透中.......  
  
  
笨笨有话说：  
    7的次方能有多少啊？不超过100万的一共就那么几个，每个的取值从0到5，  
组合起来也没有多少啊，看看哪个组合刚好凑成100万不就行了。  
    如果嫌找出最多的那个组合费事，把所有凑成100万的输出不就行了？我就不信，  
能凑成100万的情况会有那么多吗？应该屈指可数吧！      
  
  
歪歪有话说：  
    如果要求是10的次幂的话，1,10,100,1000，.... 会怎么样？很容易算哦。  
那么，10是个特殊的数字吗？难道不是因为我们人类有10个手指吗？  
如果我们的手指是7根.......7进制你听说过吗？

算出来是16份，结果如下图，不知道是不是最大的份数，如果不是请在最下方评论正确答案，感谢！！

#include<iostream> #include<algorithm> using namespace std; int a[8]={823543,117649,16807,2401,343,49,7,1}; int v[8]={0},MAX=0,flag=0; void dfs(int s) { int i,sum=0,ss=0; if (flag) return; if (s>1000000) { return ; } if (s == 1000000) { for (i=0; i<8; i++) { sum+=v[i]; } if(MAX < sum) { for (i=0; i<8; i++) { cout<<v[i]<<" "; } cout<<endl; for (i=0; i<8; i++) { printf("%d * %d = %d\n",a[i],v[i],a[i]*v[i]); } MAX = sum; for (i=0;i<8;i++) { ss+=a[i]*v[i]; } flag=1; cout<<ss<<endl; } // cout<<endl; return ; } for (i=0; i<8; i++) { if (v[i]<=4) { s+=a[i]; v[i]++; dfs(s); s-=a[i]; v[i]--; } } } int main() { dfs(0); cout<<MAX; return 0; }

![Center][]

题目：猜算式  
  
  
你一定还记得小学学习过的乘法计算过程，比如：  
  
  
   273  
x   15  
\------  
  1365  
  273  
\------  
  4095  
    
请你观察如下的乘法算式  
  
  
    \*\*\*  
x   \*\*\*  
\--------  
    \*\*\*  
   \*\*\*  
  \*\*\*  
\--------  
  \*\*\*\*\*  
    
星号代表某位数字，注意这些星号中，  
0~9中的每个数字都恰好用了2次。  
(如出现因字体而产生的对齐问题，请参看图p1.jpg)  
  
  
请写出这个式子最终计算的结果，就是那个5位数是多少？  
  
  
注意：只需要填写一个整数，不要填写任何多余的内容。比如说明文字。  
  
  
\------------------------------------------------------------  
  
  
剧透中......  
  
  
笨笨有话说：  
    把所有可能的3位数乘以3位数搜索一遍的话....  
关键是，这20个数字中0~9都用了两次，需要统计每个数字出现的次数...  
看起来有点麻烦啊！  
  
  
歪歪有话说：  
    我敢打赌！如果有某个数字出现次数不足2次，就一定有某个数字出现多于2次！  
这样，在累积出现次数的时候，只要看到某数已经出现3次了，就果断否定之！

#include<iostream> #include<string.h> #include<algorithm> using namespace std; int i,j; int check() { int a,b,c,k,s; int v[20]={0}; v[i%10]++; v[i/10%10]++; v[i/100]++; v[j%10]++; v[j/10%10]++; v[j/100]++; for (k=0; k<20; k++) { if (v[k] > 2) return 0; } a = i*(j%10); b = i*(j/10%10); c = i*(j/100); if (a/1000>0||b/1000>0||c/1000>0) return 0; v[a%10]++; v[a/10%10]++; v[a/100]++; v[b%10]++; v[b/10%10]++; v[b/100]++; v[c%10]++; v[c/10%10]++; v[c/100]++; s = i*j; v[s%10]++; v[s/10%10]++; v[s/100%10]++; v[s/1000%10]++; v[s/10000%10]++; for (k=0; k<20; k++) { if (v[k] > 2) return 0; } return 1; } int main() { for (i=100; i<=999; i++) { for (j=100; j<=999; j++) { if (check()) { cout<<i<<" "<<j<<endl; cout<<i*j<<endl; } } } return 0; }

标题：数字段计数  
  
  
在一个给定的字符串中，既包含数字也包含字母。  
我们不关心具体的数字、字母都是什么。  
我们只是想知道，被字母隔开的数字区域一共有多少个？  
  
  
换句话说，把连续的数字看成一个数字段（单个的数字也算一段），那么这样的“段”有多少呢？  
  
  
比如："YYY5532XX6X78" 就包含3个数字段。  
而，"45TTT7799M" 包含两个数字段。    
  
  
下面的程序解决了这个问题。  
其思路是：每发现一个由字母到数字的“跳变”就计数。  
请仔细阅读源码，提交划线的位置缺少的代码。  
  
  
注意：  
只提交划线部分缺少的代码，不要包含已经存在的代码或符号。  
也不要画蛇添足地写出任何注释或说明性文字。  
  
  
注意选择你所使用的语言。  
  
  
java代码：  
String s = "7AAA1234BBB5555KIKI8888FF1319621d....kkk9kk";  
boolean old\_tag = false;  // 表示开始不是数字  
boolean tag = false;   
int n = 0; // 数字组计数  
for(int i=0; i<s.length(); i++)\{  
char c = s.charAt(i);  
tag = c>='0' && c<='9';  // 是否为数字  
if(\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_) n++;  //填空位置  
old\_tag = tag;  
\}  
  
System.out.println(n);  
  
  
  
c/c++代码：  
char s\[\] = "7AAA1234BBB5555KIKI8888FF1319621d....kkk9kk";  
int old\_tag = 0;  // 表示开始不是数字  
int tag = 0;   
int n = 0; // 数字组计数  
int i;  
for(i=0; s\[i\]; i++)\{  
char c = s\[i\];  
tag = c>='0' && c<='9';  // 是否为数字  
if(\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_) n++;   //填空位置  
old\_tag = tag;  
\}  
  
printf("%d\\n", n);  
  
  
//这样写不对,对于数字在末尾的就无法计数了,感谢评论区5楼的指正,谢谢  
!tag&&old\_tag

//应该这样,当前的是数字且上一个不是数字

tag && !old\_tag

标题：报数游戏  
  
  
有 n (1<n<10000)个小朋友站成一个圆圈。  
选定一个小朋友为1号，从他（她）开始顺时针编号：1,2,3,4，...  
  
  
游戏开始! 从1号小朋友起,顺时针报数,从1报起。  
即：1号小朋友报1，2号小朋友报2，3号小朋友报3, ....  
  
  
游戏规定，报到数字 m(1<m<100) 的小朋友立即退出报数圈。  
在他（她）的顺时针方向的下一个小朋友（如果有的话）开始重新从1报数...  
游戏这样一直进行下去，直到圈中只剩下一个小朋友。  
  
  
求最后剩下的小朋友的编号。  
  
  
输入：两个整数，n 和 m， 用空格分开。含义如上。  
  
  
输出：一个整数，表示最后剩下的小朋友的编号。  
  
  
比如：  
输入：  
15 3  
程序应该输出：  
5  
  
  
再比如：  
输入：  
7 4  
程序应该输出：  
2  
  
  
资源约定：  
峰值内存消耗（含虚拟机） < 256M  
CPU消耗  < 1000ms  
  
  
  
  
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。  
  
  
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。  
java选手注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。  
java选手注意：主类的名字必须是：Main，否则按无效代码处理。  
  
  
c/c++选手注意: main函数需要返回0  
c/c++选手注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。  
c/c++选手注意: 所有依赖的函数必须明确地在源文件中 \#include <xxx>， 不能通过工程设置而省略常用头文件。  
  
  
提交程序时，注意选择所期望的语言类型和编译器类型。  
  
  
\--------------------------------------  
  
  
ps.   
剧透中.....  
  
  
笨笨有话说：  
    如果用一个数组来表示小朋友，用一个变量来记着当前的小朋友....  
麻烦的是如何表示小朋友已经“离席”.....要不把他（她）的位置填为特殊值。  
当前位置需要不断移动，移动到数组边沿需要折回来，好麻烦啊...  
  
  
歪歪有话说：  
    自己做个循环小链表挺好的，正好和实际情况一模一样。怎么判断只剩一个孩子呢？  
自己的下一个还是自己！  
  
  
\#include<iostream>    
\#include<cstdio>    
using namespace std;    
int main()    
\{    
    int n, m,i,s=0;    
scanf("%d %d",&n,&m);   
if (n==0 && m==0)    
break;    
s = 0;    
for(i=2;i<=n;i++)    
\{    
s=(s+m)%i;    
\}    
cout<<s+1<<endl;    
    return 0;    
\}

标题：加密解密  
  
  
    Playfair密码由英国人发明，它使用方便而且可以让频度分析法失效，直到一战中才被破译。  
    其一变种方法如下：首先选择一个密钥单词（称为pair）（剔除重复字母，且都为小写字母），然后与字母表中其他字母一起填入至一个5x5的方阵中，填入方法如下：  
1.首先按行填入密钥串，重复的字母忽略之。  
2.紧接其后，按字母序按行填入不在密钥串中的字母。  
3.由于方阵中只有25个位置，最后剩下的那个字母则不需填入。  
如果密钥为lanqiao，则该方阵如下：    
l a n q i  
o b c d e  
f g h j k  
m p r s t  
u v w x y  
  
  
在加密一对字母时，如da，在方阵中找到以这两个字母为顶点的矩形。  
这对字母的加密字母为该矩形的另一对顶点，如本例中为bq。  
  
  
请设计程序，使用上述方法对输入串进行加密，并输出加密后的串。  
  
  
另有细则如下：  
1、一对一对取字母，如果最后只剩下一个字母，则不变换，直接放入加密串中；  
2、如果一对字母中的两个字母相同，则不变换，直接放入加密串中；  
3、如果一对字母中有一个字母不在矩阵中，则不变换，直接放入加密串中；、  
  
  
4、如果字母对出现在方阵中的同一行或同一列，如fk或ky，则只需简单对调这两个字母，即变换为kf或yk；  
  
  
5、如果在正方形中能够找到以字母对为顶点的矩形，假如字母对为da，则该矩形的另一对顶点字母中，与d同行的字母应在前面，在上例中应是bq；同样若待变换的字母对为pj，则变换后的字母对应为sg；  
6、本程序中输入串均为小写字母，并不含标点、空格或其它字符。  
  
  
解密方法与加密相同，即对加密后的字符串再加密，将得到原始串。  
  
  
输入格式如下：  
输入为两行字符串，  
第一行为密钥单词（长度小于等于25），  
第二行为待加密字符串（长度小于等于50），  
两行字符串末尾都有一个回车换行符，  
并且，两行字符串均为小写字母，不含其它字符。  
  
  
输出为一行，表示加密后的字符串。  
  
  
例如：  
输入：  
lanqiao  
dasai  
  
  
程序应该输出：  
bqpqi  
  
  
  
  
再例如：  
输入：  
dasai  
lanqiao  
  
  
程序应该输出：  
ksltaio  
  
  
  
  
资源约定：  
峰值内存消耗（含虚拟机） < 256M  
CPU消耗  < 1000ms  
  
  
  
  
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。  
  
  
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。  
java选手注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。  
java选手注意：主类的名字必须是：Main，否则按无效代码处理。  
  
  
c/c++选手注意: main函数需要返回0  
c/c++选手注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。  
c/c++选手注意: 所有依赖的函数必须明确地在源文件中 \#include <xxx>， 不能通过工程设置而省略常用头文件。  
  
  
提交程序时，注意选择所期望的语言类型和编译器类型。

#include<iostream> #include<string.h> #include<cstdio> using namespace std; char my[100],pw[100],str[25],s[5][5],ch,passwd[100]; int k=0,v[30]={0}; int f1(char x,char y) { int i,j,a,b,c,d; for (i=0; i<5; i++) for (j=0; j<5; j++) { if (x == s[i][j]) { a = i; b = j; } if (y == s[i][j]) { c=i; d=j; } } if (a==c || b==d) { return 1; } return 0; } int f(char x, char y) //两个有一个不在 { int i,j,flag=0; for (i=0; i<5; i++) for (j=0; j<5; j++) { if (x==s[i][j] || y == s[i][j]) { flag++; } } if (flag == 1) { return 1; } return 0; } void f2(char x,char y)//找对角 { int i,j,a,b,c,d; for (i=0; i<5; i++) { for (j=0; j<5; j++) { if (s[i][j] == x) { a = i; b = j; } if (s[i][j] == y) { c = i; d = j; } } } passwd[k++] = s[a][d]; passwd[k++] = s[c][b]; } int main() { int i,j; scanf("%s%s",my,pw); for (i=0; my[i]; i++) { v[my[i]-'a']++; if (v[my[i]-'a'] > 1) { continue; } str[k++] = my[i]; } ch = k/5+'a'; //ch为接着的起始字母 for (i=k; i<25;) { v[ch-'a']++; if (v[ch-'a'] > 1) { ch++; continue; } str[i] = ch++; i++; } k=0; for (i=0; i<5 ;i++)//放入5*5数组中 for (j=0; j<5; j++) { s[i][j] = str[k++]; } k=0; for (i=0; pw[i];) { if (pw[i+1]!='\0') { if (pw[i] == pw[i+1] || f(pw[i],pw[i+1])) //相等 ,或者有一个不再矩阵中 { passwd[k++] = pw[i]; passwd[k++] = pw[i+1]; i+=2; continue; } if (f1(pw[i],pw[i+1])) //同行或同列,调换两者 { passwd[k++] = pw[i+1]; passwd[k++] = pw[i]; i+=2; continue; } f2(pw[i],pw[i+1]); //找对角的 i+=2; } else if (pw[i+1] == '\0') { passwd[k++] = pw[i]; break; } } passwd[k] = '\0'; puts(passwd); return 0; }

题目：滑动解锁  
  
  
滑动解锁是智能手机一项常用的功能。你需要在3x3的点阵上，从任意一个点开始，反复移动到一个尚未经过的"相邻"的点。这些划过的点所组成的有向折线，如果与预设的折线在图案、方向上都一致，那么手机将解锁。  
  
  
所谓两个点“相邻”：当且仅当以这两个点为端点的线段上不存在尚未经过的点。  
  
  
此外，许多手机都约定：这条折线还需要至少经过4个点。  
  
  
为了描述方便，我们给这9个点从上到下、从左到右依次编号1-9。即如下排列：  
  
  
1 2 3  
4 5 6  
7 8 9  
  
  
那么1->2->3是非法的，因为长度不足。  
1->3->2->4也是非法的，因为1->3穿过了尚未经过的点2。  
2->4->1->3->6是合法的，因为1->3时点2已经被划过了。  
  
  
某大神已经算出：一共有389112种不同的解锁方案。没有任何线索时，要想暴力解锁确实很难。  
不过小Hi很好奇，他希望知道，当已经瞥视到一部分折线的情况下，有多少种不同的方案。  
遗憾的是，小Hi看到的部分折线既不一定是连续的，也不知道方向。  
  
  
例如看到1-2-3和4-5-6，  
那么1->2->3->4->5->6，1->2->3->6->5->4, 3->2->1->6->5->4->8->9等都是可能的方案。  
  
  
  
  
你的任务是编写程序，根据已经瞥到的零碎线段，求可能解锁方案的数目。  
  
  
输入：  
每个测试数据第一行是一个整数N(0 <= N <= 8)，代表小Hi看到的折线段数目。  
以下N行每行包含两个整数 X 和 Y (1 <= X, Y <= 9)，代表小Hi看到点X和点Y是直接相连的。  
  
  
输出：  
对于每组数据输出合法的解锁方案数目。  
  
  
  
  
例如：  
输入：  
8  
1 2  
2 3  
3 4  
4 5  
5 6  
6 7  
7 8  
8 9  
  
  
程序应该输出：  
2  
  
  
再例如：  
输入：  
4  
2 4  
2 5  
8 5  
8 6  
  
  
程序应该输出：  
258  
  
  
  
  
  
  
  
  
资源约定：  
峰值内存消耗（含虚拟机） < 256M  
CPU消耗  < 1000ms  
  
  
  
  
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。  
  
  
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。  
java选手注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。  
java选手注意：主类的名字必须是：Main，否则按无效代码处理。  
  
  
c/c++选手注意: main函数需要返回0  
c/c++选手注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。  
c/c++选手注意: 所有依赖的函数必须明确地在源文件中 \#include <xxx>， 不能通过工程设置而省略常用头文件。  
  
  
提交程序时，注意选择所期望的语言类型和编译器类型。  
  
  
\--------------------------------  
  
  
ps.  
剧透中....  
  
  
笨笨有话说：  
    我感觉9层循环就可以，每层循环都设定下一步连到哪个数字。再把不合要求的滤掉就是了。  
....等等....长度大于等于4的都是合法方案, 我想从第5层循环开始，每层都要增加一个选项，表示：图案终止了！  还需要有个设施，记录当前已经走过的数字......  
.....还有....回溯，这个千万不能忘记哦，回到上层循环就要把本层的选择从路径历史中清除！  
  
  
  
  
歪歪有话说：  
    这么多层，还是递归吧！把历史路径、剩余目标步数当参数传递好像挺不错的。

#include<iostream> using namespace std; int no[10][10]={0},v[10]={0},cnt=0,a[10]={0}; int n,f[9][2]={0}; int check(int x) { int i,j; for (i=1; i<=n; i++) //检测 { for (j=2; j<=x; j++) { if ((a[j]==f[i][0] && a[j-1]==f[i][1]) || (a[j]==f[i][1]&&a[j-1]==f[i][0])) break; } if (j>x) return 0; } return 1; } void dfs(int x) { int i; if (x>4) { if (check(x-1)) { cnt++; } } for (i=1; i<=9; i++) { if (!v[i]) { if (x>1) { if (no[i][a[x-1]] //如果当前选的点(i)和上一个选的点(a[x-1])是跨点的，比如1和9跨5,1和3跨2 && !v[no[i][a[x-1]]]) //那么两个点中间的点是必须被走过的，假如没走过就是非法的 continue; } a[x] = i; v[i] = 1; dfs(x+1); v[i] = 0; } } } int main() { int i,j; no[1][3] = no[3][1] = 2; no[1][9] = no[9][1] = 5; no[1][7] = no[7][1] = 4; no[2][8] = no[8][2] = 5; no[3][7] = no[7][3] = 5; no[4][6] = no[6][4] = 5; no[7][9] = no[9][7] = 8; no[3][9] = no[9][3] = 6; cin>>n; if (n == 0) { cout<<389112; return 0; } for (i=1; i<=n; i++) { cin>>f[i][0]>>f[i][1]; } dfs(1); cout<<cnt; return 0; }

[Center]: /images/20220708/32ce2ced951b40d08112c33f9f67ee18.png