输入一行：input()
输入的一行有多个信息：input().split()
有多组测试用例(多组同时输入): while true try except...
1.计算字符串最后一个单词的长度，单词以空格隔开。
输入：hello world 输出：5
a=input(). split() print( len(a[ -1]) if len(a)> 1 else len(a[ 0]))
Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
import sys for line in sys.stdin:#读入数据 a = line. split() print len(a[- 1])
2.写出一个程序，接受一个由字母和数字组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。
a=input().lower() b=input().lower() print(a. count(b))
注：Python lower() 方法转换字符串中所有大写字符为小写。
3.明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作(同一个测试用例里可能会有多组数据，希望大家能正确处理)。
while True: try: n=int(input()) #读入第一行：随机整数的个数 res=set() for i in range(n): res.add(int(input())) # 读入第n行：n个随机整数组成的数组 for i in sorted(res): print(i) except: break
注：set是一个无序且不重复的元素集合。
4.• 连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组；
• 长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
def printStr( string): if len( string) <= 8: print( string + "0" * ( 8 - len( string))) else: while len( string) > 8: print( string[: 8]) string = string[ 8:] print( string + "0" * ( 8 - len( string))) a=input() b=input() printStr(a) printStr(b)
5.写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。（多组同时输入 ）
while True: try: print(int(input(), 16)) except: break
python整数之间的进制转换:
10进制转16进制: hex(16) ==> 0x10
16进制转10进制: int('0x10', 16) ==> 16
6.功能:输入一个正整数，按照从小到大的顺序输出它的所有质数的因子（如180的质数因子为2 2 3 3 5 ）,最后一个数后面也要有空格
a= int(input()) def q(x): iszhi= 1 for i in range( 2, int( x** 0. 5+ 2)): if x%i== 0: iszhi= 0 print(str(i),end= " ") q(int(x/i)) break if iszhi== 1: print(str( x),end= " ") q(a)
注：质数（prime number）又称素数。质数定义为在大于1的自然数中，除了1和它本身以外不再有其他因数的数称为质数
7.写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。
print(round(float(input())+0.001))
注：由于python对于浮点数存储有点抽风（4.5会存储成4.4999999），所以要加上0.001
8. 数据表记录包含表索引和数值，请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照key值升序进行输出。
from collections import defaultdict while True: try: a=int(input()) dd=defaultdict(int) #指定字典的值为int for i in range(a): key,val=map(int,input().split()) dd[key]+=val for i in sorted(dd.keys()): print(str(i)+ " "+str(dd[i])) except: break
defaultdic默认字典,使用defaultdict任何未定义的key都会默认返回一个根据method_factory参数不同的默认值, 而相同情况下dict()会返回KeyError.
9.输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
result= "" for i in input()[:: -1]: if i not in result: result+=i print(result)
10.编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计。
print (len(set([i for i in input() if ord(i) in range(128)])))
import sys print(len( set(list(sys.stdin.readline()))))
11.输入一个整数，将这个整数以字符串的形式逆序输出,程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001
print(input()[::-1])
line = "abcde" line[:-1] 结果为：'abcd'其实就是去除了这行文本的最后一个字符（换行符）后剩下的部分。
line = "abcde" line[::-1] 结果为：'edcba' 倒序输出
12.写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。例如：abcd---------dcba
print(input()[::-1])
13.将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符
print(" ".join(input().split()[::-1]))
14.给定n个字符串，请对n个字符串按照字典序排列。
num = int(input()) s = [] for i in range(num): s. append(input()) s.sort() for i in s: print (i)
注：sort功能很强大 无论是字母或者数字都可以排序
15.输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。
a= int(input()) print(bin(a). replace( "0b", "").count( "1"))
16.求最小公倍数
正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。
def gcd(a, b): """最大公约数.""" while b: a, b = b, a % b return a def lcm(a, b): """最小公倍数.""" return a * b // gcd(a, b) #//表示整数除法 while True: try: a,b=map(int,input().split()) print(lcm(a,b)) except: break
最大公因数的算法：
(1)辗转相除法：有两整数a和b：
① a%b得余数c
② 若c=0，则b即为两数的最大公约数
③ 若c≠0，则a=b，b=c，再回去执行①
map接收一个函数和一个可迭代对象（如列表）作为参数，用函数处理每个元素，然后返回新的列表。
ACM有时需要要a b c这样的一行格式输入，这时可以用map函数来处理，这里假设a,b,c都是整数。
例如：a, b, c = map(int, raw_input().split())
17.计算一个数字的立方根，不使用库函数
# 牛顿迭代 a = float(input()) e = 0. 0001 t = a while abs(t*t*t - a) > e: # x(i+1) = x(i) - f(xi)/f(xi)' t = t - ( t*t*t - a )* 1.0 / ( 3 * t*t) print ( "%.1f" %t)
18.将一个字符串str的内容颠倒过来，并输出。str的长度不超过100个字符。 如：输入“I am a student”，输出“tneduts a ma I”。
print(input()[::-1])
19.从输入任意个整型数，统计其中的负数个数并求所有非负数的平均值
a=input().split() fu=[] zheng=[] for i in a: if int(i)< 0: fu. append( int(i)) else: zheng. append( int(i)) print( len(fu)) print(round(sum(zheng)/ len(zheng), 1))
注：最后四舍五入保留一位小数，round(n,1)
20.Redraiment是走梅花桩的高手。Redraiment总是起点不限，从前到后，往高的桩子走，但走的步数最多，不知道为什么？你能替Redraiment研究他最多走的步数吗
#最长上升子序列 import bisect while True: try: a, b = int(input()), map( int, input(). split()) q = [] for v in b: pos = bisect.bisect_left( q, v) if pos == len( q): q.append(v) else: q[pos] = v print(len( q)) except: break
注：动态规划之最长上升子序列。
21.输入一个字符串，对字符中的各个英文字符，数字，空格进行统计（可反复调用）
按照统计个数由多到少输出统计结果，如果统计的个数相同，则按照ASII码由小到大排序输出
while True: try: from collections import defaultdict dd, s, res = defaultdict(list), input(), "" for i in set(s): dd[s. count(i)].append(i) for i in sorted(dd.keys(), reverse= True): res += "". join(sorted(dd[i], key=ord)) print(res) except: break
22.输入整型数组和排序标识，对其元素按照升序或降序进行排序（一组测试用例可能会有多组数据）
while True: try: a=int(input()) b= map(int,input(). split()) c=int(input()) if c== 0: print( " ". join( map(str,sorted(b, reverse= False)))) if c== 1: print( " ". join( map(str,sorted(b, reverse= True)))) except: break
23.功能:等差数列 2，5，8，11，14。。。。
输入:正整数N >0
输出:求等差数列前N项和
while True: try: a = int(input()) print( 3 * a * (a - 1) // 2 + 2*a) except: break
注：等差数列求和公式：Sn=a1*n+n*(n-1)*d/2
24.自守数是指一个数的平方的尾数等于该数自身的自然数。例如：25^2 = 625，76^2 = 5776，9376^2 = 87909376。请求出n以内的自守数的个数
while True: try: a, res = int(input()), 0 for i in range( 0, a + 1): if str(i ** 2).endswith(str(i)): res += 1 print(res) except: break
注：Python endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
26.首先输入要输入的整数个数n，然后输入n个整数。输出为n个整数中负数的个数，和所有正整数的平均值，结果保留一位小数。
while True: try: a,nums, pos,neg= int(input()), map( int,input(). split()),[], 0 for num in nums: if num> 0: pos.append(num) elif num< 0: neg+= 1 print(str(neg)+ " 0" if not pos else str(neg)+ " "+ "{0:.1f}".format(sum( pos)/len( pos))) except: break
27.将一个字符中所有出现的数字前后加上符号“*”，其他字符保持不变
while True: try: a, res, isNum = input(), "", False for i in a: if i.isdigit(): if not isNum: res = res + "*" + i else: res += i isNum = True else: if isNum: res = res + "*" + i else: res += i isNum = False if a[ -1].isdigit(): res+= "*" print(res) except: break
29.计票统计
输入：候选人的人数，第二行输入候选人的名字，第三行输入投票人的人数，第四行输入投票。
输出：每行输出候选人的名字和得票数量。
from collections import Counter while True: try: a=input() b=input(). split() c=input() d=input(). split() invalid= 0 cc = Counter(d) for i in b: print(i + " : " + str(cc[i])) invalid+=cc[i] print( "Invalid : " + str(len(d)-invalid)) except: break
30.编写一个函数，传入一个int型数组，返回该数组能否分成两组，使得两组中各元素加起来的和相等，并且，所有5的倍数必须在其中一个组中，所有3的倍数在另一个组中（不包括5的倍数），能满足以上条件，返回true；不满足时返回false。
while 1: try: n = raw_input() l = raw_input().split() sum1 = sum2 = 0 ll = [] for i in l: if int(i) % 5 == 0: sum1 += int(i) elif int(i) % 3 == 0: sum2 += int(i) else: ll.append(int(i)) d_value = abs(sum1 - sum2) if not ll and d_value == 0: print 'true' elif not ll and d_value != 0: print 'false' else: s = set() for x in ll: tmp = list(s) for y in tmp: s.add(x + y) s.add(x) for may_value in s: if d_value == abs((sum(ll) - may_value) - may_value): print 'true' break else: print 'false' except:
31.在字符串中找出连续最长的数字字符串。
输入：一个字符串。
输出：字符串中最长的数字字符串和它的长度。如果有相同长度的串，则要一块儿输出，但是长度还是一串的长度
while True: try: a = input() maxLen, maxStrs, curLen, curStr = 0, [], 0, "" for i, v in enumerate(a): if v.isnumeric(): curLen += 1 curStr += v if curLen > maxLen: maxLen = curLen maxStrs = [curStr] elif curLen == maxLen: maxStrs.append(curStr) else: curLen = 0 curStr = "" print( "".join(maxStrs) + "," + str(maxLen)) except: break
37.功能: 求一个byte数字对应的二进制数字中1的最大连续数，例如3的二进制为00000011，最大连续2个1
while True: try: res, a = 0, bin(int(input())).replace( "0b", "") for i in range( 1, len(a) + 1): if "1" * i in a: res = i else: break print(res) except: break
39.找出给定字符串中大写字符(即'A'-'Z')的个数
import sys for a in sys.stdin: count= 0 for i in a: if i.isupper(): count+= 1 print( count)
41.字符串匹配：判断短字符串中的所有字符是否在长字符串中全部出现
while True: try: a,b=set(input()),set(input()) print ( "true" if a&b==a else "false") except: break
42.将两个整型数组按照升序合并，并且过滤掉重复数组元素
while True: try: a,b, c,d=input(),list( map(int,input(). split())),input(),list( map(int,input(). split())) print( "". join( map(str,sorted(list( set(b+d)))))) except: break
43.计算字符串的相似度
def editDistance(str1, str2): len1, len2 = len(str1) + 1, len(str2) + 1 dp = [[ 0 for i in range(len2)] for j in range(len1)] for i in range(len1): dp[i][ 0] = i for j in range(len2): dp[ 0][j] = j for i in range( 1, len1): for j in range( 1, len2): dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (str1[i - 1] != str2[j - 1])) return dp[ -1][ -1] while True: try: print( "1/" + str(editDistance(input(), input()) + 1)) except: break
44.请设计一个算法完成两个超长正整数的加法。
while True: try: a = input() b = input() print(str(int(a) + int(b))) except: break
45.计算两个字符串的最大公共字串的长度，字符不区分大小写
def find_lcsubstr(s1, s2): m=[[ 0 for i in range(len(s2)+ 1)] for j in range(len(s1)+ 1)] #生成0矩阵，为方便后续计算，比字符串长度多了一列 mmax= 0 #最长匹配的长度 p= 0 #最长匹配对应在s1中的最后一位 for i in range(len(s1)): for j in range(len(s2)): if s1[i]==s2[j]: m[i+ 1][j+ 1]=m[i][j]+ 1 if m[i+ 1][j+ 1]>mmax: mmax=m[i+ 1][j+ 1] p=i+ 1 return mmax #返回最长子串及其长度 while True: try: a,b=input(),input() print(find_lcsubstr(a,b)) except: break
51.实现删除字符串中出现次数最少的字符，若多个字符出现次数一样，则都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。
from collections import defaultdict while True: try: a = input() dd = defaultdict(int) for i in a: dd[i] += 1 for i in dd: if dd[i] == min(dd.values()): a = a.replace(i, "") print(a) except: break
注：Python 字典(Dictionary) values() 函数以列表返回字典中的所有值。
52. 中级对字符串中的所有单词进行倒排。（非构成单词的字符均视为单词间隔符）
s = input() for i in s: if not i.isalnum(): s = s.replace(i, ' ') s = s. split() s. reverse() new_s = ' '.join( s) print(new_s)
注：Python isalnum() 方法检测字符串是否由字母和数字组成。
list.reverse() 函数用于反向列表中元素。
53.输出7有关数字的个数，包括7的倍数，还有包含7的数字（如17，27，37...70，71，72，73...）的个数（一组测试用例里可能有多组数据，请注意处理）
while True: try: a=int(input()) res= 0 for i in range( 7,a+ 1): #右边是开区间 if "7" in str(i) or i% 7== 0: res+= 1 print(res) except: break
54.输入n个整数，输出其中最小的k个。
输入说明 1 输入两个整数 2 输入一个整数数组
while True: try: count=int(input(). split()[ 1]) array=list( map(int,input().strip(). split())) print( " ". join( map(str,sorted(array)[: count]))) except: break
注：Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
55.找出字符串中第一个只出现一次的字符（通过率30%）
while True: try: s=input() for i in s: if s.count(i)== 1: print(i) break else: print( -1) except: break
while True: try: from collections import Counter a = input() c = list( map(lambda c: c[ 0], list( filter(lambda c: c[ 1] == 1, Counter(a).most_common())))) if not c: print(- 1) for i in a: if i in c: print(i) break except: break
56. 任意一个偶数（大于2）都可以由2个素数组成，组成偶数的2个素数有很多种情况，本题目要求输出组成指定偶数的两个素数差值最小的素数对
import math def isPrime(n): for i in range( 2, int(math.sqrt(n)) + 1): if n % i == 0: return False return True while True: try: num ,start= int(input()) // 2, 1 if num% 2== 1: start= 0 for i in range(start, num, 2): a, b = num + i, num - i if isPrime(a) and isPrime(b): print(b) print(a) break except: break
57.输入一个整数,计算整数二进制中1的个数
while True: try: a=int(input()) print(bin(a).count( "1")) except: break
注：当出现错误时，添加while true try except试试
58.一个DNA序列由A/C/G/T四个字母的排列组合组成。G和C的比例（定义为GC-Ratio）是序列中G和C两个字母的总的出现次数除以总的字母数目（也就是序列长度）。在基因工程中，这个比例非常重要。因为高的GC-Ratio可能是基因的起始点。
给定一个很长的DNA序列，以及要求的最小子序列长度，研究人员经常会需要在其中找出GC-Ratio最高的子序列。
while True: try: a, b = input(), int(input()) maxStr, maxCnt = a[:b], a[:b]. count( "C") + a[:b]. count( "G") for i in range( 0, len(a) - b): if a[i:i + b]. count( "C") + a[i:i + b]. count( "G") > maxCnt: maxCnt = a[i:i + b]. count( "C") + a[i:i + b]. count( "G") maxStr = a[i:i + b] print(maxStr) except: break
59.输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。
while True: try: a=input() char,space,number,other= 0, 0, 0, 0 for i in a: if i== " ":space+= 1 elif i.isnumeric(): number+= 1 elif i.isalpha():char+= 1 else:other+= 1 print(char) print(space) print(number) print(other) except: break
60.字符串排序
while True: try: a = input() # res是最终返回的字符串的列表形式，char是提取的英文字母。 res, char = [ False] * len(a), [] # 经过这个循环，把相应的非英文字母及其位置存储到了res中。并且把英文字母提取出来了。 for i, v in enumerate(a): if v.isalpha(): char.append(v) else: res[i] = v # 使用lambda表达式排序，暴力有效。 char.sort( key=lambda c: c.lower()) # 将char中对应的字符填到res中。 for i, v in enumerate(res): if not v: res[i] = char[ 0] char.pop( 0) print( "". join(res)) except: break
61.有一只兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子，假如兔子都不死，问每个月的兔子总数为多少？
#第一个月一只，第二个月一只，第三个月两只。然后符合且波纳契数列 while True: try: a=int(input()) arr=[ 1, 1] while len(arr)<a: arr.append(arr[ -1]+arr[ -2]) print(arr[ -1]) except: break
62.有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？
while True: try: a=int(input()) if a!= 0: print(a// 2) except: break
注：通过数学分析，最后获得的饮料数是总空瓶数整除2 。
63.密码验证合格:
1.长度超过8位
2.包括大小写字母.数字.其它符号,以上四种至少三种
3.不能有相同长度超2的子串重复
import re import sys for i in sys.stdin.readlines(): print "OK" if len(i.strip())> 8 and sum([ 1 if re.search( r"[A-Z]",i.strip()) else 0, 1 if re.search( r"[a-z]",i.strip()) else 0, 1 if re.search( r"[0-9]",i.strip()) else 0, 1 if re.search( r"[^0-9a-zA-Z]",i.strip()) else 0])> 2 and sum(map( lambda c:i.strip().count(i.strip()[c:c+ 3])> 1,range( 1,len(i.strip()) -3)))== 0 else "NG"
注： re.findall 的简单用法（返回string中所有与pattern相匹配的全部字串，返回形式为数组）
|
|
64.简单密码破解
他是这么变换的，大家都知道手机上的字母： 1--1， abc--2, def--3, ghi--4, jkl--5, mno--6, pqrs--7, tuv--8 wxyz--9, 0--0,就这么简单，渊子把密码中出现的小写字母都变成对应的数字，数字和其他的符号都不做变换，
d={ "abc": 2, "def": 3, "ghi": 4, "jkl": 5, "mno": 6, "pqrs": 7, "tuv": 8, "wxyz": 9, } while True: try: a,res=input(), "" for i in a: if i.isupper(): if i!= "Z": res+=chr(ord(i.lower())+ 1) else: res+= "a" elif i.islower(): for j in d.keys(): if i in j: res+=str(d[j]) break else: res+=i print(res) except: break
65.计算最少出列多少位同学，使得剩下的同学排成合唱队形
算法：动态规划
用到概念：递增子序列
#-*- coding:utf -8 -*- def middle(b,target): #b为排序数组，所以能进行二分查找，pos返回当前的target在b数组中是第几大的数，也就是前面有多少是有序的 low = 0 high = len(b) - 1 pos = len(b) while(low < high): mid = (low + high) / 2 if (b[ mid] < target): low = mid + 1 else: high = mid pos = high return pos def deal( array,res): b = [ 9999] * len( array) b[ 0] = array[ 0] res = res + [ 1] for i in range( 1, len( array)): pos = middle(b, array[i]) res = res + [pos + 1] #前面有几个比当前数小的值 b[pos] = array[i] #让数组b有序，且每个位置上的数都变成遍历到的最小值 return res while True: try: n = int(raw_input()) a = raw_input(). split( ' ') array = map( int,a) dp1 = [] dp2 = [] dp1 = deal( array,dp1) array.reverse() dp2 = deal( array,dp2) dp2.reverse() a = max(dp1[i] + dp2[i] for i in range(n)) print (n-a+ 1) except: break
66.请解析IP地址和对应的掩码，进行分类识别。要求按照A/B/C/D/E类地址归类，不合法的地址和掩码单独归类。
输入：多行字符串。每行一个IP地址和掩码，用~隔开。
输出:统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数，之间以空格隔开。
# -*- coding: utf-8 -*- import re def isLegalIP(IP): if not IP or IP == "": return False pattern = re.compile( r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$") match = pattern.match(IP) if not match: return False nums = IP.split( ".") for num in nums: n = int(num) if n< 0 or n> 255: return False return True def CatagoryIP(IP): if not IP or IP == "": return False nums = IP.split( ".") # A if 126 >= int(nums[ 0]) >= 1: return "A" # B if 191 >= int(nums[ 0]) >= 128: return "B" # C if 223 >= int(nums[ 0]) >= 192: return "C" # D if 239 >= int(nums[ 0]) >= 224: return "D" # E if 255 >= int(nums[ 0]) >= 240: return "E" return False def isPrivateIP(IP): if not IP or IP == "": return False nums = IP.split( ".") if int(nums[ 0]) == 10: return True if int(nums[ 0]) == 172: if 31 >= int(nums[ 1]) >= 16: return True if int(nums[ 0]) == 192 and int(nums[ 1]) == 168: return True return False def isLegalMaskCode(Mask): if not Mask or Mask == "": return False if not isLegalIP(Mask): return False binaryMask = "".join(map( lambda x: bin(int(x))[ 2:].zfill( 8), Mask.split( "."))) indexOfFirstZero = binaryMask.find( "0") indexOfLastOne = binaryMask.rfind( "1") if indexOfLastOne > indexOfFirstZero: return False return True try: A, B, C, D, E, Err, P = [ 0, 0, 0, 0, 0, 0, 0] while True: s = raw_input() IP, Mask = s.split( "~") if not isLegalIP(IP) or not isLegalMaskCode(Mask): Err += 1 else: if isPrivateIP(IP): P += 1 cat = CatagoryIP(IP) if cat == "A": A += 1 if cat == "B": B += 1 if cat == "C": C += 1 if cat == "D": D += 1 if cat == "E": E += 1 except: print (A, B, C, D, E, Err, P) pass
67.蛇形矩阵
while True: try: n, curNum = int(input()), 1 res = [[ 0 for i in range(n)] for j in range(n)] for i in range(n): for j in range(i + 1): res[i - j][j] = curNum curNum += 1 for i in res: print( " ".join(map(str, (filter( lambda i: i != 0, i))))) except: break
68.购物车
def max_fun(N, m,v,p, q): res = [[ 0]*(N+ 1) for _ in range( m+ 1)] #商品 for i in range( 1, m+ 1): # 价格 for j in range( 10,N+ 1, 10): # 为主件时 if q[i-1]== 0: #主件 #res[i][j]= res[i-1][j] if v[i- 1] <= j: res[i][j] = max(res[i- 1][j], res[i- 1][j-v[i- 1]] + v[i- 1]*p[i- 1]) # 为配件时 q[i-1] != 0 elif v[i- 1] + v[ q[i-1]] <= j: res[i][j] = max(res[i- 1][j], res[i- 1][j-v[i- 1]-v[ q[i-1]]] + v[i- 1]*p[i- 1]+ v[ q[i-1]]*p[ q[i-1]]) print(res[ m][ int(N/ 10)* 10]) N_m = input(). split( ' ') N = int(N_m[ 0]) m = int(N_m[ 1]) v =[] p=[] q=[] for i in range( m): vpq = input(). split( ' ') v.append( int(vp q[0])) p.append( int(vp q[1])) q.append( int(vp q[2])) max_fun(N, m,v,p, q)
69.输入一个字符串,输出:返回有效密码串的最大长度(密码是对称的)
def longestPalindrome(s): if s==s[ : :- 1] :return len(s) maxLen= 0 for i in range(len(s)): if i-maxLen>= 1 and s[i-maxLen- 1 :i+ 1]==s[i-maxLen- 1 :i+ 1][ : :- 1]: maxLen+= 2 continue if i-maxLen>= 0 and s[i- maxLen:i+ 1]==s[i- maxLen:i+ 1][ : :- 1]: maxLen+= 1 return maxLen while True: try: a=input() if a: print(longestPalindrome(a)) except: break
70.名字的漂亮程度：给出一个名字，该名字有26个字符串组成，定义这个字符串的“漂亮度”是其所有字母“漂亮度”的总和。
每个字母都有一个“漂亮度”，范围在1到26之间。没有任何两个字母拥有相同的“漂亮度”。字母忽略大小写。
给出多个名字，计算每个名字最大可能的“漂亮度”。
from collections import Counter while True: try: a=int(input()) for i in range(a): c,start,res=Counter(input()), 26, 0 for j in c.most_common(): res+=j[ 1]*start start-= 1 print(res) except: break
注：most_comman返回一个TopN列表。如果n没有被指定，则返回所有元素。当多个元素计数值相同时，排列是无确定顺序的
70.查找和排序
def rank_record(inp_num,rank_rule): dic_name=[] while(inp_num> 0): inp_name=input() dic_name.append(inp_name) inp_num-= 1 inp_name_sort=sorted(dic_name,key= lambda a:int(a.split( ' ')[ 1]),reverse=(rank_rule -1)) return inp_name_sort while True: try: inp_num=int(input()) rank_rule=int(input()) for i in rank_record(inp_num,rank_rule): print (i) except: break
