python题库刷题训练软件 python 刷题

刷题目录

• 一、四位数逆序输出

• 1.题意
• 2.解题思路

• 二、时间计算

• 1.题意
• 2.解题思路

• 三、烧热水

• 1.题意
• 2.解题思路

• 四、利息计算

• 1.题意
• 2.解题思路

• 五、BMI指数计算

• 1.题意
• 2.解题思路

• 六、温度转换

• 1.题意
• 2.解题思路

• 七、圆的周长与面积

• 1.题意
• 2.解题思路

• 八、三角形面积

• 1.题意
• 2.解题思路

• 九、字符串逆序

• 1.题意
• 2.解题思路

• 十、字符串截取

• 1.题意
• 2.解题思路

• 十一、判断回文字符串

• 1.题意
• 2.解题思路

• 十二、计算字符个数

• 1.题意
• 2.解题思路

• 十三、节约用电

• 1.题意
• 2.解题思路

• 十四、克莱姆法则求解方程

• 1.题意
• 2.解题思路

• 十五、计算年薪

• 1.题意
• 2.解题思路

• 十六、划分分数等级

• 1.题意
• 2.解题思路

• 十七、字母反转

• 1.题意
• 2.解题思路

• 十八、查找指定字符

• 1.题意
• 2.解题思路

• 二十、单词统计【part one】

• 1.题意
• 2.解题思路

• 二十一、温度转换【part two】

• 1.题意
• 2.解题思路

• 二十二、字符串循环左移

• 1.题意
• 2.解题思路

• 二十三、打印空心三角形

• 1.题意
• 2.解题思路

• 二十四、工作日的力量【part one】

• 1.题意
• 2.解题思路

• 三十、数列求和【part one】

• 1.题意
• 2.解题思路

• 三十一、数列求和【part two】

• 1.题意
• 2.解题思路

• 三十二、列表元素绝对值排列

• 1.题意
• 2.解题思路

• 三十三、删除字符串中连续的重复字符

• 1.题意
• 2.解题思路

• 三十五、列表合并去重

• 1.题意
• 2.解题思路

• 三十七、乘积的列表

• 1.题意
• 2.解题思路

• 三十八、0的组合

• 1.题意
• 2.解题思路

• 三十九、矩阵翻来覆去的运算

• 1.题意
• 2.解题思路

• 四十一、和谐列表

• 1.题意
• 2.解题思路

• 四十三、字符串基本操作

• 1.题意
• 2.解题思路

• 四十五、有序列表插入元素

• 1.题意
• 2.解题思路

• 四十六、列表排列

• 1.题意
• 2.解题思路

• 四十八、字符串的行数

• 1.题意
• 2.解题思路

• 四十九、身份证提取信息

• 1.题意
• 2.解题思路

• 五十、稀疏矩阵存储

• 1.题意
• 2.解题思路

• 五十二、不常见的单词

• 1.题意
• 2.解题思路

• 五十三、最常见的单词

• 1.题意
• 2.解题思路

• 五十四、又见字符统计

• 1.题意
• 2.解题思路

• 五十五、寻找十全十美数

• 1.题意
• 2.解题思路

• 五十七、有序列表的重复项删除

• 1.题意
• 2.解题思路

• 五十八、字符间最短的距离

• 1.题意
• 2.解题思路

• 六十一、书籍购买

• 1.题意
• 2.解题思路

• 六十三、歌咏小能手

• 1.题意
• 2.解题思路

• 六十四、矩阵相加

• 1.题意
• 2.解题思路

• 六十五、寻找最佳组合

• 1.题意
• 2.解题思路

• 六十六、单词的区域

• 1.题意
• 2.解题思路

• 六十七、矩阵的乘法

• 1.题意
• 2.解题思路

• 七十一、三个数必有最大2

• 1.题意
• 2.解题思路

• 七十四、反转单词中的字母

• 1.题意
• 2.解题思路

• 七十六、列表元素排序【part two】

• 1.题意
• 2.解题思路

• 七十七、稀疏矩阵的表示

• 1.题意
• 2.解题思路

• 七十八、字符串的重新排列

• 1.题意
• 2.解题思路

• 七十九、下三角矩阵判断

• 1.题意
• 2.解题思路

• 八十一、求和运算

• 1.题意
• 2.解题思路

• 八十二、寻找缺失的整数

• 1.题意
• 2.解题思路

• 八十三、求矩阵局部极大值

• 1.题意
• 2.解题思路

• 八十五、寻找不一样的约数

• 1.题意
• 2.解题思路

• 八十六、输出指定的英文字母

• 1.题意
• 2.解题思路

• 八十九、七进制数

• 1.题意
• 2.解题思路

• 九十一、循环数数

• 1.题意
• 2.解题思路

一、四位数逆序输出

1.题意

2.解题思路

方法一：字符串切片
输出为字符串类型，利用字符串的切片将字符串反转，然后循环输出每个字符
注意：
①字符串切片操作[-1::-1]可以实现字符串反转
②注意输出操作，如何用空格隔开输出

s=input()
s=s[-1::-1]
for i in s:
    print(i,end=" ")

方法二：列表反转
利用列表进行计算，把每一个字符以整型的形式存进列表中，将列表反转然后输出列表中的元素，也可以不用反转直接逆序输出列表中的每一个元素

s=list(map(int,input()))
s.reverse()
for i in s:
    print(i,end=" ")

方法三：分离数位
把字符串转化为整型，以整数的形式计算，利用/和%分离每一位用变量存储，然后直接逆序输出每一位。这种方法太简单，不再细说
方法四：

t=input()
s=t[-1::-1]
print(s[0],s[1],s[2],s[3])

二、时间计算

1.题意

2.解题思路

本质上也是个分离数位的问题，给定秒数分别计算小时、分钟、秒，小学数学问题，具体计算看代码，主要python中的这道题输出需注意，可以使用以下两种方式输出：
方法一：直接print()中输出

n=eval（input())
h=n/3600
m=n%3600/60
s=n%3600%60
print("%d时%d分%d秒"%(h,m,s))

方法二：利用字符串中的.format()格式化函数输出
需注意：此时变量的类型与前面占位符中的类型需要对应，因为/是除不是整除，得到的是浮点型，所以还需要类型转换为int，有下面两种实现。而上面直接print()输出，相当于是直接输出把浮点型变成int强制类型转换了。

n=eval（input())
h=int(n/3600)
m=int(n%3600/60)
s=int(n%3600%60)
print("{:d}时{:d}分{:d}秒".format(h,m,s))

n=eval（input())
h=n//3600
m=n%3600//60
s=n%3600%60
print("{:d}时{:d}分{:d}秒".format(h,m,s))

三、烧热水

1.题意

2.解题思路

输入这个三个变量，然后根据题目中公式计算即可。没啥好说的，只需要注意输入输出是浮点型

m=eval（input())
qf=eval（input())
ql=eval（input())

q=m*(ql-qf)*4184
print("%.1lf"%(q))

四、利息计算

1.题意

2.解题思路

也是一个简单的计算问题，但是需注意题目中有几个坑：
①年利率要转换为月利率，即年利率/12=月利率
②年数要转换为月数，即年数*12=月数
③月利率是一个百分比，所以要乘上0.01变成百分数
④多少次方使用两个乘号

ml=eval（input())
f=eval（input())
y=eval（input())

mf=ml/((1+(f/12)*0.01)**(y*12))
print("%.2f"%(mf))

五、BMI指数计算

1.题意

2.解题思路

简单的公式计算，注意输入和输出格式即可。

w,h=eval（input()),eval（input())
ans=w/(h*h)
print("%.2f"%(ans))

w,h=eval（input()),eval（input())
ans=w/(h*h)
print("{:.2f}".format(ans))

六、温度转换

1.题意

2.解题思路

利用字符串切片，切出第一个字符和后面的问题，判断利用公式进行温度转换，注意输出

s=input()
x=s[0]
t=eval（s[1::])
if x=="C":
    f=t*1.8+32
    print("F{:.2f}".format(f))
if x=='F':
    c=(t-32)/1.8
    print("C{:.2f}".format(c))

七、圆的周长与面积

1.题意

2.解题思路

简单计算没啥好说的，注意类型之间的转换和输出

r=eval（input())
pi=3.14159
l=2*pi*r
s=pi*r*r
print("%.4f %.4f"%(l,s))

八、三角形面积

1.题意

2.解题思路

简单公式计算问题，需注意开平方的实现方式：
①利用python自带的幂运算函数pow(x,1/2)
②导入math数学函数库，利用里面的.sqrt()开平方函数
③利用乘方运算**0.5

方法一：

a=eval（input())
b=eval（input())
c=eval（input())
p=(a+b+c)/2
s=pow(p*(p-a)*(p-b)*(p-c),1/2)
print("%.2f"%(s))

方法二：

import math
a=eval（input())
b=eval（input())
c=eval（input())
p=(a+b+c)/2
s=math.sqrt(p*(p-a)*(p-b)*(p-c))
print("%.2f"%(s))

方法三：

a=eval（input())
b=eval（input())
c=eval（input())
p=(a+b+c)/2
ans=(p*(p-a)*(p-b)*(p-c))**0.5
print("%.2f"%(ans))

九、字符串逆序

1.题意

2.解题思路

超简单题，与第一题四位数逆序输出中的方法一样。
方法一：字符串切片

s=input()
s=s[-1::-1]
print(s)

方法二：列表反转函数

