2017牛客网校招模拟第三场笔试编程题
题目来源：https://www.nowcoder.com/test/5217106/summary
1.变换次数
牛牛想对一个数做若干次变换，直到这个数只剩下一位数字。变换的规则是：将这个数变成 所有位数上的数字的乘积。比如285经过一次变换后转化成2*8*5=80.
问题是，要做多少次变换，使得这个数变成个位数。
输入描述:
输入一个整数。小于等于2,000,000,000。
输出描述:
输出一个整数，表示变换次数。
输入例子:
285
输出例子:
2
分析：
直接暴力计算即可。
1 #include<iostream>
2 using namespace std; 3 int main() 4 { 5 int num, count, tmp; 6 count = 0; 7 cin >> num; 8 while (num > 9) 9 { 10 tmp = 1; 11 for (; num; num = num / 10) 12 { 13 tmp = tmp*(num % 10); 14 } 15 num = tmp; 16 count++; 17 } 18 cout << count << endl; 19 return 0; 20 }
2. 神奇数
给出一个区间[a, b]，计算区间内“神奇数”的个数。
神奇数的定义：存在不同位置的两个数位，组成一个两位数（且不含前导0），且这个两位数为质数。
比如：153，可以使用数字3和数字1组成13，13是质数，满足神奇数。同样153可以找到31和53也为质数，只要找到一个质数即满足神奇数。
输入描述:
输入为两个整数a和b，代表[a, b]区间 (1 ≤ a ≤ b ≤ 10000)。
输出描述:
输出为一个整数，表示区间内满足条件的整数个数
输入例子:
11 20
输出例子:
6
分析：
对区间内的数进行枚举,然后按照题目要求的性质进行判断即可。
1 #include<iostream>
2 using namespace std; 3 bool isprime(int n) //判断是否为质数
4 { 5 for (int i = 2; i * i <= n; i++) 6 { 7 if (n % i == 0) 8 return false; 9 } 10 return true; 11 } 12
13 bool MagicNum(int m) //判断是否为神奇数
14 { 15 int cnt[10]; 16 memset(cnt, 0, sizeof(cnt)); 17 while (m) 18 { 19 cnt[m % 10]++; 20 m /= 10; 21 } 22 for (int i = 1; i < 10; i++) 23 { 24 for (int j = 1; j < 10; j++) 25 { 26 if (i != j && cnt[i] && cnt[j]) 27 { 28 if (isprime(i * 10 + j)) 29 return true; 30 } 31 else if (i == j && cnt[i] >= 2) 32 { 33 if (isprime(i * 10 + j)) 34 return true; 35 } 36 } 37 } 38 return false; 39 } 40
41 int main() 42 { 43 int a, b ,count; 44 count = 0; 45 cin >> a >> b; 46 for (int i = a; i <= b; i++) //对区间的数进行枚举
47 { 48 if (MagicNum(i)) //调用函数，进行判断，函数返回true或者false
49 count++; 50 } 51 cout << count << endl; //输出结果
52 return 0; 53 }
3. 添加字符
牛牛手里有一个字符串A，羊羊的手里有一个字符串B，B的长度大于等于A，所以牛牛想把A串变得和B串一样长，这样羊羊就愿意和牛牛一起玩了。
而且A的长度增加到和B串一样长的时候，对应的每一位相等的越多，羊羊就越喜欢。比如"abc"和"abd"对应相等的位数为2，为前两位。
牛牛可以在A的开头或者结尾添加任意字符，使得长度和B一样。现在问牛牛对A串添加完字符之后，不相等的位数最少有多少位？
输入描述:
第一行为字符串A，第二行为字符串B，A的场地小于等于B的长度，B的长度小于等于50.字符均为小写字母。
输出描述:
输出一个整数表示A串添加完字符之后，不相等的位数最少有多少位？
输入例子:
abe
cabc
输出例子:
1
分析：
情况分为两种：1.A的长度小于B的长度 2.A的长度等于B的长度
当小于时，就枚举B串的一个偏移量,然后枚举维护最小的不相等的位数。
当等于时，就直接对比就好了。
1 #include<iostream>
2 #include<string>
3 using namespace std; 4
5 int main() 6 { 7 string a, b; 8 cin >> a >> b; 9 int aLength = a.size(), bLength = b.size(); 10 if (aLength < bLength) 11 { 12 int ans = 1e9; 13 for (int i = 0; i + aLength <= bLength; i++) 14 { 15 int cnt = 0; 16 for (int j = 0; j < aLength; j++) 17 { 18 if (a[j] != b[i + j]) 19 cnt++; 20 } 21 if (cnt < ans) 22 { 23 ans = cnt; 24 } 25 } 26 cout << ans << endl; 27 return 0; 28 } 29 else { 30 int cnt = 0; 31 for (int j = 0; j < aLength; j++) 32 { 33 if (a[j] != b[j]) 34 ++cnt; 35 } 36 cout << cnt << endl; 37 } 38 return 0; 39
40 }
4. 数组变换
牛牛有一个数组，里面的数可能不相等，现在他想把数组变为：所有的数都相等。问是否可行。
牛牛可以进行的操作是：将数组中的任意一个数改为这个数的两倍。
这个操作的使用次数不限，也可以不使用，并且可以对同一个位置使用多次。
输入描述:
输入一个正整数N (N <= 50)
接下来一行输入N个正整数，每个数均小于等于1e9.
输出描述:
假如经过若干次操作可以使得N个数都相等，那么输出"YES", 否则输出"NO"
输入例子:
2
1 2
输出例子:
YES
分析：
把数组每一个元素都除以2，直到它为奇数。如果此时数组每个元素都一样，满足条件，输出YES
1 #include<iostream>
2 #include<string>
3 using namespace std; 4
5 int num[55]; 6 int main() 7 { 8 int n; 9 cin >> n; 10 for (int i = 0; i < n; i++) 11 cin >> num[i]; 12 string res = "YES"; 13 for (int i = 0; i < n; i++) 14 { 15 while (!(num[i] & 1)) 16 num[i] >>= 1; 17 } 18 for (int i = 1; i < n; i++) 19 { 20 if (num[i] != num[0]) 21 res = "NO"; 22 } 23 cout << res << endl; 24 return 0; 25 }
5. 排序子序列
牛牛定义排序子序列为一个数组中一段连续的子序列,并且这段子序列是非递增或者非递减排序的。牛牛有一个长度为n的整数数组A,他现在有一个任务是把数组A分为若干段排序子序列,牛牛想知道他最少可以把这个数组分为几段排序子序列.
如样例所示,牛牛可以把数组A划分为[1,2,3]和[2,2,1]两个排序子序列,至少需要划分为2个排序子序列,所以输出2
输入描述:
输入的第一行为一个正整数n(1 ≤ n ≤ 10^5)
第二行包括n个整数A_i(1 ≤ A_i ≤ 10^9),表示数组A的每个数字。
输出描述:
输出一个整数表示牛牛可以将A最少划分为多少段排序子序列
输入例子:
6
1 2 3 2 2 1
输出例子:
2
分析：
考虑序列A_1, A_2, . . . , A_i是一个单调的序列.显然如果对于j < i把序列分为A_1, A_2. . . A_j 和 A_j+1, A_j+2, . . . , A_i 两个部分不会使问题变得更优.
于是我们可以贪心的去重复下面过程: 1、 从序列中找出最长的单调连续子序列 2、 删除找出的最长的单调连续子序列
这里的单调序列包括非递增和非递减,而判断子序列是否单调的时候,注意处理等于的情况。
1 #include<iostream>
2 #include<vector>
3 using namespace std; 4
5 int main() 6 { 7 int n; 8 cin >> n; 9 vector <int> A; 10 int ans = 1; 11 for (int i = 0; i < n; ++i) 12 { 13 int x; 14 cin >> x; 15 if (A.size() <= 1) 16 A.push_back(x); 17 else
18 { 19 if (A[0] <= A.back() && A.back() <= x) 20 A.push_back(x); 21 else if (A[0] >= A.back() && A.back() >= x) 22 A.push_back(x); 23 else
24 { 25 ans++; 26 A.clear(); 27 A.push_back(x); 28 } 29 } 30 } 31 cout << ans << endl; 32 return 0; 33 }
6. 组队竞赛
牛牛举办了一次编程比赛,参加比赛的有3*n个选手,每个选手都有一个水平值a_i.现在要将这些选手进行组队,一共组成n个队伍,即每个队伍3人.牛牛发现队伍的水平值等于该队伍队员中第二高水平值。
例如:
一个队伍三个队员的水平值分别是3,3,3.那么队伍的水平值是3
一个队伍三个队员的水平值分别是3,2,3.那么队伍的水平值是3
一个队伍三个队员的水平值分别是1,5,2.那么队伍的水平值是2
为了让比赛更有看点,牛牛想安排队伍使所有队伍的水平值总和最大。
如样例所示:
如果牛牛把6个队员划分到两个队伍
如果方案为:
team1:{1,2,5}, team2:{5,5,8}, 这时候水平值总和为7.
而如果方案为:
team1:{2,5,8}, team2:{1,5,5}, 这时候水平值总和为10.
没有比总和为10更大的方案,所以输出10.
输入描述:
输入的第一行为一个正整数n(1 ≤ n ≤ 10^5)
第二行包括3*n个整数a_i(1 ≤ a_i ≤ 10^9),表示每个参赛选手的水平值.
输出描述:
输出一个整数表示所有队伍的水平值总和最大值.
输入例子:
2
5 2 8 5 1 5
输出例子:
10
分析：
对于所有参赛队员,我们把他们的水平值进行逆序排序,然后逐一挨着安排每个队伍,然后计算出队伍水平值总和,即为所求。
1 #include<iostream>
2 #include<algorithm>
3
4 using namespace std; 5
6 const int maxn = 300100; 7 int a[maxn]; 8
9 int main() 10 { 11 int n; 12 cin >> n; 13 for (int i = 0; i < 3 * n; i++) 14 cin >> a[i]; 15 sort(a, a + 3 * n); 16 long long ans = 0; 17 for (int i = 0; i < n; i++) 18 ans += a[n + 2 * i]; 19 printf("%lld\n", ans); 20 return 0; 21 }
7. 牛牛的数列
牛牛现在有一个n个数组成的数列,牛牛现在想取一个连续的子序列,并且这个子序列还必须得满足:最多只改变一个数,就可以使得这个连续的子序列是一个严格上升的子序列,牛牛想知道这个连续子序列最长的长度是多少。
输入描述:
输入包括两行,第一行包括一个整数n(1 ≤ n ≤ 10^5),即数列的长度;
第二行n个整数a_i, 表示数列中的每个数(1 ≤ a_i ≤ 10^9),以空格分割。
输出描述:
输出一个整数,表示最长的长度。
输入例子:
6
7 2 3 1 5 6
输出例子:
5
分析：
正着枚举记录一下当前位置的连续上升子序列长度,倒着也做一遍。
最后枚举一个连接点即可。
1 #include <iostream>
2 #include<algorithm>
3 using namespace std; 4
5 const int maxn = 100000 + 5; 6 const int INF = 0x3f3f3f3f; 7
8 int a[maxn], n; 9 int pre[maxn], suf[maxn]; 10 int main() { 11 cin >> n; 12 for (int i = 1; i <= n; i++) 13 scanf_s("%d", a + i); 14 a[0] = INF, a[n + 1] = INF; 15 for (int i = 1; i <= n; i++) 16 pre[i] = a[i - 1] < a[i] ? pre[i - 1] + 1 : 1; 17 for (int i = n; i >= 1; i--) 18 suf[i] = a[i] < a[i + 1] ? suf[i + 1] + 1 : 1; 19 int ans = 1; 20 for (int i = 1; i <= n; i++) 21 { 22 ans = max(ans, pre[i - 1] + 1); 23 ans = max(ans, suf[i + 1] + 1); 24 if (a[i + 1] - a[i - 1] >= 2) 25 ans = max(ans, pre[i - 1] + suf[i + 1] + 1); 26 } 27 printf("%d\n", ans); 28 return 0; 29 }