机试整理（python)_对关键字序列{81,94,11,96,12,35,17,95,28,58,41,75,15}进行手动

华为机试整理（python)

1-字符串最后一个单词的长度

计算字符串最后一个单词的长度，单词以空格隔开。

输入描述:一行字符串，非空，长度小于5000。

输出描述:整数N，最后一个单词的长度。

a=input().split()
print(len(a[-1]) if len(a)>1 else len(a[0]))
1
2
'
运行
运行

2-计算字符个数

写出一个程序，接受一个由字母和数字组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。

输入描述:第一行输入一个有字母和数字以及空格组成的字符串，第二行输入一个字符。

输出描述:输出输入字符串中含有该字符的个数。

a=input().lower()
b=input().lower()
print(a.count(b))
1
2
3

#也可以
import sys
input_str=sys.stdin.readline().strip().lower()
target_char=sys.stdin.readline().strip().lower()
print(input_str.count(target_char))
1
2
3
4
5
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
'
运行
运行

#也可以
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
'
运行
运行

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)
1
2
3
4
5
6
7
8
9
10
11
12
13

#也可以
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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5-进制转换

写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。（多组同时输入 ）

输入描述:输入一个十六进制的数值字符串。

输出描述:输出该数值的十进制字符串。

while True:
    try:
        print(int(input(),16))
    except:
        break
1
2
3
4
5
'
运行
运行

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)
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

#也可以
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)
1
2
3
4
5
6
7
8
9
10
11
12
13
'
运行
运行

7-取近似值

写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。

输入描述:输入一个正浮点数值

输出描述:输出该数值的近似整数值

print(round(float(input())+0.001))
1
'
运行
运行

#也可以
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))
1
2
3
4
5
6
7
8
9
10
11
12
13
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

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)
1
2
3
4
5
6
7
8

9-读取不重复的整数

输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。

输入描述:输入一个int型整数

输出描述:按照从右向左的阅读顺序，返回一个不含重复数字的新的整数

result=""
for i in input()[::-1]:
    if i not in result:
        result+=i
print(result)
1
2
3
4
5
'
运行
运行

#也可以
num = input()
num = num[::-1]
num1 = list(set(num))
num1.sort(key=num.index)
print(''.join(num1))
1
2
3
4
5
6
'
运行
运行

10-字符个数统计

编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)，换行表示结束符，不算在字符里。不在范围内的不作统计。

输入描述:输入N个字符，字符在ACSII码范围内。

输出描述:输出范围在(0~127)字符的个数。

print (len(set([i for i in input() if ord(i) in range(128)])))
1
'
运行
运行

#也可以
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)
1
2
3
4
5
6
7
8
9
10
11
'
运行
运行

11-数字颠倒

描述：

输入一个整数，将这个整数以字符串的形式逆序输出

程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001

输入描述:输入一个int整数

输出描述:将这个整数以字符串的形式逆序输出

print(input()[::-1])
1
'
运行
运行

#也可以
a=input()
s=str(a)
lis=[]
for i in s:
    lis.append(i)
lis.reverse()
 
print(''.join(lis))
1
2
3
4
5
6
7
8
9
'
运行
运行

12-字符串反转

写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。例如：

输入描述:输入N个字符

输出描述:输出该字符串反转后的字符串

print(input()[::-1])
1
'
运行
运行

#也可以
a=input()
s=str(a)
lis=[]
for i in s:
    lis.append(i)
lis.reverse()
print(''.join(lis))
1
2
3
4
5
6
7
8
'
运行
运行

13-句子逆序

将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符

#接口说明

/**
 \* 反转句子
 \* 
 \* @param sentence 原句子
 \* @return 反转后的句子
 */
public String reverse(String sentence);
1
2
3
4
5
6
7
8
9

输入描述:将一个英文语句以单词为单位逆序排放。

输出描述:得到逆序的句子

print(" ".join(input().split()[::-1]))
1
'
运行
运行

