怒刷python作业（西北工业大学cpSkill平台）

以下作业题仅为参考答案，为了锻炼思维的目的，尽量多的自己实现功能少引包，大家对题有更好的思路和更方便的包欢迎大家多多留言，祝愿大家共同进步

1.hello word

略...

2.A+B

A = int(input())
B = int(input())
print(A+B)

3.N位小数

f = float(input())
n = int(input())
print(round(f,n))

4.二进制（题目错误，只要第二个输出的也是a的二进制题目就能通过）

调用函数

a = int(input())
b = int(input())
print(bin(a),bin(b),a & b)

全部自己实现

a = int(input())
b = int(input())
def toBin(num):
    s = ""
    while num > 0:
        s += str(num&1)
        num >>= 1
        l = list(s)
        l.reverse()
    return "".join(l)
print("0b"+toBin(a))
print("0b"+toBin(b))

5.ASCII

n = int(input())
a = input()
print(chr(n),ord(a))

6.进制转换

n = int(input())
print(oct(n), hex(n),bin(n), sep = ",")

7.整数格式输出

a = int(input())
print("{:<10d}".format(a))
print("{:>10d}".format(a))
print("{:<+10d}".format(abs(a)))
print("{:>+10d}".format(abs(a)))

8.浮点数输出

a = float(input())
print("{:<.6f}".format(a),"{:<.2f}".format(a),"{:<.8f}".format(a), "{:.6e}".format(a), "{:,}".format(a), sep = "/")

9.各种表示

a = int(input())
print('{:b}'.format(a), '{:o}'.format(a), oct(a), '{:x}'.format(a), hex(a), '{:#X}'.format(a), sep = ",")

10.动态宽度

toBin函数：按位得到n位长度的逆序二进制并借助list反转，然后使用join方法将list还原为字符串

m = int(input())
n = int(input())
def toBin(num, n):
    s = ""
    for i in range(0, n):
        s += str(num&1)
        num >>= 1
        l = list(s)
        l.reverse()
    return "".join(l)
print(toBin(m, n))

使用格式化函数format和rjust方法改进 ^[rjust方法：返回一个原字符串并右对齐。第一个参数是填充字符的目标长度，第二个参数是空位要填充的字符]

a = int(input())
n = int(input())
print("{:b}".format(a).rjust(n, '0'))

11.两个分数加减乘除

a = int(input())
b = int(input())
c = int(input())
d = int(input())
def simple(d):
    a = d['molecule']
    b = d['denominator']
    while a%b != 0:
        tmp=a%b
        a = b
        b = tmp
    d['molecule'] /= b
    d['denominator'] /= b
dict = {'molecule':a*d+b*c, 'denominator':b*d}
simple(dict)
print("("+str(a)+"/"+str(b)+")"+"+("+str(c)+"/"+str(d)+")"+"="+str(int(dict['molecule']))+"/" + str(int(dict['denominator'])))
dict['molecule'] = a*d-b*c
simple(dict)
print("("+str(a)+"/"+str(b)+")"+"-("+str(c)+"/"+str(d)+")"+"="+str(int(dict['molecule']))+"/" + str(int(dict['denominator'])))
dict['molecule'] = a*c
simple(dict)
print("("+str(a)+"/"+str(b)+")"+"*("+str(c)+"/"+str(d)+")"+"="+str(int(dict['molecule']))+"/" + str(int(dict['denominator'])))
dict['molecule'] = a*d
dict['denominator'] = b*c
simple(dict)
print("("+str(a)+"/"+str(b)+")"+"/("+str(c)+"/"+str(d)+")"+"="+str(int(dict['molecule']))+"/" + str(int(dict['denominator'])))

12.计算狗的年龄

a = int(input())

if a<=2:
    print(a*10.5)
else:
    print(int(2*10.5+(a-2)*4))

13.风寒指数

import math
v = float(input())
t = float(input())
chill = 13.12+0.6215*t-11.37*math.pow(v, 0.16)+0.3965*t*math.pow(v, 0.16)
print(round(chill))

14.圆柱

import math
h = float(input())
r = float(input())
pai = 3.14159265
print("{:.4f}".format(pai*pow(r, 2)*h))
print("{:.4f}".format(pai*pow(r, 2)*2+2*pai*r*h))

15.直角坐标转换为极坐标

import math
x = float(input())
y = float(input())
print("{:.4f}".format(math.sqrt(pow(x, 2)+pow(y, 2))), "{:.4f}".format(math.atan2(y, x)), sep = ",")

16.给定经纬度计算地球上两点之间的距离

import math
latitude1 = math.radians(float(input()))
longitude1 = math.radians(float(input()))
latitude2 = math.radians(float(input())) #纬度
longitude2 = math.radians(float(input())) #经度

#经纬度转换弧度

def har(th):
    return math.pow(math.sin(th/2), 2)

#求差值
vlon = abs(longitude1 - longitude2)
vlat = abs(latitude1 - latitude2)

h = har(vlat)+math.cos(latitude1)*math.cos(latitude2)*har(vlon)
print("{:.4f}".format(2*6371*math.asin(math.sqrt(h))), "km", sep = "")

17.勾股定理

import math
a = int(input())
b = int(input())
max = a if a>b else b
min = a if a<b else b
def isTriangle(a, b, c):
    if a+b > c and a+c > b and b+c > a and abs(a-b) < c and abs(a-c) < b and abs(c-b) < a:
        return True
    else:
        return False
condition1 = int(math.sqrt(math.pow(max, 2) - math.pow(min,2)))
condition2 = int(math.sqrt(math.pow(max, 2) + math.pow(min,2)))
if(isTriangle(min, max, condition2) and math.pow(min, 2)+math.pow(max, 2) == math.pow(condition2, 2) and condition2 > max):
        print("c")
elif(isTriangle(min, max, condition1) and  math.pow(min, 2)+math.pow(condition1, 2) == math.pow(max, 2) ):
    if condition1<min:
        print("a")
    if condition1<max and condition1>min:
        print("b")
else:
    print("non")

18.RGB转换HSV

R = int(input())/255
G = int(input())/255
B = int(input())/255
def max(a, b, c):
    m = a if a > b else b
    m = m if m > c else c
    return m
def min(a, b, c):
    m = a if a < b else b
    m = m if m < c else c
    return m
V = maximum = max(R, G, B)
minimum = min(R, G, B)
S = (maximum - minimum)/maximum
if maximum == R:
    H = (G-B)/(V-minimum)
if maximum == G:
    H = 2+(B-R)/(maximum-minimum)
if maximum == B:
    H = 4+(R-G)/(maximum-minimum)
H *= 60
if H<0:
    H += 360
print("{:.4f}".format(H), "{:.4%}".format(S), "{:.4%}".format(V), sep = ",")

19.比率

f = float(input())
# 分数通分
def simple(d):
    a = d['molecule']
    b = d['denominator']
    while a%b != 0:
        tmp=a%b
        a = b
        b = tmp
    d['molecule'] /= b
    d['denominator'] /= b
