Python OJ50题_三个非负整数 ,分别表示小根的作业成绩、小测成绩和期末考试成绩。相邻两个数之间

0 A+B Problem

题目描述
用来适应环境的题目，自然比较简单些。 计算2个整数的和。这两个整数都在1到1000之间。

输入
输入只有一行，包括2个整数a, b。之间用一个空格分开。

输出
输出只有一行（这意味着末尾有一个回车符号），包括1个整数。
必须用print（）输出你的结果，才能通过OJ的评判

#!/usr/bin/python3 
a,b=map(int,input().split())
print(a+b)
1
2
3

1 python的hello world

题目描述
请在一行输出 “Python = Pile + sensensen”

输入
程序无输入

输出
按照题目要求输出

#!/usr/bin/python3
print("Python = Pile + sensensen")
1
2

2 python成绩

题目描述
森森最近学习了Python课，这门课程的总成绩计算方法是：总成绩=作业成绩×20%+小测成绩×30%+期末考试成绩×50% （课程实际评分规则请以任课教师要求为准）
森森想知道，这门课程自己最终能得到多少分。

输入
输入文件只有1行，包含三个非负整数A、B、C，分别表示森森的作业成绩、小测成绩和期末考试成绩。
相邻两个数之间用一个空格隔开，三项成绩满分都是100分。
0 ≤ A、 B、 C ≤ 100 且 A、 B、 C 都是 10 的整数倍

输出
输出文件只有1行，包含一个整数，即森森这门课程的总成绩，满分也是100分

#!/usr/bin/python3
while True:
    a,b,c=map(int,input().split())
    if (a>=0 and a<=100 and a%10==0 and b>=0 and b<=100 and b%10==0 and c>=0 and c<=100 and c%10==0):
        break
sum=a * 0.2 + b * 0.3 + c * 0.5
print(int(sum))
1
2
3
4
5
6
7

#!/usr/bin/python3
a, b, c= map(int, input().split())
d = int (a*0.2 + b*0.3 + c*0.5)
print(d)

1
2
3
4
5

3 eval() 函数的使用1

题目描述
Pile 学了 eval() 函数，感觉非常好用。所以，她也希望你能掌握这个技能。让我们开始吧。

输入
输入一行一个字符串，表示 eval() 函数所需要执行的语句。保证可以正常执行 eval() 函数。

输出
输出 eval() 函数执行的语句。

#!/usr/bin/python3
eval(input())
1
2

4.math 库的使用1

题目描述
森森在学专业课的时候，发现一个神奇的函数，叫 Gamma 函数。
森森想知道 Gamma 函数的值。

输入
输入一行一个正整数 n ，表示森森想要知道的函数值。

输出
输出一行一个浮点数，表示 Gamma(n) 的值。

#!/usr/bin/python3
import math
x=input()
out=math.gamma(int(x))
print(out)
1
2
3
4
5

5.字符串存在判定

题目描述
Pile 想要知道，一个字符串在另一个字符串内是否存在。

输入
输入第一个字符串表示字符串 a；
第二行一个字符串 b

输出
输出 ‘True’ 或者 ‘False’ ，表示字符串是否存在。

#!/usr/bin/python3
str1=input()
str2=input()
if str1 in str2:
    print("True")
else:
    print("False")
1
2
3
4
5
6
7

#!/usr/bin/python3
a = input()
b = input()
if b.find(a) != -1:
    print("True")
else : print("False")

1
2
3
4
5
6
7

6.回文串的判断

题目描述
Pile 想知道她构造的一个字符串是不是回文串，请你帮她判断一下吧。
回文串的定义是反向排列与原串相同。

输入
一行一个字符串，表示 Pile 提供给你的字符串。

输出
输出 ‘True’ 表示输入的串是回文串；否则输出 ‘False’ 。

#!/usr/bin/python3
str1=input()
str2=str1[ : :-1]
if(str1==str2):
    print("True")
else:
    print("False")
1
2
3
4
5
6
7

7.成绩分析

题目描述
森森的期末考试考完了，她想知道自己的成绩等级。
她的成绩与等级之间是这样转换的：
成绩在 90~100 分之间是 A;
成绩在 80~89 分之间是 B;
成绩在 70~79 分之间是 C;
成绩在 60~69 分之间是 D;
成绩在 0~59 分之间是 F。
请你根据她的成绩计算出她的等级。当然，她可能会输入一个错误的值，这时候请输出 “Error!” 。

输入
输入一行一个整数，表示森森的成绩

输出
输出一个字母或者 “Error!” 表示结果。

#!/usr/bin/python3
grade=input()
grade=int(grade)
if(grade>=90 and grade<=100):
    print("A")
elif(grade>=80 and grade<=89):
    print("B")
elif(grade>=70 and grade<=79):
    print("C")
elif(grade>=60 and grade<=69):
    print("D")
elif(grade>=0 and grade<=59):
    print("F")
else:
    print("Error!")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

8.最大公约数

题目描述
Pile 想要知道一个经典问题：
给你两个数，请求出一个数的最大公约数

输入
输入两行，其中：
第一行一个正整数，表示 a
第二行一个正整数，表示 b

输出
输出 a, b 的最大公约数

#!/usr/bin/python3
import  math
a=eval(input())
b=eval(input())
print(math.gcd(a,b))
1
2
3
4
5

9.输出偶数

题目描述
森森最喜欢偶数了。
请你帮她输出 从 1 到 n 的所有偶数~

输入
输入一行一个数，表示上文中的 n

输出
输出多行，保证一行有且只有一个偶数。

#!/usr/bin/python3
import  math
n=eval(input())
for i in range(1,n+1):
    if i%2==0 :
        print(i)
1
2
3
4
5
6

10.计算均值

题目描述
Pile 想问你一个问题：
给你 n（1 <= n <= 10000）个整数，求它们的和与均值。

输入
输入第一行是一个整数n，表示有n个整数。
第2~n+1行每行包含1个整数。

输出
输出一行，先输出和，再输出平均值（保留到小数点后5位），两个数间用单个空格分隔。

#!/usr/bin/python3
n=eval(input())
sum=0
for i in range(0,n):
    num=eval(input())
    sum+=num
average=sum/n
print("{} {:.5f}".format(sum,average))
1
2
3
4
5
6
7
8

11.计算阶乘

题目描述
森森想知道 1! + 2! + … + n!，请你帮她计算一下吧。

输入
输入一行一个整数 n, 表示上文的 n

输出
输出一个整数表示结果

#!/usr/bin/python3
n=eval(input())
factorial,sum=1,0
for i in range(1,n+1):
    factorial*=i
    sum+=factorial
 
print(sum)
1
2
3
4
5
6
7
8

12.汇率兑换

题目描述
按照课本中温度转换程序的设计思路，按照 1美元 = 6人民币的汇率编写美元和人民币的双向兑换程序。

输入
输入一行字符串，表示人民币或者美元的数量。保证字符串的最后一位是 A-Z 的字母，其他位置均为数字。
人民币的最后一位一定是 ‘R’ 或者 ‘r’
美元的最后一位一定是 ‘D’ 或者 ‘d’

输出
输出转换后的结果。结果表示为一个字符串，前面输出一个整数，最后一位输出 “R” 或者 “D” 表示人民币或者美元。
如果不能转换，输出 “Error!” 。

#!/usr/bin/pyth
money=input()
if money[-1] in ["R","r"]:
    Dollar=int(money[0:-1])/6
    print("{0:d}D".format(int(Dollar)))