#也可以
l = input().split(' ')
print(' '.join(l[::-1]))
1
2
3
'
运行
运行

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)
1
2
3
4
5
6
7

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
1
2
3
4
5
6
7
8
9
10
11
'
运行
运行

15-求int型正整数在内存中存储时1的个数

输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。

输入描述: 输入一个整数（int类型）

输出描述:这个数转换成2进制后，输出1的个数

a=int(input())
print(bin(a).replace("0b","").count("1"))
1
2
'
运行
运行

num = int(input())
print(bin(num).count('1'))
1
2
'
运行
运行

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）
1
2
3
4
5
6
7
8
9
10
11
12
13

输入描述:一行字符串

输出描述:最终坐标，以,分隔

# -*- 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
'
运行
运行

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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

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')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

19-密码验证合格程序

密码要求:
1.长度超过8位
2.包括大小写字母.数字.其它符号,以上四种至少三种
3.不能有相同长度超2的子串重复
说明:长度超过2的子串
1
2
3
4
5

输入描述:

一组或多组长度超过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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
'
运行
运行

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())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
'
运行
运行

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
1
2
3
4
5
6
7
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
'
运行
运行

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，满足条件 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
'
运行
运行

#!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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
'
运行
运行

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个整数
1
2
3

输出描述:求得的“最佳方案”组成“素数伴侣”的对数。

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
'
运行
运行

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个字符。 
1
2
3
4
5
6
7
8
9
10

输入描述:输入说明输入一串要加密的密码输入一串加过密的密码

输出描述:输出说明输出加密后的字符输出解密后的字符

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
'
运行
运行

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)
{
}
1
2
3
4
5
6
7
8
9
10

输入描述:输入两个字符串

输出描述:输出转化后的结果

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
'
运行
运行

30-【中级】单词倒排

对字符串中的所有单词进行倒排。

说明：

1、每个单词是以26个大写或小写英文字母构成；

2、非构成单词的字符均视为单词间隔符；

3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符；

4、每个单词最长20个字母；

输入描述:输入一行以空格来分隔的句子

输出描述:输出句子的逆序

print(" ".join(input().replace("*"," ").replace("#"," ").replace("!"," ").replace("$"," ").split()[::-1]))
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
'
运行
运行

33-图片整理

Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过C语言解决。

输入描述:Lily使用的图片包括"A"到"Z"、“a"到"z”、“0"到"9”。输入字母或数字个数不超过1024。

输出描述:Lily的所有图片按照从小到大的顺序输出

while True:
    try:
        print(''.join(sorted(input())))
    except:
        break
1
2
3
4
5
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输入描述:输入正整数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
1
2
3
4
5
6
7
8
9
10
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11

输入描述:先输入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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
'
运行
运行

36-统计每个月兔子的总数

有一只兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子，假如兔子都不死，问每个月的兔子总数为多少？

  /**
   \* 统计出兔子总数。
   \* 
   \* @param monthCount 第几个月
   \* @return 兔子总数
   */
  public static int getTotalCount(int monthCount)
  {
    return 0;
  }
1
2
3
4
5
6
7
8
9
10

输入描述:输入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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
'
运行
运行

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;
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

输入描述:输入起始高度，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
1
2
3
4
5
6
7
8
9
10
11
'
运行
运行

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;
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

输入描述:输入一行字符串，可以有空格

输出描述:统计其中英文字符，空格字符，数字字符，其他字符的个数

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
'
运行
运行

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])
1
2
3
4
5

输出描述:利用给定的砝码可以称出的不同的重量数

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
'
运行
运行

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) 
1
2
3
4
5
6

输入描述:输入一个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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
'
运行
运行

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

输入描述:输入两个整数，分别表示二位数组的行数，列数。再输入相应的数组，其中的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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
'
运行
运行

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
2
3
4
5
6
7
8
9
10
11
12
13

输入描述:输入说明 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
'
运行
运行

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
5
6
7
8
9
10
11
12
13
14
15
16
17

输入描述: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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'
运行
运行

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按顺序向该数组赋值。不用考虑数组是否越界，测试用例保证
1
2
3
4
5
6
7
8