# 判断小数位有几位
len = len(str(f))-len(str(int(f)))-1
dict = {'molecule':f*pow(10, len), 'denominator':pow(10, len)}
simple(dict)
print(str(int(dict['molecule']))+"/" + str(int(dict['denominator'])))

20.指定精度输入

第一步得到保留n+1位浮点数的字符串s,判断要保留的最后一位小数的下一位要不要进位并完成舍和入得到最后一位小数，然后将保留n-1位小数的字符串和最后一位小数合并字符串得到最终结果：从精度上考虑，缺点也很明显，只判断了要保留的最后一位小数位的下一位，而不是整个小数部分进位，会出现应该进位却没进位的情况

f = float(input())
n = int(input())
s = str(f)[0:len(str(int(f)))+n+2]
if(int(s[len(s)-1])>4):
    s2 = str(int(s[len(s)-2])+1) 
else:
    s2 = str(int(s[len(s)-2]))
s = s[0:len(str(int(f)))+n]+s2
print(s)

可以参考前面 N位小数的那一道题 使用round函数,但是注意round函数并不总是四舍五入，会受计算机表示精度的影响，同时也受python版本影响 ^[Python2.7中，保留值将保留到离上一位更近的一端（四舍六入），如果距离两端一样远，则保留到离0远的一边；python3.5中，保留值将保留到离上一位更近的一端（四舍六入），如果距离两边一样远，会保留到偶数的一边 注意：python3.8.5并非保留偶端] 根据题目给的测试用例，很明显千分位的5是进位的情况，说明距离两端一样远的情况下，则保留到离0远的一边，那么很明显刷题平台是python2.x的环境，直接使用round函数就能通过

f = float(input())
n = int(input())
print(round(f, n))

21.整数组合

import math
n = int(input())
m = int(input())
sum = 0
for i in range(m):
    sum += n*int(math.pow(10, i))*(m-i)
print(sum)

# 解法为按位计算，第一次循环统计各位，第二次十位以此类推...每一位的个数随循环减少
# 555
#  55
#   5

# pow(10, i)效率还可以提升，利用迭代
sum = 0
tmp = 1
for i in range(m):
    sum += n*tmp*(m-i)
    tmp *= 10
print(sum)

22.组合数

n = int(input())
count = 0
for a in range(10):
    for b in range(10):
        for c in range(10):
                d = n-a-b-c
                if 0 <= d <= 9:
                    count += 1
print(count)

23对称数

integer = int(input())
def isSymmetry(a, b):
    if (a=='9'and b=='6') or (a=='6'and b=='9') or a == b:
        return True
    else:
        return False
flag = True
for i in range(len(str(integer))>>1):
    if False == isSymmetry(str(integer)[i], str(integer)[len(str(integer))-i-1]):
        flag = False
if flag:
    print("Yes")
else:
    print("No")

24.平行线

x1 = float(input())
y1 = float(input())
x2 = float(input())
y2 = float(input())
x3 = float(input())
y3 = float(input())
x4 = float(input())
y4 = float(input())
if(y2-y1)/(x2-x1) == (y4-y3)/(x4-x3):
    print("Yes")
else:
    print("No")

25.阶乘末尾

n = int(input())
product = 1
for i in range(1, n+1):
    product *= i
num = 0
for i in range(len(str(product))):
    if('0' == str(product)[len(str(product))-i-1]):
        num+=1
    else:
        break
print(num)

26.操作数

n = int(input())
def count(n):
    sum = 0
    while(n > 0):
        sum += int(n%10)
        n /= 10
    return sum
nums = 0
while n>0:
    n -= count(n)
    nums += 1
print(nums)

27.斐波那契数列

n = int(input())
def fib(n):
    if 1 == n or 2 == n:
        return 1
    a = 0
    b = 1
    c = 1
    for i in range(n-2): 
        a = b
        b = c
        c = a+b
    return c
print(fib(n))

28.圆

import math
x1 = int(input())
y1 = int(input())
x2 = int(input())
y2 = int(input())
x3 = int(input())
y3 = int(input())
a=2*(x2-x1)
b=2*(y2-y1)
c=2*(x3-x2)
d=2*(y3-y2)
e=x2*x2+y2*y2-x1*x1-y1*y1
f=x3*x3+y3*y3-x2*x2-y2*y2
x=(b*f-d*e)/(b*c-d*a)
y=(c*e-a*f)/(b*c-d*a)
r=math.sqrt((x-x1)*(x-x1)+(y-y1)*(y-y1))
print("{:.3f}".format(r), "{:.3f}".format(x), "{:.3f}".format(y), sep = ",")

29.回文数

integer = int(input())
def isSymmetry(a, b):
    if a == b:
        return True
    else:
        return False
flag = True
for i in range(len(str(integer))>>1):
    if False == isSymmetry(int(str(integer)[i]), int(str(integer)[len(str(integer))-i-1])):
        flag = False
if flag:
    print("Yes")
else:
    print("Not")

代码改进

n = int(input())
s = str(n)
res = ""
for i in range(len(str(n))):
    res += str(s[i])
if int(res) == n:
    print("Yes")
else:
    print("Not") 

30.方程组

a = float(input())
b = float(input())
c = float(input())
d = float(input())
e = float(input())
f = float(input())
if a/d == b/e and a/d != c/f:
    print("error")
else:
    x=(c*e-f*b)/(a*e-d*b)
    y=(c*d-a*f)/(b*d-e*a)
    print("{:.3f}".format(x), "{:.3f}".format(y), sep = " ")

31.长安

---

以下代码每输入一行就会输出结果到缓冲区

# a!/(a-n)!
def factorial(n, a):
        pro = 1
        tmp = n
        for i in range(a):
            pro *= tmp
            tmp -= 1
        return pro
# b!/a!*(b-a)!
def c(a, b):
    return factorial(a+b, a)/factorial(a, a)
def cout(bx, by, px, py):
    if px <= bx and py <= by:
        return c(bx, by) - c(px, py)*c(bx-px, by-py)
    else:
        return c(bx, by)
bx = by = px = py = 1
while True:
    bx,by,px,py = map(int,input().split(","))
    if bx>=0 and by>=0 and px>=0 and py>=0:
        print(int(cout(bx, by, px, py)))
    else:
        break

以下代码每输入一条用例就会将结果存储到列表中，直到输入的测试用例不符合条件，再一次性输出所有结果

# n!/(n-a)!
def factorial(n, a):
        pro = 1
        tmp = n
        for i in range(a):
            pro *= tmp
            tmp -= 1
        return pro
# b!/a!*(b-a)!
def c(a, b):
    return factorial(a+b, a)/factorial(a, a)
def cout(bx, by, px, py):
    if px <= bx and py <= by:
        return c(bx, by) - c(px, py)*c(bx-px, by-py)
    else:
        return c(bx, by)
