广告区

广告区


本站消息

站长简介/公众号

关注本站官方公众号:程序员总部,领取三大福利!
福利一:python和前端辅导
福利二:进程序员交流微信群,专属于程序员的圈子
福利三:领取全套零基础视频教程(python,java,前端,php)

  价值13000svip视频教程,python大神匠心打造,零基础python开发工程师视频教程全套,基础+进阶+项目实战,包含课件和源码

  出租广告位,需要合作请联系站长

+关注
已关注

分类  

暂无分类

标签  

暂无标签

日期归档  

2021-07(3)

2021-08(8)

Python基础刷题,期末不挂科~~~(已完结)

发布于2022-06-13 20:43     阅读(1300)     评论(0)     点赞(20)     收藏(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)

原文链接:https://blog.csdn.net/qq_46009744/article/details/124806325







所属网站分类: 技术文章 > 博客

作者:yoyo

链接:https://www.pythonheidong.com/blog/article/1593587/49b593ea3ca31c70670e/

来源:python黑洞网

任何形式的转载都请注明出处,如有侵权 一经发现 必将追究其法律责任

20 0
收藏该文
已收藏

评论内容:(最多支持255个字符)