输入描述:输入一个int整数

输出描述:输出多个ABCD

while True:
    try:
        n = int(input())
        str = 'ABCD'*n
        print(str)
    except:
        break
1
2
3
4
5
6
7
'
运行
运行

48-四则运算

请实现如下接口
  /* 功能：四则运算
   \* 输入：strExpression：字符串格式的算术表达式，如: "3+2*{1+2*[-4/(8-6)+7]}"
  \* 返回：算术表达式的计算结果
   */
  **public** **static** **int** calculate(String strExpression)
  {
/* 请实现*/
 **return** 0;
 } 

约束：
1.pucExpression字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。
2.pucExpression算术表达式的有效性由调用者保证; 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输入描述:输入一个算术表达式

输出描述:得到计算结果

s=input()
print(eval(s))
1
2
'
运行
运行

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
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输入描述:输入说明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
1
2
3
4
5
6
7
8
9
10
11
'
运行
运行

50-计算字符串的距离

Levenshtein 距离，又称编辑距离，指的是两个字符串之间，由一个转换成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。编辑距离的算法是首先由俄国科学家Levenshtein提出的，故又叫Levenshtein Distance。

Ex：

字符串A:abcdefg

字符串B: abcdef

通过增加或是删掉字符”g”的方式达到目的。这两种方案都需要一次操作。把这个操作所需要的次数定义为两个字符串的距离。

要求：

给定任意两个字符串，写出一个算法计算它们的编辑距离。

请实现如下接口
/* 功能：计算两个字符串的距离
 \* 输入： 字符串A和字符串B
 \* 输出：无
 \* 返回：如果成功计算出字符串的距离，否则返回-1
 */
   **public**  **static**  **int** calStringDistance (String charA, String charB)
  {
 **return** 0;
  } 
1
2
3
4
5
6
7
8
9
10

输入描述:输入两个字符串

输出描述:得到计算结果

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
'
运行
运行

52-表达式求值

给定一个字符串描述的算术表达式，计算出结果值。

输入字符串长度不超过100，合法的字符包括”+, -, *, /, (, )”，”0-9”，字符串内容的合法性及表达式语法的合法性由做题者检查。本题目只涉及整型计算。

输入描述:输入算术表达式

输出描述:计算出结果值

while True:
    try:
        a=input();
        print(eval(a))
    except:
        break
1
2
3
4
5
6
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

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)
1
2
3
4
5
6
7
8
9
10

输入描述:输入一个数字

输出描述:输出完全数的个数

#coding: utf-8
while True:
    try:
        a=int(input())
        print(len(list(filter(lambda x: x < a, [6, 28, 496, 8128]))))
  
    except:
        break
1
2
3
4
5
6
7
8
'
运行
运行

55-无线OSS－高精度整数加法

在计算机中，由于处理器位宽限制，只能处理有限精度的十进制整数加减法，比如在32位宽处理器计算机中，
参与运算的操作数和结果必须在-2^31~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
1
2
3
4
5
6
7
8
9
'
运行
运行

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
3
4
5
6
7
8
9
10
11
12
13

输入描述:输入说明 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
1
2
3
4
5
6
7
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
'
运行
运行

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)
1
2
3
4
5
6
7
8
9
10

输入描述:输入两个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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
'
运行
运行

60-查找输入整数二进制中1的个数

请实现如下接口
public  static  int findNumberOf1( int num)
  {
 /* 请实现 */
return 0;
 } 譬如：输入5 ，5的二进制为101，输出2
1
2
3
4
5
6

输入描述:输入一个整数

输出描述:计算整数二进制中1的个数

while True:
    try:
        n=int(input())
        sbit=bin(n)
        print(sbit.count('1'))
    except:
        break
1
2
3
4
5
6
7
'
运行
运行

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)
1
2
3
4
5
6
7
8
9
10
11

62-MP3光标位置

MP3 Player因为屏幕较小，显示歌曲列表的时候每屏只能显示几首歌曲，用户要通过上下键才能浏览所有的歌曲。为了简化处理，假设每屏只能显示4首歌曲，光标初始的位置为第1首歌。