elif money[-1] in ["D","d"]:
    RMB=int(money[0:-1])*6
    print("{0:d}R".format(int(RMB)))
else:
    print("Error!")
1
2
3
4
5
6
7
8
9
10

13.进度条的显示

题目描述
实现一个进度条函数，具体的实现方法可以与书上的代码以及对照进行实现。

输入
输入 scale 表示输出进度条的精度。

输出
输出整个执行过程。

#!/usr/bin/python3
scale = eval(input())
count=0
print("------start------")
for i in range(0,101,int(100/scale)):
    a = '*' * count*2
    b = '.' * (scale*2 - count*2)
    c = i
    count=count+1
    print("{:>3.0f} %[{}->{}]".format(c, a, b))
print("------end-----")
1
2
3
4
5
6
7
8
9
10
11

14.因子数

题目描述
森森非常喜欢数字4和7，看到一个数字她就想快速计算出因子里面分别有几个4和7，但是智商捉急的她总是要算很久，喜欢编程的你能够帮助她吗？

输入
第一行一个整数n，表示给定的数字。

输出
两个用空格隔开的数字，分别表示给定数字的因子中4和7的个数。

#!/usr/bin/python3
num = eval(input())
m1=0
m2=0
while(divmod(num,7)[1]==0):
        num=num//7
        m1=m1+1
 
while(divmod(num,4)[1]==0):
    num=num//4
    m2=m2+1
 
print(m2,m1)
1
2
3
4
5
6
7
8
9
10
11
12
13

15.文章检测

题目描述
给你一篇英文文章，请问你里面有多少个空格、数字字符、英文字母和其他字母。

输入
输入多行文字，以 EOF 结束
每一行表示一个文章的段落

输出
输出一行提示信息，具体格式见样例。

#!/usr/bin/python3
stopword = 'EOF'
stri = ''
int_num,str_num,space_num=0,0,0
 
try:
    for line in iter(input, stopword):
        stri += line + '\n'
except EOFError:
    pass
 
stri = stri[0:-1]
other_num=stri.count("\n")
stri2=stri.replace("\n","")
 
for item in stri2:
    if item.isdigit() :
        int_num+=1
    elif item.isalnum():
        str_num+=1
    elif item.isspace() :
        space_num+=1
    else:
        other_num +=1
print("{} spaces, {} numbers, {} letters, {} other characters.".format(space_num,int_num,str_num,other_num))
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

16.eval() 函数的使用2

题目描述
森森希望多了解一下 eval() 函数，于是她给你了几个定义：
x = 12, y = 14
她希望你能计算她的表达式。
她可能需要使用 math 库来保证表达式的正常执行。

输入
输入一行字符串表示 x 和 y 的表达式

输出
输出一行一个数，表示字符串的值。

#!/usr/bin/python3
import math
x=12
y=14
str=eval(input())
print(str)
1
2
3
4
5
6

17.质数的和与积

题目描述
Pile 想知道一个简单的问题：
两个质数的和是S，它们的积最大是多少？

输入
一个不大于10000的正整数S，为两个质数的和。

输出
一个整数，为两个质数的最大乘积。数据保证有解。

#!/usr/bin/python3
import math
 
num=eval(input())
 
def isPrime(n):
    if n <=1 :
        return False
    for i in range(2,int(math.sqrt(n)+1)):
        if n %i ==0:
            return  False
 
    return True
 
a=num//2
b=num-a
 
while 1:
    if isPrime(a) and isPrime(b):
        print(a*b)
        break
    a=a-1
    b=num-a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

18.寻找多数元素

题目描述
森森在学习列表的时候，发现一道经典的题目：在一个序列中寻找多数元素。
她给你了一道简化版的问题：
询问你这个序列里面出现次数最多的元素的出现次数。

输入
输入多行，一行一个数表示序列里面的每一个数。
注：使用
try:
except EOFError:
来判断什么时候结束输入

输出
输出一行，表示出现次数最多的数字的出现次数。

#!/usr/bin/python3
stopword = 'EOF'
stri = ''
ls=[]
max=1
try:
    for line in iter(input, stopword):
        stri += line + '\n'
except EOFError:
   pass
ls=stri.split('\n')
del ls[-1]
for item  in ls :
    num=ls.count(item)
    if num >max:
        max=num
print(max)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#!/usr/bin/python3

list=[]
while(1):
    try:
        num=int(input())
        list.append(num)
    except:
        break
dict={}#字典
for key in list:
    dict[key]=dict.get(key,0)+1 #查询字典中key是否有，有的话返回key值，没有返回0
value=max(dict.values())
print(value)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

19.判断素数

题目描述
Pile 想实现一个判断素数的函数。当这个数是素数的时候输出 ‘True’ ，不是素数输出 ‘False’ 。
但是她是一个粗心的孩子，她有时候会输入一些奇怪的字符串，这个时候你需要输出 ‘invalid’。

输入
输入一行一个字符串表示 Pile 的输入。

输出
对于输入，输出一行字符串 ‘True’ ‘False’ 或者 ‘invalid’ 表示结果。

#!/usr/bin/python3
import  math
def isPrime(n):
    if n<=1:
        return False
    elif n==2:
        return True
    else:
        for i in range(2,int(math.sqrt(n))+1):
            if  n % i ==0:
                return False
        return True
try:
    str=input()
    math.sqrt(int(str))
    M=isPrime(int(str))
    print(M)
except (TypeError,ValueError):
    print('invalid')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#!/usr/bin/python3
import math

def is_prime(number):  # 判断是否为素数
    sqrt = int(math.sqrt(number))
    for j in range(2, sqrt + 1):  # 从2到number的算术平方根迭代
        if number % j == 0:  # 判断j是否为number的因数
                return 'False'
    return 'True'

str = input()
int1_count = 0

for i in str:
    if i.isdigit():
        int1_count += 1

if int1_count!=len(str):
    print('invalid')
else:
    print(is_prime(int(str)))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

20.所有参数的乘积

题目描述
森森想要写一个返回多个参数的乘积函数。你需要这样调用：
#!/usr/bin/python3

print(eval(input()))

输入
输入一行表示字符串，保证字符串的格式为：
multi(参数列表)
其中参数列表中每个数以逗号分隔。
保证至少有一个参数。

输出
如果输入的参数均可以参与乘法运算，输出乘积；
否则输出第一个不合法的参数，形式为 :
Invalid arg x
x 表示第 x 个参数不合法

#!/usr/bin/python3
 
def multi(*args):
    result = 1
    count = 0
    try:
        for item in args:
            count += 1
            item= item + 1 - 1 #判断是否为数字
            result *= item
    except TypeError:
        return ('Invalid arg %d'%count)
    return result
print(eval(input()))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

21. 到底怎么样才能写好 Python?

题目描述
Pile 想知道，到底怎么样才能写好 Python？你需要输出一篇 Tim Peters 的文章来告诉 Pile。

输入
程序无输入。

输出
输出题目所要求的文章。

#!/usr/bin/python3
import this
1
2

22. CSV 文件解析

题目描述
森森喜欢将 CSV 文件打开看看，但是当她看到的文件里面都有好多逗号的时候，她觉得很不舒服。
她需要你去把一个 CSV 文件的逗号去掉并换成 \t 。
请你帮帮她吧。

输入
输入多行，表示一个 CSV 文件。

输出
输出多行，表示你的输出。注意逗号都需要换成 \t 。

#!/usr/bin/python3
lines = ''
stopword = 'EOF'
try:
    for line in iter(input, stopword):
        lines += line +'\t'+'\n'