s=input()
a=list(s)
a.reverse()
for i in a:
    print(i,end="")

十、字符串截取

1.题意

2.解题思路

这道题纯无聊题，最傻的方法直接输出呗

print("故宫长城")

正规做法：是使用字符串切片和.join()拼接函数
注意切片范围顺序和.join()方法如何使用

s=input()
s1=s[4:5+1:1]
s2=s[7:8+1:1]
seq=(s1,s2)
t=""
print(t.join(seq))

十一、判断回文字符串

1.题意

2.解题思路

方法一：
通过判断字符串是奇数长度还是偶数长度，分别来根据中间实行切片左右两段，如果左端等于右端的逆序，说明就是回文串
注意输出时需要先输出原本的字符串

s=input()
le=len(s)

if le%2==0:
    s1=s[0:le//2:1]
    s2=s[le//2:le:1]
else:
    s1=s[0:le//2+1:1]
    s2=s[le//2:le:1]
s2=s2[-1::-1]
print(s)
if s1==s2:

    print("Yes")
else:
    print("No")

方法二：
利用列表反转，先让两个列表分别等于字符串s，将其中一个列表反转，判断两个列表是否相等即可。列表相等即列表中对应的每一个元素的值相等

s=input()
s1=list(s)
s2=list(s)
s2.reverse()

print(s)
if s1==s2:
    print("Yes")
else:
    print("No")

方法三：
使用reversed()函数
reversed(seq)。
reversed 函数返回一个反转的迭代器。
seq – 要转换的序列，可以是 tuple, string, list 或 range。

s = input()
rs = list(reversed(s))
print(s)
if list(s) == rs:
    print("Yes")
else:
    print("No")

十二、计算字符个数

1.题意

2.解题思路

方法一：
利用lower()方法把大写字母都转换为小写字母，再利用count()方法统计在字符串中字符出现的次数。
也可以利用upper()方法把小写字母都转换为大写字母
注意：本题目的输入是以空格隔开的，学会如何处理这种输入

s,f = input().split()
s=s.lower()
f=f.lower()
cnt=s.count(f)
print(cnt)

s,f = input().split()
s=s.upper()
f=f.upper()
cnt=s.count(f)
print(cnt)

方法二：

s1, s2 = input().split() 
s3 = s1.lower()
s4 = s2.lower()
print(len(s3.split(s4))-1)

十三、节约用电

1.题意

2.解题思路

简单多重分支题目，没啥好说的

format输出方法：

n=eval（input())

if n<0:
    print("Invalid Value!")
elif n<=50:
    res=0.53*n
    print("cost = %.2f"%(res))
else:
    res=(n-50)*(0.53+0.05)+50*0.53
    print("cost = %.2f"%(res))

f-string输出方法：

n=float(input())

if n<0:
    print("Invalid Value!")
elif n<=50:
    m=n*0.53
    print(f"cost = {m:.2f}")
else:
    m=50*0.53+(n-50)*0.58
    print(f"cost = {m:.2f}")

十四、克莱姆法则求解方程

1.题意

2.解题思路

也是一个公式计算问题，但需要注意以下几点：
①如何处理这种以逗号分隔开的数据？
②类型转化问题：eval（)评估函数可以把字符串上面的引号去掉，自动识别出其是什么类型。
③计算时分母不能为0，所以这个题要先判断，再去计算结果。而不能先计算结果再判断

a,b,c,d,e,f=input().split(",")
a=eval（a)
b=eval（b)
c=eval（c)
d=eval（d)
e=eval（e)
f=eval（f)

if a*d-b*c==0:
    print("The equation has no solution")
else:
    x = (e * d - b * f) / (a * d - b * c)
    y = (a * f - e * c) / (a * d - b * c)
    print("x=%.1f,y=%.1f"%(x,y))

十五、计算年薪

1.题意

2.解题思路

简单的分支结构计算题目，注意以下输出格式即可

s=input()
n=eval（input())
res=0
if n<40000:
    res=n*(1+0.05)
else :
    res=40000+2000+(n-40000)*(1+0.02)
print("{:s}新一年的年薪是：{:.1f}元".format(s,res))

十六、划分分数等级

1.题意

2.解题思路

最简单的多分支结构

n=eval（input())
if n<=100 and n>=90:
    print("A")
elif n<=89 and n>=80:
    print("B")
elif n<=79 and n>=70:
    print("C")
elif n<=69 and n>=60:
    print("D")
elif n<=59 and n>=0:
    print("E")
else:
    print("Invalid")

十七、字母反转

1.题意

2.解题思路

本题关键是在于如何多组换行数据输入，利用while循环+input语句，循环结束条件单独判断：
大小写之间的互换可以直接使用字符串swapcase方法

while True:
    s=input()
    if s=="$":
        break
    elif s[-1]=="$":
        print(s[0:-1].swapcase())
        break
    else:
        print(s.swapcase())

十八、查找指定字符

1.题意

2.解题思路

先把指定字符和模板字符都转化为大写或者小写，再直接用rfind()方法去查找出现该字符的最大下标即可
字符串常用的几种方法：
①.lower()把所有大写字母转为小写字母，注意还要赋给一个值
②.upper()把所有小写字母转为大写字母，注意还要赋给一个值
③.rfind()查找出现该字符的最大下标，如果没有，返回-1

s=input()
t=input()
if len(t)>20:
    print("输入错误！")
else:
    s=s.upper()
    t=t.upper()
    res=t.rfind(s)
    if res==-1:
        print("Not Found")
    else:
        print("index = %d"%(res))

下面这是第一次做的时候自己写的垃圾代码，哈哈哈哈

n = input()
s = input()
if len(s)>20:
    print("输入错误！")
else:
    if n<='z' and n>='a':
        s=s.lower()
        c = s.rfind(n)
        if c != -1:
            print("index = {}".format(c))
        else:
            print('Not Found')
    elif n<='Z' and n>='A':
        s=s.upper()
        c = s.rfind(n)
        if c != -1:
            print("index = {}".format(c))
        else:
            print('Not Found')
    else:
        c = s.rfind(n)
        if c != -1:
            print("index = {}".format(c))
        else:
            print('Not Found')

方法三：

s=input()
t=input()
s=s.lower()
t=t.lower()
if len(t)>20:
    print("输入错误！")
else:
    t1 = list(t)
    if s in t1:
        print("index = {:d}".format(t.rfind(s)))
    else:
        print("Not Found")

二十、单词统计【part one】

1.题意

2.解题思路

超简单偷鸡方法，利用输入处理数据把空格自动删除掉，存到列表中，有几个元素吧就是有几个单词了
哈哈哈哈哈哈哈

s=list(input().split())
print(len(s))

二十一、温度转换【part two】

1.题意

2.解题思路

方法一：
分支结构，一共需要判断五次

n=input()
if n[-1]=='C':
    n1=n[:-1]
    m=float(n1)*1.8+32
    m=('%.2f'%m)
    print(str(m)+'F')
elif n[-1]=='c':
    n1 = n[:-1]
    m = float(n1) * 1.8 + 32
    m=('%.2f'%m)
    print(str(m)+'f')
elif n[-1]=='F':
    n1 = n[:-1]
    m=(float(n1)-32)/1.8
    m=('%.2f'%m)
    print(str(m)+'C')
elif n[-1]=='f':
    n1 = n[:-1]

    m = (float(n1)-32)/ 1.8
    m=('%.2f'%m)
    print(str(m)+'c')
else:
    print('输入格式错误！')

方法二：

利用字符串切片和成员运算符：
（1）以字符串形式输入，切片出最后一位字符，利用成员运算符判断是哪种类型的
（2）然后进行利用公式进行计算，如果注意强制类型转换
（3）输出时注意是如何最后一个字母之间是如何处理转化：
ord是把字符转化为对应的编码
chr是把对应编码转化为对应字符
不管大小写，F和C之间编码差3

t=input()
if t[-1] in ['F','f']:
    c=(float(t[0:-1])-32)/1.8
    print(f'{c:.2f}{chr(ord(t[-1])-3)}')
elif t[-1] in ['c','C']:
    f=float(t[0:-1])*1.8+32
    print(f'{f:.2f}{chr(ord(t[-1])+3)}')
else:
    print("输入格式错误！")

二十二、字符串循环左移

1.题意

2.解题思路

方法一：利用字符串的切片来做即可，easy

s=input()
n=eval（input())
s1=s[0:n:1]
s2=s[n::1]
print(s2+s1)

s=list(input())
n=eval（input())
s1=s[0:n:1]
s2=s[n:len(s)+1:1]
s3=s2+s1
for i in s3:
    print(i,end="")

方法二：利用列表的切片来做(列表也是序列类型，序列类型都可以进行切片)

s=list(input())
n=eval（input())
s1=s[0:n:1]
s2=s[n:len(s)+1:1]
s3=s2+s1
for i in s3:
    print(i,end="")

二十三、打印空心三角形

1.题意

2.解题思路

核心思想：经典的遍历循环嵌套的题目，即两重嵌套循环：一个控制行数，一个控制每一行的内容*和空格
注意输出语句格式和每一行结束后要换行
几种方式实现方式吧，核心思想都是一样的：

n=eval（input())
for i in range(1,n+1):
    if i==1 or i==n:
        for j in range(i):
            print("*",end="")
    else:
        print("*",end="")
        for j in range(i-2):
            print(" ",end="")
        print("*",end="")
    print(end="\n")