现在要实现通过上下键控制光标移动来浏览歌曲列表，控制逻辑如下：

1. 歌曲总数<=4的时候，不需要翻页，只是挪动光标位置。

光标在第一首歌曲上时，按Up键光标挪到最后一首歌曲；光标在最后一首歌曲时，按Down键光标挪到第一首歌曲。

其他情况下用户按Up键，光标挪到上一首歌曲；用户按Down键，光标挪到下一首歌曲。

2. 歌曲总数大于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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'
运行
运行

64-配置文件恢复

有6条配置命令，它们执行的结果分别是：

注意：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
1
2
3
4
5
6
7
8
9
10
11
12
13
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
'
运行
运行

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 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输入描述:输入多行，先输入要排序的人的个数，然后分别输入他们的名字和成绩，以一个空格隔开

输出描述:按照指定方式输出名字和成绩，名字和成绩之间以一个空格隔开

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
'
运行
运行

70-百钱买百鸡问题

公元前五世纪，我国古代数学家张丘建在《算经》一书中提出了“百鸡问题”：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？

详细描述：
接口说明
原型：
int GetResult(vector &list)
输入参数：
无
输出参数（指针指向的内存区域保证有效）：
  list 鸡翁、鸡母、鸡雏组合的列表
返回值：
   -1 失败   
   0 成功
1
2
3
4
5
6
7
8
9
10
11

输入描述:输入任何一个整数，即可运行程序。

输出描述:输出鸡翁、鸡母、鸡雏组合的列表

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
1
2
3
4
5
6
7
8
9
10
11
12
13
'
运行
运行

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;
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

输入描述:输入三行，分别是年，月，日

输出描述:成功:返回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
1
2
3
4
5
6
7
8
9
10
'
运行
运行

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)
1
2
3
4
'
运行
运行

73-公共字串计算

计算两个字符串的最大公共字串的长度，字符不区分大小写

详细描述：
接口说明
原型：
int getCommonStrLength(char * pFirstStr, char * pSecondStr);
输入参数：
   char * pFirstStr //第一个字符串
   char * pSecondStr//第二个字符串
1
2
3
4
5
6
7

输入描述:输入两个字符串

输出描述:输出一个整数

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
1
2
3
4
5
6
7
8
9
10
11
'
运行
运行

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;
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输入描述:输入一个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
1
2
3
4
5
6
7
8
9
10
'
运行
运行

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

76-超长正整数相加

请设计一个算法完成两个超长正整数的加法。

接口说明
 /*
 请设计一个算法完成两个超长正整数的加法。
 输入参数：
 String addend：加数
 String augend：被加数
 返回值：加法结果
 */
 public String AddLongInteger(String addend, String augend)
 {
   /*在这里实现功能*/
 return null;   
 }
1
2
3
4
5
6
7
8
9
10
11
12
13

输入描述:输入两个字符串数字

输出描述:输出相加后的结果，string型

while True:     
    try:
        print(str(int(input())+int(input())))   
    except:
        break
1
2
3
4
5
'
运行
运行

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
2
3
4
5
6
7
8
9
10
11

约束：

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
'
运行
运行

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
5
6
7
8
9
10
11
12
13
14

输入描述:

输入说明，按下列顺序输入：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
1
2
3
4
5
6
'
运行
运行

79-字符串匹配

判断短字符串中的所有字符是否在长字符串中全部出现

详细描述：
接口说明
原型：
boolIsAllCharExist(char* pShortString,char* pLongString);
输入参数：
  char* pShortString：短字符串
  char* pLongString：长字符串
1
2
3
4
5
6
7

输入描述:输入两个字符串。第一个为短字符，第二个为长字符。

输出描述:返回值：true或false

while True:
    try:
        a,b=set(input()),set(input())
        print ("true" if a&b==a else "false")
    except:
        break
1
2
3
4
5
6
'
运行
运行

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;
 }