except EOFError:
    pass
after_lines = lines.replace(',', '\t')
print(after_lines)
1
2
3
4
5
6
7
8
9
10

#!/usr/bin/python3
import csv

#输入csv文件
fo = open("shishi.csv","w")
list=[]

stopword = ''
stri = ''
try:
    for line in iter(input, stopword):
        stri += line + '\n'
except EOFError:
   pass
stri = stri[0:-1]
list = stri.split(",")

fo.write(",".join(list)+"\n")
fo.close()

#输出csv文件
fo = open("shishi.csv","r")
ls = []
for line in fo:
    line = line.replace("\n","")
    ls = line.split(",")
    lns = ""
    for s in ls:
       lns += "{}\t".format(s)
    print(lns)
fo.close()

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

23. 重复元素的判定

题目描述
Pile 想知道一个集合里面有没有重复元素，请你帮帮她吧。

输入
输入第一行表示元素的个数 N。
以下 N 行，每行一个数字。

输出
如果有重复元素，请输出两行：第一行"True" ；第二行，输出一个数，表示是第几个元素重复。如果有多个重复的，请输出重复元素中编号最小的； （注：这里重复元素中编号最小的指从第2个重复的元素开始算，如1 2 2则输出第二个2所在的位置3，1 3 4 3输出4，1 3 4 5 3 3输出5，依次类推。）
否则，输出一行 “False” 表示没有元素重复。

#!/usr/bin/python3
a = int(input())
t = 0
y = []
for i in range(a):
    y.append(int(input()))
for i in range(len(y)):
    if t == 0:
        if y.count(y[i])>1:
            t = 1
            for j in range(len(y[i+1:])):
                if y[i] == y[i+1+j]:
                    print("True")
                    print(i+2+j)
                    break      
if t == 0:
    print("False") 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#!/usr/bin/python3
list=[]
N = int(input())

while(N):
    try:
        num=int(input())
        list.append(num)
        N -= 1
    except:
        break

i = 0
dict={}#字典
for key in list:
    dict[key]=dict.get(key,0)+1 #查询字典中key是否有，有的话返回key值，没有返回0
    i +=1
    if dict[key] == 2:
        print("True")
        print(i)
        break

value=max(dict.values())
if value<2:
    print("False")


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

24. 计算集合的并

题目描述
森森喜欢求两个集合的并，请你帮她求一下吧。

输入
输入两行，每行表示一个集合，每个集合的元素（均为数字）以一个空格分隔。

输出
输出一行表示集合。

#!/usr/bin/python3
s1 = set(map(int, input().split()))
s2 = set(map(int, input().split()))
s = s1 | s2
print(s)
1
2
3
4
5

25. 计算标准差

题目描述
Pile 想知道好多个数字的标准差。

输入
输入多行，每行表示一个整数

输出
输出标准差，输出格式可以参考样例。
输出的标准差要求利用科学计数法表示，且只能输出 2 位数，例如 1.2e+09。

#!/usr/bin/python3
import math
 
def mean(numbers):#计算平均值
    s = 0.0
    for num in numbers:
        s = s +num
    return s / len(numbers)
 
def dev(numbers,mean):#计算方差
    sdev = 0.0
    for num in numbers:
      sdev = sdev + (num - mean)**2
    return math.sqrt(sdev/(len(numbers)-1))
 
list=[]
while(1):
    try:
        num=int(input())
        list.append(num)
    except:
        break
 
n = list
m = mean(n)
print("dev = {:.2}.".format(dev(n,m)))
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

26 键值查询

题目描述
给你一个集合，请你输出我想要知道的键所对应的值。

输入
输入第一行表示一个集合。
第二行表示我想要知道的键。

输出
输出一个值，表示结果。

#!/usr/bin/python3
dct = eval(input())
k = input()
print(dct[k])
1
2
3
4

27 月份输出

题目描述
Pile 想知道月份的英文表示。她会输入一个月份，请你输出对应的表示。
每个月份用三个英文字母表示，且第一个字母是大写，后面两个是小写。

输入
输入一行一个整数，表示月份的数字。

输出
输出一行一个字符串表示月份。
字符串长度一定是 3 。

#!/usr/bin/python3
month = "JanFebMarAprMayJunJulAugSepOctNovDec"
monthid = eval(input())
pos = (monthid - 1)*3
print(month[pos: pos+3])
1
2
3
4
5

28 字符串进制转换

题目描述
请你将一个 10 进制的整数字符串转换成 16 进制。

输入
输入一行字符串，表示一个 10 进制。

输出
输出一个字符串，表示转换的结果。

#!/usr/bin/python3
num = int(input())
print(hex(num))
1
2
3

29 CSV 文件转换成 JSON 文件

题目描述
森森有一个 csv 文件，她希望转换成 json 文件。
请你帮她做一下吧。

输入
输入多行，表示 csv 文件。

输出
输出多行，表示 json 文件。

#!/usr/bin/python3
import json
try:
    a = []
    while(1):
        a.append(input().split(","))
except EOFError:
    pass
b = []
for i in a[1:]:
    b.append(dict(sorted(zip(a[0],i))))
print(json.dumps(b,indent = 4))
1
2
3
4
5
6
7
8
9
10
11
12

30 集合的交

题目描述
森森森喜欢求两个集合的交，请你帮她求一下吧。

输入
输入两行，每行表示一个集合，每个集合的元素（均为数字）以一个空格分隔。

输出
输出一行表示集合。

#!/usr/bin/python3
a ,b = set(map(int , input().split(" "))) ,set(map(int , input().split(" ")))
print(a&b)
1
2
3

31 小型登陆系统

题目描述
给用户三次输入用户名和密码的机会，要求如下：‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬
1）如输入第一行输入用户名为 ‘Pile’ ,第二行输入密码为 ‘MAKIKAWAYI’，输出 ‘SUCCESS’，退出程序；‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬
2）当一共有3次输入用户名或密码不正确输出 ‘FAILED’。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬

输入
输入最多 6 行。
每两行表示一组测试数据，其中第一行表示账号，第二行表示密码。
保证最后一定能输出结果。

输出
输出一行 ‘SUCCESS’ 或者 ‘FAILED’ ，表示登录成功或者失败。

i = 0
while i < 3:
    name = input()
    key = input()
    if name == 'Pile':
        if key == 'MAKIKAWAYI':
            print('SUCCESS')
            exit(0)
    i += 1
print('FAILED')
 
1
2
3
4
5
6
7
8
9
10
11

32 密码

题目描述

在上一题里， Pile 设置的密码是 ‘MAKIKAWAYI’ ，森森森觉得这个密码过于简单，于是告诉 Pile，怎么样设置一个安全的密码。那什么样的密码才叫安全的呢？一般来说一个比较安全的密码至少应该满足下面两个条件：
(1).密码长度大于等于 8 ，且不要超过 16。
(2).密码中的字符应该来自下面“字符类别”中四组中的至少三组。

这四个字符类别分别为：
1.大写字母：A,B,C…Z;
2.小写字母：a,b,c…z;
3.数字：0,1,2…9;
4.特殊符号：~,!,@,#,$,%,^;

然而规则太多了，森森森也有点搞晕了。于是她给你一个密码，她想问你这个密码是不是安全的。

输入
输入数据第一行包含一个数 M (M ≤ 50) ，接下有 M 行，每行一个密码（长度最大可能为 50 ），密码仅包括上面的四类字符。

输出
对于每个测试实例，判断这个密码是不是一个安全的密码，是的话输出 YES ，否则输出 NO 。