n = eval（input())
cnt = 0
for i in range(1, n+1):
    if i == 1:
        print("*")
    elif i == n:
        for j in range(1, n + 1):
            print("*", end="")
    else:
        print("*", end="")
        for j in range(i-2):
            print(" ",end="")
        print("*")

n=eval（input())
for i in range(1,n+1):
    for j in range(1,i+1):
        if j==1 or i==j or i==n:
            print("*",end='')
        else:
            print(end=' ')
    print(end='\n')

二十四、工作日的力量【part one】

1.题意

2.解题思路

遍历一遍n天，只要是在星期六和星期七这两天就减0.01，其他天数加0.01

主要是理解以下两点：
①如何判断星期六和星期天这两天？ i%7=6 为星期六 i%7=0为星期天
②理解退步和进步表示关系 res*=（1±0.01）

n = eval（input())
res=1.0
for i in range(1,n+1):
    if i%7==0 or i%7==6:
        res=res*(1-0.01)
    else:
        res=res*(1+0.01)
print("%.2f"%(res))

三十、数列求和【part one】

1.题意

2.解题思路

方法一：通过判断本身是奇偶数来实现正负交替

n=eval（input())
sum=0
for i in range(1,n+1):
    if i%2==0:
        sum=sum-(i**i)
    else:
        sum=sum+(i**i)
print(sum)

方法二：
循环遍历从1—n，累加变量初始值赋0，用一个变量控制-1的变换即可。

n=eval（input())
t=1
s=0
for i in range(1,n+1):
    s=s+t*i**i
    t*=-1
print(s)

三十一、数列求和【part two】

1.题意

2.解题思路

方法一：
循环遍历从1—n，用t控制正负号系数，i是底数，此时指数需要单独用k控制

n=eval（input())
s=0
t=1
k=1
for i in range(1,n+1):
    if k>10:
        k=1
    s+=i**k*t
    t*=-1
    k+=1
print(s)

方法二：这个是同学想出来的思路
依然是循环遍历从1—n，用t控制正负号系数，i是底数，
不过此时指数的控制换了思想，用每一个i的最后一位当作指数，特判一下当i的最后一位为0时，指数为10

n=eval（input())
t=1
s=0
for i in range(1,n+1):
    a=i%10
    if a==0:
        a=10

    s+=i**(a)*t
    t=-t
print(s)

三十二、列表元素绝对值排列

1.题意

2.解题思路

在列表中将元素存储为整数，调用列表的sort()方法。
注意：
①如何将元素存储为整型？两种方法 。map映射或者是列表推导式
②如何实现列表绝对值排序？两种方法。自己编写绝对值函数调用，或者直接调用绝对值关键字

def dx(x):
    return abs(x)

a = input().split(" ")
s1 = [int(a[i]) for i in range(len(a))]
s1.sort(key=dx)
print(s1)

更加简单的方法，在abs就是绝对值得关键字，直接在sort中直接key=abs即可。

s=list(map(int,input().split()))
s.sort(key=abs)
print(s)

三十三、删除字符串中连续的重复字符

1.题意

2.解题思路

判断字符串中前一个字符和后一个字符是否相等即可，如果不相等，就把前一个输出(或者把后一个输出)，再注意一下边界就OK

方法一：
每一个字符是和后面的字符进行判断处理，然后最后一个字符特判处理

s=input()
for i in range(len(s)-1):
    if s[i+1]!=s[i]:
        print(s[i],end="")
print(s[len(s)-1])

方法二：
每一个字符和前面的字符进行特判处理，然后第一个字符特判处理

s = input()
print(s[0],sep="",end="")
for i in range(1,len(s)):
    if s[i]==s[i-1]:
        continue
    else:
        print(s[i],sep="",end="")

方法三：
每一个字符和前面的字符进行特判处理，然后第一个字符特判处理
只不过是先将处理好的字符先存入到一个新列表中，然后运用join方法一起输出

a,b=list(input()),[]
b.append(a[0])
for i in range(1,len(a)):
    if a[i-1]!=a[i]:
        b.append(a[i])
print(''.join(b))

错误代码：

a,b=list(input()),[]
b.append(a[0])
for i in range(0,len(a)):
    if a[i-1]!=a[i]:
        b.append(a[i])
print(''.join(b))

如果此时是从0开始的，因为此时一开始的a[i-1]不会报越界错误，因为 a[0-1]为a[-1]，一开始和a[-1]比较，就不对了，应该是前一个字符或者后一个字符比较。

三十五、列表合并去重

1.题意

2.解题思路

排序和去重的实现方式，这里有一个简单方法便是set集合，可以自动实现排序+去重。注意以下几个知识点：
1.set的用法
①得到是一个集合{}，要想得到列表还要转化
②set是集合，创建集合set()。
③向集合中添加元素s.add(x)。如果元素x不在集合中，将x增加到s，如果已存在，则不会有任何操作
2.input.split()和input.split(" ")的区别：
split()和split(’ ')是有区别的，split（）是将多个空格当成一个空格；但用split(’ ')的时候，多个空格也要分割，所以可能会分割出来空。
3.map映射函数的用法：
map(映射函数，序列…)，即根据指定映射函数对多个参数序列进行运算
①map()函数是将指定的序列中所有元素作为参数，通过指定函数，将结果构成一个新的序列返回。
②序列个数由映射函数的参数个数决定
③map()函数的返回值是迭代对象map

方法一：

a=list(map(int,input().split()))
b=list(map(int,input().split()))
a.extend(b)
a=list(set(a))
print(a)

a = input().split(" ")
b = input().split(" ")
s1 = [int(i) for i in a]
s2 = [int(i) for i in b]
s1.extend(s2)

s1 = list(set(s1))
print(s1)

方法二：

a,b=list(map(int,input().split())),list(map(int,input().split()))
c=list(set(a+b))
c.sort()
print(c)

三十七、乘积的列表

1.题意

2.解题思路

方法一：变乘为除，注意为零时情况
第一次做这道题的思路的时候，自己聪明的想出一个绝对无敌的方法，就是变乘为除，先把所有数都乘一遍，然后除去当前这个数便是当前数的结果，结果提交一直报WA，哦，原来是还可能出现0这种数，0乘任何数都是0了，而且分母也不能为0。所以这种方法还是麻烦

a = input().split(" ")
s1 = []
for i in range(len(a)):
    s1.append(int(a[i]))

s2 = []
d1 = 1
d2 = 1
for i in range(len(s1)):
    if s1[i] == 0:
        d2 = d2*s1[i]
    else:
        d1 = d1*s1[i]

cnt = s1.count(0)
if cnt==1:
    for i in range(len(s1)):
        if s1[i] == 0:
            t = d1
        else:
            t = int(d2/s1[i])
        s2.append(t)
elif cnt>1:
    t = 0
    for i in range(len(s1)):
        s2.append(t)
elif cnt==0:
    for i in range(len(s1)):
        t = int(d1/s1[i])
        s2.append(t)

print(s2)

方法二：两重循环枚举
两重循环枚举，外循环控制枚举到哪个数了，内循环枚举除当前数外其余数相乘，将结果添加到一个新列表即可。
注意：除去当前数的判断条件该如何表示

错误代码：

a=list(map(int,input().split()))
b=[]
for i in range(len(a)):
    ans=1
    for j in range(len(a)):
        if a[j]==a[i]:
            pass
        else:
            ans=ans*a[j]
    b.append(ans)
print(b)

正确代码：

a=list(map(int,input().split()))
b=[]
for i in range(len(a)):
    ans=1
    for j in range(len(a)):
        if j==i:
            pass
        else:
            ans=ans*a[j]
    b.append(ans)
print(b)

三十八、0的组合

1.题意

2.解题思路

①以列表形式输入
②对列表中元素进行排序，目的是使情况相同的序列顺序也保持一致，方便对序列进行去重
③三重循环从头到尾枚举三个数相加等于0的情况
④如果满足将其以元组的形式添加到集合中
⑤因为集合自动实现了去重，结果只需输出集合的长度即可

注意
1.set的用法：
①得到是一个集合{}，要想得到列表还要转化
②set是集合，创建集合set()。
③向集合中添加元素s.add(x)。如果元素x不在集合中，将x增加到s，如果已存在，则不会有任何操作
2.sorted()函数和列表的.sort()方法
注意sorted函数对输入数据的简便处理
3.序列类型只有三种：字符串、列表、元组
字典和集合不是序列类型

a=list(map(int,input().split()))
a.sort()
b=set()
for i in range(len(a)):
    for j in range(i+1,len(a)):
        for k in range(j+1,len(a)):
            if a[i]+a[j]+a[k]==0:
                b.add((a[i],a[j],a[k]))
print(len(b))

a=list(map(int,input().split()))
a=sorted(a)
b=set()
for i in range(len(a)):
    for j in range(i+1,len(a)):
        for k in range(j+1,len(a)):
            if a[i]+a[j]+a[k]==0:
                b.add((a[i],a[j],a[k]))
print(len(b))

a = sorted(list(map(int,input().split())))
l = len(a)
b = set()
for i in range(l):
    for j in range(i+1,l):
        for k in range(j+1,l):
            if a[i]+a[j]+a[k]==0:
                b.add((a[i],a[j],a[k]))
print(len(b))

三十九、矩阵翻来覆去的运算

1.题意

2.解题思路

这道题题意好理解，关键是要学会如何在Python输入矩阵：
两种方法，但本质上都是列表套列表
①

n=int(input())
a=[]
for i in range(n):
    s=list(map(int,input().split()))
    a.append(s)