1
2
3
4
5
6
7
8
9
10
11
12

输入描述:输入一个真分数，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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
'
运行
运行

81-二维数组操作

有一个数据表格为二维数组（数组元素为int类型），行长度为ROW_LENGTH,列长度为COLUMN_LENGTH。对该表格中数据的操作可以在单个单元内，也可以对一个整行或整列进行操作，操作包括交换两个单元中的数据；插入某些行或列。

请编写程序，实现对表格的各种操作，并跟踪表格中数据在进行各种操作时，初始数据在表格中位置的变化轨迹。

详细要求:

1.数据表规格的表示方式为“行*列”, 数据表元素的位置表示方式为[行,列]，行列均从0开始编号

2.数据表的最大规格为9行*9列，对表格进行操作时遇到超出规格应该返回错误

3.插入操作时，对m*n表格，插入行号只允许0_{m，插入列号只允许0}n。超出范围应该返回错误

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
'
运行
运行

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()
1
2
3
4
5
6
7
8
9
10
11
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

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 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

​ 请根据输入的密码字符串，进行安全评定。

​ 注：

​ 字母：a-z, A-Z

​ 数字：-9

​ 符号包含如下： (ASCII码表可以在UltraEdit的菜单view->ASCII Table查看)

​ !"#$%&'()*+,-./ (ASCII码：x21~0x2F)

​ :;<=>?@ (ASCII<=><=><=><=><=>码：x3A~0x40)