import re
def keygrade(key):
    pattern1 = re.compile('[0-9]+')
    pattern2 = re.compile('[a-z]+')
    pattern3 = re.compile('[A-Z]+')
    pattern4 = re.compile('[~,!,@,#,$,%,^]+')
    if len(key) not in range(8, 17):
        return False
    typekey = 0
    if pattern1.findall(key):
        typekey += 1
    if pattern2.findall(key):
        typekey += 1
    if pattern3.findall(key):
        typekey += 1
    if pattern4.findall(key):
        typekey += 1
    if typekey >= 3:
        return True
    else:
        return False
 
M = int(input())
keylist = []
for i in range(0, M):
    keylist.append(input())
for i in range(0, M):
    if keygrade(keylist[i]):
        print('YES')
    else:
        print('NO')
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

33 斐波那契数列Fibonacci问题

题目描述
斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……在数学上，斐波那契数列以如下被以递推的方法定义：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=3，n∈N*）在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用，为此，美国数学会从1963年起出版了以《斐波纳契数列季刊》为名的一份数学杂志，用于专门刊载这方面的研究成果。
现在请你编程计算一下这个数列
已知 f(0) = f(1) = 1, f(n) = f(n - 1) + f(n - 2) (n ≥ 2)。
现在给定一个数 n, 请求出 f(n) 。

输入
输入第一行包含一个正整数 T, 表示数据的组数。
之后 T 行，每行一个正整数 n 。
保证 1 ≤ T ≤ 1000, 1 ≤ n ≤ 40。
此题如果超时可以看看提示信息

输出
对于每个输入，输出一行一个数，表示 f(n)。

def fibonacci(num):
    if num <= 1:
        return 1
    else:
        a, b, c = 0, 1, 0
        for i in range(0, num):
            c = a + b
            a = b
            b = c
        return c
T = int(input())
numlist =[]
for i in range(0, T):
    numlist.append(int(input()))
for i in range(0, T):
    print(fibonacci(numlist[i]))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

34 列表实现筛选法求素数

题目描述
实现一个程序，输入一个大于等于 5 且小于 50000 的自然数 x ，请你构造一个列表，这个列表只包括不相同的两个数，要求它们在小于等于 x 的前提下最大，并将这个列表输出。

输入
输入只有唯一一行，表示上文中的 x 。

输出
输出一个只含有两个数的列表，要求如题意所示，注意列表元素要满足递增关系，见样例。

n = eval(input())
c = []
for i in range (n , 2 ,  -1):
    p = 1
    for j in range( 2 , int(pow(n,0.5))+1  ):
        if i % j == 0:
            p = 0
            break
    if p == 1:
        c.append(i)
    if len(c) == 2 :
        print(c[::-1])    
        break
1
2
3
4
5
6
7
8
9
10
11
12
13

35. 圆周率的计算

题目描述
求解圆周率可以采用蒙特卡罗方法，在一个正方形中撒点，根据在1/4圆内点的数量占总撒点数的比例计算圆周率值。
请以给定的数字作为随机数种子，获得用户输入的撒点数量，编写程序输出圆周率的值，保留小数点后6位。

输入
输入两行，第一行表示用户撒点的数量，第二行表示随机数种子。
保证撒点数量 < 3*105

输出
输出一个含有 6 位小数的值，表明本次撒点实验得到的圆周率。

#!/usr/bin/python3
from random import random, seed
 
DARTS = eval(input())
zhongzi = int(input())
seed(zhongzi)
hits = 0.0
for i in range(DARTS):
    x, y = random(), random()
    dist = pow(x ** 2 + y ** 2, 0.5)
    if dist <= 1.0:
        hits = hits + 1
pi = 4 * (hits/DARTS)
print("{:.6f}".format(pi))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

36.凯撒密码

题目描述
凯撒密码是古罗马凯撒大帝用来对军事情报进行加解密的算法，它采用了替换方法对信息中的每一个英文字符循环替换为字母表序列中该字符后面的第三个字符，即，字母表的对应关系如下：‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬
原文：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‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬
密文：D E F G H I J K L M N O P Q R S T U V W X Y Z A B C‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬
对于原文字符P，其密文字符C满足如下条件：C=(P+x) mod 26‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬
上述是凯撒密码的加密方法，解密方法反之，即：P=(C-x) mod 26‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪
其中x为偏移量。‬
假设用户可能使用的输入包含大小写字母azAZ、空格和特殊符号，请编写一个程序，对输入字符串进行凯撒密码加密，直接输出结果，其中空格和特殊符号不用进行加密处理。

输入
输入两行，第一行是凯撒密码字符串，第二行表示偏移量。
保证偏移量 > 0，字符串长度在 100 以内。

输出
输出一行，表示最终得到的字符串。

#!/usr/bin/python3
code = list(input())
x = int(input())
string_s=''
for cr in code:
    if (ord(cr)>=65 and ord(cr)<=90):
        a = ord(cr)-65
        a = (a+x)%26
        cr = chr(65+a)
    elif (ord(cr)>= 97 and ord(cr)<= 122):
        a = ord(cr)-97
        a = (a+x)%26
        cr = chr(97+a)
    string_s+=cr
print(string_s)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

37. 字符串重复判断

题目描述
从一篇文章中取出 N 个字符串，这 N 个字符串构成一个数组（列表） A，假设每个字符串只包含小写字母，返回由数组 A 中每个字符串都包含的字符构成的字符串，字符串中的字母都按照字母序排列。

输入
输入一个列表，每个字符串都是由引号括起来的。

输出
输出一个符合题意的字符串，注意这个字符串包含双引号"。

#!/usr/bin/env python3
import ast
 
def main():
    a = ast.literal_eval(input())
    dataset2 = []
    out = ''
    stra = ''
    for i in a[0]:
        dataset2.append(i) 
        for i1 in range(1,len(a)):
            if i not in a[i1]:
                del(dataset2[-1])
                break
            stra = a[i1].replace(i,'',1)
            a[i1] = stra
    dataset2 = sorted(dataset2)
    for i in range(len(dataset2)):
        out += str(dataset2[i])
    print('"{}"'.format(out))
if __name__ == '__main__':
    main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

38. 卡片选择

题目描述
从一篇文章中取出 N 个字符串，这 N 个字符串构成一个数组（列表） A，假设每个字符串只包含小写字母，返回由数组 A 中每个字符串都包含的字符构成的字符串，字符串中的字母都按照字母序排列。

输入
输入一个列表，每个字符串都是由引号括起来的。

输出
输出一个符合题意的字符串，注意这个字符串包含双引号"。

#!/usr/bin/python3
def maxlist(thelist):
    if 0 not in thelist:
        print(-1)
    elif 5 not in thelist:
        print(0)
    else:
        for i in range(thelist.count(5), 8, -1):
            if 5 * i % 9 == 0:
                print('5' * i + '0' * thelist.count(0))
                exit(0)
        print(0)
n = int(input())
filist = list(map(int, input().split()))
maxlist(filist)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

39. Life, the Universe, and Everything

题目描述
Please rewrite small numbers from input to output. Stop processing input after reading in the number 42. All numbers at input are integers of one or two digits.
请将很小的数从输入重写到输出。当读到数字 42 时停止处理输入。所有在输入的数字都只有 1 或 2 位数。

输入
多行输入，输入满足题意。

输出

#!/usr/bin/python3
lists = []
while True:
    nums = int(input())
    if(nums==42):
        for number in lists:
            print(number)
        while(1):
            nums = input()
    lists.append(nums)