②

n=int(input())
a=[]
for i in range(n):
    s=input()
    a.append([int(n) for n in s.split()])

先特判一下错误情况，然后两重循环遍历列表，计算该矩阵除副对角线、最后一列和最后一行以外的所有元素之和

i!=n-1 ：去除最后一行
j!=n-1 ：去除最后一列
i+j!=n-1：去除副对角线

方法一：

n=int(input())
a=[]
for i in range(n):
    s=list(map(int,input().split()))
    a.append(s)
#print(a)
if len(a[0]) != n:
    print("输入错误，请重新输入！")
else:
    sum=0
    for i in range(n):
        for j in range(n):
            if i!=n-1 and j!=n-1 and i+j!=n-1:
                sum+=a[i][j]
    print(sum)

方法二：

n=int(input())
a=[]
for i in range(n):
    s=input()
    a.append([int(n) for n in s.split()])
#print(a)
if len(a[0]) != n:
    print("输入错误，请重新输入！")
else:
    sum=0
    for i in range(n):
        for j in range(n):
            if i!=n-1 and j!=n-1 and i+j!=n-1:
                sum+=a[i][j]
    print(sum)

四十一、和谐列表

1.题意

2.解题思路

（1）输入这段序列
（2）循环遍历这段序列：
找每个元素最大值和最小值之间差别为1的最长序列，所以这段序列要么是由i和i+1构成，要么是i和i-1构成
所以只需要找出现先的他们出现的最大次数即可，最后输出这个次数

方法一：

a=list(map(int,input().split(",")))
d={}
for i in a:
    if i in d:
        d[i] += 1
    else:
        d[i] = 1
res = []
for i in d:
    if i + 1 in d:
        res.append(d[i]+d[i+1])
if not res:
    print(0)
else:
    print(max(res))

方法二：
核心：
①count(n)+count(n+1)
②count(n)+count(n-1)

a=list(map(int,input().split(",")))
res=0
for i in a:
    if i+1 in a:
        res=max(res,a.count(i)+a.count(i+1))
print(res)

a=list(map(int,input().split(",")))
maxl=0
for i in a:
    if a.count(i+1)>0 or a.count(i-1)>0:
        maxi=max(a.count(i+1)+a.count(i),a.count(i-1)+a.count(i))
        if maxl<=maxi:
            maxl=maxi
print(maxl)

方法三：

a=list(map(int,input().split(",")))
maxl=0
for i in a:
    if (i+1 in a) or (i-1 in a):
        maxi=max(a.count(i+1)+a.count(i),a.count(i-1)+a.count(i))
        if maxl<=maxi:
            maxl=maxi
print(maxl)

四十三、字符串基本操作

1.题意

2.解题思路

循环遍历一遍字符串统计大写字母、小写字母、数字，注意输出格式即可，最后还要转化为大写

s = input()
cnt1,cnt2,cnt3,cnt4=0,0,0,0
for i in s:
    if i>='a' and i<='z':
        cnt1+=1
    elif i>='A' and i<='Z':
        cnt2+=1
    elif i>='0' and i<='9':
        cnt3+=1
    else:
        cnt4+=1

print("字母字符数有{:d}，阿拉伯数字字符数有{:d}，其他字符有{:d}，本条字符转换为:{:s}".format(cnt1+cnt2,cnt3,cnt4,s.upper()))

四十五、有序列表插入元素

1.题意

2.解题思路

方法一：
直接将待插入值插到列表最后，然后排序即可得到新序列
计算插入的最大索引值：直接利用小技巧，在新序列中利用方法找到第一个出现的索引值+该插入值出现的次数-1(它本身)即可得到
注意：
输入还可以语句在一行中来写
输出使用fstring方式简单

a,b=list(map(int,(input().split()))),eval（input())
a.append(b)
a.sort()
print(f"输出后的列表为{a},插入索引值为{a.index(b)+a.count(b)-1}")

方法二：
第一次时用的方法，较麻烦，但也很好理解

a = list(map(int,input().split()))
n =eval（input())

if n >=a[len(a)-1]:
    a.insert(len(a),n)
    print("输出后的列表为", end="")
    print(a, end="")
    print(",插入索引值为", end="")
    print(len(a)-1)
elif n<a[0]:
    a.insert(0,n)
    print("输出后的列表为", end="")
    print(a, end="")
    print(",插入索引值为", end="")
    print(0)
else:
    t = 0
    for i in range(len(a)):
        if n >= a[i] and n < a[i + 1]:
            t = i
            break

    a.insert(t + 1, n)

    print("输出后的列表为", end="")
    print(a, end="")
    print(",插入索引值为", end="")
    print(t + 1)

四十六、列表排列

1.题意

2.解题思路

方法一：
很简单的一道题，两次循环，第一次循环先将除0和0.0外的数遍历添加到一个新列表中，第二次循环将0和0.0按顺序添加到列表中，将新列表输出即可
注意输入方式

s=list(map(eval,input().split(",")))
t=[]
for i in s:
    if i!=0 or i!=0.0:
        t.append(i)
for i in s:
    if i==0 or i==0.0:
        t.append(i)
print(t)

方法二：
注意输入方式，可以直接用map(eval,)，自动识别映射了
直接利用列表中的排序方法

list.sort(cmp=None, key=None, reverse=False)
①cmp – 可选参数,如果指定了该参数会使用该参数的方法进行排序。
②key --主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
③ reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
bool()函数对括号内的内容判断真假，真则返回true,假则返回false。
一般来说，对于数字类型，为0则假，非0 则真。
假的情况往往较少，下面列举一些为假的情况。
1.定义为false的对象：None 和False
2.值为0的数字类型:0, 0.0 ,0j,Decimal(0),fraction(0,1)
3.空的序列和集合：’’,{},(),[],set(),range(0)

所以key=bool，如果是为假，先排序，而只有0和0.0为假，所以在降序输出reverse = True即可得到

a = list((input().split(",")))
for i in range(len(a)):
    if a[i].count('.')==1:
        a[i]=float(a[i])
    else:
        a[i]=int(a[i])
a.sort(key=bool, reverse=True)

print(a)

a = list(map(eval,(input().split(","))))
a.sort(key=bool, reverse=True)
print(a)

四十八、字符串的行数

1.题意

2.解题思路

（1）先以列表的形式输入

dic=list(map(eval,input().split()))
s=input()
#print(dic)

（2）通过循环将列表转换为字典

widths={}
for i in range(len(dic)):
    widths[dic[i][0]]=dic[i][1]
#print(widths)

（3）循环计算使用了多少行，多少列

lines,width=1,0
for i in s:
    w=widths[i]
    width+=w
    if width>100:
        lines+=1
        width=w

（4）以列表的形式输出

print([lines,width])

a=list(map(eval,input().split()))
s=input()

word={}
for i in range(len(a)):
    word[a[i][0]]=a[i][1]

r=0
l=1
for i in s:
    r+=word[i]
    if r>100:
        l+=1
        r=word[i]
print([l,r])

方法一：

dic=list(input().split())
s=input()

widths={}
lines,width=1,0
for i in range(len(dic)):
    dic[i]=eval（dic[i])
for i in dic:
    widths[i[0]]=i[1]

for i in s:
    w=widths[i]
    width+=w
    if width>100:
        lines+=1
        width=w
print([lines,width])

方法二：

n = input().split()
s = input()
n = list(map(eval, n))
widths = {}
sum1 = 0
a = 0
for i in range(len(n)):
    widths[n[i][0]] = n[i][1]

total = 0
row = 1
for i in range(len(s)):
    num = widths[s[i]]
    if total + num > 100:
        total = num
        row += 1
    else:
        total = total+num
print([row, total])

四十九、身份证提取信息

1.题意

2.解题思路

方法一：

s=input()
if len(s)==18 and s[0:-1].isdigit() and (((s[-1]>='0' and s[-1]<='9') or (s[-1]>='A' and s[-1]<='Z'))) :
    y = int(s[6:10])
    m = int(s[10:12])
    d = int(s[12:14])
    t = int(s[16])
    if y>2022 or m>12 or d>31:
        print("输入错误！")
    elif(t%2==0):
        print("此人出生日期是{:d}年{:02d}月{:02d}日,性别是女,今年{:3d}岁".format(y,m,d,2022-y))
    elif(t%2!=0):
        print("此人出生日期是{:d}年{:02d}月{:02d}日,性别是男,今年{:3d}岁".format(y,m,d,2022-y))
else:
    print("输入错误！")

方法二：

n=input()
l=len(n)
if l!=18 or int(n[6:10])>2022 or int(n[10:12])>12 or int(n[12:14])>31 or (n[-1].isupper() == False and n[-1].isdigit()==False):
    print("输入错误！")
else:
    if eval（n[-2])%2!=0:
        s="男"
    else:
        s="女"
    print(f"此人出生日期是{n[6:10]}年{n[10:12]}月{n[12:14]}日,性别是{s},今年{2022-eval（n[6:10]):3}岁")

id = input()
if not id[:17].isdigit() or len(id) != 18 or (not id[-1].isupper() and not id[-1].isdigit()):
    str1 = '输入错误！'
else:
    year = id[6:10]
    min = id[10:12]
    day = id[12:14]
    if int(year) <= 2022 and 1 <= int(min) <= 12 and int(day) <= 31:
        if int(id[16])%2 == 0:
            s = '女'
        else:
            s = '男'
        str1 = f'此人出生日期是{year}年{min}月{day}日,性别是{s},今年{2022-int(year):3}岁'
    else:
        str1 = '输入错误！'