​ []^_` (ASCII码：x5B~0x60)

{|}~ (ASCII码：x7B~0x7E)

接口描述：
 Input Param 
   String pPasswordStr:  密码，以字符串方式存放。
 Return Value
  根据规则评定的安全等级。

 public static Safelevel GetPwdSecurityLevel(String pPasswordStr)
 {
   /*在这里实现功能*/
 return null;
 }
1
2
3
4
5
6
7
8
9
10
11

输入描述:输入一个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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
'
运行
运行

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

89-在字符串中找出连续最长的数字串

样例输出

输出123058789，函数返回值9

输出54761，函数返回值5

接口说明
函数原型：
  unsignedint Continumax(char** pOutputstr, char* intputstr)
输入参数：
  char* intputstr 输入字符串；
输出参数：
  char** pOutputstr: 连续最长的数字串，如果连续最长的数字串的长度为0，应该返回空字符串；如果输入字符串是空，也应该返回空字符串； 
返回值：
 连续最长的数字串的长度
1
2
3
4
5
6
7
8
9

输入描述:输入一个字符串。

输出描述:输出字符串中最长的数字字符串和它的长度。如果有相同长度的串，则要一块儿输出，但是长度还是一串的长度

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
'
运行
运行

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()
// 功能：清除投票结果，释放所有资源
// 输入：
// 输出：无
// 返回
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

输入描述:输入候选人的人数，第二行输入候选人的名字，第三行输入投票人的人数，第四行输入投票。

输出描述:每行输出候选人的名字和得票数量。

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
'
运行
运行

93-表示数字

将一个字符中所有出现的数字前后加上符号“*”，其他字符保持不变
public static String MarkNum(String pInStr)
{
return null;
}
注意：输入数据可能有多行
1
2
3
4
5
6

输入描述:输入一个字符串

输出描述:字符中所有出现的数字前后加上符号“*”，其他字符保持不变

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
'
运行
运行

95-自动售货系统

1 总体说明

考生需要模拟实现一个简单的自动售货系统，实现投币、购买商品、退币、查询库存商品及存钱盒信息的功能。

系统初始化时自动售货机中商品为6种商品,商品的单价参见1.1规格说明，存钱盒内放置1元、2元、5元、10元钱币，商品数量和钱币张数通过初始化命令设置，参见2.1 系统初始化。

1.1规格说明

\1. 商品:每种商品包含商品名称、单价、数量三种属性，其中商品名不重复。考生不能修改商品名称和单价，初始化命令设置商品数量。这些信息在考试框架中进行定义，考生在实现功能代码时可直接使用。

\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 元张数

商品和各种面额钱币取值范围只是作为初始化命令的限制，其它场景下不限制取值范围；考试框架已经实现取值范围的检查，考生不需要关注。

功能说明：设置自动售货机中商品数量和存钱盒各种面额的钱币张数；

约束说明：系统在任意阶段均可执行r初始化系统；考生不需要关注参数的合法性，不需要关注增加或缺少参数的场景；

输出说明：输出操作成功提示（执行完r命令后系统会自动输出操作结果，考生不需要再次调用输出函数），例：

.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”。

例：

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”。

例:

2.4 退币

命令格式：c

功能说明：

（1） 如果投币余额等于0的情况下，输出“E009:Work failure”；

（2） 如果投币余额大于0的情况下，按照 退币原则 进行“找零”，输出退币信息；

约束说明：

（1） 系统在任意阶段都可以退币；

（2） 退币方式必须按照 退币原则 进行退币；

输出说明：如果退币成功，按照 退币原则 输出退币信息。

例，退5元钱币:

2.5 查询

命令格式：q 查询类别

功能说明：

（1） 查询自动售货机中商品信息，包含商品名称、单价、数量。 根据商品数量从大到小进行排序；商品数量相同时，按照商品名称的先后顺序进行排序 。

例如：A1的商品名称先于A2的商品名称，A2的商品名称先于A3的商品名称。

（2） 查询存钱盒信息，包含各种面额钱币的张数；

（3） 查询类别如下表所示:

如果“查询类别”参数错误，输出“E010:Parameter error”。“查询类别”参数错误时，不进行下面的处理；

输出说明：

“查询类别”为0时，输出自动售货机中所有商品信息（商品名称单价数量）例：

“查询类别”为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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
'
运行
运行

96-自守数

自守数是指一个数的平方的尾数等于该数自身的自然数。例如：25^2 = 625，76^2 = 5776，9376^2 = 87909376。请求出n以内的自守数的个数

接口说明
/*
功能: 求出n以内的自守数的个数
输入参数：
int n
返回值：
n以内自守数的数量。
*/

public static int CalcAutomorphicNumbers( int n)
{
/*在这里实现功能*/
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输入描述: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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
'
运行
运行

98-输入整型数组和排序标识，对其元素按照升序或降序进行排序

输入整型数组和排序标识，对其元素按照升序或降序进行排序（一组测试用例可能会有多组数据）

接口说明
原型：
void sortIntegerArray(Integer[] pIntegerArray, int iSortFlag);
输入参数：
Integer[] pIntegerArray：整型数组
int iSortFlag：排序标识：0表示按升序，1表示按降序
输出参数：
无
返回值：
void
1
2
3
4
5
6
7
8
9
10

输入描述:输入需要输入的整型数个数

输出描述:输出排好序的数字

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
1
2
3
4
5
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10

输入描述:输入多行，先输入数组的个数，再输入相应个数的整数

输出描述:输出结果

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
'
运行
运行

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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

输入描述:首先输入数字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
1
2
3
4
5
6
7
8
9
10
11
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
'
运行
运行

103-字符逆序

将一个字符串str的内容颠倒过来，并输出。str的长度不超过100个字符。 如：输入“I am a student”，输出“tneduts a ma I”。

输入参数：

inputString：输入的字符串

返回值：

输出转换好的逆序字符串

输入描述:输入一个字符串，可以有空格

输出描述:输出逆序的字符串

print (input()[::-1])
1
'
运行
运行

104-求解立方根

计算一个数字的立方根，不使用库函数

详细描述：
接口说明
原型：
public static double getCubeRoot(double input)
输入:double 待求解参数
返回值:double 输入参数的立方根，保留一位小数
1
2
3
4
5
6

输入描述:待求解参数 double类型

输出描述:输入参数的立方根 也是double类型

def lifang(a):
    a=float(a)
    return a**(1/3)
 
b=input()
print('%0.1f'%lifang(b))
1
2
3
4
5
6
'
运行
运行

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
'
运行
运行