1
2
3
4
5
6
7
8
9
10

40. 23333

题目描述
给定一个十进制数N。N满足：除了最高位是2，其余都是3，且3的个数大于0。求N在K进制的表示。

输入
输入一行两个整数N, K

输出
一个K进制数。

#!/usr/bin/python3
list=['0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F']
[num,K]=map(int,input().split())
 
outlist=[]
 
while(1):
    quotient=num//K
    remainder=num%K
    outlist.append(remainder)
    if(quotient==0):
        break
    num=quotient
 
outstr=''
for i in range(0,len(outlist)):
    outstr+=list[outlist[len(outlist)-1-i]]
 
print(outstr)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

41. 整数数列求和

题目描述
求s=a+aa+aaa+aaaa+….的值，其中，a是0~9范围内的一个数字。输入n和a，其中n表示累加的项数。例如，当n=5,a=2时，s=2+22+222+2222+22222。

输入
输入整数n和a, 0 ≤ a ≤ 9, n ≤ 10000

输出
计算s=a+aa+aaa+aaaa+….的值并输出，其中共有n项进行累加。

#!/usr/bin/python3
n,a = input().split()
sum = 0
a = int(a)
b = a
for i in range(int(n)):
    sum += a
    a = a*10+b
print(sum)
1
2
3
4
5
6
7
8
9

42.星号三角形

题目描述
读入一个整数N，N是奇数，输出由星号字符组成的等边三角形，要求：‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬
第1行1个星号，第2行3个星号，第3行5个星号，依次类推，最后一行共 N 个星号。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬

输入
一行一个整数，表示 N (N ≤ 30) 且 N 是奇数

输出
输出题目要求的三角形