print(str1)

五十、稀疏矩阵存储

1.题意

2.解题思路

将两个序列分别用列表存储，特判一下长度是否相同，相同的遍历一遍，求对应索引上值的和
方法一：

a = list(map(int,input().split()))
b = list(map(int,input().split()))

if len(a) != len(b):
    print("不构成矩阵。")
else:
    for i in range(len(a)):
        print(a[i]+b[i],end=" ")

方法二：使用.join()方法输出
注意.join()方法是如何使用的，它要求带切割的序列里每一个元素都必须是字符串类型，所以要先把每一个元素都转化为字符串类型

a=list(map(int,input().split()))
b=list(map(int,input().split()))
if len(a)!=len(b):
    print("不构成矩阵。")
else:
    sum=0
    l=[]
    for i in range(len(a)):
        sum=str(a[i]+b[i])
        l.append(sum)
    print(" ".join(l))

五十二、不常见的单词

1.题意

2.解题思路

方法一：
用列表操作，将两个列表合并，计算出现一次的元素，如果出现了一次就添加到新列表中，输出新列表

s1 = list(input().split())
s2 = list(input().split())
s1.extend(s2)
s3=[]
for i in range(len(s1)):
   if s1.count(s1[i])==1:
        s3.append(s1[i])
print(s3)

方法二：

s1=list(input().split())
s2=list(input().split())
t=[]
for i in s1:
    if i not in s2 and s1.count(i)==1:
        t.append(i)
for i in s2:
    if i not in s1 and s2.count(i)==1:
        t.append(i)
print(t)

五十三、最常见的单词

1.题意

2.解题思路

字典题
步骤：
（1）注意输入
（2）数据处理
（3）新建字典
dict.fromkeys(seq[, val])
创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
（4）计算机字典中每一个键的values值
（5）求最大值
（6）输出
方法一：

a=input()
b=eval（input())
a=a.lower()

for i in "!,.:;'?":
    a=a.replace(i," ")
l=list(a.split())

d=dict.fromkeys(l,0)

for i in l:
    if i in b:
        d[i]=-1
    else:
        d[i]+=1

res=max(d.values())

s=[]
for k,v in d.items():
    if v==res:
        s.append(k)
print(s)

方法二：

n = input()
m = eval（input())
n = n.lower()
str1 = ''
lst = ['!', ',', '.', ':', ';', '\'', '?']
for i in n:
    if i in lst:
        continue
    else:
        str1 += i
str1 = str1.split()
d = dict.fromkeys(str1,0)
for i in str1:
    if i in m:
        d[i] = -1
    else:
        d[i]+=1
o = max(d.values())
l = []
for k,v in d.items():
    if v == o:
        l.append(k)
print(l)

s=input()
ban=eval（input())

s=s.lower()
t=['!',',','.',':',';',"'",'?']

str=""
for i in s:
    if i in t:
        continue
    else:
        str+=i
str=str.split()
#print(str)

d=dict.fromkeys(str,0)
#print(d)

for i in str:
    if i in ban:
        d[i]=-1
    else:
        d[i]+=1

m=max(d.values())
l=[]
for k,v in d.items():
    if v==m:
        l.append(k)
print(l)

五十四、又见字符统计

1.题意

2.解题思路

①首先要排除错误的情况，如果字符串中出现非字母，直接输出错误，使用string.isalpha()方法：如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
②然后将字符串全部转为大写，或者全部转为小写来操作。
③核心操作：遍历一遍26个英文字母（大写或小写），利用count()方法统计字符串中每个字母出现的个数，然后存到一个列表中
这里要用到字符串中的chr() 和 ord()函数
chr()将unicode编码转换为相对应字符
ord()将字符转换为unicode编码
也可以直接记住 a是97 ，z是122
④最后输出这个列表

普通写法：

s=input()
if s.isalpha()==False:
    print("Error!")
else:
    s=s.lower()
    t=[]
    for i in range(ord('a'), ord('z')+1):
       t.append(s.count(chr(i)))
    print(t)

s=input()
if s.isalpha()==False:
    print("Error!")
else:
    s=s.lower()
    t=[]
    for i in range(97,122+1):
       t.append(s.count(chr(i)))
    print(t)

列表推导式写法：

s=input()
if s.isalpha()==False:
    print("Error!")
else:
    s=s.lower()
    print([s.count(chr(i)) for i in range(ord('a'), ord('z')+1)])

五十五、寻找十全十美数

1.题意

2.解题思路

方法一：
核心思想：构造序列，存入列表中，判断两个列表是否相等

s=list(map(eval,input().split(",")))
flag=1
for i in s:
    a=list(map(int,str(i)))
    a.sort()

    t=[]
    for j in range(1,len(str(i))+1):
        t.append(j)

    if a==t:
        flag=0
        print(i)
if flag==1:
    print("not found")

方法二：

x=list(input().split(","))
lex=len(x)
t=0
for i in range(lex):
    f=0
    l = [k for k in range(1, len(x[i]) + 1)]
    for j in range(len(x[i])):
        if len(set(x[i]))!=len(x[i]) or int(x[i][j]) not in l:
            f=1
            break
    if f==0:
        t+=1
        print(x[i])
if t==0:
    print("not found")

方法三：

s=list(input().split(","))
s1=[]
cnt=0
for i in s:
    flag=0
    l = [k for k in range(1,len(i) + 1)]
    for j in range(len(i)):
        if len(set(i))!=len(i) or int(i[j]) not in l:
            flag = 1
            break
    if flag==0:
         cnt+=1
         print(i)
if cnt==0:
    print("not found")

五十七、有序列表的重复项删除

1.题意

2.解题思路

最简单的方法，使用set()集合，但是题目要求不让使用set来做，管他呢，能过就行
一句代码就过：

print(len(list(set((map(int,input().split()))))))

s1 = list(input().split())
print(len(set(s1)))

五十八、字符间最短的距离

1.题意

2.解题思路

两重循环暴力遍历字符串即可，每一个字符都遍历，与已知字符的下标比较求出最小值，添加到新列表中，每个字符都重复这样操作，直到外循环遍历完整个字符串为止。

方法一：

s=input()
c=input()
t=[]
for i in range(len(s)):
    ans=1000000
    for j in range(len(s)):
        if s[j]==c:
            ans=min(ans,abs(j-i))
    t.append(ans)
print(t)

方法二：

n = input()
m = input()
lst = []
len1 = []
answer = []
for i in range(len(n)):
    if n[i] == m:
        lst.append(i)
for l in range(len(n)):
    len1.clear()
    for j in lst:
        len1.append(abs(l-j))
    answer.append(min(len1))
print(answer)

六十一、书籍购买

1.题意

2.解题思路

简单的分支结构题目，只需要注意输出格式即可，三种方法：
①纯print语句输出
②字符串format格式化方法
③fstring输出方法
本题显然用第三种方法更简单

n=eval（input())
s=input()
ans=0
if s=="yes":
    if n>=15:
        ans=7.5
    elif n>=10 and n<15:
        ans=8
    else:
        ans=8.5
if s=="no":
    if n>=15:
        ans=8.5
    else:
        ans=9.5
print(f"享受{ans}折优惠")

六十三、歌咏小能手

1.题意

2.解题思路

方法一：
将得分输入到列表中，
把最小值，最大值从列表中删除，求和再求平均值，循环再计算

n=eval（input())
a= list(map(int,input().split(",")))

a.remove(max(a))
a.remove(min(a))

sum = 0
for i in a:
    sum += i
ave = float(sum/(n-2))
cnt = 0
for i in a:
    if i<ave:
        cnt+=1
print("此人最终得分是:{:.3f},有{:d}个低于平均值的成绩。".format(ave, cnt))

n=eval（input())
a= list(map(int,input().split(",")))
a.remove(max(a))
a.remove(min(a))
ave = sum(a)/(n-2)
cnt = 0
for i in a:
    if i<ave:
        cnt+=1
print("此人最终得分是:{:.3f},有{:d}个低于平均值的成绩。".format(ave, cnt))

方法二：
直接利用函数sum(),max(),min()计算出平均数，再遍历一遍列表，如果小于平均值并且不是最大值和最小值，就计数

n=eval（input())
a=list(map(int,input().split(",")))
ave=(sum(a)-max(a)-min(a))/(n-2)
cnt=0
for i in a:
    if i<ave and i!=max(a) and i!=min(a):
        cnt+=1
print("此人最终得分是:{:.3f},有{:d}个低于平均值的成绩。".format(ave,cnt))

六十四、矩阵相加

1.题意

2.解题思路

（1）矩阵输入
利用列表套列表的方式实现
（2）矩阵计算
二重循环遍历矩阵，对应数相加，存到一个临时变量t中，
（3）输出矩阵
因为用的是临时变量保存结果，所以需要直接输出t，注意输出的格式。
每个元素占三位，中间对齐，元素之间由两个空格组成。并且注意什么时候换行。

注意：每个元素占三位，不满三位的话会用一个空格占

实现一：

n=int(input())
a=[]
for i in range(n):
    s=list(map(int,input().split()))
    a.append(s)

b=[]
for i in range(n):
    s=list(map(int,input().split()))
    b.append(s)

for i in range(n):
    for j in range(n):
        t=a[i][j]+b[i][j]
        print("{:^3d}".format(t),end="  ")
    print(end="\n")

