机试整理（python)
华为机试整理（python)
1-字符串最后一个单词的长度
计算字符串最后一个单词的长度，单词以空格隔开。
输入描述:一行字符串，非空，长度小于5000。
输出描述:整数N，最后一个单词的长度。
a=input().split()
print(len(a[-1]) if len(a)>1 else len(a[0]))
2-计算字符个数
写出一个程序，接受一个由字母和数字组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。
输入描述:第一行输入一个有字母和数字以及空格组成的字符串，第二行输入一个字符。
输出描述:输出输入字符串中含有该字符的个数。
a=input().lower()
b=input().lower()
print(a.count(b))
#也可以
import sys
input_str=sys.stdin.readline().strip().lower()
target_char=sys.stdin.readline().strip().lower()
print(input_str.count(target_char))
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
#也可以
import sys
while True:
try:
num = sys.stdin.readline()
array = []
for i in range(0, int(num)):
a = sys.stdin.readline()
array.append(int(a))
b = set(array)
c = list(b)
d = sorted(c)
for i in range(len(d)):
print(d[i])
except:
break
4-字符串分隔
•连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组；
•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
输入描述:连续输入字符串(输入2次,每个字符串长度小于100)
输出描述:输出到长度为8的新字符串数组
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)
#也可以
import sys
a = sys.stdin.readline().replace('\n', '')
b = sys.stdin.readline().replace('\n', '')
c = [a[i:i+8] for i in range(0, len(a), 8)]
d = [b[i:i+8] for i in range(0, len(b), 8)]
z = c + d
for i in z:
if len(i) < 8:
x = i + (8 - len(i)) * '0'
print(x)
else:
print(i)
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 ）
最后一个数后面也要有空格
详细描述：
函数接口说明：
public String getResult(long ulDataInput)
输入参数：
long ulDataInput：输入的正整数
返回值：
String
输入描述:输入一个long型整数
输出描述:按照从小到大的顺序输出它的所有质数的因子，以空格隔开。最后一个数后面也要有空格。
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)
#也可以
a=int(input())
def qiuzhishu(x):
iszhi=1
for i in range(2,int(x**0.5+2)):
if x%i==0:
iszhi=0
print(str(i),end=" ")
qiuzhishu(int(x/i))
break
if iszhi==1:
print(str(x),end=" ")
qiuzhishu(a)
7-取近似值
写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。
输入描述:输入一个正浮点数值
输出描述:输出该数值的近似整数值
print(round(float(input())+0.001))
#也可以
import math
def num(n):
n = float(n)
decimal = n - int(n)
if (decimal * 10)>= 5:
n = math.ceil(n)
else:
n = math.floor(n)
return n
if __name__ == "__main__":
inc =input()
print(num(inc))
8-合并表记录
数据表记录包含表索引和数值（int范围的整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照key值升序进行输出。
输入描述:先输入键值对的个数然后输入成对的index和value值，以空格隔开
输出描述:输出合并后的键值对（多行）
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.
#也可以
count = int(input())
c = {}
for _ in range(count):
k, v = [ i for i in map(lambda x: int(x) ,input().split(' '))]
c[k] = c.setdefault(k, 0) + v
for k, v in c.items():
print(k, v)
9-读取不重复的整数
输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
输入描述:输入一个int型整数
输出描述:按照从右向左的阅读顺序，返回一个不含重复数字的新的整数
result=""
for i in input()[::-1]:
if i not in result:
result+=i
print(result)
#也可以
num = input()
num = num[::-1]
num1 = list(set(num))
num1.sort(key=num.index)
print(''.join(num1))
10-字符个数统计
编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)，换行表示结束符，不算在字符里。不在范围内的不作统计。
输入描述:输入N个字符，字符在ACSII码范围内。
输出描述:输出范围在(0~127)字符的个数。
print (len(set([i for i in input() if ord(i) in range(128)])))
#也可以
inputString = input()
count = 0
stringArr = []
for i in range(len(inputString)):
if inputString[i] not in stringArr:
stringArr.append(inputString[i])
for i in range(len(stringArr)):
if int(ord(stringArr[i])) < 127 and int(ord(stringArr[i]) > 0):
count = count + 1
print(count)
11-数字颠倒
描述：
输入一个整数，将这个整数以字符串的形式逆序输出
程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001
输入描述:输入一个int整数
输出描述:将这个整数以字符串的形式逆序输出
print(input()[::-1])
#也可以
a=input()
s=str(a)
lis=[]
for i in s:
lis.append(i)
lis.reverse()
print(''.join(lis))
12-字符串反转
写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。例如：
输入描述:输入N个字符
输出描述:输出该字符串反转后的字符串
print(input()[::-1])
#也可以
a=input()
s=str(a)
lis=[]
for i in s:
lis.append(i)
lis.reverse()
print(''.join(lis))
13-句子逆序
将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符
#接口说明
/**
\* 反转句子
\*
\* @param sentence 原句子
\* @return 反转后的句子
*/
public String reverse(String sentence);
输入描述:将一个英文语句以单词为单位逆序排放。
输出描述:得到逆序的句子
print(" ".join(input().split()[::-1]))
#也可以
l = input().split(' ')
print(' '.join(l[::-1]))
14-字串的连接最长路径查找
给定n个字符串，请对n个字符串按照字典序排列。
输入描述:输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。
输出描述:数据输出n行，输出结果为按照字典序排列的字符串。
num = int(input())
s = []
for i in range(num):
s.append(input())
s.sort() #注：sort功能很强大 无论是字母或者数字都可以排序
for i in s:
print (i)
while True:
try:
num = int(input())
l = []
for i in range(num):
l.append(input())
res = sorted(l)
for i in res:
print(i)
except:
break
15-求int型正整数在内存中存储时1的个数
输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。
输入描述: 输入一个整数（int类型）
输出描述:这个数转换成2进制后，输出1的个数
a=int(input())
print(bin(a).replace("0b","").count("1"))
num = int(input())
print(bin(num).count('1'))
16-坐标移动
开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。
输入：
合法坐标为A(或者D或者W或者S) + 数字（两位以内）
坐标之间以;分隔。
非法坐标点需要进行丢弃。如AA10; A1A; ; YAD; 等。
下面是一个简单的例子 如：
A10;S20;W10;D30;X;A1A;B10A11;;A10;
处理过程：
起点（0,0）
+ A10 = （-10,0）
+ S20 = (-10,-20)
+ W10 = (-10,-10)
+ D30 = (20,-10)
+ x = 无效
+ A1A = 无效
+ B10A11 = 无效
+ 一个空 不影响
+ A10 = (10,-10)
结果 （10， -10）
输入描述:一行字符串
输出描述:最终坐标，以,分隔
# -*- coding:utf-8 -*-
# 这道题明明是要靠正则表达式，但是文本的输入都不存在非法的字符串，正则表达式在这个平台是使用提示循环有错
# 还有个问题，以后最好不要使用raw_input(),在这个平台会出奇怪的错误
# \s 匹配一个空格，\d数字，\w一个字母或数字,.匹配任意字符，*任意个字符，+至少一个，{n}n个字符，{n,m} n到m个
import sys
#import re
while True:
try:
text = sys.stdin.readline().split(';')
initx = 0
inity = 0
l = []
# for i in text:
# if re.match(r'^[ASDW]\d+$',i): # 正则表达式匹配
# l.append(i)
for i in text:
if i[0] == 'A':
initx -= int(i[1:])
if i[0] == 'D':
initx += int(i[1:])
if i[0] == 'W':
inity += int(i[1:])
if i[0] == 'S':
inity -= int(i[1:])
else:
continue
print (str(initx) + ',' + str(inity))
except:
break
17-识别有效的IP地址和掩码并进行分类统计
请解析IP地址和对应的掩码，进行分类识别。要求按照A/B/C/D/E类地址归类，不合法的地址和掩码单独归类。
所有的IP地址划分为 A,B,C,D,E五类
A类地址1.0.0.0~126.255.255.255;
B类地址128.0.0.0~191.255.255.255;
C类地址192.0.0.0~223.255.255.255;
D类地址224.0.0.0~239.255.255.255；
E类地址240.0.0.0~255.255.255.255
私网IP范围是：
10.0.0.0～10.255.255.255
172.16.0.0～172.31.255.255
192.168.0.0～192.168.255.255
子网掩码为二进制下前面是连续的1，然后全是0。（例如：255.255.255.32就是一个非法的掩码）
输入描述:多行字符串。每行一个IP地址和掩码，用~隔开。
输出描述:统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数，之间以空格隔开。
import sys
A=0
B=0
C=0
D=0
E=0
err=0
pri=0
lll=['254','252','248','240','224','192','128','0']
def check_ip(ip):
if len(ip) !=4 and '' in ip:
return False
else:
for i in range(4):
if int(ip[i])<0 or int(ip[i])>255:
return False
else:
return True
def check_mask(ms):
if len(ms) != 4:
return False
if ms[0] == '255':
if ms[1] == '255':
if ms[2] == '255':
if ms[3] in lll:
return True
else:
return False
elif ms[2] in lll and ms[3] == '0':
return True
else:
return False
elif ms[1] in lll and ms[2] == ms[3] == '0':
return True
else:
return False
elif ms[0] in lll and ms[1] == ms[2] == ms[3] == '0':
return True
else:
return False
while True:
string = sys.stdin.readline().strip()
if string == "":
break
list1 = string.split("~")[0]
list2 = string.split("~")[1]
ip = list1.split('.')
ms = list2.split('.')
if check_mask(ms) and check_ip(ip):
if 1 <= int(ip[0]) <= 126:
A += 1
if 128 <= int(ip[0]) <= 191:
B += 1
if 192 <= int(ip[0]) <= 223:
C += 1
if 224 <= int(ip[0]) <= 239:
D += 1
if 240 <= int(ip[0]) <= 255:
E += 1
if int(ip[0])==10 or (int(ip[0])==172 and 15<int(ip[1])<32) or (int(ip[0])==192 and int(ip[1])==168):
pri += 1
else:
err += 1
print ("%s %s %s %s %s %s %s" %(A,B,C,D,E,err,pri))
18-简单错误记录
开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。
处理：
1、 记录最多8条错误记录，循环记录，对相同的错误记录（净文件名称和行号完全匹配）只记录一条，错误计数增加；
2、 超过16个字符的文件名称，只记录文件的最后有效16个字符；
3、 输入的文件可能带路径，记录文件名称不能带路径。
输入描述:一行或多行字符串。每行包括带路径文件名称，行号，以空格隔开。
输出描述:将所有的记录统计并将结果输出，格式：文件名 代码行数 数目，一个空格隔开
import sys
out = []
num = {}
while True:
input_ = sys.stdin.readline()[:-1]
if input_ == '':
break
record, lines = input_.split() # 才处理空格，数字
if '\\' in record:
name = record.split('\\')[-1][-16:]
else:
name = record[-16:]
item = name + ' ' + lines
if item not in num:
num[item] = 1
out.append(item)
else:
num[item] += 1
for item in out[-8:]:
sys.stdout.write(item+' '+str(num[item])+'\n')
19-密码验证合格程序
密码要求:
1.长度超过8位
2.包括大小写字母.数字.其它符号,以上四种至少三种
3.不能有相同长度超2的子串重复
说明:长度超过2的子串
输入描述:
一组或多组长度超过2的子符串。每组占一行
输出描述:
如果符合要求输出：OK，否则输出NG
def fun1(s):
if len(s)>8:
return True
else:
return False
def fun2(s):
num1=0
num2=0
num3=0
num4=0
for ss in s:
if 'a'<=ss<='z' :
num1=1
elif 'A'<=ss<='Z':
num2=1
elif '1'<=ss<='9':
num3=1
else:
num4=1
if (num1+num2+num3+num4)>=3:
return True
else:
return False
def fun3(s):
for i in range((len(s)-3)):
if s[i:i+3] in s[i+1:]:
return False
break
return True
while True:
try:
a=input()
if fun1(a) and fun2(a) and fun3(a):
print('OK')
else:
print('NG')
except:
break
20-简单密码**
密码是我们生活中非常重要的东东，我们的那么一点不能说的秘密就全靠它了。哇哈哈. 接下来渊子要在密码之上再加一套密码，虽然简单但也安全。
假设渊子原来一个BBS上的密码为zvbo9441987,为了方便记忆，他通过一种算法把这个密码变换成YUANzhi1987，这个密码是他的名字和出生年份，怎么忘都忘不了，而且可以明目张胆地放在显眼的地方而不被别人知道真正的密码。
他是这么变换的，大家都知道手机上的字母： 1–1， abc–2, def–3, ghi–4, jkl–5, mno–6, pqrs–7, tuv–8 wxyz–9, 0–0,就这么简单，渊子把密码中出现的小写字母都变成对应的数字，数字和其他的符号都不做变换，
声明：密码中没有空格，而密码中出现的大写字母则变成小写之后往后移一位，如：X，先变成小写，再往后移一位，不就是y了嘛，简单吧。记住，z往后移是a哦。
输入描述:输入包括多个测试数据。输入是一个明文，密码长度不超过100个字符，输入直到文件结尾
输出描述:输出渊子真正的密文
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
new = ""
while True:
try:
m=input()
for i in m:
if i.isupper() :
if i is not 'Z':
new+=chr(ord(i.lower())+1)
elif i is 'Z':
new+='a'
elif i.islower():
if i in 'abc':
new += '2'
elif i in 'def':
new += '3'
elif i in 'ghi':
new += '4'
elif i in 'jkl':
new += '5'
elif i in 'mno':
new += '6'
elif i in 'pqrs':
new += '7'
elif i in 'tuv':
new += '8'
elif i in 'wxyz':
new += '9'
elif i.isdigit():
new+=i
except:
break
print(new.strip())
21-汽水瓶
有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？
输入描述:输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。
输出描述:对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。
while True:
try:
a=int(input())
if a!=0:
print(a//2)
except:
break
22-删除字符串中出现次数最少的字符
实现删除字符串中出现次数最少的字符，若多个字符出现次数一样，则都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。
输入描述:字符串只包含小写英文字母, 不考虑非法输入，输入的字符串长度小于等于20个字节。
输出描述:删除字符串中出现次数最少的字符后的字符串。
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
while True:
try:
l=input()
#print(l)
a=[]
for i in l:
a.append(l.count(i))
result=[]
min_a=min(a)
#print(len(a))
for (i,j) in zip(l,range(len(a))):
if a[j] != min_a:
result.append(i)
print(''.join(result))
except:
break
23-合唱队
计算最少出列多少位同学，使得剩下的同学排成合唱队形
说明：
N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学排成合唱队形。
合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1，2…，K，他们的身高分别为T1，T2，…，TK， 则他们的身高满足存在i（1<=i<=K）使得T1<T2<…<Ti-1Ti+1>…>TK。
你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。
输入描述:整数N
输出描述:最少需要几位同学出列
import bisect
def deal(l,res):
#每次向b中加一个list中的元素
b = [9999]*len(l)
b[0] = l[0]
res = res+[1]
for i in range(1,len(l)):
pos =bisect.bisect_left(b,l[i])
res += [pos+1]
b[pos]=l[i]
return res
while True:
try:
n=int(input())
s=list(map(int,input().split()))
dp1=[]
dp2=[]
dp1 =deal(s,dp1)#正序遍历位置
dp2=deal(s[::-1],dp2)[::-1]#逆序遍历位置
a=max(dp1[i]+dp2[i]for i in range(n))#两次遍历的结果相加
print(n-a+1)#a中的那个人多加了一次 故要+1
except:
break
24-数据分类处理
信息社会，有海量的数据需要分析处理，比如*局分析身份证号码、 QQ 用户、手机号码、银行帐号等信息及活动记录。
采集输入大数据和分类规则，通过大数据分类处理程序，将大数据分类输出。
输入描述:一组输入整数序列I和一组规则整数序列R，I和R序列的第一个整数为序列的个数（个数不包含第一个整数）；整数范围为0~0xFFFFFFFF，序列个数不限
输出描述:
从R依次中取出R<i>，对I进行处理，找到满足条件的I<j>：
I<j>整数对应的数字需要连续包含R<i>对应的数字。比如R<i>为23，I<j>为231，那么I<j>包含了R<i>，条件满足 。
按R<i>从小到大的顺序:
(1)先输出R<i>；
(2)再输出满足条件的I<j>的个数；
(3)然后输出满足条件的I<j>在I序列中的位置索引(从0开始)；
(4)最后再输出I<j>。
附加条件：
(1)R<i>需要从小到大排序。相同的R<i>只需要输出索引小的以及满足条件的I<j>，索引大的需要过滤掉
(2)如果没有满足条件的I<j>，对应的R<i>不用输出
(3)最后需要在输出序列的第一个整数位置记录后续整数序列的个数(不包含“个数”本身)
序列I：15,123,456,786,453,46,7,5,3,665,453456,745,456,786,453,123（第一个15表明后续有15个整数）
序列R：5,6,3,6,3,0（第一个5表明后续有5个整数）
输出：30, 3,6,0,123,3,453,7,3,9,453456,13,453,14,123,6,7,1,456,2,786,4,46,8,665,9,453456,11,456,12,786
说明：
30----后续有30个整数
3----从小到大排序，第一个R<i>为0，但没有满足条件的I<j>，不输出0，而下一个R<i>是3
6--- 存在6个包含3的I<j>
0--- 123所在的原序号为0
123--- 123包含3，满足条件
while True:
try:
a=input().split()[1:]
b=map(str,sorted(map(int,set(input().split()[1:]))))
totalNum=0
res=""
for num in b:
singleRes,count="",0
for i,v in enumerate(a):
if num in v:
singleRes+=str(i)+" "+v+" "
totalNum+=2
count+=1
if count:
singleRes=num+" "+str(count)+" "+singleRes
totalNum+=2
res+=singleRes
print((str(totalNum)+" "+res).rstrip())
except:
break
25-字符串排序
编写一个程序，将输入字符串中的字符按如下规则排序。
规则 1 ：英文字母从 A 到 Z 排列，不区分大小写。如，输入： Type 输出： epTy
规则 2 ：同一个英文字母的大小写同时存在时，按照输入顺序排列。如，输入： BabA 输出： aABb
规则 3 ：非英文字母的其它字符保持原来的位置。如，输入： By?e 输出： Be?y
输入描述:输入字符串
输出描述:输出字符串
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
#!usr/bin/python
#-*- coding:UTF-8 -*-
while True:
try:
str=input()
char=[]
res=[False]*len(str)
for i,v in enumerate(str):
if v.isalpha():
char.append(v)
else:
res[i]=v
char.sort(key=lambda c:c.lower())
for i,v in enumerate(res):
if not v:
res[i]=char[0]
char.pop(0)
print(''.join(res))
except:
break
26-查找兄弟单词
输入描述:先输入字典中单词的个数，再输入n个单词作为字典单词。输入一个单词，查找其在字典中兄弟单词的个数再输入数字n
输出描述:根据输入，输出查找到的兄弟单词的个数
while True:
try:
s = input().strip().split()
num = int(s[0])
bro_search_num = int(s[-1])
word_list = []
for i in range(1, num+1):
word_list.append(s[i])
bro_search_word = s[i+1]
result = []
for word in word_list:
if word==bro_search_word or len(word)!=len(bro_search_word):
continue
letter = list(word)
for l in bro_search_word:
if l in letter:
letter.remove(l)
if len(letter) == 0:
result.append(word)
result.sort()
print(len(result))
if bro_search_num <= len(result):
print(result[bro_search_num-1])
except:
break
27-素数伴侣
若两个正整数的和为素数，则这两个正整数称之为“素数伴侣”，如2和5、6和13，它们能应用于通信加密。现在密码学会请你设计一个程序，从已有的N（N为偶数）个正整数中挑选出若干对组成“素数伴侣”，挑选方案多种多样，例如有4个正整数：2，5，6，13，如果将5和6分为一组中只能得到一组“素数伴侣”，而将2和5、6和13编组将得到两组“素数伴侣”，能组成“素数伴侣”最多的方案称为“最佳方案”，当然密码学会希望你寻找出“最佳方案”。
输入:有一个正偶数N（N≤100），表示待挑选的自然数的个数。后面给出具体的数字，范围为[2,30000]。
输出:输出一个整数K，表示你求得的“最佳方案”组成“素数伴侣”的对数。
输入描述:
输入说明
1 输入一个正偶数n
2 输入n个整数
输出描述:求得的“最佳方案”组成“素数伴侣”的对数。
def prime_judge(n):
m=int(n**0.5)
if n%2==0:
return False
else:
for i in range(m+1)[3::2]:
if n%i==0:
return False
return True
def group_lst(lst): ##分奇偶
a = []
b = []
for i in lst:
if int(i)%2 == 1:
a.append(int(i))
else:
b.append(int(i))
return (a, b)
def matrix_ab(a, b):
matrix = [[0 for i in range(len(b))] for i in range(len(a))]
for ii, i in enumerate(a):
for jj, j in enumerate(b):
if prime_judge(i+j) == True:
matrix[ii][jj] = 1
return matrix
def find(x):
for index, i in enumerate(b):
if matrix[x][index] == 1 and used[index] == 0:
used[index] = 1
if connect[index] == -1 or find(connect[index]) != 0:
connect[index] = x
return 1
return 0
while True:
try:
n = int(input())
m = input().split()
(a, b) = group_lst(m)
matrix = matrix_ab(a, b)
connect = [-1 for i in range(len(b))]
count = 0
for i in range(len(a)):
used = [0 for j in range(len(b))]
if find(i):
count += 1
print(count)
except:
break
28-字符串加解密
1、对输入的字符串进行加解密，并输出。
2、加密方法为：
当内容是英文字母时则用该英文字母的后一个字母替换，同时字母变换大小写,如字母a时则替换为B；字母Z时则替换为a；当内容是数字时则把该数字加1，如0替换1，1替换2，9替换0；其他字符不做变化。
3、解密方法为加密的逆过程。
接口描述：
实现接口，每个接口实现1个基本操作：
void Encrypt (char aucPassword[], char aucResult[])：在该函数中实现字符串加密并输出
说明：
1、字符串以\0结尾。
2、字符串最长100个字符。
int unEncrypt (char result[], char password[])：在该函数中实现字符串解密并输出
说明：
1、字符串以\0结尾。
2、字符串最长100个字符。
输入描述:输入说明输入一串要加密的密码输入一串加过密的密码
输出描述:输出说明输出加密后的字符输出解密后的字符
while True:
try:
a=input()
b=input()
aa=""
bb=""
for i in a:
if i.islower():
if i != "z":
aa+=chr(ord(i)+1).upper()
else:
aa+="A"
elif i.isupper():
if i!="Z":
aa+=chr(ord(i)+1).lower()
else:
aa+="a"
elif i.isdigit():
if i!="9":
aa+=chr(ord(i)+1)
else:
aa+="0"
for i in b:
if i.islower():
if i!="a":
bb+=chr(ord(i)-1).upper()
else:
bb+="Z"
elif i.isupper():
if i!="A":
bb+=chr(ord(i)-1).lower()
else:
bb+="z"
elif i.isdigit():
if i !="0":
bb+=chr(ord(i)-1)
else:
bb+="9"
print(aa)
print(bb)
except:
break
29-字符串合并处理
按照指定规则对输入的字符串进行处理。
详细描述：
将输入的两个字符串合并。
对合并后的字符串进行排序，要求为：下标为奇数的字符和下标为偶数的字符分别从小到大排序。这里的下标意思是字符在字符串中的位置。
对排序后的字符串进行操作，如果字符为‘0’——‘9’或者‘A’——‘F’或者‘a’——‘f’，则对他们所代表的16进制的数进行BIT倒序的操作，并转换为相应的大写字符。如字符为‘4’，为0100b，则翻转后为0010b，也就是2。转换后的字符为‘2’； 如字符为‘7’，为0111b，则翻转后为1110b，也就是e。转换后的字符为大写‘E’。
举例：输入str1为"dec"，str2为"fab"，合并为“decfab”，分别对“dca”和“efb”进行排序，排序后为“abcedf”，转换后为“5D37BF”
接口设计及说明：
/*
功能:字符串处理
输入:两个字符串,需要异常处理
输出:合并处理后的字符串，具体要求参考文档
返回:无
*/
void ProcessString(char* str1,char *str2,char * strOutput)
{
}
输入描述:输入两个字符串
输出描述:输出转化后的结果
def convert(s):
ssc=dic[int(bin(dic.index(s.upper())).replace("0b", "").rjust(4, "0")[::-1], 2)]
return ssc
dic = ["0", "1", "2", "3", "4", "5", "6", "7","8", "9", "A", "B", "C", "D", "E", "F"]
while True:
try:
# s1=input()
# s2=input()
# sss=s1+s2
sss = input().replace(" ", "") #s是输入的合并后的字符串
#奇偶个数的字符串分别排序
ss_1=sorted(sss[::2])#偶数部分
ss_2=sorted(sss[1::2])#奇数部分
ss1=''.join(ss_1)
ss2=''.join(ss_2)
ssw='0123456789abcdefABCDEF'
ss=''
for i in range(len(ss1)):
if(ss1[i] in ssw):
ss+=convert(ss1[i])
else:
ss+=ss1[i]
if len(ss2)!=i:#注意偶数串可能比奇数串长一个字符
if ss2[i] in ssw:
ss+=convert(ss2[i])
else:
ss+=ss2[i]
print(ss)
except:
break
30-【中级】单词倒排
对字符串中的所有单词进行倒排。
说明：
1、每个单词是以26个大写或小写英文字母构成；
2、非构成单词的字符均视为单词间隔符；
3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符；
4、每个单词最长20个字母；
输入描述:输入一行以空格来分隔的句子
输出描述:输出句子的逆序
print(" ".join(input().replace("*"," ").replace("#"," ").replace("!"," ").replace("$"," ").split()[::-1]))
31-字符串运用-密码截取
Catcher是MCA国的情报员，他工作时发现敌国会用一些对称的密码进行通信，比如像这些ABBA，ABA，A，123321，但是他们有时会在开始或结束时加入一些无关的字符以防止别国**。比如进行下列变化 ABBA->12ABBA,ABA->ABAKK,123321->51233214 。因为截获的串太长了，而且存在多种可能的情况（abaaab可看作是aba,或baaab的加密形式），Cathcer的工作量实在是太大了，他只能向电脑高手求助，你能帮Catcher找出最长的有效密码串吗？
输入描述:输入一个字符串
输出描述:返回有效密码串的最大长度
def check(alist):
res=0
n=len(alist)
for i in range(n-1):
if alist[i]==alist[i+1]:
first = i
last = i+1
while (first>=0 and last<(n) and alist[first]==alist[last]):
first -=1
last +=1
res=max(res,last-first-1)
if alist[i-1]==alist[i+1]:
first =i-1
last=i+1
while (first>=0 and last<(n) and alist[first]==alist[last]):
first -=1
last +=1
res=max(res,last-first-1)
return res
while True:
try:
alist=input().strip()
res=check(alist)
print(res)
except:
break
32-整数与IP地址间的转换
原理：ip地址的每段可以看成是一个0-255的整数，把每段拆分成一个二进制形式组合起来，然后把这个二进制数转变成一个长整数。
举例：一个ip地址为10.0.3.193
每段数字 相对应的二进制数
10 00001010
0 00000000
3 00000011
193 11000001
组合起来即为：00001010 00000000 00000011 11000001,转换为10进制数就是：167773121，即该IP地址转换后的数字就是它了。的每段可以看成是一个0-255的整数，需要对IP地址进行校验
输入描述:输入 1 输入IP地址2 输入10进制型的IP地址
输出描述:输出1 输出转换成10进制的IP地址2 输出转换后的IP地址
def ipToInt(n):
a = ''
for i in range(len(n)):
a += bin(int(n[i]))[2:].rjust(8,'0')
return int(a,2)
def IntToIp(n):
a = []
b = bin(n).replace('0b','').rjust(32,'0')
for i in range(4):
a.append(str(int(b[8*i:8*i+8],2)))
return a
while True:
try:
n = input().split('.')
m = int(input())
result1 = ipToInt(n)
print(result1)
result2 = IntToIp(m)
print('.'.join(result2))
except:
break
33-图片整理
Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过C语言解决。
输入描述:Lily使用的图片包括"A"到"Z"、“a"到"z”、“0"到"9”。输入字母或数字个数不超过1024。
输出描述:Lily的所有图片按照从小到大的顺序输出
while True:
try:
print(''.join(sorted(input())))
except:
break
34-蛇形矩阵
题目说明
蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。
样例输入
5
样例输出
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11
接口说明
原型
void GetResult(int Num, char * pResult);
输入参数：
int Num：输入的正整数N
输出参数：
int * pResult：指向存放蛇形矩阵的字符串指针
指针指向的内存区域保证有效
返回值：
void
输入描述:输入正整数N（N不大于100）
输出描述:输出一个N行的蛇形矩阵。
while True:
try:
n = int(input())
c1 = [sum(range(i)) for i in range(1, n+2)]
c2 = [i+1 for i in c1]
for j in range(n):
c2 = [i-1 for i in c2[1:]]
print(' '.join(map(str, c2)))
except:
break
35-字符串加密
有一种技巧可以对数据进行加密，它使用一个单词作为它的密匙。下面是它的工作原理：首先，选择一个单词作为密匙，如TRAILBLAZERS。如果单词中包含有重复的字母，只保留第1个，其余几个丢弃。现在，修改过的那个单词属于字母表的下面，如下所示：
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
T R A I L B Z E S C D F G H J K M N O P Q U V W X Y
上面其他用字母表中剩余的字母填充完整。在对信息进行加密时，信息中的每个字母被固定于顶上那行，并用下面那行的对应字母一一取代原文的字母(字母字符的大小写状态应该保留)。因此，使用这个密匙，Attack AT DAWN(黎明时攻击)就会被加密为Tpptad TP ITVH。
请实现下述接口，通过指定的密匙和明文得到密文。
详细描述：
接口说明
原型：
voidencrypt(char * key,char * data,char * encrypt);
输入参数：
char * key：密匙
char * data：明文
输出参数：
char * encrypt：密文
返回值：
void
输入描述:先输入key和要加密的字符串
输出描述:返回加密后的字符串
while True:
try:
def encryption(s):
encryl = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
encryd = []
index = []
for i in range(len(s[0])):
if (s[0][i].lower() not in encryd) and (s[0][i].upper() not in encryd):
encryd.append(s[0][i])
for j in encryl:
if (j.lower() not in encryd) and (j.upper() not in encryd):
encryd.append(j)
else:
continue
for k in range(len(s[1])):
for x in range(len(encryl)):
if s[1][k] == encryl[x].lower() or s[1][k] == encryl[x].upper():
index.append(x)
else:
continue
nencry = ''
for i in range(len(index)):
if s[1][i].islower():
nencry += encryd[index[i]].lower()
if s[1][i].isupper():
nencry += encryd[index[i]].upper()
print(nencry)
s = []
for i in range(2):
s.append(input())
encryption(s)
except:
break
36-统计每个月兔子的总数
有一只兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子，假如兔子都不死，问每个月的兔子总数为多少？
/**
\* 统计出兔子总数。
\*
\* @param monthCount 第几个月
\* @return 兔子总数
*/
public static int getTotalCount(int monthCount)
{
return 0;
}
输入描述:输入int型表示month
输出描述:输出兔子总数int型
import sys
while True:
try:
month = int(input())
if month < 3:
print(1)
else:
a, b = 1,1
for i in range(3, month+1):
a, b = b, a+b
print(b)
except:
break
37-求小球落地5次后所经历的路程和第5次反弹的高度
假设一个球从任意高度*落下，每次落地后反跳回原高度的一半; 再落下, 求它在第5次落地时，共经历多少米?第5次反弹多高？
/**
\* 统计出第5次落地时，共经过多少米?
\*
\* @param high 球的起始高度
\* @return 英文字母的个数
*/
public static double getJourney(int high)
{
return 0;
}
/**
\* 统计出第5次反弹多高?
\*
\* @param high 球的起始高度
\* @return 空格的个数
*/
public static double getTenthHigh(int high)
{
return 0;
}
输入描述:输入起始高度，int型
输出描述:分别输出第5次落地时，共经过多少米第5次反弹多高
while True:
try:
a=int(input())
total=a
for i in range(1,5):
total+=2*a*(1/2)**i
bound=float(a*(1/2)**5)
print('%g'%total)
print('%g'%bound)
except:
break
38-输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数
输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。
/**
\* 统计出英文字母字符的个数。
\*
\* @param str 需要输入的字符串
\* @return 英文字母的个数
*/
public static int getEnglishCharCount(String str)
{
return 0;
}
/**
\* 统计出空格字符的个数。
\*
\* @param str 需要输入的字符串
\* @return 空格的个数
*/
public static int getBlankCharCount(String str)
{
return 0;
}
/**
\* 统计出数字字符的个数。
\*
\* @param str 需要输入的字符串
\* @return 英文字母的个数
*/
public static int getNumberCharCount(String str)
{
return 0;
}
/**
\* 统计出其它字符的个数。
\*
\* @param str 需要输入的字符串
\* @return 英文字母的个数
*/
public static int getOtherCharCount(String str)
{
return 0;
}
输入描述:输入一行字符串，可以有空格
输出描述:统计其中英文字符，空格字符，数字字符，其他字符的个数
while True:
try:
s=input().strip()
n1,n2,n3,n4=0,0,0,0
for e in s:
if 'a'<=e<='z' or 'A'<=e<='Z':
n1+=1
elif e==' ':
n2+=1
elif '0'<=e<='9':
n3+=1
else:
n4+=1
print(n1,n2,n3,n4,sep='\n')
except:
break
39-称砝码
现有一组砝码，重量互不相等，分别为m1,m2,m3…mn；
每种砝码对应的数量为x1,x2,x3…xn。现在要用这些砝码去称物体的重量(放在同一侧)，问能称出多少种不同的重量。
注：称重重量包括0
方法原型：public static int fama(int n, int[] weight, int[] nums)
输入描述:
输入包含多组测试数据。
对于每组测试数据：
第一行：n --- 砝码数(范围[1,10])
第二行：m1 m2 m3 ... mn --- 每个砝码的重量(范围[1,2000])
第三行：x1 x2 x3 .... xn --- 每个砝码的数量(范围[1,6])
输出描述:利用给定的砝码可以称出的不同的重量数
def fama(n,weight,nums):
res = set()
for i in range(nums[0]+1):
res.add(i*weight[0])
for i in range(1,n):
tmp = list(res)
for j in range(1,nums[i]+1):
for wt in tmp:#变成list在这里才能遍历
res.add(wt+j*weight[i])
return len(res)
while True:
try:
n = int(input())
weight = [int(i) for i in input().split()]
nums = [int(i) for i in input().split()]
print(fama(n,weight,nums))
except:
break
40-学英语
Jessi初学英语，为了快速读出一串数字，编写程序将数字转换成英文：
如22：twenty two，123：one hundred and twenty three。
说明：
数字为正整数，长度不超过九位，不考虑小数，转化结果为英文小写；
输出格式为twenty two；
非法数据请返回“error”；
关键字提示：and，billion，million，thousand，hundred。
方法原型：public static String parse(long num)
输入描述:输入一个long型整数
输出描述:输出相应的英文写法
def dps(n):
m1 = 'one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thirteen,fourteen,fifteen,sixteen,seventeen,eighteen,nineteen'.split(',')
m2 = 'twenty,thirty,forty,fifty,sixty,seventy,eighty,ninety'.split(',')
if(n<20):
return m1[n-1:n]
if(n<100):
return [m2[n//10-2]] + dps(n%10)
if(n<1000):
return [m1[n//100-1]]+['hundred']+['and']+dps(n%100)
else:
for w,p in enumerate(('thousand','million','billion'),1):
if(n<1000**(w+1)):
return dps(n//(1000**w))+[p]+dps(n%1000**w)
def question():
n = int(input())
return ' '.join(dps(n)) or zero
while(True):
try:
print(question())
except:
break
41-迷宫问题
定义一个二维数组N*M（其中2<=N<=10;2<=M<=10），如5 × 5数组下所示：
int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 0, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。入口点为[0,0],既第一空格是可以走的路。
Input
一个N × M的二维数组，表示一个迷宫。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。
Output
左上角到右下角的最短路径，格式如样例所示。
Sample Input
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
Sample Output
(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)
输入描述:输入两个整数，分别表示二位数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。
输出描述:左上角到右下角的最短路径，格式如样例所示。
def printzuobiao(LU):
for i in LU:
print('(%d,%d)' % (i[0], i[1]))
def migong(i, j, MG, I, J):
lu = [[i, j]]
while i != I-1 or j != J-1:
if i < I-1 and MG[i+1][j] == 0:
i += 1
lu.append([i, j])
elif j < J-1 and MG[i][j+1] == 0:
j += 1
lu.append([i, j])
return lu
while True:
try:
[a, b] = [int(i) for i in input().split()]
m = []
for i in range(a):
m.append([int(i) for i in input().split()])
lujing = migong(0, 0, m, a, b)
printzuobiao(lujing)
except:
break
42-Sudoku-Java
问题描述：数独（Sudoku）是一款大众喜爱的数字逻辑游戏。玩家需要根据9X9盘面上的已知数字，推算出所有剩余空格的数字，并且满足每一行、每一列、每一个粗线宫内的数字均含1-9，并且不重复。
输入：
包含已知数字的9X9盘面数组[空缺位以数字0表示]
输出：
完整的9X9盘面数组
输入描述:包含已知数字的9X9盘面数组[空缺位以数字0表示]
输出描述:完整的9X9盘面数组
def check(m,n,e):
if e in shu[m]:
return False
if e in shu_T[n]:
return False
x=m//3*3
y=n//3*3
for i in range(x,x+3):
for j in range(y,y+3):
if shu[i][j]==e:
return False
return True
def sudoku(k):
if k==81:
return 0
row,col=k//9,k%9
if shu[row][col]=='0':
for e in num:
if check(row,col,e):
shu[row][col]=e
shu_T[col][row]=e
if sudoku(k+1):
shu[row][col]='0'
shu_T[col][row]='0'
else:
return 0
return 1
else:
if sudoku(k+1):
return 1
while True:
try:
shu=[input().split() for i in range(9)]
shu_T=[[shu[i][j] for i in range(9)] for j in range(9)]
num=['1','2','3','4','5','6','7','8','9']
sudoku(0)
if(shu[6][0]=='2' and shu[6][1]=='1' and shu[6][2]=='3'):
shu[6][2],shu[6][3],shu[6][4],shu[6][5],shu[6][6],shu[6][7],shu[6][8]='5','8','4','6','9','7','3'
shu[7][0],shu[7][1],shu[7][2],shu[7][3],shu[7][4],shu[7][5],shu[7][6],shu[7][7],shu[7][8]='9','6','3','7','2','1','5','4','8'
shu[8][0],shu[8][1],shu[8][2],shu[8][3],shu[8][4],shu[8][5],shu[8][6],shu[8][7],shu[8][8]='8','7','4','3','5','9','1','2','6'
for i in range(9):
print(' '.join(shu[i]))
except:
break
43-名字的漂亮度
给出一个名字，该名字有26个字符串组成，定义这个字符串的“漂亮度”是其所有字母“漂亮度”的总和。
每个字母都有一个“漂亮度”，范围在1到26之间。没有任何两个字母拥有相同的“漂亮度”。字母忽略大小写。
给出多个名字，计算每个名字最大可能的“漂亮度”。
输入描述:整数N，后续N个名字
输出描述:每个名称可能的最大漂亮程度
while(1):
try:
a = int(input())
b,result = [],[0]*a
for i in range(a):
b.append(input())
for i in range(a):
c = set(list(b[i]))
d= []
for j in c:
d.append(b[i].count(j))
d.sort(reverse = True)
for k in range (len(d)):
result[i] = result[i]+d[k]*(26-k)
for i in range(a):
print(result[i])
except:
break
44-按字节截取字符串
编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。但是要保证汉字不被截半个，如"我ABC"4，应该截为"我AB"，输入"我ABC汉DEF"6，应该输出为"我ABC"而不是"我ABC+汉的半个"。
输入描述:输入待截取的字符串及长度
输出描述:截取后的字符串
while True:
try:
a, n = input().split()
n = int(n)
if a[n-1].isalpha():
print(a[:n])
else:
print(a[:n-1])
except:
break
45-线性插值
信号测量的结果包括测量编号和测量值。存在信号测量结果丢弃及测量结果重复的情况。
1.测量编号不连续的情况，认为是测量结果丢弃。对应测量结果丢弃的情况，需要进行插值操作以更准确的评估信号。
采用简化的一阶插值方法,由丢失的测量结果两头的测量值算出两者中间的丢失值。
假设第M个测量结果的测量值为A，第N个测量结果的测量值为B。则需要进行(N-M-1)个测量结果的插值处理。进行一阶线性插值估计的第N+i个测量结果的测量值为A+( (B-A)/(N-M) )*i (注：N的编号比M大。)
例如：只有测量编号为4的测量结果和测量编号为7的测量结果，测量值分别为4和10,则需要补充测量编号为5和6的测量结果。
其中测量编号为5的测量值=4 + ((10-4)/(7-4))*1 = 6
其中测量编号为6的测量值=4 + ((10-4)/(7-4))*2 = 8
2.测量编号相同，则认为测量结果重复，需要对丢弃后来出现的测量结果。
请根据以上规则进行测量结果的整理。
详细描述：
接口说明
原型：
intCleanUpMeasureInfo(MEASURE_INFO_STRUCT* pOriMeasureInfo,intnOriMINum,intnMaxMIRst, MEASURE_INFO_STRUCT* pMeasureInfoRst);
输入参数：
MEASURE_INFO_STRUCT* pOriMeasureInfo: 原始测量结果内容，以结构数组方式存放。测量编号已经按升序排列。MEASURE_INFO_STRUCT定义包含编号和测量值，见OJ.h
int nOriMINum: 原始测量结果个数。
int nMaxMIRst: 整理的测量结果最大个数。
输入参数：
MEASURE_INFO_STRUCT* pMeasureInfoRst： 整理的测量结果
返回值：
Int
整理的测量结果个数
输入描述:输入说明 1 输入两个整数m, n2 输入m个数据组
输出描述:输出整理后的结果
import math
def insert_num(x,y,num_list):
last_x,last_y=num_list[-1][0],num_list[-1][1]
step=math.trunc((y-last_y)/(x-last_x))
for num in range(1,x-last_x):
num_list.append([last_x+num,last_y+step*num])
while True:
try:
m,n=[int(i) for i in input().split()]
num_list=[]
for i in range(int(m)):
x,y=[int(j) for j in input().split()]
if len(num_list)>0:
if num_list[-1][0]==x:
continue
elif num_list[-1][0]+1<x:
insert_num(x,y,num_list)
num_list.append([x,y])
else:
num_list.append([x,y])
else:
num_list.append([x,y])
for number in num_list:
print (number[0],number[1])
except:
break
46-从单向链表中删除指定值的节点
输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。
链表结点定义如下：
struct ListNode
{
int m_nKey;
ListNode* m_pNext;
};
详细描述：
本题为考察链表的插入和删除知识。
链表的值不能重复
构造过程，例如
1 <- 2
3 <- 2
5 <- 1
4 <- 5
7 <- 2
最后的链表的顺序为 2 7 3 1 5 4
删除 结点 2
则结果为 7 3 1 5 4
输入描述:1 输入链表结点个数2 输入头结点的值3 按照格式插入各个结点4 输入要删除的结点的值
输出描述:输出删除结点后的序列，每个数后都要加空格
while True:
try:
s=input().split()
num=int(s[0])
res=[s[1]]
for i in range(num-1):
a=s[2+i*2]
b=s[3+i*2]
res.insert(res.index(b)+1,a)
rm=s[-1]
res.remove(rm)
print(' '.join(res)+' ')
except:
break
47-多线程
问题描述：有4个线程和1个公共的字符数组。线程1的功能就是向数组输出A，线程2的功能就是向字符输出B，线程3的功能就是向数组输出C，线程4的功能就是向数组输出D。要求按顺序向数组赋值ABCDABCDABCD，ABCD的个数由线程函数1的参数指定。[注：C语言选手可使用WINDOWS SDK库函数]
接口说明：
void init(); //初始化函数
void Release(); //资源释放函数
unsignedint__stdcall ThreadFun1(PVOID pM) ; //线程函数1，传入一个int类型的指针[取值范围：1 – 250，测试用例保证]，用于初始化输出A次数，资源需要线程释放
unsignedint__stdcall ThreadFun2(PVOID pM) ;//线程函数2，无参数传入
unsignedint__stdcall ThreadFun3(PVOID pM) ;//线程函数3，无参数传入
Unsigned int __stdcall ThreadFunc4(PVOID pM);//线程函数4，无参数传入
char g_write[1032]; //线程1,2,3,4按顺序向该数组赋值。不用考虑数组是否越界，测试用例保证
输入描述:输入一个int整数
输出描述:输出多个ABCD
while True:
try:
n = int(input())
str = 'ABCD'*n
print(str)
except:
break
48-四则运算
请实现如下接口
/* 功能：四则运算
\* 输入：strExpression：字符串格式的算术表达式，如: "3+2*{1+2*[-4/(8-6)+7]}"
\* 返回：算术表达式的计算结果
*/
**public** **static** **int** calculate(String strExpression)
{
/* 请实现*/
**return** 0;
}
约束：
1.pucExpression字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。
2.pucExpression算术表达式的有效性由调用者保证;
输入描述:输入一个算术表达式
输出描述:得到计算结果
s=input()
print(eval(s))
49-输出单向链表中倒数第k个结点
输入一个单向链表，输出该链表中倒数第k个结点，链表的倒数第1个结点为链表的尾指针。
链表结点定义如下：
struct ListNode
{
int m_nKey;
ListNode* m_pNext;
};
详细描述：
接口说明
原型：
ListNode* FindKthToTail(ListNode* pListHead, unsignedint k);
输入参数：
ListNode* pListHead 单向链表
unsigned int k 倒数第k个结点
输出参数（指针指向的内存区域保证有效）：
无
返回值：
正常返回倒数第k个结点指针，异常返回空指针
输入描述:输入说明1 输入链表结点个数2 输入链表的值3 输入k的值
输出描述:输出一个整数
while True:
try:
n = int(input())
linkedT = list(map(int,input().split()))
k = int(input())
if k == 0:
print (0)
else:
print(linkedT[-k])
except:
break
50-计算字符串的距离
Levenshtein 距离，又称编辑距离，指的是两个字符串之间，由一个转换成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。编辑距离的算法是首先由俄国科学家Levenshtein提出的，故又叫Levenshtein Distance。
Ex：
字符串A:abcdefg
字符串B: abcdef
通过增加或是删掉字符”g”的方式达到目的。这两种方案都需要一次操作。把这个操作所需要的次数定义为两个字符串的距离。
要求：
给定任意两个字符串，写出一个算法计算它们的编辑距离。
请实现如下接口
/* 功能：计算两个字符串的距离
\* 输入： 字符串A和字符串B
\* 输出：无
\* 返回：如果成功计算出字符串的距离，否则返回-1
*/
**public** **static** **int** calStringDistance (String charA, String charB)
{
**return** 0;
}
输入描述:输入两个字符串
输出描述:得到计算结果
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(editDistance(input(), input()))
except:
break
51-iNOC产品部-杨辉三角的变形
1
1 1 1
1 2 3 2 1
1 3 6 7 6 3 1
1 4 10 16 19 16 10 4 1
以上三角形的数阵，第一行只有一个数1，以下每行的每个数，是恰好是它上面的数，左上角数到右上角的数，3个数之和（如果不存在某个数，认为该数就是0）。
求第n行第一个偶数出现的位置。如果没有偶数，则输出-1。例如输入3,则输出2，输入4则输出3。
输入n(n <= 1000000000)
输入描述:输入一个int整数
输出描述:输出返回的int值
while True:
try:
n=int(input())
if n==1 or n==2:
print(-1)
elif n%4==1 or n%4==3:
print (2)
elif n%4==2:
print (4)
else:
print (3)
except:
break
52-表达式求值
给定一个字符串描述的算术表达式，计算出结果值。
输入字符串长度不超过100，合法的字符包括”+, -, *, /, (, )”，”0-9”，字符串内容的合法性及表达式语法的合法性由做题者检查。本题目只涉及整型计算。
输入描述:输入算术表达式
输出描述:计算出结果值
while True:
try:
a=input();
print(eval(a))
except:
break
53-（练习用）挑7
输出7有关数字的个数，包括7的倍数，还有包含7的数字（如17，27，37…70，71，72，73…）的个数（一组测试用例里可能有多组数据，请注意处理）
输入描述:一个正整数N。(N不大于30000)
输出描述:不大于N的与7有关的数字个数，例如输入20，与7有关的数字包括7,14,17.
while True:
try:
n = int(input())
a = 0
for i in range(1,n+1):
if i%7 == 0:
a += 1
elif '7' in str(i):
a += 1
print(a)
except:
break
54-iNOC产品部–完全数计算
完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。
它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。
例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。
给定函数count(int n),用于计算n以内(含n)完全数的个数。计算范围, 0 < n <= 500000
返回n以内完全数的个数。 异常情况返回-1
/**
*
*完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。
*它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。
*例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。
*给定函数count(int n),用于计算n以内(含n)完全数的个数
* @param n 计算范围, 0 < n <= 500000
* @return n 以内完全数的个数, 异常情况返回-1
*/
public static int count( int n)
输入描述:输入一个数字
输出描述:输出完全数的个数
#coding: utf-8
while True:
try:
a=int(input())
print(len(list(filter(lambda x: x < a, [6, 28, 496, 8128]))))
except:
break
55-无线OSS－高精度整数加法
在计算机中，由于处理器位宽限制，只能处理有限精度的十进制整数加减法，比如在32位宽处理器计算机中，
参与运算的操作数和结果必须在-231~231-1之间。如果需要进行更大范围的十进制整数加法，需要使用特殊
的方式实现，比如使用字符串保存操作数和结果，采取逐位运算的方式。如下：
9876543210 + 1234567890 = ?
让字符串 num1=“9876543210”，字符串 num2=“1234567890”，结果保存在字符串 result = “11111111100”。
-9876543210 + (-1234567890) = ?
让字符串 num1="-9876543210"，字符串 num2="-1234567890"，结果保存在字符串 result = “-11111111100”。
要求编程实现上述高精度的十进制加法。
要求实现方法：
public String add (String num1, String num2)
【输入】num1：字符串形式操作数1，如果操作数为负，则num1的前缀为符号位’-’
num2：字符串形式操作数2，如果操作数为负，则num2的前缀为符号位’-’
【返回】保存加法计算结果字符串，如果结果为负，则字符串的前缀为’-’
注：
(1)当输入为正数时，’+‘不会出现在输入字符串中；当输入为负数时，’-‘会出现在输入字符串中，且一定在输入字符串最左边位置；
(2)输入字符串所有位均代表有效数字，即不存在由’0’开始的输入字符串，比如"0012", "-0012"不会出现；
(3)要求输出字符串所有位均为有效数字，结果为正或0时’+‘不出现在输出字符串，结果为负时输出字符串最左边位置为’-’。
输入描述:输入两个字符串
输出描述:输出给求和后的结果
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
while True:
try:
print(int(input())+int(input()))
except:
break
56-输入n个整数，输出其中最小的k个
输入n个整数，输出其中最小的k个。
详细描述：
接口说明
原型：
bool GetMinK(unsignedint uiInputNum, int * pInputArray, unsignedint uiK, int * pOutputArray);
输入参数：
unsignedint uiInputNum //输入整数个数
int * pInputArray //输入整数数组
unsignedint uiK //需输出uiK个整数
输出参数（指针指向的内存区域保证有效）：
int * pOutputArray //最小的uiK个整数
返回值：
false 异常失败
true 输出成功
输入描述:输入说明 1 输入两个整数 2 输入一个整数数组
输出描述:输出一个整数数组
while True:
try:
k=int(input().split()[1])
array=list(map(int,input().split()))
print(' '.join(map(str,sorted(array)[:k])))
except:
break
57-找出字符串中第一个只出现一次的字符(题面已经更新)
找出字符串中第一个只出现一次的字符
输入描述:输入一个非空字符串
输出描述:输出第一个只出现一次的字符，如果不存在输出-1
while True:
try:
res = input()
count = []
for i in res:
if res.count(i) ==1:
count.append(i)
if count:
print(count[0])
else:
print(-1)
except:
break
58-查找组成一个偶数最接近的两个素数
任意一个偶数（大于2）都可以由2个素数组成，组成偶数的2个素数有很多种情况，本题目要求输出组成指定偶数的两个素数差值最小的素数对
输入描述:输入一个偶数
输出描述:输出两个素数
def func(n):
def judge(number):
for i in range(2, number // 2 + 1):
if number % i == 0:
return False
return True
res = []
if n == 4:
res = [2, 2]
else:
for i in range(n // 2, n):
if judge(i) and judge(n - i):
res = [n - i, i]
break
return res
while True:
try:
N = int(input())
res = func(N)
for i in res:
print(i)
except:
break
59-放苹果
把M个同样的苹果放在N个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？（用K表示）5，1，1和1，5，1 是同一种分法。
输入
每个用例包含二个整数M和N。0<=m<=10，1<=n<=10。
样例输入
7 3
样例输出
8
/**
\* 计算放苹果方法数目
\* 输入值非法时返回-1
\* 1 <= m,n <= 10
\* @param m 苹果数目
\* @param n 盘子数目数
\* @return 放置方法总数
*
*/
public static int count(int m, int n)
输入描述:输入两个int整数
输出描述:输出结果，int型
def func(m,n):
if m == 0 or n == 1:
return 1
if n > m:
return func(m,m)
else:
return func(m,n-1) + func(m-n,n)
while True:
try:
a = list(map(int,input().split()))
print(func(a[0],a[1]))
except:
break
60-查找输入整数二进制中1的个数
请实现如下接口
public static int findNumberOf1( int num)
{
/* 请实现 */
return 0;
} 譬如：输入5 ，5的二进制为101，输出2
输入描述:输入一个整数
输出描述:计算整数二进制中1的个数
while True:
try:
n=int(input())
sbit=bin(n)
print(sbit.count('1'))
except:
break
61-DNA序列
一个DNA序列由A/C/G/T四个字母的排列组合组成。G和C的比例（定义为GC-Ratio）是序列中G和C两个字母的总的出现次数除以总的字母数目（也就是序列长度）。在基因工程中，这个比例非常重要。因为高的GC-Ratio可能是基因的起始点。
给定一个很长的DNA序列，以及要求的最小子序列长度，研究人员经常会需要在其中找出GC-Ratio最高的子序列。
输入描述:输入一个string型基因序列，和int型子串的长度
输出描述:找出GC比例最高的子串,如果有多个输出第一个的子串
a = input()
n = int(input())
m = len(a)
res = 0
re = []
for i in range(m - n + 1):
buff = a[i:i+n].count("G")+a[i:i+n].count("C")
if res < buff:
res = buff
re = a[i:i+n]
print(re)
62-MP3光标位置
MP3 Player因为屏幕较小，显示歌曲列表的时候每屏只能显示几首歌曲，用户要通过上下键才能浏览所有的歌曲。为了简化处理，假设每屏只能显示4首歌曲，光标初始的位置为第1首歌。
现在要实现通过上下键控制光标移动来浏览歌曲列表，控制逻辑如下：
- 歌曲总数<=4的时候，不需要翻页，只是挪动光标位置。
光标在第一首歌曲上时，按Up键光标挪到最后一首歌曲；光标在最后一首歌曲时，按Down键光标挪到第一首歌曲。
其他情况下用户按Up键，光标挪到上一首歌曲；用户按Down键，光标挪到下一首歌曲。
- 歌曲总数大于4的时候（以一共有10首歌为例）：
特殊翻页：屏幕显示的是第一页（即显示第1 – 4首）时，光标在第一首歌曲上，用户按Up键后，屏幕要显示最后一页（即显示第7-10首歌），同时光标放到最后一首歌上。同样的，屏幕显示最后一页时，光标在最后一首歌曲上，用户按Down键，屏幕要显示第一页，光标挪到第一首歌上。
一般翻页：屏幕显示的不是第一页时，光标在当前屏幕显示的第一首歌曲时，用户按Up键后，屏幕从当前歌曲的上一首开始显示，光标也挪到上一首歌曲。光标当前屏幕的最后一首歌时的Down键处理也类似。
其他情况，不用翻页，只是挪动光标就行。
输入描述:
输入说明：
1 输入歌曲数量
2 输入命令 U或者D
输出描述:
输出说明
1 输出当前列表
2 输出当前选中歌曲
while True:
try:
num=int(input())
command=input()
head,tail,i =1,4,1
if(num<=4):
for ci in command:
if (ci=='U'):
if i==1:
i=num
else:
i-=1
else:
if i==num:
i=1
else:
i+=1
head,tail=1,num
else:
for ci in command:
if (ci=='U'):
if i==1:
i=num
head,tail=num-3,num
else:
i-=1
if i<head:
head,tail=i,i+3
else:
if i==num:
i=1
head,tail=1,4
else:
i+=1
if i>tail:
head,tail=i-3,i
ans=list(range(head,tail+1))
print(' '.join(str(j) for j in ans))
print(i)
except:
break
63-查找两个字符串a,b中的最长公共子串
查找两个字符串a,b中的最长公共子串。若有多个，输出在较短串中最先出现的那个。
输入描述:输入两个字符串
输出描述:返回重复出现的字符
while True:
try:
str1=input()
str2=input()
n = 0
s = ''
if len(str1)>len(str2):
str1,str2 = str2, str1
for i in range(len(str1)+1):
if str1[i-n:i] in str2:
s = str1[i-n:i]
n +=1
print(s)
except:
break
64-配置文件恢复
有6条配置命令，它们执行的结果分别是：
| 命 令 | 执 行 |
|---|---|
| reset | reset what |
| reset board | board fault |
| board add | where to add |
| board delet | no board at all |
| reboot backplane | impossible |
| backplane abort | install first |
| he he | unkown command |
注意：he he不是命令。
为了简化输入，方便用户，以“最短唯一匹配原则”匹配：
1、若只输入一字串，则只匹配一个关键字的命令行。例如输入：r，根据该规则，匹配命令reset，执行结果为：reset what；输入：res，根据该规则，匹配命令reset，执行结果为：reset what；
2、若只输入一字串，但本条命令有两个关键字，则匹配失败。例如输入：reb，可以找到命令reboot backpalne，但是该命令有两个关键词，所有匹配失败，执行结果为：unkown command
3、若输入两字串，则先匹配第一关键字，如果有匹配但不唯一，继续匹配第二关键字，如果仍不唯一，匹配失败。例如输入：r b，找到匹配命令reset board 和 reboot backplane，执行结果为：unknown command。
4、若输入两字串，则先匹配第一关键字，如果有匹配但不唯一，继续匹配第二关键字，如果唯一，匹配成功。例如输入：b a，无法确定是命令board add还是backplane abort，匹配失败。
5、若输入两字串，第一关键字匹配成功，则匹配第二关键字，若无匹配，失败。例如输入：bo a，确定是命令board add，匹配成功。
6、若匹配失败，打印“unkown command”
输入描述:多行字符串，每行字符串一条命令
输出描述:执行结果，每条命令输出一行
lst1 = 'reset,reset board,board add,board delet,reboot backplane,backplane abort'.split(',')
lst2 = 'reset what,board fault,where to add,no board at all,impossible,install first'.split(',')
while True:
try:
s = input()
if s in lst1:
index = lst1.index(s)
print(lst2[index])
else:
print('unkown command')
except:
break
65-24点游戏算法
给出4个1-10的数字，通过加减乘除，得到数字为24就算胜利
输入：
4个1-10的数字。[数字允许重复，但每个数字仅允许使用一次，测试用例保证无异常数字]
输出：
true or false
输入描述:输入4个int整数
输出描述:返回能否得到24点，能输出true，不能输出false
def f(res,n):
x = False
if len(n) == 1:
if n[0] ==res:
return True
else:
return False
for i in range(len(n)):
a = n[i]
b = n[:]
b.remove(a)
x = x or f(res-a,b) or f(res*a,b) or f(res/a,b) or f(res+a,b)
return x
while True:
try:
n = input().split()
flag = False
if len(n) != 4:
print('false')
break
for i in range(4):
n[i] = float(n[i])
if f(24.0, n):
print('true')
else:
print('false')
except:
break
66-成绩排序
查找和排序
题目：输入任意（用户，成绩）序列，可以获得成绩从高到低或从低到高的排列,相同成绩都按先录入排列在前的规则处理。
例示：
jack 70
peter 96
Tom 70
smith 67
从高到低 成绩
peter 96
jack 70
Tom 70
smith 67
从低到高
smith 67
Tom 70
jack 70
peter 96
输入描述:输入多行，先输入要排序的人的个数，然后分别输入他们的名字和成绩，以一个空格隔开
输出描述:按照指定方式输出名字和成绩，名字和成绩之间以一个空格隔开
import sys
while True:
try:
num=int(sys.stdin.readline().strip())#人数
flag=int(sys.stdin.readline().strip())#正序
value_list=[]
for i in range(0,num):
item=[each for each in sys.stdin.readline().strip().split()]
item[1]=int(item[1])
value_list.append(item)
if flag==0:
sortlist=sorted(value_list,key=lambda x:x[1],reverse=True)
else:sortlist=sorted(value_list,key=lambda x:x[1],reverse=False)
for each in sortlist:
print (str(each[0])+' '+str(each[1]))
except:
# print e.message
break
67-矩阵乘法
如果A是个x行y列的矩阵，B是个y行z列的矩阵，把A和B相乘，其结果将是另一个x行z列的矩阵C。这个矩阵的每个元素是由下面的公式决定的
输入描述:
输入包含多组数据，每组数据包含：
第一行包含一个正整数x，代表第一个矩阵的行数
第二行包含一个正整数y，代表第一个矩阵的列数和第二个矩阵的行数
第三行包含一个正整数z，代表第二个矩阵的列数
之后x行，每行y个整数，代表第一个矩阵的值
之后y行，每行z个整数，代表第二个矩阵的值
输出描述:对于每组输入数据，输出x行，每行z个整数，代表两个矩阵相乘的结果
while True:
try:
row1 = int(input())
row2 = int(input())
col2 = int(input())
matrix1 = []
matrix2 = []
b = []
def muti(s1,s2):
add = 0
for i in range(len(s1)):
add += s1[i] * s2[i]
return add
for i in range(row1):
# s1=input().split(' ')
#line = list(map(int, input().split(' ')))
line=[int(x) for x in input().split()]
matrix1.append(line)
for i in range(row2):
#line = list(map(int, input().split(' ')))
line=[int(x) for x in input().split()]
matrix2.append(line)
for i in range(col2):
a = []
for j in range(row2):
a.append(matrix2[j][i])
b.append(a)
for i in range(row1):
c = []
for j in range(col2):
c.append(muti(matrix1[i],b[j]))
c=list(map(str,c))
print(' '.join(c))
#for j in range(col2 - 1):
#print(muti(matrix1[i], b[j]), end=' ')
#print(muti(matrix1[i], b[-1]))
except:
break
68-矩阵乘法计算量估算
矩阵乘法的运算量与矩阵乘法的顺序强相关。
例如：
A是一个50×10的矩阵，B是10×20的矩阵，C是20×5的矩阵
计算ABC有两种顺序：（（AB）C）或者（A（BC）），前者需要计算15000次乘法，后者只需要3500次。
编写程序计算不同的计算顺序需要进行的乘法次数
输入描述:输入多行，先输入要计算乘法的矩阵个数n，每个矩阵的行数，列数，总共2n的数，最后输入要计算的法则
输出描述:输出需要进行的乘法次数
while True:
try:
n=int(input())
arr=[]
stack=[]
result=0
for i in range(n):
arr.append(list(map(int,input().split())))
p=input()
for i in range(3*n-2):
if p[i]=='(':
pass
elif p[i]==')':
a=stack.pop()
b=stack.pop()
result=result+b[1]*a[1]*b[0]
stack.append([b[0],a[1]])
else:
stack.append(arr[ord(p[i])-65])
print(result)
except:
break
69-字符串通配符
在计算机中，通配符一种特殊语法，广泛应用于文件搜索、数据库、正则表达式等领域。现要求各位实现字符串通配符的算法。
要求：
实现如下2个通配符：
*：匹配0个或以上的字符（字符由英文字母和数字0-9组成，不区分大小写。下同）
？：匹配1个字符
输入：
通配符表达式；
一组字符串。
输出：
返回匹配的结果，正确输出true，错误输出false
输入描述:先输入一个带有通配符的字符串，再输入一个需要匹配的字符串
输出描述:返回匹配的结果，正确输出true，错误输出false
while True:
try:
a=input()
b=input()
x=0
y=0
k=1
while x<len(a)-1 and y<len(b)-1:
if a[x]==b[y] or a[x]=='?':
x+=1
y+=1
elif a[x]=='*':
if a[x+1]==b[y+1] or a[x+1]==False or b[x+1]==False:
x+=1
y+=1
else:y+=1
else:
k=0
break
if k==1:
print('true')
else:
print('false')
except:
break
70-百钱买百鸡问题
公元前五世纪，我国古代数学家张丘建在《算经》一书中提出了“百鸡问题”：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
详细描述：
接口说明
原型：
int GetResult(vector &list)
输入参数：
无
输出参数（指针指向的内存区域保证有效）：
list 鸡翁、鸡母、鸡雏组合的列表
返回值：
-1 失败
0 成功
输入描述:输入任何一个整数，即可运行程序。
输出描述:输出鸡翁、鸡母、鸡雏组合的列表
def main():
a = input()
print("0 25 75")
print("4 18 78")
print("8 11 81")
print("12 4 84")
if __name__ == "__main__":
while True:
try:
main()
except:
break
71-计算日期到天数转换
根据输入的日期，计算是这一年的第几天。。
详细描述：
输入某年某月某日，判断这一天是这一年的第几天？。
接口设计及说明：
/*****************************************************************************
Description : 数据转换
Input Param : year 输入年份
Month 输入月份
Day 输入天
Output Param :
Return Value : 成功返回0，失败返回-1（如：数据错误）
*****************************************************************************/
public static int iConverDateToDay(int year, int month, int day)
{
/* 在这里实现功能，将结果填入输入数组中*/
return 0;
}
/*****************************************************************************
Description :
Input Param :
Output Param :
Return Value : 成功:返回outDay输出计算后的第几天;
失败:返回-1
*****************************************************************************/
public static int getOutDay()
{
return 0;
}
输入描述:输入三行，分别是年，月，日
输出描述:成功:返回outDay输出计算后的第几天; 失败:返回-1
while True:
try:
[year, month, day] = [int(i) for i in input().split()]
monthday = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
days = sum(monthday[:month - 1]) + day
if month > 2 and year % 4 == 0 or year % 400 == 0 and year % 100 != 0:
days += 1
print(days)
except:
break
72-参数解析
在命令行输入如下命令：
xcopy /s c:\ d:\，
各个参数如下：
参数1：命令字xcopy
参数2：字符串/s
参数3：字符串c:\
参数4: 字符串d:\
请编写一个参数解析程序，实现将命令行各个参数解析出来。
解析规则：
1.参数分隔符为空格
2.对于用“”包含起来的参数，如果中间有空格，不能解析为多个参数。比如在命令行输入xcopy /s “C:\program files” “d:\”时，参数仍然是4个，第3个参数应该是字符串C:\program files，而不是C:\program，注意输出参数时，需要将“”去掉，引号不存在嵌套情况。
3.参数不定长
4.输入由用例保证，不会出现不符合要求的输入
输入描述:输入一行字符串，可以有空格
输出描述:输出参数个数，分解后的参数，每个参数都独占一行
inp=input().split(' ')
print(len(inp))
for i in inp:
print (i)
73-公共字串计算
计算两个字符串的最大公共字串的长度，字符不区分大小写
详细描述：
接口说明
原型：
int getCommonStrLength(char * pFirstStr, char * pSecondStr);
输入参数：
char * pFirstStr //第一个字符串
char * pSecondStr//第二个字符串
输入描述:输入两个字符串
输出描述:输出一个整数
while True:
try:
a = str(input())
b = str(input())
n = 0
for i in range(len(a)):
if a[i-n:i+1] in b:
n += 1
print(n)
except:
break
74-尼科彻斯定理
验证尼科彻斯定理，即：任何一个整数m的立方都可以写成m个连续奇数之和。
例如：
1^3=1
2^3=3+5
3^3=7+9+11
4^3=13+15+17+19
接口说明
原型：
/*
功能: 验证尼科彻斯定理，即：任何一个整数m的立方都可以写成m个连续奇数之和。
原型：
int GetSequeOddNum(int m,char * pcSequeOddNum);
输入参数：
int m：整数(取值范围：1～100)
返回值：
m个连续奇数(格式：“7+9+11”);
*/
public String GetSequeOddNum(int m)
{
/*在这里实现功能*/
return null;
}
输入描述:输入一个int整数
输出描述:输出分解后的string
while True:
try:
N = int(input())
a = int(N ** 2 - N + 1)
lst = [str(a)]
for i in range(1, N):
lst.append(str(a + 2 * i))
print('+'.join(lst))
except:
break
75-火车进站
给定一个正整数N代表火车数量，0<N<10，接下来输入火车入站的序列，一共N辆火车，每辆火车以数字1-9编号。要求以字典序排序输出火车出站的***。
输入描述:有多组测试用例，每一组第一行输入一个正整数N（0<N<10），第二行包括N个正整数，范围为1到9。
输出描述:输出以字典序从小到大排序的火车出站***，每个编号以空格隔开，每个输出序列换行，具体见sample。
def handle(pre_station, in_station, after_station):
if not pre_station and not in_station: # 所有车均已出栈
result.append(" ".join(after_station))
else:
if in_station: # 先出栈
after_station.append(in_station.pop())
handle(pre_station,in_station,after_station)
in_station.append(after_station.pop())
if pre_station: # 再入栈
in_station.append(pre_station.pop(0))
handle(pre_station,in_station,after_station)
pre_station.insert(0,in_station.pop())
return result
number=int(input())
pre_station=[a for a in input().split()]
result=[]
handle(pre_station,[],[])
result.sort()
for item in result:
print(item)
76-超长正整数相加
请设计一个算法完成两个超长正整数的加法。
接口说明
/*
请设计一个算法完成两个超长正整数的加法。
输入参数：
String addend：加数
String augend：被加数
返回值：加法结果
*/
public String AddLongInteger(String addend, String augend)
{
/*在这里实现功能*/
return null;
}
输入描述:输入两个字符串数字
输出描述:输出相加后的结果，string型
while True:
try:
print(str(int(input())+int(input())))
except:
break
77-计算字符串的相似度
对于不同的字符串，我们希望能有办法判断相似程度，我们定义了一套操作方法来把两个不相同的字符串变得相同，具体的操作方法如下：
1 修改一个字符，如把“a”替换为“b”。
2 增加一个字符，如把“abdd”变为“aebdd”。
3 删除一个字符，如把“travelling”变为“traveling”。
比如，对于“abcdefg”和“abcdef”两个字符串来说，我们认为可以通过增加和减少一个“g”的方式来达到目的。上面的两种方案，都只需要一次操作。把这个操作所需要的次数定义为两个字符串的距离，而相似度等于“距离＋1”的倒数。也就是说，“abcdefg”和“abcdef”的距离为1，相似度为1/2=0.5.
给定任意两个字符串，你是否能写出一个算法来计算出它们的相似度呢？
请实现如下接口
/* 功能：计算字符串的相似度
\* 输入：pucAExpression/ pucBExpression：字符串格式，如: "abcdef"
\* 返回：字符串的相似度,相似度等于“距离＋1”的倒数,结果请用1/字符串的形式,如1/2
*/
public static String calculateStringDistance(String expressionA, String expressionB)
{
/* 请实现*/
return null;
}
约束：
1、PucAExpression/ PucBExpression字符串中的有效字符包括26个小写字母。
2、PucAExpression/ PucBExpression算术表达式的有效性由调用者保证;
3、超过result范围导致信息无法正确表达的，返回null。
输入描述:输入两个字符串
输出描述:输出相似度，string类型
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:
a = input()
b = input()
print('1/' + str(editDistance(a,b)+1))
except:
break
78-整形数组合并
将两个整型数组按照升序合并，并且过滤掉重复数组元素[注: 题目更新了。输出之后有换行]
详细描述：
接口说明
原型：
voidCombineBySort(int* pArray1,intiArray1Num,int* pArray2,intiArray2Num,int* pOutputArray,int* iOutputNum);
输入参数：
int* pArray1 ：整型数组1
intiArray1Num：数组1元素个数
int* pArray2 ：整型数组2
intiArray2Num：数组2元素个数
输出参数（指针指向的内存区域保证有效）：
int* pOutputArray：合并后的数组
int* iOutputNum：合并后数组元素个数
返回值：
void
输入描述:
输入说明，按下列顺序输入：1 输入第一个数组的个数
2 输入第一个数组的数值
3 输入第二个数组的个数
4 输入第二个数组的数值
输出描述:输出合并之后的数组
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
79-字符串匹配
判断短字符串中的所有字符是否在长字符串中全部出现
详细描述：
接口说明
原型：
boolIsAllCharExist(char* pShortString,char* pLongString);
输入参数：
char* pShortString：短字符串
char* pLongString：长字符串
输入描述:输入两个字符串。第一个为短字符，第二个为长字符。
输出描述:返回值：true或false
while True:
try:
a,b=set(input()),set(input())
print ("true" if a&b==a else "false")
except:
break
80-将真分数分解为埃及分数
分子为1的分数称为埃及分数。现输入一个真分数(分子比分母小的分数，叫做真分数)，请将该分数分解为埃及分数。如：8/11 = 1/2+1/5+1/55+1/110。
接口说明
/*
功能: 将分数分解为埃及分数序列
输入参数：
String pcRealFraction:真分数(格式“8/11”)
返回值：
String pcEgpytFraction:分解后的埃及分数序列(格式“1/2+1/5+1/55+1/100”)
*/
public static String ConvertRealFractToEgpytFract(String pcRealFraction)
{
return null;
}
输入描述:输入一个真分数，String型
输出描述:输出分解后的string
while True:
try:
a = input().split('/')
up = int(a[0])
down = int(a[1])
res = ''
while up != 1:
if down%(up-1) == 0:
res = res + '1/' + str(down//(up-1)) + '+'
up = 1
else:
q = down//up
res = res + '1/'+ str(q+1) + '+'
up = up - down%up
down = down*(q+1)
if down%up == 0:
down = down//up
up = 1
res = res + '1/' + str(down)
print(res)
except:
break
81-二维数组操作
有一个数据表格为二维数组（数组元素为int类型），行长度为ROW_LENGTH,列长度为COLUMN_LENGTH。对该表格中数据的操作可以在单个单元内，也可以对一个整行或整列进行操作，操作包括交换两个单元中的数据；插入某些行或列。
请编写程序，实现对表格的各种操作，并跟踪表格中数据在进行各种操作时，初始数据在表格中位置的变化轨迹。
详细要求:
1.数据表规格的表示方式为“行*列”, 数据表元素的位置表示方式为[行,列]，行列均从0开始编号
2.数据表的最大规格为9行*9列，对表格进行操作时遇到超出规格应该返回错误
3.插入操作时，对m*n表格，插入行号只允许0m，插入列号只允许0n。超出范围应该返回错误
4.只需记录初始表格中数据的变化轨迹，查询超出初始表格的数据应返回错误
例如: 初始表格为44，可查询的元素范围为[0,0]~[3,3]，假设插入了第2行，数组变为54，查询元素[4,0]时应该返回错误
5.查询数据要求返回一个链表，链表中节点的顺序即为该查询的数据在表格中的位置变化顺序（需包含初始位置）
输入描述:输入数据按下列顺序输入：
1 表格的行列值
2 要交换的两个单元格的行列值
3 输入要插入的行的数值
4 输入要插入的列的数值
5 输入要获取运动轨迹的单元格的值
输出描述:输出按下列顺序输出：
1 初始化表格是否成功，若成功则返回0， 否则返回-1
2 输出交换单元格是否成功
3 输出插入行是否成功
4 输出插入列是否成功
5 输出要查询的运动轨迹的单元查询是否成功
while True:
try:
m,n=list(map(int,input().split()))
exchange=list(map(int,input().split()))
insertrow=int(input())
insertcol=int(input())
trace=list(map(int,input().split()))
res=[]
if 0<=m<=9 and 0<=n<=9:
res.append(0)
else:
res.append(-1)
if 0<=exchange[0]<=m-1 and 0<=exchange[1]<=n-1 and 0<=exchange[2]<=m-1 and 0<=exchange[3]<=n-1:
res.append(0)
else:
res.append(-1)
if 0<=insertrow<=m-1:
res.append(0)
else:
res.append(-1)
if 0<=insertcol<=n-1:
res.append(0)
else:
res.append(-1)
if 0<=trace[0]<=m-1 and 0<=trace[1]<=n-1:
res.append(0)
else:
res.append(-1)
for i in res:
print(i)
except:
break
82-统计大写字母个数
找出给定字符串中大写字符(即’A’-‘Z’)的个数
接口说明
原型：int CalcCapital(String str);
返回值：int
输入描述:输入一个String数据
输出描述:输出string中大写字母的个数
import sys
while True:
try:
s = input()
count = 0
for x in s:
if 'A'<=x<='Z':
count+=1
print(count)
except:
sys.exit()
83-字符串运用-密码截取
Catcher 是MCA国的情报员，他工作时发现敌国会用一些对称的密码进行通信，比如像这些ABBA，ABA，A，123321，但是他们有时会在开始或结束时加入一些无关的字符以防止别国**。比如进行下列变化 ABBA->12ABBA,ABA->ABAKK,123321->51233214 。因为截获的串太长了，而且存在多种可能的情况（abaaab可看作是aba,或baaab的加密形式），Cathcer的工作量实在是太大了，他只能向电脑高手求助，你能帮Catcher找出最长的有效密码串吗？
（注意：记得加上while处理多个测试用例）
输入描述:输入一个字符串
输出描述:返回有效密码串的最大长度
def get_count(str_in):
if str_in == str_in[::-1]:
return len(str_in)
count = 0
for ii in range(0, len(str_in)-1):
if(ii-count-1>=0 and str_in[ii-count-1:ii+1] == str_in[ii-count-1:ii+1][::-1]):
count += 2
if(ii-count>=0 and str_in[ii-count:ii+1] == str_in[ii-count:ii+1][::-1]):
count += 1
return count
while True:
try:
str_in = input().strip()
if str_in:
print(get_count(str_in))
except Exception as e:
#print(e)
break
84-求最大连续bit数
功能: 求一个byte数字对应的二进制数字中1的最大连续数，例如3的二进制为00000011，最大连续2个1
输入: 一个byte型的数字
输出: 无
返回: 对应的二进制数字中1的最大连续数
输入描述:输入一个byte数字
输出描述:输出转成二进制之后连续1的个数
while True:
try:
num = bin(int(input()))[2:]#因为前面会有0b代表二进制
n = num.split("0")
length = 0
for i in n:
if len(i) > length:
length = len(i)
print(length)
#print(num)
except:
break
85-密码强度等级
密码按如下规则进行计分，并根据不同的得分为密码进行安全等级划分。
一、密码长度:
5 分: 小于等于4 个字符
10 分: 5 到7 字符
25 分: 大于等于8 个字符
二、字母:
0 分: 没有字母
10 分: 全都是小（大）写字母
20 分: 大小写混合字母
三、数字:
0 分: 没有数字
10 分: 1 个数字
20 分: 大于1 个数字
四、符号:
0 分: 没有符号
10 分: 1 个符号
25 分: 大于1 个符号
五、奖励:
2 分: 字母和数字
3 分: 字母、数字和符号
5 分: 大小写字母、数字和符号
最后的评分标准:
\>= 90: 非常安全
\>= 80: 安全（Secure）
\>= 70: 非常强
\>= 60: 强（Strong）
\>= 50: 一般（Average）
\>= 25: 弱（Weak）
\>= 0: 非常弱
对应输出为：
VERY_WEAK,
WEAK,
AVERAGE,
STRONG,
VERY_STRONG,
SECURE,
VERY_SECURE
请根据输入的密码字符串，进行安全评定。
注：
字母：a-z, A-Z
数字：-9
符号包含如下： (ASCII码表可以在UltraEdit的菜单view->ASCII Table查看)
!"#$%&’()*+,-./ (ASCII码：x21~0x2F)
:;<=>aaa@qq.com (ASCII<=><=><=><=><=>码：x3A~0x40)
[]^_` (ASCII码：x5B~0x60)
{|}~ (ASCII码：x7B~0x7E)
接口描述：
Input Param
String pPasswordStr: 密码，以字符串方式存放。
Return Value
根据规则评定的安全等级。
public static Safelevel GetPwdSecurityLevel(String pPasswordStr)
{
/*在这里实现功能*/
return null;
}
输入描述:输入一个string的密码
输出描述:输出密码等级
while True:
try:
s=input()
res=0
if len(s)<=4:
res+=5
elif 5<=len(s)<=7:
res+=10
else:
res+=25
alpha_list=[]
digit_list = []
symbol_list=[]
for i in s:
if i.isalpha():
alpha_list.append(i)
if i.isdigit():
digit_list.append(i)
else:
symbol_list.append(i)
l=[0,0]
for i in alpha_list:
if ord(i) in range(97,123):
l[0]=1
if ord(i) in range(65,91):
l[1]=1
sum=l[0]+l[1]
if sum==1:
res+=10
if sum==2:
res+=20
if len(digit_list)==1:
res+=10
if len(digit_list)>1:
res+=20
if len(symbol_list)==1:
res+=10
if len(symbol_list)>1:
res+=25
if len(alpha_list)!=0 and len(digit_list)!=0:
res+=2
elif len(alpha_list)!=0 and len(digit_list)!=0 and len(symbol_list)!=0:
res+=3
elif sum==2 and len(digit_list)!=0 and len(symbol_list)!=0:
res+=5
else:
pass
if res>=90:
print('VERY_SECURE')
elif res>=80:
print('SECURE')
elif res>=70:
print('VERY_STRONG')
elif res>=60:
print('STRONG')
elif res>=50:
print('AVERAGE')
elif res>=25:
print('WEAK')
else:
print('VERY_WEAK')
except:
break
86-扑克牌大小
扑克牌游戏大家应该都比较熟悉了，一副牌由54张组成，含3~A、2各4张，小王1张，大王1张。牌面从小到大用如下字符和字符串表示（其中，小写joker表示小王，大写JOKER表示大王）：
3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER
输入两手牌，两手牌之间用"-“连接，每手牌的每张牌以空格分隔，”-"两边没有空格，如：4 4 4 4-joker JOKER。
请比较两手牌大小，输出较大的牌，如果不存在比较关系则输出ERROR。
基本规则：
（1）输入每手牌可能是个子、对子、顺子（连续5张）、三个、炸弹（四个）和对王中的一种，不存在其他情况，由输入保证两手牌都是合法的，顺子已经从小到大排列；
（2）除了炸弹和对王可以和所有牌比较之外，其他类型的牌只能跟相同类型的存在比较关系（如，对子跟对子比较，三个跟三个比较），不考虑拆牌情况（如：将对子拆分成个子）；
（3）大小规则跟大家平时了解的常见规则相同，个子、对子、三个比较牌面大小；顺子比较最小牌大小；炸弹大于前面所有的牌，炸弹之间比较牌面大小；对王是最大的牌；
（4）输入的两手牌不会出现相等的情况。
输入描述:输入两手牌，两手牌之间用"-“连接，每手牌的每张牌以空格分隔，”-"两边没有空格，如 4 4 4 4-joker JOKER。
输出描述:输出两手牌中较大的那手，不含连接符，扑克牌顺序不变，仍以空格隔开；如果不存在比较关系则输出ERROR。
A = '3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER'.split(' ')
while 1:
try:
s = input()
if not s:
break
except:
break
a, b = s.split('-')
w = None
p, q = a.split(' '), b.split(' ')
if len(q) != len(p):
for t in p, q:
if len(t) == 2 and t[0] == 'joker':
w = ' '.join(t)
break
elif len(t) == 4:
w = ' '.join(t)
if not w:
w = 'ERROR'
elif A.index(q[0]) > A.index(p[0]):
w = b
else:
w = a
print (w)
87-合法IP
现在IPV4下用一个32位无符号整数来表示，一般用点分方式来显示，点将IP地址分成4个部分，每个部分为8位，表示成一个无符号整数（因此不需要用正号出现），如10.137.17.1，是我们非常熟悉的IP地址，一个IP地址串中没有空格出现（因为要表示成一个32数字）。
现在需要你用程序来判断IP是否合法。
输入描述:输入一个ip地址
输出描述:返回判断的结果YES or NO
while True:
try:
nums = list(map(int, input().split(".")))
flag = 0
for i in range(len(nums)):
if nums[i] < 0 or nums[i] > 255:
flag = 1
else:
pass
if flag == 0:
print("YES")
else:
print("NO")
except:
break
88-棋盘路径
请编写一个函数（允许增加子函数），计算n x m的棋盘格子（n为横向的格子数，m为竖向的格子数）沿着各自边缘线从左上角走到右下角，总共有多少种走法，要求不能走回头路，即：只能往右和往下走，不能往左和往上走。
输入描述:输入两个正整数
输出描述:返回结果
def run(n, m):
if n == 0 or m == 0:
return 1
else:
return run(n-1, m) + run(n, m-1)
while True:
try:
n, m = map(int, input().split())
print(run(n, m))
except:
break
89-在字符串中找出连续最长的数字串
样例输出
输出123058789，函数返回值9
输出54761，函数返回值5
接口说明
函数原型：
unsignedint Continumax(char** pOutputstr, char* intputstr)
输入参数：
char* intputstr 输入字符串；
输出参数：
char** pOutputstr: 连续最长的数字串，如果连续最长的数字串的长度为0，应该返回空字符串；如果输入字符串是空，也应该返回空字符串；
返回值：
连续最长的数字串的长度
输入描述:输入一个字符串。
输出描述:输出字符串中最长的数字字符串和它的长度。如果有相同长度的串，则要一块儿输出，但是长度还是一串的长度
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
90-数组能否分为两个满足条件的数组
编写一个函数，传入一个int型数组，返回该数组能否分成两组，使得两组中各元素加起来的和相等，并且，所有5的倍数必须在其中一个组中，所有3的倍数在另一个组中（不包括5的倍数），能满足以上条件，返回true；不满足时返回false。
输入描述:第一行是数据个数，第二行是输入的数据
输出描述:返回true或者false
def part_data(data_list):
part1 = list()
part2 = list()
part3 = list()
for data in data_list:
if data % 5 == 0:
part1.append(data)
elif data % 3 == 0:
part2.append(data)
else:
part3.append(data)
diff = sum(part1) - sum(part2)
if (sum(part3) - diff) % 2 != 0:
return False
target = (sum(part3) - diff) / 2
res = search(part3, target)
return res
def search(data_list, target):
if len(data_list) == 1:
return data_list[0] == target
else:
data = data_list.pop()
if data == target:
return True
if search(data_list, target-data):
return True
if search(data_list, target):
return True
data_list.append(data)
while True:
try:
n = int(input().strip())
data_list = list(map(int, input().strip().split()))
res = part_data(data_list)
print('true' if res == True else 'false')
except:
break
91-记票统计
请实现接口：
unsigned int AddCandidate (char* pCandidateName);
功能：设置候选人姓名
输入： char* pCandidateName 候选人姓名
输出：无
返回：输入值非法返回0，已经添加过返回0 ，添加成功返回1
Void Vote(char* pCandidateName);
功能：投票
输入： char* pCandidateName 候选人姓名
输出：无
返回：无
unsigned int GetVoteResult (char* pCandidateName);
功能：获取候选人的票数。如果传入为空指针，返回无效的票数，同时说明本次投票活动结束，释放资源
输入： char* pCandidateName 候选人姓名。当输入一个空指针时，返回无效的票数
输出：无
返回：该候选人获取的票数
void Clear()
// 功能：清除投票结果，释放所有资源
// 输入：
// 输出：无
// 返回
输入描述:输入候选人的人数，第二行输入候选人的名字，第三行输入投票人的人数，第四行输入投票。
输出描述:每行输出候选人的名字和得票数量。
while 1:
try:
num = 0
d = {}
n = int(input())
m = input().split()
rs = int(input())
tp = input().split()
for i in tp:
d.setdefault(i,0)
d[i]=d[i]+1
for j in m:
if j in d.keys():
print(j+" : "+str(d[j]))
else:
print(j+" : 0")
for k in d.keys():
if k not in m:
num = num + int(d[k])
print("Invalid : "+str(num))
except:
break
92-人民币转换
考试题目和要点：
1、中文大写金额数字前应标明“人民币”字样。中文大写金额数字应用壹、贰、叁、肆、伍、陆、柒、捌、玖、拾、佰、仟、万、亿、元、角、分、零、整等字样填写。（30分）
2、中文大写金额数字到“元”为止的，在“元”之后，应写“整字，如￥ 532.00应写成“人民币伍佰叁拾贰元整”。在”角“和”分“后面不写”整字。（30分）
3、阿拉伯数字中间有“0”时，中文大写要写“零”字，阿拉伯数字中间连续有几个“0”时，中文大写金额中间只写一个“零”字，如￥6007.14，应写成“人民币陆仟零柒元壹角肆分“。
输入描述:输入一个double数
输出描述:输出人民币格式
import sys
import io
sys.stdout = io.TextIOWrapper(sys.stdout.buffer,encoding='utf-8')
numberList=['零','壹','贰','叁','肆','伍','陆','柒','捌','玖']
integralUnit=['元','拾','佰','仟','万','拾','佰','仟','亿','拾','佰','仟']
fractionUnit=['角','分']
def solveF(f,res):
# print(res)
if int(f) == 0:
res.append("整")
else:
for i in range(len(f)):
if int(f[i]) !=0:
res.append(numberList[int(f[i])])
# res.append(fractionUnit[int(f[i])])
res.append(fractionUnit[int(i)])
# print(res)
return res
while True:
try:
a = input()
if '.' in a:
a=a.split('.')
else:
a=(a+'.00').split('.')
y=a[0]
f=a[1]
# print(f)
res=['人民币']
y=y[::-1] #反过来
for i in range(len(y))[::-1]: #从i=len(y)-1开始，一直到0
# print(i)
if int(y[i]) == 0:
res.append(numberList[0])
else:
res.append(numberList[int(y[i])])
res.append(integralUnit[i])
# print(res) #有输出
# res = ''.join(res)
res=solveF(f,res)
# print([i for i in range(100)])
# 无输出
res = ''.join(res)
while ('零零' in res):
res=res.replace('零零','零')
res=res.replace('壹拾','拾')
res=res.replace('人民币零','人民币')
print(res)
except:
break
93-表示数字
将一个字符中所有出现的数字前后加上符号“*”，其他字符保持不变
public static String MarkNum(String pInStr)
{
return null;
}
注意：输入数据可能有多行
输入描述:输入一个字符串
输出描述:字符中所有出现的数字前后加上符号“*”，其他字符保持不变
while True:
try:
string = input()
length = len(string)
out = []
if string[0].isdigit():
out.append('*')
for i in range(length):
if string[i].isalpha():
if i>0 and string[i-1].isdigit():
out.append('*')
out.append(string[i])
else:
out.append(string[i])
elif string[i-1].isalpha() and i>0:
out.append('*')
out.append(string[i])
else:
out.append(string[i])
if string[-1].isdigit():
out.append('*')
print(''.join(out))
except:
break
94-记负均正
首先输入要输入的整数个数n，然后输入n个整数。输出为n个整数中负数的个数，和所有正整数的平均值，结果保留一位小数。
输入描述:首先输入一个正整数n，然后输入n个整数。
输出描述:输出负数的个数，和所有正整数的平均值。
while True:
try:
n=int(input())
data_list=map(int,input().split())
num=0
res=0
geshu=0
for i in data_list:
if i>0:
num+=1
res+=i
elif i<0:
geshu+=1
res = res/num
print("%d %.1f"%(geshu,res))
except:
break
95-自动售货系统
1 总体说明
考生需要模拟实现一个简单的自动售货系统，实现投币、购买商品、退币、查询库存商品及存钱盒信息的功能。
系统初始化时自动售货机中商品为6种商品,商品的单价参见1.1规格说明，存钱盒内放置1元、2元、5元、10元钱币，商品数量和钱币张数通过初始化命令设置，参见2.1 系统初始化。
1.1规格说明
\1. 商品:每种商品包含商品名称、单价、数量三种属性，其中商品名不重复。考生不能修改商品名称和单价，初始化命令设置商品数量。这些信息在考试框架中进行定义，考生在实现功能代码时可直接使用。
| 钱币面额 | 张数 |
|---|---|
| 10元 | X |
| 5元 | X |
| 2元 | X |
| 1元 | X |
\3. 退币原则 ：
1) 根据系统存钱盒内钱币的 信息 ，按钱币总张数最少的原则进行退币。
2) 如果因零钱不足导致不能退币，则尽最大可能退币，以减少用户损失。
例如：假设存钱盒内只有4张2元，无其它面额钱币。如果需要退币7元，系统因零钱不足无法退币，则继续尝试退币6元，最终系统成功退币3张2元,用户损失1元钱币。
\4. 投币操作说明：每次投币成功，投入的钱币面额累加到投币余额；同时，本次投入的钱币放入存钱盒中，存钱盒相应面额钱币增加。
\5. 投币余额：指当前自动售货机中用户剩余的可购买商品的钱币总额；例如：投入2元面额的钱币，投币余额增加2元；购买一件价格2元的商品，投币余额减少2元；
\6. 投币余额约束：投币余额不能超过10元。
\7. 退币操作说明：退币操作需要遵守 退币原则 ；退币成功后，投币余额清零，同时扣除存钱盒相应的金额。
\8. 购买商品操作说明：一次仅允许购买一件商品；购买商品成功后，自动售货机中对应商品数量减1，投币余额扣除本次购买商品的价格。
2 操作说明
命令字与第一个参数间使用一个空格分隔，多条命令采用分号隔开。考试系统会对输入命令格式进行处理，考生不需要关注输入命令格式的合法性，只需要实现命令处理函数。
2.1 系统初始化
命令格式：
r A1 数量 -A2 数量 -A3 数量 -A4 数量 -A5 数量 -A6 数量 1 元张数 -2 元张数 -5 元张数 -10 元张数
| 参数名称 | 参数说明 | 类型 | 取值范围 |
|---|---|---|---|
| A1数量 | 商品A1数量 | 整数 | [0,10] |
| A2数量 | 商品A2数量 | 整数 | [0,10] |
| A3数量 | 商品A3数量 | 整数 | [0,10] |
| A4数量 | 商品A4数量 | 整数 | [0,10] |
| A5数量 | 商品A5数量 | 整数 | [0,10] |
| A6数量 | 商品A6数量 | 整数 | [0,10] |
| 1元张数 | 面额1元钱币张数 | 整数 | [0,10] |
| 2元张数 | 面额2元钱币张数 | 整数 | [0,10] |
| 5元张数 | 面额5元钱币张数 | 整数 | [0,10] |
| 10元张数 | 面额10元钱币张数 | 整数 | [0,10] |
商品和各种面额钱币取值范围只是作为初始化命令的限制，其它场景下不限制取值范围；考试框架已经实现取值范围的检查，考生不需要关注。
功能说明：设置自动售货机中商品数量和存钱盒各种面额的钱币张数；
约束说明：系统在任意阶段均可执行r初始化系统；考生不需要关注参数的合法性，不需要关注增加或缺少参数的场景；
输出说明：输出操作成功提示（执行完r命令后系统会自动输出操作结果，考生不需要再次调用输出函数），例：
| 命令 | 输出 | 含义 |
|---|---|---|
| r 6-5-4-3-2-1 4-3-2-1; | S001:Initialization is successful | 初始化成功 |
.2 投币
命令格式：p 钱币面额
功能说明：
（1） 如果投入非1元、2元、5元、10元的钱币面额（钱币面额不考虑负数、字符等非正整数的情况），输出“E002:Denomination error”；
（2） 如果存钱盒中1元和2元面额钱币总额小于本次投入的钱币面额，输出“E003:Change is not enough, pay fail”，但投入1元和2元面额钱币不受此限制。
（3） 如果投币余额大于10元，输出“E004:Pay the balance is beyond the scope biggest”；
（4） 如果自动售货机中商品全部销售完毕，投币失败。输出“E005:All the goods sold out”；
（5） 如果投币成功，输出“S002:Pay success,balance=X”；
约束说明：
（1） 系统在任意阶段都可以投币；
（2） 一次投币只能投一张钱币；
（3） 同等条件下，错误码的优先级：E002 > E003 > E004 > E005；
输出说明：如果投币成功，输出“S002:Pay success,balance=X”。
例：
| 命令 | 输出 |
|---|---|
| p 10; | S002:Pay success,balance=10 |
2.3 购买商品
命令格式：b 商品名称
功能说明：
（1） 如果购买的商品不在商品列表中，输出“E006:Goods does not exist”；
（2） 如果所购买的商品的数量为0，输出“E007:The goods sold out”；
（3） 如果投币余额小于待购买商品价格，输出“E008:Lack of balance”；
（4） 如果购买成功，输出“S003:Buy success,balance=X”；
约束说明：
（1） 一次购买操作仅能购买一件商品，可以多次购买；
（2） 同等条件下，错误码的优先级：E006 > E007 > E008；
输出说明：
如果购买成功，输出“S003:Buy success,balance=X”。
例:
| 命令 | 输出 |
|---|---|
| b A1; | S003:Buy success,balance=8 |
2.4 退币
命令格式：c
功能说明：
（1） 如果投币余额等于0的情况下，输出“E009:Work failure”；
（2） 如果投币余额大于0的情况下，按照 退币原则 进行“找零”，输出退币信息；
约束说明：
（1） 系统在任意阶段都可以退币；
（2） 退币方式必须按照 退币原则 进行退币；
输出说明：如果退币成功，按照 退币原则 输出退币信息。
例，退5元钱币:
| 命令 | 输出 |
|---|---|
| c; | 1 yuan coin number=0 2 yuan coin number=0 5 yuan coin number=1 10 yuan coin number=0 |
2.5 查询
命令格式：q 查询类别
功能说明：
（1） 查询自动售货机中商品信息，包含商品名称、单价、数量。 根据商品数量从大到小进行排序；商品数量相同时，按照商品名称的先后顺序进行排序 。
例如：A1的商品名称先于A2的商品名称，A2的商品名称先于A3的商品名称。
（2） 查询存钱盒信息，包含各种面额钱币的张数；
（3） 查询类别如下表所示:
| 查询类别 | 查询内容 |
|---|---|
| 0 | 查询商品信息 |
| 1 | 查询存钱盒信息 |
如果“查询类别”参数错误，输出“E010:Parameter error”。“查询类别”参数错误时，不进行下面的处理；
输出说明：
“查询类别”为0时，输出自动售货机中所有商品信息（商品名称单价数量）例：
| 命令 | 输出 |
|---|---|
| q 0; | A1 2 6 A2 3 5 A3 4 4 A4 5 3 A5 8 2 A6 6 0 |
“查询类别”为1时，输出存钱盒信息（各种面额钱币的张数），格式固定。例：
| 命令 | 输出 |
|---|---|
| q 1; | 1 yuan coin number=4 2 yuan coin number=3 5 yuan coin number=2 10 yuan coin number=1 |
输入描述:依照说明中的命令码格式输入命令。
输出描述:输出执行结果
import sys
while True:
try:
priceGoods = {'A1':2, 'A2':3, 'A3':4, 'A4':5, 'A5':8, 'A6':6}
priceMoney = [1 , 2 , 5 , 10]
numGoods = {'A1':0, 'A2':0, 'A3':0, 'A4':0, 'A5':0, 'A6':0}
numMoney = [0] * 4
balance = 0
def printMoney(line):
print ('1 yuan coin number=%s' % (line[0]))
print ('2 yuan coin number=%s' % (line[1]))
print ('5 yuan coin number=%s' % (line[2]))
print ('10 yuan coin number=%s' % (line[3]))
def printGoods(priceGoods,numGoods,flag):# 0:sorted goods name;1:sorted num of goods
if flag == 0:
for i in range(6):
good = 'A'+str(i+1)
print (good+' '+str(priceGoods[good])+' '+str(numGoods[good]))
if flag == 1:
#print (numGoods)
numGoodsSorted = sorted(numGoods.items(),key = lambda a:a[1],reverse = True)
for i in range(6):
print (numGoodsSorted[i][0]+' '+str(priceGoods[numGoodsSorted[i][0]])+' '+str(numGoodsSorted[i][1]))
line = input().split(';')[:-1]
for i in line:
func = i.split()
if func[0] == 'r':
func[1] = func[1].split('-')
for i in range(6):
numGoods['A'+str(i+1)] += int(func[1][i])
for i in range(4):
numMoney[i] += int(func[2].split('-')[i]) #1 2 5 10
print ('S001:Initialization is successful')
elif func[0] == 'p':
if int(func[1]) not in priceMoney:
print ('E002:Denomination error')
elif int(func[1]) in [5,10] and numMoney[0] + numMoney[1] * 2 < int(func[1]):
print ('E003:Change is not enough, pay fail')
elif int(func[1]) == 10 and balance > 10:# only print when $10 input
print ('E004:Pay the balance is beyond the scope biggest')
elif numGoods['A1'] == numGoods['A2'] == numGoods['A3'] == numGoods['A4'] == numGoods['A5'] == numGoods['A6'] == 0:
print ('E005:All the goods sold out')
else:
numMoney[priceMoney.index(int(func[1]))] += 1
balance += int(func[1])
print ('S002:Pay success,balance=%d'%(balance))
elif func[0] == 'b':
if func[1] not in ['A1','A2','A3','A4','A5','A6']:
print ('E006:Goods does not exist')
elif numGoods[func[1]] == 0:
print ('E007:The goods sold out')
elif balance < priceGoods[func[1]]:
print ('E008:Lack of balance')
else:
balance -= priceGoods[func[1]]
numGoods[func[1]] -= 1
print ('S003:Buy success,balance=%d'%(balance))
elif func[0] == 'c':
if balance == 0:
sys.stdout.write('E009:Work failure')#no line break
else:
numCall = [0] * 4 #1 2 5 10
for i in range(-1,-5,-1):
numCall[i] = min(balance // priceMoney[i] , numMoney[i])
balance -= numCall[i] * priceMoney[i]
numMoney[i] -= numCall[i]
printMoney(numCall)
balance = 0
elif func[0] == 'q':
if func[1] == '0':
printGoods(priceGoods,numGoods,1)
elif func[1] == '1':
printMoney(numMoney)
else:
sys.stdout.write('E010:Parameter error')#no line break
except:
break
96-自守数
自守数是指一个数的平方的尾数等于该数自身的自然数。例如：25^2 = 625，76^2 = 5776，9376^2 = 87909376。请求出n以内的自守数的个数
接口说明
/*
功能: 求出n以内的自守数的个数
输入参数：
int n
返回值：
n以内自守数的数量。
*/
public static int CalcAutomorphicNumbers( int n)
{
/*在这里实现功能*/
return 0;
}
输入描述:int型整数
输出描述:n以内自守数的数量。
while True:
try:
num = int(input())
count = 0
for i in range(num + 1):
j = str(i ** 2)
k = j[-len(str(i)):]
if str(i) == k:
count += 1
print(count)
except:
break
97-等差数列
功能:等差数列 2，5，8，11，14。。。。
输入:正整数N >0
输出:求等差数列前N项和
返回:转换成功返回 0 ,非法输入与异常返回-1
输入描述:输入一个正整数。
输出描述:输出一个相加后的整数。
while True:
try:
n=eval(input())
num=0
for i in range(n):
num+=2+3*i
print(num)
except:
# print(-1)
break
98-输入整型数组和排序标识，对其元素按照升序或降序进行排序
输入整型数组和排序标识，对其元素按照升序或降序进行排序（一组测试用例可能会有多组数据）
接口说明
原型：
void sortIntegerArray(Integer[] pIntegerArray, int iSortFlag);
输入参数：
Integer[] pIntegerArray：整型数组
int iSortFlag：排序标识：0表示按升序，1表示按降序
输出参数：
无
返回值：
void
输入描述:输入需要输入的整型数个数
输出描述:输出排好序的数字
while True:
try:
a,b,c=input(),map(int,input().split()),input()
print(" ".join(map(str,sorted(b))) if c=="0" else " ".join(map(str,sorted(b,reverse=True))))
except:break
99-字符统计
如果统计的个数相同，则按照ASCII码由小到大排序输出 。如果有其他字符，则对这些字符不用进行统计。
实现以下接口：
输入一个字符串，对字符中的各个英文字符，数字，空格进行统计（可反复调用）
按照统计个数由多到少输出统计结果，如果统计的个数相同，则按照ASII码由小到大排序输出
清空目前的统计结果，重新统计
调用者会保证：
输入的字符串以‘\0’结尾。
输入描述:输入一串字符。
输出描述:对字符中的各个英文字符（大小写分开统计），数字，空格进行统计，并按照统计个数由多到少输出,如果统计的个数相同，则按照ASII码由小到大排序输出 。如果有其他字符，则对这些字符不用进行统计。
while True:
try:
list1=[]
arr = input()
dic = {}
for i in arr:
if not (i.isalpha() or i.isdigit() or i.isspace()):
continue
else:
if i in dic:
dic[i] += 1
else:
dic[i]=1
dic=sorted(dic.items(),key = lambda x:x[0])#先按字符ASC排
dic=sorted(dic,key = lambda x:x[1],reverse=True)#再按统计数目排
print(''.join(k for (k , v) in dic))
except:
break
100-Redraiment的走法
Redraiment是走梅花桩的高手。Redraiment总是起点不限，从前到后，往高的桩子走，但走的步数最多，不知道为什么？你能替Redraiment研究他最多走的步数吗？
样例输入
6
2 5 1 5 4 5
样例输出
3
提示
Example:
6个点的高度各为 2 5 1 5 4 5
如从第1格开始走,最多为3步, 2 4 5
从第2格开始走,最多只有1步,5
而从第3格开始走最多有3步,1 4 5
从第5格开始走最多有2步,4 5
所以这个结果是3。
接口说明
方法原型：
int GetResult(int num, int[] pInput, List pResult);
输入参数：
int num：整数，表示数组元素的个数（保证有效）。
int[] pInput: 数组，存放输入的数字。
输出参数：
List pResult: 保证传入一个空的List，要求把结果放入第一个位置。
返回值：
正确返回1，错误返回0
输入描述:输入多行，先输入数组的个数，再输入相应个数的整数
输出描述:输出结果
import bisect
while True:
try:
a = int(input())
b = map(int,input().split())
c = []
for i in b:
x = bisect.bisect_left(c,i)
if x == len(c):
c.append(i)
else:
c[x] = i
print(len(c))
except:
break
101-字符串分割
连续输入字符串(输出次数为N,字符串长度小于100)，请按长度为8拆分每个字符串后输出到新的字符串数组，
长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
首先输入一个整数，为要输入的字符串个数。
例如：
输入：2
abc
12345789
输出：abc00000
12345678
90000000
接口函数设计如下:
/*****************************************************************************
功能:存储输入的字符创
输入:字符串
输出:无
返回:0表示成功,其它返回-1
******************************************************************************/
int AddString(char *strValue);
/****************************************************************************
功能:获取补位后的二维数组的长度
输入:无
输出:无
返回:二维数组长度
*****************************************************************************/
int GetLength();
/*****************************************************************************
功能:将补位后的二维数组，与输入的二维数组做比较
输入:strInput:输入二维数组,iLen：输入的二维数组的长度
输出:无
返回:若相等,返回0;不相等,返回-1.其它:-1;
******************************************************************************/
int ArrCmp(char strInput[][9],int iLen);
输入描述:首先输入数字n，表示要输入多少个字符串。连续输入字符串(输出次数为N,字符串长度小于100)。
输出描述:按长度为8拆分每个字符串后输出到新的字符串数组，长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
while True:
try:
a = int(input())
for i in range(a):
s = input()
while len(s)>8:
print(s[:8])
s = s[8:]
print(s.ljust(8,'0'))
except:
break
102-记负均正II
从输入任意个整型数，统计其中的负数个数并求所有非负数的平均值
输入描述:输入任意个整数
输出描述:输出负数个数以及所有非负数的平均值
while True:
try:
inlist=list(map(int,input().split()))
fushu=[]
zhengshu=[]
for i in inlist:
if i<0:
fushu.append(i)
else:
zhengshu.append(i)
print(len(fushu))
zhengshu_len=len(zhengshu)
sum=0
if zhengshu_len==0:
print('0.0')
else:
for j in zhengshu:
sum+=j
print(round((sum/zhengshu_len),1 ))
except:
break
103-字符逆序
将一个字符串str的内容颠倒过来，并输出。str的长度不超过100个字符。 如：输入“I am a student”，输出“tneduts a ma I”。
输入参数：
inputString：输入的字符串
返回值：
输出转换好的逆序字符串
输入描述:输入一个字符串，可以有空格
输出描述:输出逆序的字符串
print (input()[::-1])
104-求解立方根
计算一个数字的立方根，不使用库函数
详细描述：
接口说明
原型：
public static double getCubeRoot(double input)
输入:double 待求解参数
返回值:double 输入参数的立方根，保留一位小数
输入描述:待求解参数 double类型
输出描述:输入参数的立方根 也是double类型
def lifang(a):
a=float(a)
return a**(1/3)
b=input()
print('%0.1f'%lifang(b))
105-求最小公倍数
正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。
输入描述:输入两个正整数A和B。
输出描述:输出A和B的最小公倍数。
#coding:utf-8
import sys
while True:
try:
s = sys.stdin.readline().strip()
a = int(s.split()[0])
b = int(s.split()[1])
m=a
n=b
while(a!=b):
if a>b:
a=a-b
else:
b=b-a
print(int(m*n/a))
except Exception:
break
上一篇： sql 语句阶段性总结【多表联合更新】
下一篇： update语句中使用子查询