bx = by = px = py = 1
L = []
while True:
    bx,by,px,py = map(int,input().split(","))
    if bx>=0 and by>=0 and px>=0 and py>=0:
        L.append(int(cout(bx, by, px, py)))
    else:
        break
for i in range(0, len(L)):
    print(L[i])

以上代码对于这题都是正确的，但是有时候是要区分的，刷题平台的后台如果是一条一条测试用例输入，要求一条一条结果输出那么以上第一种代码正确 ^[终端看到的结果就应该是一行测试用例紧跟着一行结果]，第二种就会错误 ^[多测试用例，然后才是多行结果]。如果刷题平台的后台测试用例是一次性输入多条测试用例最后一条是不符合条件终止循环的，要求最终一次性输出所有结果，那么以上两种代码都是正确的

32.最接近的分数

以下简单的枚举就可以通过题目

n, a, b = map(int,input().split(" "))
p = 1
q = n
for x in range(1, n+1):
    for y in range(n, 0, -1):
        if(b * x < a * y and x * q > p * y):
           p = x
           q = y
print(str(p)+"/"+str(q))

碰到题目测试用例刁钻的请增加通分函数通分，如下

n, a, b = map(int,input().split(" "))
p = 1
q = n
def simple(d):
    a = d['molecule']
    b = d['denominator']
    while a%b != 0:
        tmp=a%b
        a = b
        b = tmp
    d['molecule'] /= b
    d['denominator'] /= b
for x in range(1, 101):
    for y in range(100, 0, -1):
        if(b * x < a * y and x * q > p * y):
           p = x
           q = y
max = {'molecule':p, 'denominator':q}
simple(max)
print(str(int(max['molecule']))+"/"+str(int(max['denominator'])))

来自方一舟的损失精度评测是否有分子分母有公因子

def most_common_divisor(num1, num2):
    # 求num1和num2的最大公因子
    if num2 > num1:
        num1, num2 = num2, num1
    divisor = 1 # 返回值最大公因子
    i = 1 # 循环出口标志
    while i <= num2:
        if num1%i==0 and num2%i==0:
            if i >= divisor:
                divisor = i
        i += 1
    if divisor == 1:
        return False
    else:
        return True

n, a, b = map(int, input().split())
value = a/b
gap_min = 1001
result_deno = 1
result_nume = 0
for denominator in range(1, n+1):
    numerator = int(denominator * value)
    gap = abs(numerator/denominator - value)
    if gap < gap_min and gap != 0 and ~most_common_divisor(denominator, numerator):
        gap_min = gap
        result_deno = denominator
        result_nume = numerator
print(result_nume, '/', result_deno, sep='')

利用辗转相除法求最大公因子改造以上一舟代码使得判断是否存在公因子的函数时间复杂度降到O(1),判断某些情况是否发生只需要判断充分条件是否满足就行，不一定求得公因子只需要判断公因子存在得条件是否成立

n, a, b = map(int,input().split(" "))
p = 1
q = n
def most_common_divisor(d):
    a = d['numerator']
    b = d['denominator']
    if a%b != 0:
        tmp=a%b
        a = b
        b = tmp
    if b == d['denominator']:
        return False
    else:
        return True
value = a/b
gap_min = 1001
result_deno = 1
result_nume = 0
for denominator  in range(1, n+1):
    numerator = int(denominator * value)
    gap = abs(numerator/denominator - value)
    max = {'numerator':numerator, 'denominator':denominator}
    if gap < gap_min and gap != 0 and ~most_common_divisor(max):
        gap_min = gap
        result_deno = max['denominator']
        result_nume = max['numerator']
print(result_nume, '/', result_deno, sep='')

33.小木棍等式