n = eval（input())
a=[]
for i in range(n):
    s=list(map(int,input().split()))
    a.append(s)
b=[]
for i in range(n):
    s=list(map(int,input().split()))
    b.append(s)

t=0
for i in range(n):
    for j in range(n):
        t=a[i][j]+b[i][j]

        if j==n-1:
            print("{:^3d}  ".format(t), end="\n")
        else:
            print("{:^3d}  ".format(t), end="")

实现二：列表推导式输入二维列表

n=int(input())
a=[]
for i in range(n):
    s1=input()
    a.append([int(n) for n in s1.split()])

b=[]
for i in range(n):
    s2=input()
    b.append([int(n) for n in s2.split()])

for i in range(n):
    for j in range(n):
        t=a[i][j] + b[i][j]
        if(j==n-1):
            print("{:^3d}".format(t),end="  ")
        else:
            print("{:^3d}".format(t), end="  ")

    print(end="\n")

六十五、寻找最佳组合

1.题意

2.解题思路

方法一：

n=eval（input())
s=list(map(int,input().split(",")))


t=[]
for i in range(len(s)):
    if s[i]==9:
        t.append([s[i]])



for i in range(len(s)):
    for j in range(i+1,len(s)):
        if s[i]+s[j]==9 and s[i]!=9 and s[j] !=9:
            t.append([s[i],s[j]])


for i in range(len(s)):
    for j in range(i+1,len(s)):
        for k in range(j+1,len(s)):
            if s[i]+s[j]+s[k]==9 and s[i] !=9 and s[j] !=9and s[k] !=9:
                t.append([s[i],s[j],s[k]])


print(t)

方法二：

n = eval（input())
s = list(map(int,input().split(",")))

a = []

for i in range(len(s)):
    t = []
    if s[i]==9:
        t.append(s[i])
        a.append(t)
for i in range(len(s)):
    t = []
    flag = 0
    for j in range(i+1,len(s)):
        if s[i]+s[j]==9 and s[i]!=0 and s[j]!=0:
            flag=1
            t.append(s[i])
            t.append(s[j])
    if flag == 1:
        a.append(t)

for i in range(len(s)):
    for j in range(i+1,len(s)):
        t = []
        flag = 0
        for k in range(j+1,len(s)):
            if s[i]+s[j]+s[k]==9 and s[i]!=9 and s[j]!=9 and s[k]!=9:
                flag = 1
                t.append(s[i])
                t.append(s[j])
                t.append(s[k])
        if flag==1:
            a.append(t)

print(a)

方法三：

n=int(input())
l=list(map(int,input().split(',')))
ls=[]
for i in l[:]:
    if i==9:
        ls.append([9])
        l.remove(i)
for i in range(0,len(l)):
    for j in range(i+1,len(l)):
        if l[i]+l[j]==9:
            ls.append([l[i],l[j]])
for i in range(len(l)):
    for j in range(i+1,len(l)):
        for k in range(j+1,len(l)):
            if (l[i]+l[j]+l[k])==9:
                ls.append([l[i],l[j],l[k]])
print(ls)

n=int(input())
l=list(map(int,input().split(',')))
ls=[]
for i in l[:]:
    if i==9:
        ls.append([9])
        l.remove(i)
for i in range(len(l)-1):
    for j in range(i+1,len(l)):
        if l[i]+l[j]==9:
            ls.append([l[i],l[j]])
for i in range(len(l)-2):
    for j in range(i+1,len(l)-1):
        for k in range(j+1,len(l)):
            if (l[i]+l[j]+l[k])==9 and l[i]!=9 and l[j]!=9 and l[k]!=9:
                ls.append([l[i],l[j],l[k]])
print(ls)

六十六、单词的区域

1.题意

2.解题思路

字典题：
这个题就是要统计输入的单词在哪个颜色的区域，
（1）首先把每个颜色区域中的字母存到不同的列表中，方便后面的计算
（2）然后输入的时候字符串分割是把一个单词一个单词的输入到列表中，
for i in s: #就是遍历列表中每一个总的单词
for j in i:就是遍历每一个单词中的每一个字母
if j in ye:然后如果这个单词的字母在ye也就是黄色区域中的话， cnt +=1，cnt就增1，所以前面要就要初始化cnt=0
然后可能存在一个单词中有的字母在这个区域，有的字母在另一个区域，所以要特判一下，即if cnt == len(i):此时就是这个单词中所有的字母都在ye黄色区域中，就把这个单词添加到一个一个新列表pye中，即pye.append(i)
（3）同理，后面重复三次。分别处理三个区域，最后在将其三个列表加入到字典中，输出即可

s = list(input().split())

re = ['q','w','e','a','s','d','z','x','c','Q','W','E','A','S','D','Z','X','C']
bl = ['r','t','y','f','g','h','v','b','n','R','T','Y','F','G','H','V','B','N']
ye =['u','i','o','p','j','k','l','m','U','I','O','P','J','K','L','M']


words={}
pre=[]
for i in s:
    cnt=0
    for j in i:
        if j in re:
            cnt +=1
    if cnt== len(i):
        pre.append(i)
pbl=[]
for i in s:
    cnt=0
    for j in i:
        if j in bl:
            cnt +=1
    if cnt== len(i):
        pbl.append(i)

pye=[]
for i in s:
    cnt=0
    for j in i:
        if j in ye:
            cnt +=1
    if cnt== len(i):
        pye.append(i)
words['Red'] = pre
words['Blue'] = pbl
words['Yellow'] = pye

print(words)

六十七、矩阵的乘法

1.题意

2.解题思路

这道题最关键的其实是理解数学问题——两个矩阵是如何相乘的?
程序围绕的核心思想：
1.两个矩阵相乘必须满足：第一个一个矩阵的列等于第二个矩阵的行
2.拿第一个矩阵的每一行中的每一个元素，依次的乘后第二个矩阵的每一列中的每一个元素。

步骤：
（1）输入两个矩阵的行数和列数
第一个矩阵n行m列
第二个矩阵m行k列
所以可以进行矩阵相乘，并且最终的结果是一个n行k列的矩阵
（2）分别输入两个矩阵
利用双重列表的方式输入
（3）矩阵计算——矩阵相乘
利用上述的核心思想理解整个矩阵相乘的步骤
（4）输出
注意输出格式，本题要求行末不能有空格，并且行末换行，其余用一个空格隔开

方法一：

n,m,k=map(int,input().split())
a=[]
for i in range(n):
    s=list(map(int,input().split()))
    a.append(s)
b=[]
for i in range(m):
    s=list(map(int,input().split()))
    b.append(s)
for i in range(n):
    for j in range(k):
        sum=0
        for t in range(m):
            sum+=a[i][t]*b[t][j]
        if j==k-1:
            print(sum,end="\n")
        else:
            print(sum,end=" ")

方法二：

n, m, k = map(int, input().split())
a = []
b = []
c = []
s = ''
for i in range(n):
    a.append(list(input().split()))
for i in range(m):
    b.append(list(input().split()))
for i in range(n):
    D = []
    for j in range(k):
        d = 0
        for l in range(m):
            d += int(a[i][l]) * int(b[l][j])
        D.append(d)
    c = c + D
for i in range(n * k):
    s = s + str(c[i])
    if (i + 1) % k == 0:
        s += '\n'
    else:
        s += ' '
print(s)

七十一、三个数必有最大2

1.题意

2.解题思路

方法一：
先求出三个数中绝对值最大的那个数，将三个数都添加到列表中，遍历列表，求他们绝对值最大的数，记录这个原数值，出现了就break掉（保证是最先出现的数)。输出这个数

a = eval（input())
b = eval（input())
c = eval（input())
t = max(abs(a),abs(b),abs(c))
s= []
s.append(a)
s.append(b)
s.append(c)

for i in s:
    if abs(i)==t:
        f=i
        break;
print(f)

方法二：

a=eval（input())
b=eval（input())
c=eval（input())
res=max(abs(a),abs(b),abs(c))
ans=0
for i in a,b,c:
    if abs(i)==res:
        ans=i
        break
print(ans)

七十四、反转单词中的字母

1.题意

2.解题思路

方法一：
利用字符串中的方法：
replace():可以实现字符的替换
swapcase():可以实现大小写之间的互换
再利用字符串切片实现字符串的反转
注意以上方法每实现一步都要赋给一个值

s=input()
s=s.replace(" ","#")
s=s.swapcase()
s=s[::-1]
print(s)

方法二：
利用列表及其方法：
现将每个字符都存入列表当中，利用列表中的反转方法，将列表元素反转，遍历列表，大写元素输出为小写，小写元素输出为大写，空格输出#

s = list(input())
s.reverse()
for i in s:
    if i==" ":
        print("#",end="")
    if i>='a' and i<='z':
        print(i.upper(),end="")
    if i>='A' and i<='Z':
        print(i.lower(),end="")

七十六、列表元素排序【part two】

1.题意

2.解题思路

要求：将列表中的所有元素按照该组元素中素数的和进行排序
步骤：
（1）输入二维列表
注意本题的输入：eval能自动评估识别出输入的是一个二维列表，并且二维列表中为整型元素

a=eval（input())

（2）先判断是否为素数，写一个素数函数
这里利用了Python中循环的奖励机制
注意这里的二维列表中的元素还可能为负数，0，这些都需要特判，因为素数一定是正整数

def sushu(x):
    if x>1:
        for i in range(2, x):
            if x % i == 0:
                return False
        else:
            return True
    else:
        return False

