列表
1-1 计算序列和
编写程序,计算序列 1 - 1/5 + 1/9 - 1/13 + ... 之和，当数据项绝对值小于eps时停止
输入格式:输入eps
输出格式:输出序列和，保留2位小数
eps=float(input())
i=1
a=1
while True:
a=a+(-1)**i/(1+4*i)
if 1/(1+4*i)<eps:
break
i=i+1
print("s = {:.2f}".format(a))1-8 计算序列
编写程序,计算序列 1 - 3/4 + 5/7 - 7/10 + ... 前N项之和
输入格式:输入N
输出格式:保留2位小数输出序列和
N=int(input())
i=1
a=1
while i<=N-1:
a=a+(-1)**i*(1+2*i)/(1+3*i)
i=i+1
print("s = {:.2f}".format(a))※1-2 计算方阵的和,创建新方阵
输入 1 个正整数 n(1≤n)，再按行读入 n 阶方阵 a 和 b, 生成并输出 n 阶方阵 c，c 中的元素是 a 和 b 对应元素的和.c[i][j]=a[i][j]+b[i][j] i,j=0,1,2...n-1（1<=c[i]<=99)
输入格式:在第一行输入n；在第二行输入a方阵；在第一行输入b方阵
输出格式:输出c方阵
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
A=[]
B=[]
for i in range(n):
A.append(a[i*n:(i+1)*n])
for i in range(n):
B.append(b[i*n:(i+1)*n])
c=[]
for i in range(n):
c.append([0]*n)
for i in range(n):
for j in range(n):
c[i][j]=A[i][j]+B[i][j]
for i in range(n):
for j in range(n):
print("{:>2}".format(c[i][j]),end=' ')
print("")1-3 求矩阵各行元素之和
本题要求编写程序，求一个给定的m×n矩阵各行元素之和。
输入格式：输入第一行给出两个正整数m和n（1≤m,n≤6）。随后m行，每行给出n个整数，其间
以空格分隔。
输出格式：每行输出对应矩阵行元素之和。
m,n=map(int,input().split())
a=[]
for i in range(m):
a.append(list(map(int,input().split())))
for i in range(m):
print(sum(a[i]))
1-4 输出三角形字符阵列
本题要求编写程序，输出n行由大写字母A开始构成的三角形字符阵列。
输入格式：输入在一行中给出一个正整数n（1≤n<7）。
输出格式：输出n行由大写字母A开始构成的三角形字符阵列。格式见输出样例，其中每个字母后面都有一个空格。
n=int(input())
t=0
for i in range(n):
for j in range(n-i):
print(chr(ord("A")+t),end=" ")
t=t+1
print()※1-5 jmu-python-凯撒密码加密算法
编写一个凯撒密码加密程序，接收用户输入的文本和密钥k，对明文中的字母a-z和字母A-Z替换为其后第k个字母。
输入格式:接收两行输入，第一行为待加密的明文，第二行为密钥k。
输出格式:输出加密后的密文。
不用table
m=input() n=int(input()) new='' for i in m: if i.isalpha()==True: if chr(ord(i)+n).isalpha()==False: if ord(i)+n>122: new+=chr(ord('a')+ord(i)+n-123) elif ord(i)+n>90 and ord(i)<=90: new += chr(ord('A') + ord(i) + n - 91) else: new += chr(ord(i) + n) else: new+=i print(new)
用table
m=input() k=int(input()) abc="abcdefghijklmnopqrstuvwxyz" ABC="ABCDEFGHIJKLMNOPQRSTUVWXYZ" table1=str.maketrans(abc,abc[k:]+abc[:k]) m1=m.translate(table1) table2=str.maketrans(ABC,ABC[k:]+ABC[:k]) m2=m1.translate(table2) print(m2)
※1-6 兔子繁衍问题（斐波那契数列）
通过列表来求递归
一对兔子，从出生后第3个月起每个月都生一对兔子。小兔子长到第3个月后每个月又生一对兔子。假如兔子都不死，请问第1个月出生的一对兔子，至少需要繁衍到第几个月时兔子总数才可以达到N对？
输入格式:输入在一行中给出一个不超过10000的正整数N。
输出格式:在一行中输出兔子总数达到N最少需要的月数。
n=int(input())
s=[1,1]
i=2
if n>=2:
while True:
s.append(s[i-2]+s[i-1])
if s[i]>=n:
break
i+=1
print(i+1)
elif n==1:
print("1")1-7求二维数组周边元素的累加和
求一个二维数组周边元素的累加和。
输入一个二维数组的行数m（m<10），列数n(n<10)，二维数组的各元素值。输出周边元素之和。
输入格式:输入的第一行为矩阵的行数和列数，从第二行开始，为矩阵元素的输入。
输出格式:输出周边元素之和。
m,n=map(int,input().split())
s=[]
for i in range(m):
s.append(0)
for i in range(m):
s[i]=list(map(int,input().split()))
S=sum([sum(s[i]) for i in range(m)])
for i in range(1,m-1):
S-=sum(s[i][1:-1])
print(S)1-8 计算序列
编写程序,计算序列 1 - 3/4 + 5/7 - 7/10 + ... 前N项之和
输入格式:输入N
输出格式:保留2位小数输出序列和
N=int(input())
i=1
a=1
while i<=N-1:
a=a+(-1)**i*(1+2*i)/(1+3*i)
i=i+1
print("s = {:.2f}".format(a))1-9 列表或元组的数字元素求和
求列表中数字和,列表中嵌套层次不限2层
输入格式:在一行中输入列表或元组
输出格式:在一行中输出数字的和
输入样例:[11,2,[3,7],(68,-1),"123",9]，输出样例:99
def s(lst):
total = 0
for item in lst:
if isinstance(item, list): # 如果当前项是列表，则递归调用
total += s(item)
elif isinstance(item, tuple): # 如果当前项是元组，则递归调用
total += d(item)
elif isinstance(item, str):# 如果当前项是字符串，则处理成0。。。早说啊
total += 0
else:
total += item # 否则，直接加到总和中
return total
def d(lst):#如果输入元组
total = 0
for item in lst:
if isinstance(item, list): # 如果当前项是列表，则递归调用列表
total += s(item)
elif isinstance(item, tuple): # 如果当前项是元组，则递归调用元组
total += d(item)
elif isinstance(item, str):# 如果当前项是字符串，则处理成0。。。早说啊
total += 0
else:
total += item # 否则，直接加到总和中
return total
lst=eval(input())
if type(lst)==list:
#print(lst)
print(s(lst))
else:
print(d(lst))1-10 求分数序列前N项和
计算序列 2/1+3/2+5/3+8/5+... 的前N项之和。
说明：该序列从第2项起，每一项的分子是前一项分子与分母的和，分母是前一项的分子。
输入格式:在一行中给出一个正整数N。
输出格式:在一行中输出求得的和的值，精确到小数点后两位。（题目保证计算结果不超过双精度范围。）
#方法一:列表+1次循环
n=int(input())
z=[2,3]
m=[1,2]
s=3.5
for i in range(2,n):
z.append(z[i-2]+z[i-1])
m.append(z[i-1])
s+=z[i]/m[i]
print("{:.2f}".format(s))**1-11 间隔杀人求幸存者
n个人围成一圈，隔m个人杀掉一个人，求最后幸存的是排第几个的？
输入格式：在一行中输入n m
输出格式：幸存者编号
m,n=map(int,input().split())
l=[]
for i in range(n):
l.append(i+1)
index=0
while True:
del l[index]
if len(l)==1:
break
else:
index=(index+m-1)%len(l)
print(l)**1-12 求子集
输入一个集合，求集合的子集
def sset(Set):
res = [[]]
for num in Set:
res += [ i + [num] for i in res]
return res
print(sset(list(eval(input())))1'-13 复制
输出是什么？
list1=[1,43]
list2=list1
list1[0]=22
print(list2[0])答案：22 （list2并未创建一个新对象，而是指向list1，所以list1还是list2发生更改，他们都会更改）
1‘-14 列表元素相加的限制
下面程序的运行结果是什么？
b=[1,2,3]
b[2]=b
s = 0
for row in b:
if type(row)==list:
for elem in row:
s += elem
else:
s+=row
print(s)答案：报错
字典
**※2-1 图的字典表示
通过s[i][j]的索引方式避免多次.values()
有向图的字典表示。输入多行字符串，每行表示一个顶点和该顶点相连的边及长度，输出顶点数，边数，边的总长度。比如上图0点表示：{'O':{'A':2,'B':5,'C':4}}。用eval函数处理输入，eval函数具体用法见第六章内置函数。
输入格式:第一行表示输入的行数，下面每行输入表示一个顶点和该顶点相连的边及长度的字符串
输出格式:在一行中输出顶点数，边数，边的总长度
a=int(input())
s={}
v=0
c=0
for i in range(a):
s[i]=eval(input())
for i in s:
for j in s[i]:
v=v+sum(list(s[i][j].values()))
c=c+len(s[i][j])
print(len(s),c,v)2-2 四则运算（用字典实现）
四则运算（用字典实现），比较c语言的switch语句。
输入格式:在一行中输入一个数字，在一行中输入一个四帜运算符(+,-,*,/)，在一行中输入一个数字
输出格式:在一行中输出运算结果（小数保留2位）
a=int(input())
b=input()
c=int(input())
if b=="/" and c==0:
print("divided by zero")
else:
s = {"+": a + c, "-": a - c, "*": a * c, "/": a / c}
print("{:.2f}".format(s[b]))2-3 统计字符出现次数
本题要求编写程序，统计并输出某给定字符在给定字符串中出现的次数。
输入格式：输入第一行给出一个以回车结束的字符串（少于80个字符）；第二行输入一个字符。
输出格式：在一行中输出给定字符在给定字符串中出现的次数。
m=input()
n=input()
d={}
for i in m:
if i not in d:
d[i]=1
else:
d[i]+=1
if d.get(n)==None:
d[n]=0
print(d[n])2-4 统计工龄
给定公司N名员工的工龄，要求按工龄增序输出每个工龄段有多少员工。
输入格式:输入首先给出正整数N（≤105），即员工总人数；随后给出N个整数，即每个员工的工龄，范围在[0, 50]。
输出格式:按工龄的递增顺序输出每个工龄的员工个数，格式为：“工龄:人数”。每项占一行。如果人数为0则不输出该项。
a = int(input())
b = list(map(int, input().split()))
s = {}
for i in range(51):
s[i] = b.count(i)
for i in s:
if s[i]!=0:
print(str(i) + ":" + str(s[i]))
※2-5 求矩阵鞍点的个数
一个矩阵元素的“鞍点”是指该位置上的元素值在该行上最大、在该列上最小。本题要求编写程序，求一个给定的n阶方阵的鞍点。
输入格式：输入第一行给出一个正整数n（1≤n≤6）。随后n行，每行给出n个整数，其间以空格分隔。
输出格式：鞍点的个数
n=int(input())
d={}
c={}
b=0
for i in range(n):
d[i] = list(map(int, input().split()))
for i in d.keys():
for j in d[i]:
for k in range(len(d[i])):
if d[i][k]==max(d[i]):
c["d[{:}][{:}]".format(i,k)]=d[i][k]
for k in range(n):
min=d[0][k]
for i in d.keys():
if d[i][k]<min:
min=d[i][k]
for i in d.keys():
if d[i][k]==min:
if "d[{:}][{:}]".format(i,k) in c.keys():
b+=1
print(b)2-6 两数之和
给定一组整数，还有一个目标数，在给定这组整数中找到两个数字，使其和为目标数，如找到，解是唯一的。找不到则显示 "no answer"。输出的下标按从小到大排序。用一重循环加字典实现。
输入格式:在一行中给出这组数。在下一行输入目标数
输出格式:在一行中输出这两个数的下标，用一个空格分开。
m=list(map(int,input().split(',')))
n=int(input())
found=0
for i in range(len(m)):
for j in range(len(m)):
if i<j:
if m[i]+m[j]==n:
print(i,j)
found=1
if found==1:
break
if found==0:
print("no answer")※2-7 字典合并
输入用字符串表示两个字典，输出合并后的字典。字典的键用一个字母或数字表示。注意：1和‘1’是不同的关键字！
输入格式:在第一行中输入第一个字典字符串；在第二行中输入第二个字典字符串。
输出格式:在一行中输出合并的字典，输出按字典序。"1" 的 ASCII 码为 49，大于 1，排序时 1 在前，"1" 在后。其它的字符同理。
m=eval(input())
n=eval(input())
f={}
a=[]
for i in m.keys():
for j in n.keys():
if i==j:
f[i]=m[i]+n[j]
c={**m,**n}
d={**c,**f}
for i in d.keys():
a.append(i)
#排序"1"和'1'
f={}
for i in a:
if type(i)==int:
f[i]=i
if type(i)==str:
f[i]=ord(i)
b=dict(sorted(f.items(), key=lambda x: x[1]))
e=str({**b,**d})
#统一格式：引号全为""，输出间无空格
g=e.replace("'",'"')
g=g.replace(" ","")
print(g)#第二次写的简化版
a=eval(input())
b=eval(input())
for i in a:
for j in b:
if i==j:
b[j]=a[i]+b[j]
c={**a,**b}
c=dict(sorted(c.items(),key=lambda x:x[0] if type(x[0])== int else ord(str(x[0])),reverse=False))
print(str(c).replace(' ','').replace("'",'"'))2-8 显示数字出现次数
输入一个十进制正整数，转换成16进制数。再输入一个数(0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f）,统计这个数出现的次数。
输入格式:一行输入十进制正整数。另一行输入要统计的数。
输出格式:要统计的数出现的次数。
m=int(input())
b=hex(m)
c=list(b)[3:]
d=input()
print(c.count(d))函数
#计算最长递增子序列
#下列程序运行的结果是:7
def basic_lis(seq):
l=[1]*len(seq)
for cur ,val in enumerate(seq): #enumerate返回元素的"索引和值"
for pre in range(cur):
if seq[pre]<val:
l[cur]=max(l[cur],1+l[pre])
return max(l)
L=[49, 64, 17, 100, 86, 66, 78, 68, 87, 96, 19, 99, 35]
print(basic_lis(L))#下列程序运行的结果是:19
import math
def factors(x):
y=int(math.sqrt(x))
for i in range(2,y+1):
if (x%i ==0):
factors(x//i)
break
else:
print(x,end=' ')
return
factors(38)#下列程序输出第四行的内容是:231
def perm(choice,selected=[]):
if len(choice)==1:
print("".join(selected+choice))
else:
for i in range(len(choice)):
t=choice[i]
choice.remove(t)
selected.append(t)
perm(choice,selected)
choice.insert(i,t)
selected.pop()
first=["1","2","3"]
perm(first,selected=[])分析如右：
字符串
3-1 规则图形构建和输出
某游戏公司拟开发一款益智类小游戏，请你帮忙编写程序实现指定的界面。
输入格式:输入在一行中给出1个正整数（范围在[1,10]）
输出格式:输出对应的规则图形
n=int(input())
t=2*n-1
print("*"*t)
for i in range(n-1):
print("{:*^{:}}".format(' '*(2*i+1),t))
for i in range(n-1):
print("{:*^{:}}".format(' '*(t-2*i-4),t))
#输入3
#输出
*****
** **
* *
** **
*****3-2 从句子中输出特定类型字符
输入一个句子，输出句子中的所有数字（如2024）和数字的个数（如2024和2，共2个）
a="In 2020,Father is 56 years old."
b=list(a)
t=0
i=0
while i<len(b):
if b[i].isnumeric()==True:
for j in range(i,len(b)):
if b[j].isnumeric()==False:
print(b[i:j])
t+=1
i=j
break
else:
i+=1
print(t)循环结构
4-1斐波那契数列检索
本题要求实现一个计算Fibonacci数的简单函数，并利用其实现另一个函数,输出两正整数m和n（0<m<n≤100000）之间的所有Fibonacci数的数目。
所谓Fibonacci数列就是满足任一项数字是前两项的和（最开始两项均定义为1）的数列,fib(0)=fib(1)=1。其中函数fib(n)须返回第n项Fibonacci数；函数PrintFN(m,n)用列表返回[m, n]中的所有Fibonacci数。
函数接口：
fib(n),返回fib(n)的值
PrintFN(m,n)，用列表返回[m, n]中的所有Fibonacci数。
def fib(n):
if n==1 or n==0:
return 1
else:
return fib(n-1)+fib(n-2)
def PrintFN(m,n):
d=[]
for i in range(n):
if m<=fib(i)<=n:
d.append(fib(i))
elif fib(i)>n:#及时break避免超时
break
return d
# m,n,i=input().split()
# n=int(n)
# m=int(m)
# i=int(i)
# b=fib(i)
# print("fib({0}) = {1}".format(i,b))
# a=PrintFN(m,n)
# print(len(a))4-2使用函数求余弦函数的近似值
本题要求实现一个函数，用下列公式求cos(x)近似值，精确到最后一项的绝对值小于eps（绝对值小于eps的项不要加）：
函数接口：funcos(eps,x),其中用户传入的参数为eps和x；函数funcos应返回用给定公式计算出来，保留小数4位。
def f(n,x):
if n==1:
return 1
else:
return f(n-1,x)*(-1)*x**2/(2*n-3)/(2*n-2)
def funcos(eps,x):
n=1
s=0
while abs(f(n,x))>=eps:
s+=f(n,x)
n+=1
# print("f({:},{:})=".format(n,x)+"{:.4f}".format(f(n,x)))
return s
# eps=0.0001
# x=-3.1
# eps,x=float(eps),float(x)
# value=funcos(eps,x )
# print("cos({0}) = {1:.4f}".format(x,value))逻辑推断
5.1 反序二进制
输入一个十进制正整数，将它对应的二进制数的各位反序，形成新的十进制数输出。如有多组答案可选，则选答案字符序在先的那组答案。
如：13-->1101-->1011-->11
如：10-->1010-->0101-->5
x=eval(input())
y=0
while(___(1)___):
t=x%2
___(2)___
___(3)___
print(y)
答案：AHD
5.2 10进制转16进制
decimal = eval(input("Enter an integer: "))
hexString = ""
value = ___(1)___
while value != 0:
single = value % 16
if single == 15:
hexString = "F" + hexString
elif single == 14:
hexString = "E" + hexString
elif single == 13:
hexString = "D" + hexString
elif single == 12:
hexString = "C" + hexString
elif single == 11:
hexString = "B" + hexString
elif single == 10:
hexString = "A" + hexString
else:
hexString = ___(2)___+ hexString
value = ___(3)___
print(str(decimal) + "'s hex representation is " + hexString)
答案：BGE
m=[2,1,0,5,3,5,7,4]
def naive(M,A=None):
if A is None:
A=set(range(len(M)))
if len(A)==1:return(A)
B=set(M[i] for i in A)
C=A-B
if C:
A.remove(C.pop())
return naive(M,A)
return A
print(sum(list(naive(m))))
输出值为：8
1870
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