#!/usr/bin/python3
n=int(input())
h = int((n+1)/2)
for i in range(h):
    str1=''
    str2=''
    j = 2*i+1  #number of stars
    k = h-i-1
    for g in range(k):
        if(k==0):
            break
        str1+=' '
    for m in range(j):
        str2+='*'
    print(str1+str2+str1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

43.手机短号

题目描述
大家都知道，手机号是一个 11 位长的数字串，同时，作为学生，还可以申请加入校园网，如果加入成功，你将另外拥有一个短号。假设所有的短号都是是 6+手机号的后 5 位，比如号码为 13512345678 的手机，对应的短号就是 645678。
现在，如果给你一个手机号码，你能找出对应的短号吗？ 注意，这个手机号码可能并不是 11 位的，这个时候你需要输出 “Halation - I can’t join it!”

输入
输入数据的第一行是一个N(N <= 200)，表示有N个数据，接下来的N行每一行为一个多位的手机号码，但是长度不会超过 50。

输出
输出应包括 N 行，每行包括一个对应的短号或者提示信息，输出应与输入的顺序一致。

#!/usr/bin/python3
n = int(input())
strs=[]
for i in range(n):
    ss = input()
    strs.append(ss)
for s in strs:
    if len(s)!=11:
        print("Halation - I can't join it!")
        continue
    print('6'+s[-5:])
1
2
3
4
5
6
7
8
9
10
11

44 aaaa + bbbb

def change(x):
    re = ""
    for i in x:
        re = re + "0" * (8-len(  bin(ord(i))[2:]  )) +  bin(ord(i))[2:]  
    return re
t = eval( input() )
line = []
for i in range(t):
    z = list( map( change , list(input().split() )))
    line.append(int('0b'+str(z[0]),2) + int('0b'+str(z[1]),2))
for i in line:
    print(i)
1
2
3
4
5
6
7
8
9
10
11
12

45 6翻了

题目描述
“666”是一种网络用语，大概是表示某人很厉害、我们很佩服的意思。最近又衍生出另一个数字“9”，意思是“6翻了”，实在太厉害的意思。如果你以为这就是厉害的最高境界，那就错啦 —— 目前的最高境界是数字“27”，因为这是 3 个 “9”！
本题就请你编写程序，将那些过时的、只会用一连串“6666……6”表达仰慕的句子，翻译成最新的高级表达。

输入
输入在一行中给出一句话，即一个非空字符串，由不超过 1000 个英文字母、数字和空格组成，以回车结束。

输出
从左到右扫描输入的句子：如果句子中有超过 3 个连续的 6，则将这串连续的 6 替换成 9；但如果有超过 9 个连续的 6，则将这串连续的 6 替换成 27。其他内容不受影响，原样输出。

import re
youstr = input()
youstr = re.sub(r'6{10,}', "27", youstr)
youstr = re.sub(r'6{4,9}', "9", youstr)
print(youstr)
1
2
3
4
5

s = input()            
temp = ""
num = 0
flag = False
for i in s:
    if i == "6":       
        num = num + 1
        flag = True   
    else:               
        if flag:
            if num > 9:
                temp = temp + "27"
            elif num > 3:
                temp = temp + "9"
            else:
                temp = temp + "6" * num    
        temp = temp + i     
        num = 0
        flag = False
if flag:            
    if num > 9:
        temp = temp + "27"
    elif num > 3:
        temp = temp + "9"
    else:
        temp = temp + "6" * num
print(temp)
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

46.有理数四则运算1

题目描述
本题要求编写程序，计算 2 个有理数的和。

输入
输入两行，每行一个字符串，表示这个分数形式的有理数。其中分子和分母全是整数，分母不为 0。

输出
输出 2 个有理数的和 x/y ，注意数字需要约分到最简。

#!/usr/bin/python3
from fractions import Fraction
s1=input()
s2=input()
a=Fraction(s1)+Fraction(s2)
c = str(a.numerator)
d = str(a.denominator)
print(c+'/'+d)
1
2
3
4
5
6
7
8

47 时间复杂度1

给你一个程序：

def f(x): 
    if x == 1: return 0 
    global cnt 
    s = x 
    for i in range(2, s): 
        cnt += 1 
        if x % i == 0: return 1 
    return 2
if __name__ == '__main__': 
    cnt = 0 
    n = int(input())
    for i in range(2, n + 1): f(i) 
    print(cnt)  
1
2
3
4
5
6
7
8
9
10
11
12
13

每次给定 n, 请求出 cnt 的值。
输入
输入多行数字，以 EOF 结束。
每一行一个数字 n (1 ≤ n ≤ 10000) 表示题意中的 n 。

输出
对于每一行的 n 输出对应值。

def f(x): 
    for i in range(3,x+1):
        global cnt
        y = cnt[-1]
        z = 0
        for j in range(2, i): 
            y += 1
            if i % j == 0: 
                cnt.append(y)
                z = 1
                break
        if z == 0:
            cnt.append(y) 
                 
line = []
cnt = [0,0,0]
try :
    while (1):
        line.append(eval(input()))
except EOFError:
    pass
f(max(line))
for i in line:
    print(cnt[i])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

48 时间复杂度2

题目描述
给你一个程序：

import math
def f(x): 
    if x == 1: return 0 
    global cnt 
    s = int(math.sqrt(x))
    for i in range(2, s + 1): 
        cnt += 1 
        if x % i == 0: return 1 
    return 2
if __name__ == '__main__': 
    cnt = 0 
    n = int(input())
    for i in range(1, n + 1): f(i) 
    print(cnt)  
1
2
3
4
5
6
7
8
9
10
11
12
13
14

每次给定 n, 请求出 cnt 的值。

输入
输入多行数字，以 EOF 结束。
每一行一个数字 n (1 ≤ n ≤ 10000) 表示题意中的 n 。

输出
对于每一行的 n 输出对应值。

import math
def f(x): 
    if x == 1: return 0
    global cnt 
    s = int(math.sqrt(x))
    for i in range(2, s + 1): 
        cnt += 1
        if x % i == 0: return 1
    return 2
  
if __name__ == '__main__': 
    cnt = 0
    try :
        a = []
        while(1):
            a.append ( int(input()))
    except:
        p = [0,0]
        n = max(a)
        for i in range(2, n + 1): 
            f(i) 
            p.append(cnt)
        for i in a:
            print(p[i])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

49 admin 的密码问题

题目描述
为了准备 Python OJ 的账号，admin 有时需要为用户随机生成密码。
问题是总是有一些难以识别的密码，比如说1和l（L的小写字母），或者0和O（o的大写字母）。
一个解决方法是用@替换1，用%替换0，用L替换l，用o替换O。
现在你的任务是写一个程序来帮助 admin 核对账户信息并改变难以识别的密码。

输入
每个输入文件包含一组测试数据。
对于每组输入数据，包含一个正整数N(<=1000)，接着是N行账户信息。
每条账户信息包含一个用户名和一个密码，都是不包括空格的不超过10个字符的字符串。

输出
对于每组输入数据，首先输出需要修改的密码总数M，接着输出N行修改后的账户信息，即用户名和对应的修改后的密码。账户必须按照和读入顺序一样的顺序输出。
如果没有账户需要修改，输出一行 “There are N accounts and no account is modified”，N为账户总数。但是，如果N为1，你必须输出 “There is 1 account and no account is modified” 。

#!/usr/bin/python3
n = int(input())
strs=[]
lists=[]
for i in range(n):
    s = input()
    strs.append(s)
rec = len(strs)
sums=0
change = 0
for s in strs:
    first = s.split(' ')[0]
    back = s.split(' ')[1]
    if '1' in back or'0' in back or 'l' in back or 'O'in back:
        back = back.replace('1','@')
        back = back.replace('0', '%')
        back = back.replace('l', 'L')
        back = back.replace('O', 'o')
        lists.append(first+' '+back)
        change+=1
    else:
        sums+=1
if sums == rec and sums == 1:
    print('There is {} account and no account is modified'.format(sums))
elif sums == rec and sums>1:
    print('There are {} accounts and no account is modified'.format(sums))
else:
    print(change)
    for s in lists:
        print(s)
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

50 分级

题目描述
相信大家对于英语考试结果分班这个事情不陌生吧。
假设这一次英语的满分为 m 分，每个分数对应的人数 ci （表示分数为 i 的人有 ci 个）。现在要对这些人分班。
你需要找到一个合适的k，使得大于等于k的人数在[L,R]范围内，这些人为高级班。
同样小于k的人数也需要满足[L,R]范围，这些人为初级班。
需要你找出最小满足条件的 k ，若不存在答案，请输出 0 。

输入
输入文件共三行。
第一行输入一个整数 m(1<=m<=100)；
第二行输入 m 个整数 ci (0<=ci<=100)；
第三行输入两个整数L,R(1<=L<=R<=10000)含义见描述

输出

#!/usr/bin/python3
m = int(input())
c=input().split()
L,R = input().split()
L = int(L)
R = int(R)
flag=0
for k in range(m):
    big = 0
    small = 0
    for (index,sc) in enumerate(c):
        sc = int(sc)
        if index>=k:
            big+=sc
        else:
            small+=sc
    if  L<=big<=R and L<=small<=R:
        flag=1
        print(k+1)
        break
if flag==0:
    print(0)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

51 统计工龄

题目描述
给定公司 N 名员工的工龄，要求按工龄增序输出每个工龄段有多少员工。

输入
输入首先给出正整数N(<=105),即员工总人数；随后给出N个整数，即每个员工的工龄

输出
按工龄的递增顺序输出每个工龄的员工个数，格式为：“工龄:人数”。每项占一行。如果人数为0则不输出该项。

#!/usr/bin/python3
n = int(input())
a = list(map(int,input().split()))
a.sort()
d = {}
for i in range(n):
    d[a[i]]=d.get(a[i],0)+1
for key in d:
    print("%d:%d" %(key,d[key]))
1
2
3
4
5
6
7
8
9

52 经典逆序对问题题目描述

给定一段长度为 n 的序列 a ，求该序列中逆序对的个数

输入
第一行包括一个正整数 n(n<=100000)，代表序列 a 的长度

第二行包括 n 个正整数数a1, a2, … an(0<=ai<=10)，表示序列 a
注意第二行的每个正整数后都跟一个空格。

def merge_sort(s,l,r):
    if l >= r: return 0
    mid = l + r >> 1
    res = merge_sort(s,l,mid) + merge_sort(s,mid + 1,r)
    i = l
    j = mid + 1
    tmp = []
    while(i <= mid and j <= r):
        if(s[i] <= s[j]):
            tmp.append(s[i])
            i += 1
        else:
            res += (mid - i + 1)
            tmp.append(s[j])
            j += 1
            pass
        pass
    while(i <= mid):
        tmp.append(s[i])
        i += 1
        pass
    while(j <= r):
        tmp.append(s[j])
        j += 1
        pass
    s[l:r + 1] = tmp
    return res
n = eval(input())
s = list(map(int,input().split()))
print(merge_sort(s, 0, n - 1))
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

输出
一个整数，即逆序对个数

53 跟奥巴马一起画方块(研究生期末考试题目)

题目描述
美国总统奥巴马不仅呼吁所有人都学习编程，甚至以身作则编写代码，成为美国历史上首位编写计算机代码的总统。2014年底，为庆祝“计算机科学教育周”正式启动，奥巴马编写了很简单的计算机代码：在屏幕上画一个正方形。现在你也跟他一起画吧！

输入
输入在一行中给出正方形边长N（3≤N≤21）和组成正方形边的某种字符C，间隔一个空格。

输出
输出由给定字符C画出的正方形。但是注意到行间距比列间距大，所以为了让结果看上去更像正方形，我们输出的行数实际上是列数的50%（四舍五入取整）。

N, char = input().split()
column = int(N)
row = int(column * 0.5 + 0.5)    # 加 0.5 ，再int()，可以做到‘四舍五入’
# print(column, row)
for r in range(0, row):
    for c in range(0, column):
        print(f'{char}', end='')
    print()
1
2
3
4
5
6
7
8

54 IP的计算

输入
输入有多个case，每个case有一个正整数字 N，表示该子网最大可能连接进来的主机的个数。保证结果存在。

输出
对于每个case，输出一个满足要求的掩码，注意掩码需要用标准的IP点分形式，每个小部分是一个8位的无符号整数，共有4个部分，IP中没有空格。

#!/usr/bin/python3
def ip():
    while(1):
        t=int(input())
        t+=2
        pos=num=0
        while(t):
            t>>=1
            pos+=1
        for j in range(31,-1,-1):
            if( j>=pos ):
                num+=1<<(j%8)
            if( j%8==0 and j>0):
                print(num,end='')
                num=0
                if( j>0 ):
                    print(".",end='')
            if(j==0):
                print(num)
ip()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

56: 幸福数问题

题目描述
对一个十进制数的各位数字做一次平方和，称作一次迭代。如果一个十进制数能通过若干次迭代得到 1，就称该数为幸福数。1 是一个幸福数。此外，例如 19 经过 1 次迭代得到 82，2 次迭代后得到 68，3 次迭代后得到 100，最后得到 1。则 19 就是幸福数。显然，在一个幸福数迭代到 1 的过程中经过的数字都是幸福数，它们的幸福是依附于初始数字的。例如 82、68、100 的幸福是依附于 19 的。而一个特立独行的幸福数，是在一个有限的区间内不依附于任何其它数字的；其独立性就是依附于它的的幸福数的个数。如果这个数还是个素数，则其独立性加倍。例如 19 在区间[1, 100] 内就是一个特立独行的幸福数，其独立性为 2×4=8。
另一方面，如果一个大于1的数字经过数次迭代后进入了死循环，那这个数就不幸福。例如 29 迭代得到 85、89、145、42、20、4、16、37、58、89、…… 可见 89 到 58 形成了死循环，所以 29 就不幸福。
本题就要求你编写程序，列出给定区间内的所有特立独行的幸福数和它的独立性。

输入
输入在第一行给出闭区间的两个端点：1<A<B≤104
。

输出
按递增顺序列出给定闭区间 [A,B] 内的所有特立独行的幸福数和它的独立性。每对数字占一行，数字间以 1 个空格分隔。如果区间内没有幸福数，则在一行中输出 SAD。

l,r=input().split()
l,r=int(l),int(r)
list,ans,child=[],[],{} #list存所有的幸福树;ans存独立的幸福树，即不依赖于区间内的其他数字;child存区间内依赖该幸福数(key)的幸福数的个数（value)
for num in range(l,r+1):#枚举区间所有数字
    sum = 0
    tnum = num
    vis={}
    while sum!=1 or vis[sum]<2:
        sum = 0
        for digit in str(tnum):#对一个十进制的各位数字做一次平方和
            sum += int(digit)**2
        vis.setdefault(sum,0)#字典初始化
        vis[sum]+=1 #一次迭代结束 该数字在迭代过程中出现次数+1 
        if(vis[sum]==2):#该数字在迭代过程中出现次数==2 即首次出现死循环 当前枚举的数字num是不幸福数
            break
        tnum = sum
    if(sum==1):#数字num是幸福数 若干次迭代结束时平方和sum==1
        ans.append(num)#存进幸福数数组
        tnum = num
        sum = 0
        child.setdefault(num,0) #计算这个幸福数的独立性 即数依赖于这个数num的幸福数的个数
        while(sum!=1):
            sum = 0
            for digit in str(tnum):
                sum += int(digit) ** 2
            list.append(sum) #对幸福数迭代 迭代过程中出现的数都是幸福数 全部加进list中 但对num进行迭代 幸福数num本身没有进入list,即如果一个幸福数是独立的，在有限区间[l,r]内不依附于其他数字，则不会出现在list中
            tnum = sum
            child[num]+=1 #依赖于幸福数num的幸福数的个数+1 
        #一个幸福数num的child值为num迭代到1的过程中产生的全部sum值的个数 因为迭代到1就结束循环 过程显然是没有产生重复sum值的
 
import math
 
def isPrime(n):
    if n <= 1:
        return False
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True
 
for item in ans:
    if item not in list:#出现在list中的幸福数都是其他幸福数迭代过程中产生的
        if isPrime(item):
            child[item]*=2
        print(item,child[item])
 
if(len(ans)==0):
    print("SAD")
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

58 Cut Integer

题目描述
给一个偶数个位的正整数num，把它从中间分成左右两个整数a、b，请问 num 能不能被 a 和 b 的乘积整除，能的话输出 Yes ，不能的话输出 No

输入
第一行输入一个正整数 n (n ≤ 20) 表示输入组数。以下 n 行每行一个正整数，保证每个正整数的长度是偶数。

输出
输出 n 行，每行一个单词 Yes 或 No 表示答案。

#!/usr/bin/python3
num = int(input())
ss = []
for i in range(num):
    ss.append(input())
for s in ss:
    n = int(len(s)/2)
    s1 = s[:n]
    s2 = s[n:]
    s = int(s)
    s1 = int(s1)
    s2 = int(s2)
    if s1*s2==0:
        print('No')
        continue
    if s%(s1*s2)==0:
        print('Yes')
    else:
        print('No')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

66 列表排序

题目描述
给你一些正整数，请你将这些数插入到列表中，并将这些数按从小到大的顺序进行排序。排完序后，我想知道这个列表的一些位置上的数字，请你告诉我这些数分别是什么。

输入
第一行一个正整数 n，表示你需要对 n 个数进行排序；
接下来 n 行一行一个整数 L[i] ，表示这个列表第 i 个整数； (0 ≤ i < n)
接下来一行，一个正整数 q 表示我的询问次数；
接下来 q 行，一行一个整数表示询问第 i 位的值是多少。 (0 ≤ i < n)

输出
输出 q 行，一行一个数表示对应询问的 L[i] 值。

#!/usr/bin/python3
n = int(input())
L=[]
for i in range(n):
    sr = int(input())
    L.append(sr)
L.sort()
q = int(input())
record=[]
for j in range(q):
    ss = int(input())
    record.append(ss)
for r in record:
    print(L[r])
1
2
3
4
5
6
7
8
9
10
11
12
13
14

69.麦森数(模拟考试题目)

题目描述
形如2P-1的素数称为麦森数，这时P一定也是个素数。但反过来不一定，即如果P是个素数，2P-1不一定也是素数。到1998年底，人们已找到了37个麦森数。最大的一个是P=3021377，它有909526位。麦森数有许多重要应用，它与完全数密切相关。

任务：输入P（1000<P<300000），计算2P-1的位数和最后500位数字（用十进制高精度数表示）以及最高位数字。

输入
每组输入只包含一个整数P（1000<P<300000）。

输出
第一行：十进制高精度数2P-1的位数。

第2-11行：十进制高精度数2P-1的最后500位数字。（每行输出50位，共输出10行，不足500位时高位补0）
第12行：2P-1的最高位数字。

#!/usr/bin/python3
import math
a = int(input())
b = 2**a-1
print(int(math.log10(2) * a) + 1)
a = b % (10**500)
l = []
for i in range(500):
    l.append(a % 10)
    a =a // 10
for i in range(499,-1,-1):
    print(l[i],end="")
    if i % 50 == 0:
        print("")
print(str(b)[0])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

77 说反话

题目描述
给定一句英语，要求你编写程序，将句中所有单词的顺序颠倒输出。

输入
测试输入包含一个测试用例，在一行内给出总长度不超过300000的字符串。字符串由若干单词和若干空格组成，其中单词是由英文字母（大小写有区分）组成的字符串，单词之间用若干个空格分开。

输出
每个测试用例的输出占一行，输出倒序后的句子，并且保证单词间只有1个空格。

words = input().split()
new = []
for i in range(len(words)-1, -1, -1):
    new.append(words[i])
print(" ".join(new))
1
2
3
4
5

79: JSON 文件转换成 CSV 文件

时间限制: 1 Sec 内存限制: 128 MB

森森有一个 json 文件，她希望转换成 csv 文件。
请你帮她做一下吧。

输入
输入一行，表示 json 文件。

输出
输出多行，表示 csv 文件。注意第一行是键值的索引。具体输出格式可以参考样例。

样例输入
[{“ID”: “1”,“info”: “1”,“target”: “1”},{“ID”: “0”,“info”: “-2”,“target”: “1”}]
样例输出
ID,info,target
1,1,1
0,-2,1

#!/usr/bin/python3
import json
import csv
 
# 从输入中读取json字符串
json_str = input()
 
# 将json字符串解析为python字典对象
data = json.loads(json_str)
 
# 使用csv.writer将数据写入csv文件
with open('output.csv', 'w', newline='') as csvfile:
    writer = csv.writer(csvfile)
 
    # 写入表头
    writer.writerow(list(data[0].keys()))
 
    # 写入数据
    for row in data:
        writer.writerow(list(row.values()))
 
# 从csv文件中读取数据并输出到控制台
with open('output.csv', 'r') as csvfile:
    reader = csv.reader(csvfile)
    for row in reader:
        print(','.join(row))
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

Python JSON | 菜鸟教程
https://www.runoob.com/python/python-json.html

python基础之JSON标准库_json_chinaltx的博客-CSDN博客
https://blog.csdn.net/chinaltx/article/details/86587435
Python中json模块的load/loads方法实战及参数详解

https://blog.csdn.net/daerzei/article/details/100598901

思考题：如果 JSON 文件是多行应该如何处理？

81.寻找目标3

题目描述
在实际应用过程中，使用者对特定数据感兴趣。因此需要将这些数据提取出来。那么如何提取呢？
在本题中，会给你一个 JSON 文件，你需要将这个文件中 Value 对应值在 [A, B] 的数据提取出来，来做进一步的处理。
在提取出来的过程中需要进行检验结果，请你输出这些行来展示这些结果。

输入
第一行输入一个 JSON 文件，这个文件表现为一个一行的输入，如题目所示。
第二行输入 A, B (A<B) ，表示你需要寻找的 Value 值的范围。

输出
输出多行，按照文件读入顺序进行输出符合条件 Value 值对应的 ID。

# !/usr/bin/python3
a = eval(input())
b = list(a)
c =[]
c = input().split()
min = int(c[0])
max = int(c[1])
for i in range(len(b)):
    if min <= b[i]['Value'] <= max:
        print(b[i]['ID'])
1
2
3
4
5
6
7
8
9
10

82 图像中值滤波(研究生期末考试题目)

图像过滤是把图像中不重要的像素都染成背景色，使得重要部分被凸显出来。
现给定一幅黑白图像，要求你将灰度值位于某指定区间内的所有像素颜色都用一种指定的颜色替换。这一过程称为图像的中值滤波。
你需要完成这一过程。

输入
输入在第一行给出一幅图像的分辨率，即两个正整数 M 和 N（0<M,N≤500），另外是待过滤的灰度值区间端点 A 和 B（0≤A<B≤255）、以及指定的替换灰度值。随后 M 行，每行给出 N 个像素点的灰度值，其间以空格分隔。所有灰度值都在 [0, 255] 区间内。
注意每行数据的最后一个数字后面也有空格！

输出
输出按要求过滤后的图像。即输出 M 行，每行 N 个像素灰度值，每个灰度值占 3 位（例如黑色要显示为 000），其间以一个空格分隔。行首尾不得有多余空格。

M,N,A,B,R=input().split()
M=int(M)
N=int(N)
A=int(A)
B=int(B)
  
ls_out=[]
for i in range(M):
    for j in input().split():
        if int(j)>=A and int(j)<=B:
            ls_out.append('0'*(3-len(R))+R)
        else:
            ls_out.append('0'*(3-len(j))+j)
  
for i in range(0,len(ls_out),N):
    print(' '.join(ls_out[i:i+N]))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

85 RGB 和十六进制颜色字符串转换

题目描述
将 #FFFFFF 和 rgb(255, 255, 255) 两种形式的字符串进行相互转换。
输入
输入多行，每一行形如题目中的字符串。
保证字符串形如 #[num1][num2][num3] 或者 rgb([num1], [num2], [num3])。

输出
对于对应的输入，输出另一种格式的字符串。

样例输入
#FFFFFF
rgb(255, 255, 255)

样例输出
rgb(255, 255, 255)
#FFFFFF

while(1):
    try:
        inputstr=input()
        if(inputstr[0]=="#"):
            str1=inputstr[1:3]
            str2=inputstr[3:5]
            str3=inputstr[5:7]
            num1=int('0x'+str1,16)
            num2=int('0x'+str2,16)
            num3=int('0x'+str3,16)
            print("rgb(%s, %s, %s)" % (str(num1),str(num2),str(num3)))
        else:
            list=inputstr.split(',')
            str1=list[0][4:]
            str2=list[1][1:]
            str3=list[2][1:-1]
            # hex返回的字母A~F均为小写字母a~f，根据样例输出，用upper函数把字母全部转为大写
            hex1=hex(int(str1))[2:].upper()
            hex2=hex(int(str2))[2:].upper()
            hex3=hex(int(str3))[2:].upper()
            # 十进制转16进制时会出现缺省零的情况，用rjust函数可在字符串左侧填充0
            # 同理 ljust函数可在字符串的右侧填充0
            hex1 = hex1.rjust(2, '0')
            hex2 = hex2.rjust(2, '0')
            hex3 = hex3.rjust(2, '0')
            outputstr="#"
            outputstr=outputstr+hex1+hex2+hex3
            print(outputstr)
    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

102 Python, 我们能过

题目描述
请在一行输出 “Python, we can pass.”

输入
无输入。

输出
输出题意要求的字符串。

print('Python, we can pass.')
1

108 质因数分解

题目描述
给你一个由两个质数相乘得到的正整数n，求较大的质数

输入
一行一个整数 n ，保证 n 是两个素数的乘积且素数小于 5000

输出
一个整数 x 表示结果

样例输入
6

样例输出
3

n=eval(input())
for i in range(2,int(pow(n,0.5))+1):
    if n % i ==0:
        print(int(n/i))
        break
    else:
        pass
1
2
3
4
5
6
7

110.查验身份证

题目描述
一个合法的身份证号码由17位地区、日期编号和顺序编号加1位校验码组成。校验码的计算规则如下：
首先对前17位数字加权求和，权重分配为：
[7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
然后将计算的和对11取模得到值Z；最后按照以下关系对应Z值与校验码M的值：
Z：0 1 2 3 4 5 6 7 8 9 10
M：1 0 X 9 8 7 6 5 4 3 2
现在给定一些身份证号码，请你验证校验码的有效性，并输出有问题的号码。

输入
输入第一行给出正整数N（≤100）是输入的身份证号码的个数。随后N行，每行给出1个18位身份证号码。

输出
按照输入的顺序每行输出1个有问题的身份证号码。这里并不检验前17位是否合理，只检查前17位是否全为数字且最后1位校验码计算准确。如果所有号码都正常，则输出All passed。

n = int(input())
iden = []
for i in range(n):
    iden.append(input())
flag = [1] * n
weight = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2]
z = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
m = [1, 0, 'X', 9, 8, 7, 6, 5, 4, 3, 2]
break_temp = 0
for i in range(n):
    sum = 0
    for j in range(17):
        if iden[i][j] == 'X':
            flag[i] = 0
            break_temp = 1
            break
        else:
            sum += weight[j] * int(iden[i][j])
    if break_temp == 1:
        break_temp = 0
        continue
 
    Z = sum % 11
    if str(iden[i][17]) == str(m[Z]):
        flag[i] = 1
    else:
        flag[i] = 0
if 0 not in flag:
    print("All passed")
else:
    for i in range(len(flag)):
        if flag[i] == 0:
            print(iden[i])
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

URL 中提取域名、路径和参数列表

从 URL 中提取 协议（protocal）、主机名（netloc）、端口（port）、路径（path）、参数（params）、查询（query）和信息片断（fragment）。
其中 URL 满足以下格式：
URL = protocol