（3）写一个列表中求和函数，调用素数函数
这里的t代表着是外围列表中嵌套的列表，不是整个列表，也不是二维列表中的最小的元素，而是列表中的列表

def issum(t):
    sum=0
    for i in t:
        if sushu(i):
            sum+=i
    return sum

（4）利用列表排序的关键字key=函数名进行排序

a.sort(key=issum)

（5）输出排好序的列表

print(a)

代码：

a=eval（input())

def sushu(x):
    if x>1:
        for i in range(2, x):
            if x % i == 0:
                return False
        else:
            return True
    else:
        return False

def issum(t):
    sum=0
    for i in t:
        if sushu(i):
            sum+=i
    return sum

a.sort(key=issum)

print(a)

l = eval（input())


def paixv(i):
    sum = 0
    for j in i:
        if (isSuShu(j)):
            sum += j
    return sum


def isSuShu(num):
    if num > 1:
        for i in range(2, num):
            if (num % i) == 0:
                return False
        else:
            return True
    else:
        return False


l.sort(key=paixv)
print(l)

七十七、稀疏矩阵的表示

1.题意

2.解题思路

方法一：

m,n=map(int,input().split(","))
dic={}
ols=[]
lis=[]
count=0
for i in range(m):
    ols.append(list(map(eval,input().split())))
    if len(ols[i])!=n:
        print("Input error in line %d of the matrix!"%(i+1))
        break
else:
    for i in range(len(ols)):
        for j in range(len(ols[i])):
            dic[(j,i)]=ols[i][j]
            if ols[i][j]!=0:
                lis.append((i+1,j+1,ols[i][j]))
                count+=1
    lis.append((m,n,count))
    print(f"Triplet List:\n{tuple(lis)}\nTranspose matrix:")
    for j in range(n):
        for i in range(m):
            print("%6s" % dic[(j, i)], end='')
        if j != n - 1:
            print()

方法二：

m,n = input().split(',')
m = eval（m)
n = eval（n)
flag = 0
lst1 = []
lst2 = []
for i in range(m):
    lst = input().split()
    if len(lst) != n:
        flag = 1
        break
    lst1.append(list(map(eval,lst)))
    for j in range(len(lst)):
        if float(lst[j]) != 0.0:
            lst2.append((i+1,j+1,eval（lst[j])))
if flag == 1:
    print(f'Input error in line {i+1} of the matrix!')
else:
    y = len(lst2)
    lst2.append((m,n,y))
    print('Triplet List:',tuple(lst2),sep='\n')
    print('Transpose matrix:')
    for i in range(n):
        for j in range(m):
            print('{0:>6}'.format(lst1[j][i]),end='')
        print()

七十八、字符串的重新排列

1.题意

2.解题思路

核心：利用桶的思想
初始化一个长度一个的桶res，桶的下标就是列表 iLis[i] 的数值。
这样就可以将字符串 sLis的第 i 个字符，按照列表 iLis[i] 的值所指示的位置放置到桶内。

注意：
①res列表要开一个长度和已知字符串一样长的空列表，里面每个元素的值都初始化为空字符串
②学会使用.join()方法，这样就不用再循环输出了
string.join(seq)
以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

方法一：暴力

sli = list(input())
ili = list(map(int,input().split(",")))
res = []
for i in range(len(sli)):
    res.append("")
for i in range(len(sli)):
    res[ili[i]] = sli[i]
for i in res:
    print(i,end="")

方法二：使用了.join()方法

sli = list(input())
ili = list(map(int,input().split(",")))
res = []
for i in range(len(sli)):
    res.append("")
for i in range(len(sli)):
    res[ili[i]] = sli[i]
print("".join(res))

sl=list(input())
il=list(map(int,input().split(",")))
t=[]
for i in range(len(sl)):
    t.append(0)

for i in range(len(sl)):
    t[il[i]]=sl[i]
print("".join(t))

方法三：用列表推导式实现

sli = list(input())
ili = list(map(int,input().split(",")))

res = ["" for i in range(len(sli))]
for i in range(len(sli)):
    res[ili[i]] = sli[i]
print("".join(res))

七十九、下三角矩阵判断

1.题意

2.解题思路

（1）矩阵输入：
先是矩阵输入，利用二维列表的方法输入，记住模板
（2）矩阵计算：
然后对矩阵进行操作，两重循环遍历列表索引，i<j代表是主对角线上方的区域
（3）标志输出：
然后利用标志旗帜法标记最后输出。
（4）多组输入：
注意这个题是多组样例输入，外面还要再加一重循环，两种实现方式

方法一：

t=eval（input())
while t!=0:
    n=eval（input())
    a=[]
    for i in range(n):
        s=list(map(int,input().split()))
        a.append(s)

    flag=1
    for i in range(n):
        for j in range(n):
            if i<j and a[i][j]!=0:
                flag=0
                break

    if flag==1:
        print("Yes")
    else:
        print("No")
    t-=1

方法二：

t=eval（input())
for k in range(t):
    n=eval（input())
    a=[]
    for i in range(n):
        s=list(map(int,input().split()))
        a.append(s)
    flag=1
    for i in range(n):
        for j in range(n):
            if i<j and a[i][j]!=0:
                flag=0
    if flag==1:
        print("Yes")
    else:
        print("No")

八十一、求和运算

1.题意

2.解题思路

字典题
（1）输入列表和n
注意要先去重然后排序，方便后面的计算，去重用集合的set()
（2）循环输入n个数
然后里面两重循环遍历整个去重排好序之后的序列，找等于s的这个数，现已元组的形式存到列表当中，两重循环结束后以键值对的形式存到字典当中
（3）特判输出，标志旗帜法+统计一下没有时的个数

方法一：

a=list(set(map(int,input().split(","))))
n=eval（input())

a.sort()
#print(a)

d={}
cnt=0
for i in range(n):
    s=eval（input())
    t=[]
    for j in range(len(a)):
        flag=1
        for k in range(j+1,len(a)):
            if a[j]+a[k]==s:
                flag=0
                t.append((a[j],a[k]))
        if flag==1:
            cnt+=1
    d[s]=t

#print(cnt)
if cnt==n*len(a):
    print("None")
else:
    print(d)

方法二：

s=list(set(map(eval,input().split(","))))
n,d,t,count=int(input()),{},[],0
s.sort()
for i in range(n):
    m=eval（input())
    d[m]=[]
    for j in range(len(s)-1):
        for k in range(j+1,len(s)):
            if (s[j]+s[k]==m) and (s[j] not in t) and (s[k] not in t):
                t.append(s[j])
                t.append(s[k])
                d[m].append((s[j],s[k]))
    t=[]
for i in d:
    count+=len(d[i])
if count==0:
    print("None")
else:
    print(d)

方法三：

num=list(map(int,input().split(",")))
n=eval（input())

nums=list(set(num))

s=[]
while n!=0:
   a=eval（input())
   s.append(a)
   n=n-1

def fun(nums,res):
    if len(nums) < 2:
        return
    t=[]
    for i in range(0, len(nums) - 1):
        for j in range(i+1, len(nums)):
            if nums[i] + nums[j] == res:
                t.append((nums[i],nums[j]))
    return t

t={}
f=0
for i in s:
    t[i]=fun(nums,i)
    if t[i]== []:
        f=f+1

if f==len(s):
    print("None")
else:
    print(t)

八十二、寻找缺失的整数

1.题意

2.解题思路

方法一：
（1）首先注意输入方式，
（2）对整数序列进行升序排序，
（3）构造一个从最小值到最大值的序列
（4）然后把已知整数序列lis添加到新的序列中，如果数字出现的个数是1，就添加到新列表中，
（5）最后对新列表判断即可，注意正整数是要求n大于0

s, n = input().split()
n=eval（n)
a=list(map(int,s.split(",")))

a.sort()
t=[]
for i in range(a[0],a[len(a)-1]):
    t.append(i)

t.extend(a)
f=[]
for i in t:
    if t.count(i)==1:
        f.append(i)

if n<=0 or n>=len(f):
    print("Out Of Range!")
else:
    print("The {:d}th missing integer is {:d}!".format(n,f[n-1]))

方法二：
（1）首先注意输入方式，
（2）对整数序列进行升序排序，
（3）循环构造一个从最小值到最大值的序列，只需判断已知的整数序列lis中的数是否在序列中即可，如果不在序列中，就添加到一个新列表中
（4）最后对新列表判断即可，注意正整数是要求n大于0

s,n=input().split()
n=eval（n)
s=list(map(int,s.split(",")))
s.sort()
a=[]
for i in range(s[0],s[len(s)-1]):
    if i not in s:
        a.append(i)
if n<=0 or n>=len(a):
    print("Out Of Range!")
else:
    print(f"The {n}th missing integer is {a[n-1]}!")

方法三：

a,b=input().split()
li=list(map(int,a.split(",")))
n=int(b)
li.sort()
cnt=0
t=0
for i in range(min(li),max(li)):
    if i not in li:
        cnt+=1
        if cnt==n:
            t=i

if n>cnt or n<=0:
    print("Out Of Range!")
else:
    print(f"The {n}th missing integer is {t}!")

八十三、求矩阵局部极大值

1.题意

2.解题思路

（1）输入行数和列数：
首先注意如何输入在一行中用空格隔开的两个数
（2）输入矩阵：
然后输入矩阵，依然采用二维列表的方法存储矩阵，
（3）矩阵的计算和输出
然后对二维列表进行操作，通过两重循环遍历二维列表索引的方式操作矩阵
注意：
①循环时的边界问题
②本题要求编号从1开始，而序列索引是从0开始，所以要+1
（4）标记特殊情况
利用标志旗帜法特判特殊情况

