注：题目来源于牛客网
1.
牛牛想对一个数做若干次变换，直到这个数只剩下一位数字。
变换的规则是：将这个数变成 所有位数上的数字的乘积。比如285经过一次变换后转化成2*8*5=80.
问题是，要做多少次变换，使得这个数变成个位数。
变换的规则是：将这个数变成 所有位数上的数字的乘积。比如285经过一次变换后转化成2*8*5=80.
问题是，要做多少次变换，使得这个数变成个位数。
输入描述:
输入一个整数。小于等于2,000,000,000。
输出描述:
输出一个整数，表示变换次数。
输入例子1:
285
输出例子1:
2
个人思路：
由于 python 对于字符串的操作都很方便，因此这一题就是拆分字符串，求乘积，判断即可
正确答案（本人&&牛客网id：尼古丁布）：
def plus(n):
arr = list(str(n))
result = 1
for a in arr:
result = result * int(a)
return result
def jugde(n):
flag = False
if len(str(n)) == 1:
flag = True
return flag
n = raw_input()
count = 1
while True:
if len(str(n)) == 1:
print count - 1
break
n = plus(n)
if jugde(n):
print count
break
else:
count += 1num = list(raw_input())
def changetimes(num):
times = 0
while len(num) > 1:
res = 1
for i in num:
res *= int(i)
num = list(str(res))
times += 1
return times
print changetimes(num)2.
给出一个区间[a, b]，计算区间内“神奇数”的个数。
神奇数的定义：存在不同位置的两个数位，组成一个两位数（且不含前导0），且这个两位数为质数。
比如：153，可以使用数字3和数字1组成13，13是质数，满足神奇数。同样153可以找到31和53也为质数，只要找到一个质数即满足神奇数。
神奇数的定义：存在不同位置的两个数位，组成一个两位数（且不含前导0），且这个两位数为质数。
比如：153，可以使用数字3和数字1组成13，13是质数，满足神奇数。同样153可以找到31和53也为质数，只要找到一个质数即满足神奇数。
输入描述:
输入为两个整数a和b，代表[a, b]区间 (1 ≤ a ≤ b ≤ 10000)。
输出描述:
输出为一个整数，表示区间内满足条件的整数个数
输入例子1:
11 20
输出例子1:
6
个人思路：
“
分解字符串，取两个数，组成素数，即此数为神奇数
从区间着手
所有两位数的质数
题现在就有问题
如果 a b 都小于 10
从区间着手
所有两位数的质数
题现在就有问题
如果 a b 都小于 10
“
我当时就想，把两位数的素数找出来，存好。
对一个数字，列出所有的排列组合。
用交集运算，来求
结果，90% case，超时了。
正确答案（本人&&牛客网id：超脑程序员）：
import math
import itertools
def isPrime(x):
if x <= 1:
return False
for i in xrange(2, int(math.sqrt(x))+1):
if x % i == 0:
return False
return True
def two(n):
list1 = str(n)
list2 = []
iter = itertools.permutations(list1, 2)
list2.append(list(iter))
nums = []
for i in range(0, len(list2[0])):
nums.append(int(''.join(list2[0][i])))
return list(set(nums))
prime = []
for i in range(10, 100, 1):
if isPrime(i):
prime.append(i)
ab = [int(i) for i in raw_input().strip().split()]
a, b = ab[0], ab[1]
nums = [i for i in xrange(a, b+1)]
count = 0
for n in nums:
all = two(n)
result = set(all) & set(prime)
if len(result) != 0:
count += 1
print countwhile 1:
try:
a, b = map(int, raw_input().split())
ans = 0
cache = set()
for i in xrange(10, 100):
label = True
for j in xrange(2, i/2+1):
if i % j == 0:
label = False
break
if label:
cache.add(str(i))
for i in xrange(a, b+1):
s = str(i)
label = False
for x in xrange(len(s)):
for y in xrange(x+1, len(s)):
if s[x] + s[y] in cache or s[y] + s[x] in cache:
ans += 1
label = True
break
if label:
break
print ans
except:
breaks = ['1', '2', '3', '4']
for x in xrange(len(s)):
for y in xrange(x+1, len(s)):
print s[x] + s[y], s[y] + s[x]13 31
14 41
23 32
24 42
34 43
3.
牛牛手里有一个字符串A，羊羊的手里有一个字符串B，B的长度大于等于A，所以牛牛想把A串变得和B串一样长，这样羊羊就愿意和牛牛一起玩了。
而且A的长度增加到和B串一样长的时候，对应的每一位相等的越多，羊羊就越喜欢。比如"abc"和"abd"对应相等的位数为2，为前两位。
牛牛可以在A的开头或者结尾添加任意字符，使得长度和B一样。现在问牛牛对A串添加完字符之后，不相等的位数最少有多少位？
而且A的长度增加到和B串一样长的时候，对应的每一位相等的越多，羊羊就越喜欢。比如"abc"和"abd"对应相等的位数为2，为前两位。
牛牛可以在A的开头或者结尾添加任意字符，使得长度和B一样。现在问牛牛对A串添加完字符之后，不相等的位数最少有多少位？
输入描述:
第一行为字符串A，第二行为字符串B，A的场地小于等于B的长度，B的长度小于等于50.字符均为小写字母。
输出描述:
输出一个整数表示A串添加完字符之后，不相等的位数最少有多少位？
输入例子1:
abe cabc
输出例子1:
1
个人思路：
“
难点一：前面还是后面增加
我添加的这些，必然是要和 B 中一样，因此不用计算添加的
if a[0] != b[0] 说明是在尾部添加了
if a[n] != b[n] 说明是在首部添加了
那么就从相反的方向开始判断是否相等
因此，把 B 分两种情况，前后都断，然后与 A 比较，
我添加的这些，必然是要和 B 中一样，因此不用计算添加的
if a[0] != b[0] 说明是在尾部添加了
if a[n] != b[n] 说明是在首部添加了
那么就从相反的方向开始判断是否相等
因此，把 B 分两种情况，前后都断，然后与 A 比较，
”
我的整体思路就是上面当时想的那样，主要就是判断增加的位置，写的时候把两种情况都考虑进来
然后用切片去除增加一模一样的
最后，判断不相同的位数
结果，80% case，有些用例还是没有通过。
正确答案（牛客网id：超脑程序员）：
A = raw_input()
B = raw_input()
def str_diff_count(x,y):
count = 0
for i in range(0,len(x)):
if x[i] != y[i]:
count += 1
return count
ret = []
for i in range(len(B) - len(A) + 1):
C = B[i:len(A)+i]
ret.append(str_diff_count(A,C))
print min(ret)
主要在于 C 的出现。人家这里是，把 B 所有与 A 相同长的字符串取出来，比较，最后求最小的。！
我知道我哪里出问题了，题目也可以两头都加，我考虑的仅仅是一头补充。get it。
4.
牛牛有一个数组，里面的数可能不相等，现在他想把数组变为：所有的数都相等。问是否可行。
牛牛可以进行的操作是：将数组中的任意一个数改为这个数的两倍。
这个操作的使用次数不限，也可以不使用，并且可以对同一个位置使用多次。
牛牛可以进行的操作是：将数组中的任意一个数改为这个数的两倍。
这个操作的使用次数不限，也可以不使用，并且可以对同一个位置使用多次。
输入描述:
输入一个正整数N (N <= 50) 接下来一行输入N个正整数，每个数均小于等于1e9.
输出描述:
假如经过若干次操作可以使得N个数都相等，那么输出"YES", 否则输出"NO"
输入例子1:
2 1 2
输出例子1:
YES
个人思路：
嗯，这题当时还是一刀直入中心咯
“
1、最大的数 与 次大的数 是否为 2 的 倍关系 否 break
2、是 删最大的数，继续 1
2、是 删最大的数，继续 1
”
正确答案（本人）：
n = int(raw_input())
arr = [int(i) for i in raw_input().strip().split()]
flag = max(arr)
result = "YES"
i = 1
while i < n:
arr.remove(flag)
ci = max(arr)
print flag, ci
if flag == ci:
i += 1
flag = ci
continue
elif flag / ci % 2 != 0:
result = "NO"
break
i += 1
flag = ci
print result5.
牛牛定义排序子序列为一个数组中一段连续的子序列,并且这段子序列是非递增或者非递减排序的。牛牛有一个长度为n的整数数组A,他现在有一个任务是把数组A分为若干段排序子序列,牛牛想知道他最少可以把这个数组分为几段排序子序列.
如样例所示,牛牛可以把数组A划分为[1,2,3]和[2,2,1]两个排序子序列,至少需要划分为2个排序子序列,所以输出2
如样例所示,牛牛可以把数组A划分为[1,2,3]和[2,2,1]两个排序子序列,至少需要划分为2个排序子序列,所以输出2
输入描述:
输入的第一行为一个正整数n(1 ≤ n ≤ 10^5) 第二行包括n个整数A_i(1 ≤ A_i ≤ 10^9),表示数组A的每个数字。
输出描述:
输出一个整数表示牛牛可以将A最少划分为多少段排序子序列
输入例子1:
6 1 2 3 2 2 1
输出例子1:
2
个人思路：
当时没有思路，不知道从哪里入手。而现在：
1.求输入数组的所有连续子数组
2.求出全部排好序的子数组
例如：
6
1 2 3 2 2 1
['1', '2', '3', '2', '2', '1', '1 2', '2 3', '3 2', '2 2', '2 1', '1 2 3', '3 2 2', '2 2 1', '3 2 2 1']
1 2 3 2 2 1
['1', '2', '3', '2', '2', '1', '1 2', '2 3', '3 2', '2 2', '2 1', '1 2 3', '3 2 2', '2 2 1', '3 2 2 1']
3.求以上由2..3.4开始组成的排列组合
4.可以求出最后与输入数组相同的组合，并保存
5.最后获得排列组合最小的即可
结果，我代码逻辑是没问题的，测试超出限制内存。
现在啊，我的境界估计已经达到中层咯。对于复杂的问题，我是可以解决的，但就是性能不是很好。
正确思路（牛客网id：超脑程序员）：
def f1(a,n):
f = 0
count = 1
for i in xrange(n-1):
if(a[i] < a[i+1]):
if(f == 0):
f = 1
if(f == -1):
f = 0
count += 1
elif(a[i] > a[i+1]):
if(f == 0):
f = -1
if(f == 1):
f = 0
count += 1
return count
n = int(raw_input())
a = map(int,raw_input().split()[:n])
print f1(a,n)
而且，如果趋势不变， flag 也一直为 0。
同时如果改变，那么会有隐藏标记。
设置 1，-1 来为改变做标记。
我现在疑惑啊，这求出来也是最少 or 至少的吗？
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.
例如:
一个队伍三个队员的水平值分别是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),表示每个参赛选手的水平值.
输出描述:
输出一个整数表示所有队伍的水平值总和最大值.
输入例子1:
2 5 2 8 5 1 5
输出例子1:
10
个人思路：
我没找到最简单的思路？
正确答案（牛客网id：超脑程序员）：
n=int(raw_input())
num_list=sorted(map(int,raw_input().split(' ')),reverse=True)
countp=0
for i in xrange(n):
countp=countp+num_list[i*2+1]
print countp
i * 2 + 1 ？！所有奇数下标的和
答案正确？
666
好好看好好学
7.
牛牛现在有一个n个数组成的数列,牛牛现在想取一个连续的子序列,并且这个子序列还必须得满足:最多只改变一个数,就可以使得这个连续的子序列是一个严格上升的子序列,牛牛想知道这个连续子序列最长的长度是多少。
输入描述:
输入包括两行,第一行包括一个整数n(1 ≤ n ≤ 10^5),即数列的长度; 第二行n个整数a_i, 表示数列中的每个数(1 ≤ a_i ≤ 10^9),以空格分割。
输出描述:
输出一个整数,表示最长的长度。
输入例子1:
6 7 2 3 1 5 6
输出例子1:
5
个人思路：
我怕是陷入求所有子序列的泥潭了
def son_arr(arr):
k = 1
j = k
i = 0
son = []
while j <= len(arr):
temp = arr[i:j]
son.append(temp)
i += 1
j += 1
if j == len(arr) + 1:
k += 1
j = k
i = 0
if k == len(arr) + 1:
break
return son
利用交集，<= 1，保存符合条件的，即可
又是，我觉得自己的逻辑没有问题，简单的测试用例都可以完成。20% case，超出内存限制。和第五题十分雷同。
正确答案（牛客网id：oneseven && yanke）：
/*
解题思路:
动态规划+判断。
以v[i]开始的最长上升子序列dp1, v[i]<v[i+1]时，dp1[i] = dp1[i+1]+1;否则dp1[i]=1;
以v[i]结尾的最长上升子序列dp2, v[i]>v[i-1]时，dp2[i] = dp2[i-1]+1;否则dp2[i]=1;
对于每一个位置i
i=0时，maxLen=dp1[1]+1
i=n-1时，maxLen = dp2[n-2]+1
其他:
v[i-1]+1 < v[i+1], maxLen = dp1[i+1]+dp2[i-1]+1否则：
maxLen = max(dp1[i+1],dp2[i-1])+1
*/while 1:
try:
n = int(raw_input())
s = map(int, raw_input().split())
if n <= 2:
print n
continue
i = 1
while i < len(s) and s[i] > s[i-1]:
i += 1
last = 0
if i >= len(s) - 1:
print len(s)
continue
ans = i - last + 1
while i < len(s) - 1:
if s[i+1] < s[i]:
i += 1
last = i
continue
x = i
if s[i+1] - s[i-1] > 1:
i += 1
elif s[i] - s[i-2] > 1:
i += 1
else:
last = i
i += 1
while i < len(s) and s[i] > s[i-1]:
i += 1
ans = max(ans, i - last)
last = x
print ans
except:
break8.
小牛牛是牛牛王国的将军,为了训练出精锐的部队,他会对新兵进行训练。部队进入了n个新兵,每个新兵有一个战斗力值和潜力值,当两个新兵进行决斗时,总是战斗力值高的获胜。获胜的新兵的战斗力值就会变成对手的潜力值 + 自己的战斗力值 - 对手的战斗力值。败者将会被淘汰。若两者战斗力值一样,则会同归于尽,双双被淘汰(除了考察的那个新兵之外，其他新兵之间不会发生战斗) 。小牛牛想知道通过互相决斗之后新兵中战斗力值+潜力值最高的一个可能达到多少,你能帮助小牛牛将军求出来吗?
输入描述:
输入包括n+1行,第一行包括一个整数n(1 ≤ n ≤ 10^5); 接下来的n行,每行两个整数x和y(1 ≤ x,y ≤ 10^9)
输出描述:
输出一个整数,表示新兵中战斗力值+潜力值最高的一个能达到多少。
输入例子1:
2 1 2 2 1
输出例子1:
4
个人思路：
我以为很简单：输入的数组，两两排列组合，比较，求值，结束。
结果，上面的测试用例我通过了，说明什么？说明我的想法还是有一丝丝可能性。
牛客网 id：非白羊，讲思路：
已知获胜战斗力值会加上对手的潜力值-对手的战斗力值。
贪心思想，要培养一个战力和潜力和最大的兵王，就要尽可能多的增加其战力，即打赢所有潜力大于战力的新兵，记他们的潜力战力差的总和为add。
选兵王，有两种情况：
- 潜力qian大于战力zhan，不能与自己交战，所以要先从add中减去他的部分，最终兵王战力潜力和为add-(qian-zhan)+zhan+qian=add+2*zhan
- 否则，直接加上他的潜力战力，即add+qian+zhan
故对两种情况，分别找到战力最大值maxZhan与潜力战力和的最大值maxSum，比较2*maxZhan和maxSum, 取大的加上add即为正确答案
注意这里,当maxSum=(zhan+qian)>2*maxZhan时，因为zhan>qian,由反证可知zhan>maxZhan,自然可以打赢所有潜力大于战力的新兵。
我确实没想到：潜力战力差，以及累加一个人的战斗力。
正确答案（牛客网id：超脑程序员 && 羞香月色 两人好几个代码一样）：
def fc(a,n):
maxZhan = 0
add = 0
maxSum = 0
for i in xrange(n):
if a[i][0] < a[i][1]:
maxZhan = max(maxZhan,a[i][0])
add += a[i][1]-a[i][0]
else:
maxSum = max(maxSum,a[i][0]+a[i][1])
return add+max(2*maxZhan,maxSum)
n = int(raw_input())
a = []
for i in xrange(n):
a.append(map(int,raw_input().split()[:2]))
print fc(a,n)
扫一扫
1549
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