n = int(input())
def stick_number(num):
    # 函数返回两位数字num需要的火柴个数
    # 记录下数字0~9需要的火柴个数
    stick_num = [6, 2, 5, 5, 4, 5, 6, 3, 7, 6]
    result = 0
    if num < 10:
        result = stick_num[num]
    elif 10 <= num < 100:
        # 返回个位和十位的火柴个数
        result = stick_num[num%10] + stick_num[num//10]
    elif 100 <= num < 1000:
        result = stick_num[num%10] + stick_num[(num//10)%10] + stick_num[num//100]
    else:
        result = stick_num[num%10] + stick_num[(num//10)%10] + stick_num[num//100%10] + stick_num[num//1000]
    return result

def stick_eqution(n):
    count = 0
    if n <= 4:
        return count
    else:
        n -= 4 # 减去+和=用去的4根火柴
        for num1 in range(1000):
            for num2 in range(1000):
                if stick_number(num1) + stick_number(num2) + stick_number(num1 + num2) == n:
                    count += 1
    return count
print(stick_eqution(n))

经过贪心算法测试以下代码正确，但是不能满足本题通过的时间复杂度

n = int(input())
dict = {0:6, 1:2, 2:5, 3:5, 4:4, 5:5, 6:6, 7:3, 8:7, 9:6}  
def countStick(num):
    count = 0
    for i in range(0, len(num)):
        count += dict[int(num[i])]
    return count

def c(n):
    count = 0
    for i in range(0, 1000):
        for j in range(0, 1000):
            c = i+j
            if(countStick(str(i))+countStick(str(j))+countStick(str(c)) == n-4):
                list = [i, j, c]
                count+=1
    return count
print(c(n))

以上两种代方法的贪心测试代码

def stick_number(num):
    # 函数返回两位数字num需要的火柴个数
    # 记录下数字0~9需要的火柴个数
    stick_num = [6, 2, 5, 5, 4, 5, 6, 3, 7, 6]
    result = 0
    if num < 10:
        result = stick_num[num]
    elif 10 <= num < 100:
        # 返回个位和十位的火柴个数
        result = stick_num[num%10] + stick_num[num//10]
    elif 100 <= num < 1000:
        result = stick_num[num%10] + stick_num[(num//10)%10] + stick_num[num//100]
    else:
        result = stick_num[num%10] + stick_num[(num//10)%10] + stick_num[num//100%10] + stick_num[num//1000]
    return result

def stick_eqution(n):
    count = 0
    if n <= 4:
        return count
    else:
        n -= 4 # 减去+和=用去的4根火柴
        for num1 in range(1000):
            for num2 in range(1000):
                if stick_number(num1) + stick_number(num2) + stick_number(num1 + num2) == n:
                    count += 1
    return count





dict = {0:6, 1:2, 2:5, 3:5, 4:4, 5:5, 6:6, 7:3, 8:7, 9:6}  
def countStick(num):
    count = 0
    for i in range(0, len(num)):
        count += dict[int(num[i])]
    return count

def c(n):
    count = 0
    for i in range(0, 1000):
        for j in range(0, 1000):
            c = i+j
            if(countStick(str(i))+countStick(str(j))+countStick(str(c)) == n-4):
                list = [i, j, c]
                count+=1
    return count


for n in range(25):
    if(c(n) != stick_eqution(n)):
        print("n:", n, "远", c(n), "舟：", stick_eqution(n))
print("same")

34.铺地板

动态规划

MAX = 1001
s = [i for i in range(MAX)]
n = int(input())
s[0]=1
s[2]=3
for i in range(4, MAX, 2):
    s[i]=4*s[i-2]-s[i-4]
while n>0:
    if n&1:
        print(0)
    else:
        print(s[n]%100003)
    n = int(input())

来自一舟大佬的动态：

def floor(n):
    if n%2 == 1:
        return 0
    f = [0 for i in range(n+1)]
    f[0] = 1
    f[2] = 3
    for i in range(4, n+1, 2):
        f[i] = f[i-2]*4 - f[i-4]
    return f[n]%100003

n = int(input())
while n != 0:
    print(floor(n))
    n = int(input())

35.排队过河

def Jump(s, y):
    k = 0
    if s == 0:
        k = y + 1
    else:
        k = 2 * Jump(s - 1, y)
    return k
s,y = map(int,input().split(","))
while(-1 != s and -1 != y):
    sum = Jump(s, y)
    print(sum)
    s,y = map(int,input().split(","))

36.乘方

简单的找出规律，末尾数随次方模4的值存在规律

0: 1, 1, 1, 1... 1: 1, 1, 1, 1...
2: 2, 4, 8, 6... 3: 3, 9, 7, 1... 4: 4, 6, 4, 6... 5: 5, 5, 5, 5... 6: 6, 6, 6, 6... 7: 7, 9, 3, 1... 8: 8, 4, 2, 6... 9: 9, 1, 9, 1...

dic2 = [2, 4, 8, 6]
dic3 = [3, 9, 7, 1]
dic4 = [4, 6, 4, 6]
dic7 = [7, 9, 3, 1]
dic8 = [8, 4, 2, 6]
dic9 = [9, 1, 9, 1]
a,b = map(int,input().split(" "))
while(0 < a and 0 < b):
    if(a == 1 or a%10 == 5 or a%10 == 6):
        print(a%10)
    if(a%10 == 2):
        print(dic2[b%4 - 1])
    if(a%10 == 3):
        print(dic3[b%4 - 1])
    if(a%10 == 4):
        print(dic4[b%4 - 1])
    if(a%10 == 7):
        print(dic7[b%4 - 1])
    if(a%10 == 8):
        print(dic8[b%4 - 1])
    if(a%10 == 9):
        print(dic9[b%4 - 1])
    a,b = map(int,input().split(" "))

37.数字

def number(n):
    for a1 in range(n, 0, -1):
        for a2 in range(n, 0, -1):
            if (a1+a2)%2 != 0:
                continue
            for a3 in range(n, 0, -1):
                if  (a2+a3)%3 == 0 and (a1+a2+a3)%5 == 0:
                    max = a1+a2+a3
                    return max

n = int(input())
print(number(n))

38.吃糖果

就是简单的fibonacci数列

def F(N):
    if N == 1 or N == 2:
        return N
    else:
        return F(N - 1) + F(N - 2)
n = int(input())
while n > 0:
    print(F(n))
    n = int(input())

使用迭代改进

def F(N):
    a = 1
    b = 2
    if N == 1 or N == 2:
        return N
    else:
        for i in range(N-2):
            c = a+b
            a = b
            b = c
        return c
n = int(input())
while n > 0:       
    print(F(n))
    n = int(input())

39.上楼梯

def GoUpstairs(n):
    a = [i for i in range(n+3)]
    a[1] = 1
    a[2] = 2
    a[3] = 4
    for i in range(4, n+1, 1):
        a[i] = ((a[i-1]  + a[i-2])%1000000007  + a[i-3])%1000000007
    return a[n]
n = int(input())
while n > 0:
    print(GoUpstairs(n))
    n = int(input())

40.除法算式

题目错误：欢迎驳反

41.霍夫斯塔德序列

暴力，题目可以通过

def F(n):
 if n == 0:
     return 1
 else:
     return n - M(F(n - 1))
def M(n):
 if n == 0:
     return 0
 else:
     return n - F(M(n - 1))
num = int(input())
if num >= 0:
 f = F(num)
 m = M(num)
 print(f, m, sep=" ")

迭代，以下时间复杂度不满足：

n = int(input())
def Hofstadter_sequence(n):
    F = [i for i in range(n+1)]
    M = [i for i in range(n+1)]
    F[0] = 1
    M[0] = 0
    for i in range(1, n+1):
        M[i] = i - F[M[i-1]]
        F[i] = i - M[F[i-1]]
    return [F[n], M[n]]
u = Hofstadter_sequence(n)
if n >= 0:
    print(u[0], u[1], sep = " ")

42.非负累加

暴力算法

n, v = map(int, input().split())
count = 0
for i in range(0, v + 1):
 for ii in range(0, v + 1):
     for iii in range(0, v + 1):
         for iiii in range(0, v + 1):
             for iiiii in range(0, v + 1):
                 if (i + ii + iii + iiii + iiiii) == v:
                     count += 1
print(count)

43.扩展欧几里得算法

结果必然是一正一负

a, b = map(int, input().split())
# 得出最大公约数
def MaxDivisor(d):
    a = d[0]
    b = d[1]
    while a%b != 0:
        tmp=a%b
        a = b
        b = tmp
    return b
acb = MaxDivisor([a, b])
#求值
def fun(a, b, acb):
    x = 1
    y = 0
    while True:
        y = (acb-x*a)//b
        if acb == a*x+b*y:
            return x, y
        x += 1
x, y = fun(a, b, acb)
print(x, y, sep = " ")

44.卡塔兰数

n = int(input())
# n!/(n-a)!
def fact(n, a):
        pro = 1
        tmp = n
        for i in range(a): #n*(n-1)*...*n-a+1
            pro *= tmp
            tmp -= 1
        return pro
#n!
def factorial(n):
        pro = 1
        for i in range(n, 0, -1):
            pro *= i
        return pro
print(fact(2*n, n)//factorial(n+1))

45.倒序二进制

方法极多，任选其一:

字符串切片

#字符串切片
n = int(input())
st = str('{:b}'.format(n))
result = st[::-1]
print(result)

转换为列表，使用列表的reverse，然后再转回字符串

#列表的reverse
n = int(input())
st = str('{:b}'.format(n))#二进制转字符串
l = list(st)#字符串转换成列表
l.reverse()#翻转列表
print(''.join(l))#连接字符串并打印

使用内置函数reduce

#reduce
from functools import reduce
n = int(input())
st = str('{:b}'.format(n))
l = list(st)
result = reduce(lambda x,y:y+x,l)
print(result)

使用递归

#使用递归函数
def func(s):
    if len(s) <1:
        return s
    return func(s[1:])+s[0]
n = int(input())
st = str('{:b}'.format(n))
result = func(st)
print(result)

for循环

#for循环
def func(s):
    result = ""
    max_index = len(s)-1
    for index,value in enumerate(s):
        result += s[max_index-index]
    return result
n = int(input())
st = str('{:b}'.format(n))
result = func(st)
print(result)

46.有效运动

简单递归搞定

x1, y1, x2, y2 = map(int, input().split())
def f(x1, y1, x2, y2):
    if x1 == x2 and y1 == y2:
        return True
    if x1 > x2 or y1 > y2:
        return False
    else:
        return f(x1+y1, y1, x2, y2) or f(x1, y1+x1, x2, y2)
if f(x1, y1, x2, y2):
    print("true")
else:
    print("false")

47.佩尔数

简单递归搞定

n = int(input())
def pell(n):
    if 0 == n:
        return n
    if 1 == n:
        return n
    else:
        return 2*pell(n-1)+pell(n-2)
print(pell(n))

迭代的思想改为循环，时间复杂度降到O(n),也降低了递归方式的系统栈开销

n = int(input())
def Pell(n):
    pell = [i for i in range(n+1)]
    pell[0] = 0
    pell[1] = 1
    for i in range(2, n+1):
        pell[i] = 2*pell[i-1] + pell[i-2]
    return pell[n]
print(Pell(n))

48.Collatz conjecture

n = int(input())
def Collatz(n):
    Col = [n]
    while n > 1:
        if n%2 == 0:
            n = n//2
        else:
            n=3*n+1
        Col.append(n)
    return Col
for i in Collatz(n):
    if 1 != i:
        print(i, end = ",")
    else:
        print(i)

49.分苹果

如下推理

m	n	count
1	2	1
2	2	2
3	2	2
4	2	3
5	2	3
6	2	4
7	2	4
8	2	5
9	2	5
10	2	6

m	n	count
1	3	1
2	3	2
3	3	3
4	3	4
5	3	5
6	3	7
7	3	8
8	3	10
9	3	12
10	3	14

m	n	count
4	1	1
4	2	3
4	3	4
4	4	5
4	5	5

(1)m<=n:

f(4, 5) = f(4, 4) f(4, 4) = f(4, 3)+1 = f(4, 3) + f(0, 4) f(4, 3) = f(4, 2)+1 = f(4, 2) + f(1, 3) f(4, 2) = f(4, 1)+2 = f(4, 1) + f(2, 2) f(4, 1) = 1

f(3, 2) = f(2, 2) = 2 f(2, 2) = f(1, 2)+1 = 2 f(1, 2) = 1 f(3, 3) = f(2, 3) = 2 f(2, 3) = f(1, 3)+1 = 2 f(1, 3) = 1

f(m, n) = f(m, n-1) + f(m-n, n)

(2)m > n :

f(m, n) = f(m, m)

可以得出推导式：

f(m, n) = f(m, n-1) + f(m-n, n) m<=n

f(m, n) = f(m, m) m > n

M, N = map(int, input().split())
def Divide(m, n):
    if 0 == m or 1 == n:
       return 1
    elif n <= m:
        return Divide(m, n-1) + Divide(m-n, n)
    else:
        return Divide(m, m)
print(Divide(M, N))

50.分解因数

def dfs(a, m):
    if a == 1:
        return 1
    if m == 1:
        return 0
    if a % m == 0:
        return dfs(a,m-1) + dfs(a / m,m);  
    return dfs(a,m-1)
a = int(input())
print(dfs(a, a))

51.手机号码

这题尤其简单，只需要比较号码长度和号码前两位是否合理,两种做法

def legitimated(phoneNumber):
    right = ["13", "14", "15", "17", "18", "19"]
    #判断位数是否合理
    if len(phoneNumber) < 11 or len(phoneNumber) >11:
        return False
    netBios = phoneNumber[0:2]
    #判断是否有除数字以外的字符
    for c in phoneNumber:
        if c < '0'or c > '9':
            return False
    #判断号码前两位是否合理
    for st in right:
        if st == netBios:
            return True
    return Flase
while True:
    phoneNumber = str(input())
    if phoneNumber != "":
        print(legitimated(phoneNumber))
    else:
        break

简单方式判断字符串是否在列表中列表中

while True:
    num = input()
    if num == "":
        break
    l = ['13', '14', '15', '18', '17', '19']
    flag = False
    if num[:2] in l and len(num) == 11:
        flag = True
    else:
        flag = False
    print(flag)

扩展，用正则表达式判断合法的号码属于哪个运营商

import re
def legitimated(phoneNumber):
    if len(phoneNumber) < 11 or len(phoneNumber) >11:
        return False
    netBios = phoneNumber[0:2]
    for c in phoneNumber:
        if c < '0'or c > '9':
            return False
    if re.match(r'13[0,1,2]\d{8}',phoneNumber) or \
            re.match(r"15[5,6]\d{8}",phoneNumber) or \
            re.match(r"18[5,6]",phoneNumber) or \
            re.match(r"145\d{8}",phoneNumber) or \
            re.match(r"176\d{8}",phoneNumber):
        print("该号码属于：中国联通")
        return True
    if re.match(r"13[4,5,6,7,8,9]\d{8}",phoneNumber) or \
            re.match(r"147\d{8}|178\d{8}",phoneNumber) or \
            re.match(r"15[0,1,2,7,8,9]\d{8}",phoneNumber) or \
            re.match(r"18[2,3,4,7,8]\d{8}",phoneNumber):
        print("该号码属于：中国移动")
        return True
    if re.match(r"133\d{8}",phoneNumber) or \
            re.match(r"149\d{8}",phoneNumber) or \
            re.match(r"153\d{8}",phoneNumber) or \
            re.match(r"177\d{8}",phoneNumber) or \
            re.match(r"18[0,1，9]\d{8}",phoneNumber):
        print("该号码属于：中国电信")
        return True
    return Flase
phoneNumber = str(input())
print(legitimated(phoneNumber))

52.分词与副词

while True:
    st = str(input())
    if st == "":
        break
    if len(st) < 3:
        print(st)
    elif st[len(st)-3 : len(st)] == "ing":
        print(st+"ly")
    else:
        print(st+"ing")

54.字符交换

st = str(input())
indexOfDecimalpoint = st.index(".", 0, len(st))
indexOfComma = st.index(",", 0, len(st))
st = list(st)
if(-1 != indexOfDecimalpoint):
    st[indexOfDecimalpoint] = ','
if(-1 != indexOfComma):
    st[indexOfComma] = '.'
print("".join(st))

55.合法的日期格式

import time
while True:
 x = input()
 if x == "":
     break
 else:
     try:
         if "-" in x:
             time.strptime(x,"%Y-%m-%d")
             print(True)
         elif "." in x:
             time.strptime(x,"%Y.%m.%d")
             print(True)
         elif "/" in x:
             time.strptime(x,"%Y/%m/%d")
             print(True)
         else:
             print(True)
     except:
         print(False)

56.单词

sentence = input()
words = sentence.split(" ")
min = 10000
max = 0
max_word = ""
min_word = ""
for str in words:
    if len(str) < min:
        min_word = str
        min = len(str)
    if len(str) > max:
        max_word = str
        max = len(str)
print(min_word)
print(max_word)

57.提取字符串

while True:
    st = input()
    if st == "":
        break
    if len(st) < 2:
        print(st)
    else:
        print(st[0:2]+st[len(st)-2:len(st)])

58.IPV4地址

def f(st):
    parts = st.split(".")
    if int(parts[0]) > 255 or int(parts[0]) < 1:
        return False
    for i in range(1, len(parts)):
        if int(parts[i]) > 255 or int(parts[i]) < 0:
            return False
    return True

while True:
    st = input()
    if st == "":
        break
    print(f(st))

59.同义词

def f(st):
    indexOfNot = st.find("not")
    indexOfPoor = st.find("poor")
    if indexOfNot >= 0 and indexOfPoor > indexOfNot:
        return st[0:indexOfNot]+"good"+st[indexOfPoor+4:len(st)]
    else:
        return st
while True:
    st = input()
    if st == "":
        break
    print(f(st))

60.公式计算

formula = input()
x,y,z = map(int, input().split(" "))
#运算函数
def calculate(a, b, sign):
    if sign == '*':
        return a*b
    if sign == '/':
        return a/b
    if sign == '+':
        return a+b
    if sign == '-':
        return a-b  
if formula[1] == '*'or formula[1] == '/':
    print(formula, "=", calculate(calculate(x, y, formula[1]), z, formula[3]), sep="")
else:
    print(formula, "=", calculate(calculate(y, z, formula[3]), x, formula[1]), sep="")

借题发挥：

#超长发挥
formula = input()
#转换为列表找到两个符号的索引并记录
formulaList = list(formula)
for i in range(len(formulaList)):
    if formulaList[i] == '+' or formulaList[i] == '-' or formulaList[i] == '*' or formulaList[i] == '/':
        formulaList[i] = '#'
#得出xyz     
L = "".join(formulaList).split('#')
##x, y, z = map(L)
x = int(L[0])
y = int(L[1])
z = int(L[2])

#两个符号的索引
firt = formulaList.index('#')
formulaList[firt] = '&'
second = formulaList.index('#')
formulaList[firt] = '#'
formulaList = "".join(formulaList).split("#")
#运算函数
def calculate(a, b, sign):
    if sign == '*':
        return a*b
    if sign == '/':
        return a/b
    if sign == '+':
        return a+b
    if sign == '-':
        return a-b  
if formula[firt] == '*'or formula[firt] == '/':
    print(formula, "=", calculate(calculate(x, y, formula[firt]), z, formula[second]), sep="")
else:
    print(formula, "=", calculate(calculate(y, z, formula[second]), x, formula[firt]), sep="")

61.翻转元组

import math
map = map(int, input().split(" "))
map2List = list(map)
r = len(map2List)>>1
r += len(map2List) % 2
for i in range(r):
    map2List[i] += map2List[-i-1]
    map2List[-i-1] = map2List[i]
tup = tuple(map2List)
print(tup)

62.元祖相乘

m = map(int, input().split(" "))
map2tup = tuple(m)
result = 1
for i in range(len(map2tup)):
    result *= map2tup[i]
print(result)

63.列表切片

m,n = map(int, input().split(" "))
seq = map(int, input().split(" "))
lis = list(seq)
print(lis[2:5])

64.排序|||

x = input()
L = x.split(";")
result = []
for i in range(0, len(L)):
    s = str(L[i])
    s = s.strip("(")
    s = s.strip(")")
    m, n = map(int, s.split(","))
    t = (m, n)
    result.append(t)
print(sorted(result, key=lambda x: (x[1])))

65.排序||

x = input()
L = x.split(",")
resultL = sorted(L, key=lambda x: (int(x[1:len(x)])))
s = " ".join(resultL)
print(s)

66.循环相同

list1 = list(input().split(" "))
list2 = list(input().split(" "))
def vv(list1, list2):
    if len(list1) != len(list2):
        return False
    for i in range(len(list1)):
        pr = []
        flag = False
        for j in range(len(list1)):
            if(list1[j] == list2[(j+i)%len(list2)]):
                flag = True
            else:
                flag = False
                break
        if flag:
            return flag
    return False
print(vv(list1, list2)) 

67.元组复杂度

n = input()
L = list(input().split(" "))
print(L.count(n))

68.排序|

x = input()
L = x.split(" ")
resultL = sorted(L, key=lambda x: int(x)*-1)
s = " ".join(resultL)
print(s)

69.重复字符

st = str(input())
charSet = {}
for i in st:
    if i in charSet:
        charSet[str(i)] += 1 
    else:
        charSet[str(i)] = 1
# 清洗字符只出现一次的数据
keys = charSet.keys()
resultSet = {}
for it in keys:
    if charSet[it] >= 2:
        resultSet[it] = charSet[it]
#打印
keys = resultSet.keys()
for it in keys:
    print(it,resultSet[it], sep = " ")

70.列表差异

list1 = list(map(str, input().split(" ")))
list2 = list(map(str, input().split(" ")))
dict1 = {}
dict2 = {}
for i in list1:
    dict1.setdefault(i)
for i in list2:
    dict2.setdefault(i)
dict3 = {}
keys1 = dict1.keys()
for it in keys1:
    if it in dict2:
        continue
    else:
        dict3.setdefault(it)
keys2 = dict2.keys()
for it in keys2:
    if it in dict1:
        continue
    else:
        dict3.setdefault(it)
print(" ".join(list(dict3.keys())))

71.对称差集

这道题和列表差异如出一辙，直接使用之前的代码并且对最后的结果列表排序 ^[简单解释为什么要排序：题目后台测试数据结果要保证唯一性]

list1 = list(map(str, input().split(" ")))
list2 = list(map(str, input().split(" ")))
dict1 = {}
dict2 = {}
#列表转换为字典
for i in list1:
    dict1.setdefault(i)
for i in list2:
    dict2.setdefault(i)
#将差异元素放入dict3
dict3 = {}
keys1 = dict1.keys()
for it in keys1:
    if it in dict2:
        continue
    else:
        dict3.setdefault(it)
keys2 = dict2.keys()
for it in keys2:
    if it in dict1:
        continue
    else:
        dict3.setdefault(it)
#结果字典转换为列表排序，然后转为字符串输出
res = list(dict3.keys())
res.sort(key = str)
print(" ".join(res))

这是出自集合字典的习题，因此可以使用集合的 symmetric_difference函数 ^[symmetric_difference_update() 方法移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。]

L1 = input().split()
L2 = input().split()
s1 = set(L1)
s2 = set(L2)
res = s1.symmetric_difference(s2) 
res = list(res)
res.sort(key=str)
print(" ".join(res))

72.生成字典||

直接遍历两个分别代表键值列表创建字典

list1 = list(map(str, input().split()))
list2 = list(map(str, input().split()))
resDict = {}
for i in range(len(list1)):
    resDict[list1[i]] = list2[i]
print(resDict)

借助zip函数将键值对打包成元组生成列表来创建字典

keysList = input().split()
valuesList = input().split()
resultDict = dict(zip(keysList, valuesList))
print(resultDict)

73.差集

参考列表差异和对称差集继续修改求差集

list1 = list(map(str, input().split(" ")))
list2 = list(map(str, input().split(" ")))
dict1 = {}
dict2 = {}
#列表转换为字典
for i in list1:
    dict1.setdefault(i)
for i in list2:
    dict2.setdefault(i)
#将存在第一个集合且不存在第二个集合的元素放入dict3
dict3 = {}
keys1 = dict1.keys()
for it in keys1:
    if it in dict2:
        continue
    else:
        dict3.setdefault(it)
#结果字典转换为列表排序，然后转为字符串输出
res = list(dict3.keys())
res.sort(key = str)
print(" ".join(res))

调用求差集的函数 ^[求得的集合一定要排序，不然平台通不过]

set1 = set(input().split())
set2 = set(input().split())
resList = list(set1.difference(set2))
print(" ".join(resList))

74.并集

参考列表差异、对称差集和差集继续修改求并集

list1 = list(map(str, input().split(" ")))
list2 = list(map(str, input().split(" ")))
dict1 = {}
dict2 = {}
#列表转换为字典
for i in list1:
    dict1.setdefault(i)
for i in list2:
    dict2.setdefault(i)
#将存在第一个集合且不存在第二个集合的元素放入dict3
dict3 = {}
keys1 = dict1.keys()
for it in keys1:
    if it in dict3:
        continue
    else:
        dict3.setdefault(it)
keys2 = dict2.keys()
for it in keys2:
    if it in dict3:
        continue
    else:
        dict3.setdefault(it)
#结果字典转换为列表排序，然后转为字符串输出
res = list(dict3.keys())
res.sort(key = str)
print(" ".join(res))

使用求并集得函数union

set1 = set(input().split())
set2 = set(input().split())
resList = list(set1.union(set2))
resList.sort(key = str)
print(" ".join(resList))

75.字典相加

str1 = list(input().split(","))
str2 = list(input().split(","))
str1 += str2
resDict = {}
for st in str1:
    key_value = st.split(":")
    if key_value[0] in resDict:
        resDict[key_value[0]] += int(key_value[1])
    else:
        resDict[key_value[0]] = int(key_value[1])
print(resDict)

76.生成字典|||

import copy
List = list(input().split())
List.reverse()
def recursion(dic, resDict, st):
    dic[st] = resDict
resDict = {}
dic = {}
for i in List:
    recursion(dic, resDict, i)
    resDict = copy.deepcopy(dic) #深拷贝
    dic = {}
print(resDict)

77.生成字典|

n = int(input())
List = []
for i in range(1, n+1):
    List.append(i)
resDict = {}
for i in List:
    resDict[i] = i*i
print(resDict)

78.字典排序

keys = []
values = []
while True:
    st = input()
    if st == "":
        break
    st = st.split(" ")
    keys.append(st[0])
    values.append(st[1])
getDict = dict(zip(keys, values))

#按值排序
##print(sorted(getDict.items(), key = lambda kv:(int(kv[1]), kv[0])))
print(list(sorted(getDict.items(), key=lambda getDict:getDict[1],reverse = False)))
#按键排序
##print(sorted (getDict))
print(list(sorted(getDict.items(), key=lambda getDict:getDict[0],reverse = True)))

79.交集

参考列表差异、对称差集、差集和并集继续修改求交集

list1 = list(map(str, input().split(" ")))
list2 = list(map(str, input().split(" ")))
dict1 = {}
dict2 = {}
#列表转换为字典
for i in list1:
    dict1.setdefault(i)
for i in list2:
    dict2.setdefault(i)
#交集元素加入dict3
dict3 = {}
keys1 = dict1.keys()
for it in keys1:
    if it in dict1 and  it in dict2 and ~(it in dict3):
        dict3.setdefault(it)
    else:
        continue
keys2 = dict2.keys()
for it in keys2:
    if it in dict1 and  it in dict2 and ~(it in dict3):
        dict3.setdefault(it)
    else:
        continue
#结果字典转换为列表排序，然后转为字符串输出
res = list(dict3.keys())
res.sort(key = str)
print(" ".join(res))

调用Set intersection() 方法

set1 = set(input().split())
set2 = set(input().split())
resList = list(set1.intersection(set2))
resList.sort(key = str)
print(" ".join(resList))

80.字典最大值最小值

str1 = list(input().split(","))
getDict = {}
for st in str1:
    key_value = st.split(":")
    if key_value[0] in getDict:
        continue
    else:
        getDict[key_value[0]] = int(key_value[1])
#按值排序
resDict = dict(sorted(getDict.items(), key=lambda getDict:getDict[1],reverse = False))
values = list(resDict.values())
print(values[len(values)-1], values[0])

81.罗马数字||

def RomanInt2Int(str):
    d = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
    count = 0
    for i in range(len(str) - 1):
        if d[str[i]] < d[str[i + 1]]:
            count -= d[str[i]]
        else:
            count += d[str[i]]
    count += d[str[len(str) - 1]]
    return count if 1 < count < 3999 else False
str = input()
print(RomanInt2Int(str))

82.Pow方法

class Calculate:
    def __init__(self, x, n):
        self._x = x
        self._n = n
    def pow(self):
        res = 1
        if n < 0:
            self._x = 1/self._x
        for i in range(0, abs(n)):
            res *= self._x
        return res
x, n = map(int, input().split())
c = Calculate(x, n)
print(c.pow())

83.圆类

class Circle:
    def __init__(self, x):
        self._r = r
    def area(self):
        return self._r*self._r*3.14
    def perimeter(self):
        return 2*self._r*3.14
r = float(input())
c = Circle(r)
print(c.area(), c.perimeter())

84.闭合括号

class utils:
    def __init__(self, st):
        self.st = st
    def changeSt(self, st):
        self.st = st
    def islegal(self):
        lis = []
        dic = {')':'(', ']':'[', '}':'{'}
        for i in range(len(s)):
            if self.st[i] == '(' or self.st[i] == '[' or self.st[i] == '{':
                lis.append(self.st[i])
            if self.st[i] == ')' or self.st[i] == ']' or self.st[i] == '}':
                if lis[len(lis)-1] == dic[self.st[i]]:
                    lis.pop()
        if len(lis) == 0:
            return True
        else:
            return False
u = utils("")
while True:
    s = input()
    if  s == "":
        break
    u.changeSt(s)
    print(u.islegal())

85.矩形类

class Rectangle:
    def __init__(self, L, W):
        self._L = L
        self._W = W
    def perimeter(self):
        return self._L*self._W
l,w = map(int, input().split())
r = Rectangle(l, w)
print(r.perimeter())

86.唯一子集

from math import pow
class A:
    def __init__(self, _s):
        self.s = _s

    def fun(self):
        Len = len(self.s)
        ll = []
        for ii in range(0, int(pow(Len, 2) - 1)):
            lll = []
            for j in range(Len):
                if (ii >> j) % 2:
                    lll.append(self.s[Len - j - 1])
            lll.sort()
            ll.append(lll)
        if ll[-1] != self.s:
            ll.append(self.s)
        return ll
x = input()
l1 = x.split()
for i in range(0, len(l1)):  # 变为int
    l1[i] = int(l1[i])

s1 = set(l1)
l1 = list(s1)  # 去重
l1.sort(reverse=False)  # 排序
a = A(l1)
print(a.fun())

87.罗马数字|

class Int2Roman:
    def __init__(self, n):
        self._n = n
    def int2Roman(self):
        s = list(self._n)
        s.reverse()
        res = ""
        Units = ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"]
        Tens = ["X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"]
        Hundreds = ["C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"]
        Thousands = ["M", "MM", "MMM"]
        All = []
        All.append(Units)
        All.append(Tens)
        All.append(Hundreds)
        All.append(Thousands)
        for i in range(len(s)):
            res = All[i][int(s[i])-1] + res
        return res
n = input()
ir = Int2Roman(n)
print(ir.int2Roman())

88.反向字符串

class ReverseString:
    def __init__(self, str):
        self._str = str
    def reverseStr(self):
        res = ""
        L = self._str.split(" ")
        L.reverse()
        return " ".join(L)
st = input()
rs = ReverseString(st)
print(rs.reverseStr())

89.和为零

class ChooseThree:
    def __init__(self, lis):
        self._Lis = lis
    def chooses(self):
        Res = []
        for i in range(len(self._Lis)):
            for j in range(i+1, len(self._Lis)):
                for k in range(j+1, len(self._Lis)):
                    if 0 == self._Lis[i]+self._Lis[j]+self._Lis[k]:
                        subRes = []
                        subRes.append(self._Lis[i])
                        subRes.append(self._Lis[j])
                        subRes.append(self._Lis[k])
                        Res.append(subRes)
                    else:
                        continue
        return Res
lis = list(map(int, input().split()))
st = ChooseThree(lis)
print(st.chooses())

90.特定目标

class SpecialGoals:
    def __init__(self, lis, n):
        self._Lis = lis
        self._n = n
    def find(self):
        res = ['', '+', '', '=', '']
        res[len(res)-1] = str(self._n)
        for i in range(len(self._Lis)):
            for j in range(i+1, len(self._Lis)):
                if self._Lis[i]+self._Lis[j] == self._n:
                    res[0] = str(self._Lis[i])
                    res[2] = str(self._Lis[j])
                    return " ".join(res)
lis = list(map(int, input().split()))
n = int(input())
sg = SpecialGoals(lis, n)
print(sg.find())

91.URL

import re
def url(string: str) -> list :
    # 含括号匹配时不作处理仅返回括号内容
    # 在括号前假设?:后返回所有元素
    result = re.findall(r'(?:https?|ftp|file)://[-A-Za-z0-9+&@#/%?=~_|!:,.;]+[-A-Za-z0-9+&@#/%=~_|]', string)
    return result
st = input()
print(url(st))

92.数组旋转

list = list(input().split(" "))
n = int(input())
pr = []
flag = False
for j in range(len(list)):
    pr.append(list[(j+n)%len(list)])
print(" ".join(pr))

93.Z字形输出

n = int(input())
lis = []
for i in range(n):
    line = input().split()
    lis.extend(line)
res = []
for i in range(n): 
    if 0 == i:
        for j in range(n):
            res.append(lis[j])
    elif n-1 == i:
        for j in range(n*(n-1), n*n):
            res.append(lis[j])
    else:
        res.append(lis[(i+1)*(n-1)])
print(" ".join(res))

94.斐波那契序列倍数（error）

n, k = map(int, input().split())
f = [0, 1]
i = 2
while n:
    f_i = f[i-1] + f[i-2]  # 添加入斐波那契数列
    f.append(f_i)
    if f[i] % k == 0:
        # 每发现一个k的倍数进行n的自减
        n -= 1
    i += 1
print(len(f)-1)

95.火柴棒

def f(n):
    res = 0
    for i in range(1, n+1):
        res += 3*i
    return res
n = int(input())
print(f(n))

96.镜像字符

chStr = input()
chLis = []
for i in range(len(chStr)):
    chLis.append(chStr[i])
n = int(input())
def f(n, Lis):
    dic = {}
    for i in range(0,26):
        dic[chr(i+ord('a'))] = chr(219-i-ord('a'))
    for i in range(n-1, len(Lis)):
        Lis[i] = dic[Lis[i]]
f(n, chLis)
print("".join(chLis))

97.匹配

#用求交集的方式求
str1, str2 = map(str, input().split(" "))
dic1 = {}
dic2 = {}
res = []
for i in range(len(str1)):
    dic1.setdefault(str1[i])
for i in range(len(str2)):
    dic2.setdefault(str2[i])
keys = dic1
for it in keys:
    if it in dic2:
        res.append(it)
print(len(res))

98.参考排序

是按照第二个序列的值排序的因此只需要将两个等长序列分别作为键和值创建字典，然后对字典按值排序，拿出所有键便是参考第二个序列对第一个序列排序的结果序列

keys = input().split(" ")
values = input().split(" ")   
getDict = dict(zip(keys, values))
Lis = dict(sorted(getDict.items(), key=lambda getDict:getDict[1],reverse = False))
#sorted函数返回的是列表元素所排序的迭代对象的元素
print(" ".join(Lis.keys()))

99.最大元素

values = list(map(int, input().split(" ")))
values = sorted(values)
print(values[len(values)-1])

"""
20 10 20 4 101 4 10
"""

100.24小格式

timeAPM = input().split(" ")
if timeAPM[1] == "AM":
    lis = timeAPM[0].split(":")
    if int(lis[0]) == 12:
        lis[0] = "00"
    print(":".join(lis))
elif timeAPM[1] == "PM":
    lis = timeAPM[0].split(":")
    if int(lis[0]) != 12:
        lis[0] = str((int(lis[0]) + 12)%24)
    print(":".join(lis))

对上面代码进一步简化

timeAPM = input().split(" ")
lis = timeAPM[0].split(":")
if int(lis[0]) == 12 and timeAPM[1] == "AM":
    lis[0] = "00"
elif int(lis[0]) != 12 and timeAPM[1] == "PM":
    lis[0] = str((int(lis[0]) + 12)%24)
print(":".join(lis))