m,n=map(int,input().split())
a=[]
for i in range(m):
    s=list(map(int,input().split()))
    a.append(s)
flag=1
for i in range(1,m-1):
    for j in range(1,n-1):
        if a[i][j]>a[i+1][j] and a[i][j]>a[i-1][j] and a[i][j]>a[i][j+1] and a[i][j]>a[i][j-1]:
            flag=0
            print("%d %d %d"%(a[i][j],i+1,j+1))
if flag==1:
    print("None %d %d"%(m,n))

n,m=map(int,input().split())
a=[]
for i in range(n):
    s=list(map(int,input().split()))
    a.append(s)

flag=1
for i in range(1,n-1):
    for j in range(1,m-1):
        if a[i][j]>a[i-1][j] and a[i][j]>a[i+1][j] and a[i][j]>a[i][j-1] and a[i][j]>a[i][j+1]:
            flag=0
            print(a[i][j],i+1,j+1,end="\n")
if flag==1:
    print("None %d %d"%(n,m))

n,m=map(int,input().split())
a=[]
for i in range(n):
    s=list(map(int,input().split()))
    a.append(s)

flag=1
for i in range(n):
    for j in range(m):
        if i!=0 and i!=n-1 and j!=0 and j!=m-1 and a[i][j]>a[i-1][j] and a[i][j]>a[i+1][j] and a[i][j]>a[i][j-1] and a[i][j]>a[i][j+1]:
            flag=0
            print(a[i][j],i+1,j+1,end="\n")
if flag==1:
    print("None %d %d"%(n,m))

八十五、寻找不一样的约数

1.题意

2.解题思路

（1）输入n和m，注意输入的方法
（2）计算n和m的约数，分别用两重循环枚举来做
（3）得到n和m的约数之后，需要找出他们不相同的约数
这里用到的思路就是先将两组约数合并（不管用什么方法合并），然后利用count方法找出出现一次的约数，那么他就是不相同的
（可以找到后添加到一个新列表中然后再排序，也可以先排序，找到后直接输出）
（4）输出：注意输出格式
方法一：

n,m=map(int,input().split())

a=[]
for i in range(1,n+1):
    for j in range(1,n+1):
        if i*j==n:
            a.append(i)

b=[]
for i in range(1,m+1):
    for j in range(1,m+1):
        if i*j==m:
            b.append(i)
a=a+b

a.sort()
flag=1
for i in a:
    if a.count(i)==1 and i!=a[-1]:
        print(i,end=",")
        flag=0
    elif a.count(i)==1 and i==a[-1]:
        print(i,end="")
        flag=0
if flag==1:
    print("not found")

方法二：

s= list(map(int,input().split()))
n= s[0]
m= s[1]

s1 = []
for i in range(n+1):
    for j in range(n+1):
        if i*j==n :
            s1.append(i)

for i in range(m+1):
    for j in range(m+1):
        if i*j==m :
            s1.append(i)

t = []
flag=0
for i in s1:
    if s1.count(i)==1:
        t.append(i)
        flag=1
t.sort()
if flag==0:
    print("not found")
else:
    for i in range(len(t)):
        if i==len(t)-1:
            print(t[i])
        else:
            print(t[i], end=',')

八十六、输出指定的英文字母

1.题意

2.解题思路

用列表进行计算，
①先将列表反转，这样就可以实现从右开始挑选了
②遍历列表，判断是否是小写字母，在这个字母之前是否出现过，利用not in 成员运算符和切片实现，是的话存入到一个新列表中
（核心：(s[i] not in s[0:i]）
③对新列表进行操作：特判not found情况，也就是不足七个字母
否则，先切片截取前七个数，然后反转这个列表，输出列表中的每个元素即可
注意：
①列表切片反转可以直接在切片中一步完成，不需要使用reverse方法
②输出没必要遍历列表输出每一个元素，直接用join()方法即可

方法一：

s=list(input())
s.reverse()
t=[]
for i in range(len(s)):
    if s[i]>='a' and s[i]<='z' and (s[i] not in s[0:i]):
        t.append(s[i])
if len(t)<7:
    print("not found")
else:
   
    t=t[0:6+1:1]
    t.reverse()
    print("".join(t))

方法二：

s=list(input())
s.reverse()
t=[]
for i in range(len(s)):
    if s[i]>='a' and s[i]<='z' and (s[i] not in s[0:i]):
        t.append(s[i])
if len(t)<7:
    print("not found")
else:
    t=t[6::-1]
    print("".join(t))

方法三：第一次做的时候，纯暴力，比较愚蠢的做法

st =list(input())

s=[]
for i in range(len(st)):
    if st[i]<='z' and st[i]>='a':
        s.append(st[i])
s.reverse()
s1=[]
s1.append(s[0])
for i in range(1,len(s)):
    flag = 0
    for j in range(0,i):
        if s[i]==s[j]:
            flag=1
            break
    if flag==0:
        s1.append(s[i])

if len(s1)<7:
    print("not found")
else:
    s2 = []
    for i in range(len(s1)):
        if i == 6:
            s2.append(s1[i])
            break
        else:
            s2.append(s1[i])
    s2.reverse()
    for i in range(len(s1)):
        if i==6:
            print(s2[i])
            break
        else:
            print(s2[i],end="")

八十九、七进制数

1.题意

2.解题思路

核心思想：——短除法
即转换为n进制就是取余n，然后整除n作为条件，当整除n的结果为0时，循环终止

模板：

res=""
while k!=0:
    res=str(k%n)+res
    k=k//n

注意：
（1）取余时拼接：
通过转化为字符串形式进行余数的拼接
（2）特判：
这道题需要特判一下，当为负数的情况，需要再加上一个负号，前面计算时先按整数计算，所以加绝对值。

方法一：

k=int(input())
n=abs(k)

t=""
while n!=0:
    t=str(n%7)+t
    n=n//7
if k<0:
    print('-'+t)
else:
    print(t)

a=eval（input())
n=abs(a)
t=""
while n!=0:
    x=n%7
    n=n//7
    t=str(x)+t
if a<0:
    print("-"+t)
else:
    print(t)

a=eval（input())
n=abs(a)
t=""
while n!=0:
    x=n%7
    n=n//7
    t=str(x)+t
if a<0:
    t="-"+t
print(t[::])

a=eval（input())
n=abs(a)
t=""
while n!=0:
    x=n%7
    n=n//7
    t=t+str(x)
if a<0:
    t=t+"-"
print(t[::-1])

方法二：

n =eval（input())
flag = False
s = ""
res = ""
if n<0:
    n=-n
    flag=True
while n != 0:
    res = str(n % 7 ) + res
    n //= 7

if flag:
    res='-'+res
elif res=="":
    res="0"
print(res)

九十一、循环数数

1.题意

2.解题思路

方法一：
第一重循环：遍历1~n，将数字转变为字符串，方便进行循环移位，开一个标记变量

第二重循环：实现将字符串循环移位，再将其转换为整数

核心：num=num[1:]+num[:1] 利用字符串切片，能够实现循环移位的操作

第三重循环：判读整数是否为素数，用标记变量标记，计数

n = input()
s1=n[1:]
s2=n[:1]
s=n[1:]+n[:1]
print(s1)
print(s2)
print(s)

代码：

import math

n=int(input())
sum=0
for i in range(2,n):
    flag=True
    num=str(i)
    for j in range(len(num)):
        num=num[1:]+num[:1]
        temp=int(num)
        for k in range(2, int(math.sqrt(temp)) + 1):
            if temp % k == 0:
                flag = False
                break
        if flag==False:
            break
    if flag:
        sum += 1
print(sum)

n=eval（input())

cnt=0
for i in range(2,n):
    t=str(i)
    flag=True
    for j in range(len(t)):
        t=t[1:]+t[:1]
        x=int(t)

        for k in range(2,x):
            if x%k==0:
                flag=False
                break
        if flag==False:
            break
    if flag==True:
        cnt+=1
print(cnt)

方法二：把判断素数封装为函数

n=eval（input())

def sushu(x):
    for i in range(2,x):
        if x%i==0:
            return False
    else:
        return True

cnt=0
for i in range(2,n):
    t=str(i)
    flag=True
    for j in range(len(t)):
        t=t[1:]+t[:1]
        x=int(t)
        if sushu(x)==False:
            flag=False
            break
    if flag==True:
        cnt+=1
print(cnt)

方法三：

import math
L=['0','2','4','5','6','8']
def judgeNum(x):
    if x==1 or x==0:
        return False
    else:
        for i in range(2,int(math.sqrt(x))+1):
            if x%i==0:
                return False
    return True

def MoreJudge(x):
    s=str(x)
    for i in s:
        if i in L:
            return False
    ms=""
    for i in range(len(s)):
        ms+=s[i]
        if i==len(s)-1:
            for j in range(i):
                ms+=s[j]
        else:
            ct=i+1
            for j in range(len(s)-1):
                if ct>=len(s):
                    ct=0
                ms+=s[ct]
                ct+=1
        if judgeNum(int(ms))!=True:
            return False
        ms=""
    return True

n=int(input())
cnt=0
for i in range(n):
    if i<=10:
        if judgeNum(i):
            cnt+=1
    else:
        if judgeNum(i):
            if MoreJudge(i):
                cnt+=1
print(cnt)