python 练习题

最新推荐文章于 2024-08-26 18:56:03 发布
Stesthu
最新推荐文章于 2024-08-26 18:56:03 发布
阅读量170
点赞数
分类专栏： python 文章标签： python
本文链接：https://blog.csdn.net/Stesthu/article/details/126009813
版权
python 专栏收录该内容
3 篇文章 0 订阅
订阅专栏
#!/usr/bin/env python
# -*- coding:utf-8 -*-

# 计算顺子
def S(j,k):
    x = [i for j in range(0 , 4) for i in range(3 , 15)]
    y=j+k
    # 移除已经出现的牌 和 自己手中的牌
    for i in y:
        x.remove(i)
    # 去重重复的数字
    s = sorted(set(x))
    # print(s)
    if len(s)>=5:
        q=[]
        for p in range(0,len(s)):
            if p != len(s)-1:
                # 计算相邻2个数字的差值
                q.append(s[p+1]-s[p])
        z=0
        e=[]
        # print(q)
        for i in range(0,len(q)):
            # print(z,e)
            # 如果差值等于1，连续的数字加1，否则，连续数字为0，e=q=s
            if q[i]==1:
                z+=1
                e.append(i)
            else:
                z=0
                e = []
        # 判断连续数字，如果长度大于5，那么可以组成顺子
        if z >= 5:
            # print(e)
            # print(s[e[0]:e[-1]+2])
            return s,s[e[0]:e[-1]+2]
        else:
            return '不能组成顺子1'
    else:
        return '不能组成顺子2'

j=[3,3,3,3,8,8,8,8]
k=[12,12,12,12]
print(S(j,k))

j=[3,3,3,3,4,4,5,5,6,7,8,9,10,11,12,13,14]
k=[4,5,6,7,8,8,8]
print(S(j,k))
j=[3,3,3,3,4,5,6,7,11,11,11,11]
k=[4,4,4,5,5,5,6,6,6,7,7,7,8,8,8,8,13,13,13,13]
print(S(j,k))

# 计算最短步长
def g(l):
    def sd(ll,x,k=[]):
        # x累加长度，不能超过 数组本身的长度
        if x < len(ll):
            k .append(ll[x])
            x+=ll[x]
            # 如果 长度正好等于数组的长度，那么就走完了
            if x+1==len(ll):
                k.append(ll[x])
                return k
            else:
                # 如果长度不等于数组长度，那么继续递归调用，x累加
                return sd(ll,x,k)
        else:
            # 如果超长，就返回空数组
            return []
    if len(l) <= 100:
        print('len',len(l))
        # 计算 一半的长度
        max=int(len(l)/2)
        j=[]
        # 循环max次
        for i in range(1,max):
            k=sd(l,i,[])
            if k != []:
                j.append(k)
        if j==[]:
            print('没得步长')
            return 0
        s=[len(i) for i in j]
        print(s,'最短步长：',j,min(s))

    else:
        return '长度不满足'
print('*'*12,'步长计算')
l=[7,5,9,4,2,6,8,3,5,4,3,9]
g(l)
l=[0,1,2,3,4,5,6,7,8,9,1,55]
g(l)

# 正方体翻面数字
print('*'*12,'正方体反面')
init_6={'1':1,'2':2,'3':3,'4':4,'5':5,'6':6}
init_3={'前后':{'前':3,'后':4},'上下':{'上':5,'下':6},'左右':{'左':1,'右':2}}
# 左转
# 左右：左= 上下：上  5
# 上下：上=左右：右   2
init_3={'左右':{'左':5,'右':6},'前后':{'前':3,'后':4},'上下':{'上':2,'下':1}}
# 右转
# 左右：右=上下：上
# 上下：上=左右：左
init_3={'左右':{'左':1,'右':2},'前后':{'前':3,'后':4},'上下':{'上':5,'下':6}}
# 后转
# 前后：前=上下：下  1
# 上下：上=前后：前 3
init_3={'左右':{'左':5,'右':6},'前后':{'前':3,'后':4},'上下':{'上':2,'下':1}}
init_3={'左右':{'左':5,'右':6},'前后':{'前':1,'后':2},'上下':{'上':3,'下':4}}
# 前转
# 前后：前=上下：上  3
# 上下：上=前后：后  2
init_3={'左右':{'左':5,'右':6},'前后':{'前':3,'后':4},'上下':{'上':2,'下':1}}

# 逆时针旋转：
init_3={'左右':{'左':1,'右':2},'前后':{'前':3,'后':4},'上下':{'上':5,'下':6}}
# 左右：左=前后：后
# 前后：前=左右：左
# 上下：上=上下：上
init_3={'左右':{'左':4,'右':3},'前后':{'前':1,'后':2},'上下':{'上':5,'下':6}}
# 顺时针旋转：
# 左右：左=前后：后
# 前后：前=左右：左
# 上下：上=上下：上
init_3={'左右':{'左':3,'右':4},'前后':{'前':2,'后':1},'上下':{'上':5,'下':6}}
import copy
def cube_test(l):
    init= { '左右': {'左': 1 , '右': 2},'前后': {'前': 3 , '后': 4} , '上下': {'上': 5 , '下': 6}}
    init_copy= { '左右': {'左': 1 , '右': 2},'前后': {'前': 3 , '后': 4} , '上下': {'上': 5 , '下': 6}}
    for i in l:
        if i == 'L':
            init_copy['左右']['左']=init['上下']['上']
            init_copy['左右']['右']=init['上下']['下']
            init_copy['上下']['上']=init['左右']['右']
            init_copy['上下']['下']=init['左右']['左']
            init=copy.deepcopy(init_copy)
        if i =='R':
            init_copy['上下']['上']=init['左右']['左']
            init_copy['上下']['下']=init['左右']['右']
            init_copy['左右']['左']=init['上下']['下']
            init_copy['左右']['右']=init['上下']['上']
            init=copy.deepcopy(init_copy)
        if i== 'F':
            init_copy['前后']['前']=init['上下']['上']
            init_copy['前后']['后']=init['上下']['下']
            init_copy['上下']['上']=init['前后']['后']
            init_copy['上下']['下']=init['前后']['前']
            init=copy.deepcopy(init_copy)
        if i== 'B':
            init_copy['前后']['前']=init['上下']['下']
            init_copy['前后']['后']=init['上下']['上']
            init_copy['上下']['上']=init['前后']['前']
            init_copy['上下']['下']=init['前后']['后']
            init=copy.deepcopy(init_copy)
        if i== 'A':
            init_copy['左右']['左']=init['前后']['后']
            init_copy['左右']['右']=init['前后']['前']
            init_copy['前后']['前']=init['左右']['左']
            init_copy['前后']['后']=init['左右']['右']
            init=copy.deepcopy(init_copy)
        if i== 'C':
            init_copy['左右']['左']=init['前后']['前']
            init_copy['左右']['右']=init['前后']['后']
            init_copy['前后']['前']=init['左右']['右']
            init_copy['前后']['后']=init['左右']['左']
            init=copy.deepcopy(init_copy)
    print('init',init)
l='LR'
l='FCR'
l='LRFBAC'
cube_test(l)

print('*'*12,'计算连续字符串的数量')
#计算连续字符串的数量
def strtest(strt):
    l=list(strt.lower())
    # print(l)
    k = 1
    s = ''
    for i in range(len(l)):
        # 最后一个处理
        if i+1 == len(l) :
            if l[i]==l[i-1]:
                s += l[i]
                s += str(k)
            else:
                k=1
                s += l[i]
                s += str(k)
        else:
            if l[i] == l[i + 1]:
                k += 1
            else:
                s += l[i]
                s += str(k)
                k = 1
    print('s',s)
strtest('SSSss44444444sssstrttttiiiii99999')

print('*'*12,'和最大的连续子串')
# 和最大的连续子串/和最小的字串
l=[-1,2,-3,6,4,5,-6,7,8,9,7,4,-1,4,-1,5,120,-7]
k=0
max=0
for i in l:
    k+=i
    if k >= max:
        max=k
print(max)
print(sum(l))

print('*'*12,'正整数组成最大的数 冒泡算法')
#  将
#  解题想法：
# 利用冒泡排序，每次将最小位置的数放在最后
num = "22,221,33,93,96,933,98,973,974,9,9999"
nums = num.split(',')
for i in range(len(nums)):
    for j in range(0 , len(nums) - 1):
        if str(nums[j]) + str(nums[j + 1]) < str(nums[j + 1]) + str(nums[j]):
            nums[j] , nums[j + 1] = nums[j + 1] , nums[j]
res = ""
for i in range(len(nums)):
    res = res + str(nums[i])
print(str(int(res)))


def f(m , l , n):
    # 解题想法：先用set去重，再排序，再取前后n个元素判断是否有交集，再求和
    # set无序，且无排序方法
    ll = list(set(l))
    ll.sort()

    # 注意l可能存在重复元素，所以不能用m-n
    # 集合减法，减去存在的相同元素,没有相同元素，元素个数不会减少，如果元素个数少于n个，说明存在相同元素
    # 存在问题：7个数字，计算4个长度：4个最大的，3个最小的
    print(ll[0:n])
    print(ll[len(ll)-n:])
    print(set(ll[0:n]) - set(ll[len(ll) - n:]))
    if len(set(ll[0:n]) - set(ll[len(ll) - n:])) != n:
        return -1
    sum1 = 0
    sum2 = 0
    for i in range(n):
        sum1 += ll[i]
    ll.reverse()
    for i in range(n):
        sum2 += ll[i]
    return sum1 + sum2
m=8
l=[1,2,3,4,5,6]
n=2
print(f(m , l , n))
# n=3  0:3 5:8
# n=2 0:2 6:8
# n=4 0:4 4:8
x='12345'
print(x[::-1])
nums = [1, 2, 3, 4]
print(",".join(map(str, nums)))
x=map(str,nums)
print(list(x))

# 拼接url
def compound(x,y):
    if '/' in x:
       k= x.replace('/','')
    if '/' in y:
        j=y.replace('/','')
    return '/'+ k+'/'+j+'/'
print(compound('abc/','/ef/'))
print(compound('/abc','/ef/'))

# 磁盘容量排序
# 换算相同的单位排序
def hardDisk_sort(l):
    k={}
    for i in l:
        if i.endswith('M'):
            p=i.split('M')[0]
            if '.' in p:
                le=len(p.split('.')[1])
            s=int('1'+'0'*le)
            k[i]=int(p.split('.')[1])/s+int(p.split('.')[0])
        if i.endswith('G'):
            p=i.split('G')[0]
            if '.' in p:
                le=len(p.split('.')[1])
            s=int('1'+'0'*le)
            k[i]=int(p.split('.')[1])*1000/s+int(p.split('.')[0])
        if i.endswith('T'):
            p = i.split('T')[0]
            if '.' in i:
                le = len(p.split('.')[1])
            s = int('1' + '0' * le)
            k[i] = int(p.split('.')[1]) * 1000000 / s+int(p.split('.')[0])
    a=sorted(k.items(),key=lambda x:x[1],reverse=True)
    return dict(a)
l=['60.89M','120.0000008G','0.00000001T']
print(hardDisk_sort(l))

# gpu耗时计算
# 2 , 5 ,[1,3,2,5,3,5]
# 1: 1 +3:1+3,2:1+
def countTime(a,b,l):
    p=0
    q=0
    for i in l:
        # 判断是否超过处理的长度，不超过就处理次数加1
        if i+q <=a:
            p+=1
        # 任务数超过处理长度，则次数+1,余数进入下一次循环处理
        else:
            w=i+q-a
            p+=1
            x=w/a
            q=w%a
            p+=int(x)
    return p
print(countTime(3 , 5 ,[1,3,2,5,3,5]))
print(countTime(3 , 5 ,[1,2,3,4,5]))
print(countTime(4 , 5 ,[5,4,1,1,1]))

# 滑动窗口最大和
def slidingWindow(s,l,num):
    if s%num==0:
        k=0
        p=[]
        for i in l:
            k+=1
            if k%num==0:
                p.append(sum(l[k-3:k]))
    else:
        o=s%num
        z=l[0:s-o]
        k=0
        p=[]
        for i in z:
            k+=1
            if k%num==0:
                p.append(sum(l[k-3:k]))
        p.append(sum(l[s-o:]))
    print(p)


slidingWindow(7,[12 ,10, 20 ,30, 15, 23,88],3)
slidingWindow(8,[12 ,10, 20 ,30, 15, 23,1,6],3)
slidingWindow(6,[12 ,10, 20 ,30, 15, 23],3)
def  slidingWindow_2(s,l,num):
    k=0
    pp=[]
    q=0
    for i in l:
        k+=1
        q+=i
        # print(i,k)
        if k%num==0:
            k=0
            pp.append(q)
            q=0
    if s % num != 0:
        # print(s % num)
        pp.append(sum(l[s - s % num:]))
    print(pp)
slidingWindow_2(7,[12 ,10, 20 ,30, 15, 23,88],3)
slidingWindow_2(8,[12 ,10, 20 ,30, 15, 23,1,6],3)
slidingWindow_2(6,[12 ,10, 20 ,30, 15, 23],3)

# 和最大的子矩阵
# 思路 循环加总所有的子矩阵，求最大和，2次循环取值
def countNMS(n,m,s):
    k=s.split('\n')
    max=0
    mm=[[] for i in range(0,m)]
    nn=[]
    for v in k:
        nn.append([int(i) for i in v.split(' ')])
    # 矩阵转置
    # k[0][0]=mm[0][0]
    # k[0][1]=mm[1][]
    # k[0][2]=mm[2][0]
    # k[0][3]=mm[3][0]
    # k[1][0]=mm[1][1]
    # k[1][1]=mm[1][1]
    # k[2][0]=mm[2][2]
    # k[2][1]=mm[2][2]
    for p in range(0,m):
        for o in range(0,n):
            # print(p,o)
            mm[p].append(nn[o][p])
    print(mm)
    for i in range(0,n):
        # 行
        flag=0
        for k in range(0,m):
            # 列
            print('%%%%%%%',i,k)
            print(nn[i][k:])
            print(mm[k][i:])
            maxflag=sum(nn[i][k:])+sum(mm[k][i:])-nn[i][k]
            flag+=1
            print(maxflag)
            max=maxflag if maxflag > max  else max
            if flag:
                flag=0
                continue

    print('max',max)
s="-3 5 -1 5\n" \
  "2 4 -2 4\n" \
  "-1 3 -1 3"
# countNMS(3 , 4 , s)

s="-3 2 -1\n" \
  "5 4 3\n" \
  "-1 -2 -1\n" \
  "5 4 3"
# countNMS(4 , 3 , s)


def countNMS2(n,m,s):
    k=s.split('\n')
    max=0
    mm=[[] for i in range(0,m)]
    nn=[]
    for v in k:
        # 将矩阵存储为列表 横向
        nn.append([int(i) for i in v.split(' ')])
    # 矩阵转置
    # k[0][0]=mm[0][0]
    # k[0][1]=mm[1][]
    # k[0][2]=mm[2][0]
    # k[0][3]=mm[3][0]
    # k[1][0]=mm[1][1]
    # k[1][1]=mm[1][1]
    # k[2][0]=mm[2][2]
    # k[2][1]=mm[2][2]
    for p in range(0,m):
        for o in range(0,n):
            # print(p,o)
            # 将列表转换存储
            mm[p].append(nn[o][p])
    print('mm',mm)
    nnc=[]
    mmc=[]
    for i in range(0,n):
        # 行
        flag=0
        for k in range(i,m):
            # 2个列表循环，存储子矩阵组成的列表
            nnc.append(nn[i][k:])
            mmc.append(mm[k][i+1:])
            flag+=1
            print(i,k,nn[i][k:],mm[k][i+1:])
            if flag > 0:
                break
    for i in range(0,n):
        flag=0
        for k in range(i,m):
            # 双循环，计算子矩阵的总和
            x=sum([sum(i) for i in nnc])
            y=sum([sum(i) for i in mmc])
            print('x+y',x+y)
            if x+y > max:
                max=x+y
                nncc=copy.deepcopy(nnc)
                mmcc=copy.deepcopy(mmc)
            # 移除外围矩阵，计算子矩阵
            nnc.remove(nn[i][k:])
            mmc.remove(mm[k][i+1:])
            flag+=1
            if flag:
                break
    print('max',max)
    print('nncc',nncc)
    print('mmcc',mmcc)
s="-3 -5 -1 -5\n" \
  "-2 4 -2 4\n" \
  "-1 3 -1 3"
countNMS2(3 , 4 , s)


# 服务器广播
# s[0][0]=1 s[1][1]=1 s[2][2]=1  3条
# s[0][0]=1 s[0][1]=1 s[1][0]=1 s[1][1]=1 1条
# 1 0 0
# 1 0 1
# 0 1 1
print('**'*8,'Broadcast**  历时14个工作时 写出解决办法')
def Broadcast(n,m,s):
    k=s.split('\n')
    mm=[[] for i in range(0,m)]
    nn=[]
    for v in k:
        # 将矩阵存储为列表 横向
        nn.append([int(i) for i in v.split(' ')])
    for p in range(0,m):
        for o in range(0,n):
            # print(p,o)
            # 将列表转换存储
            mm[p].append(nn[o][p])
    x=[]
    # 计算为1的坐标
    for i in range(0,n):
        for k in range(0,n):
            if nn[i][k]==1:
                x.append((i,k))
    if x==[]:
        return '不能为空'
    # print('x',x)
    if len(x) == 1:
        return x,'广播次数：1次'
    # 计算 坐标元组的差值，差值为（1，0）或者（0，1）则是相邻坐标
    # 计算出来不存在差值大于1的坐标，则单独处理
    y=[]
    f=0
    xx=copy.deepcopy(x)
    for i in x:
        for k in x:
            if i !=k:
                if (i[0] - k[0] == 1 and i[1] - k[1] == 0) or (i[0] - k[0] == 0 and i[1] - k[1] == 1):
                                y.append([])
                                y[f].append(i)
                                y[f].append(k)
                                if i in xx:
                                    # 去掉已经是相邻的坐标，剩下的就是不相邻的坐标
                                    xx.remove(i)
                                if k in xx:
                                    xx.remove(k)
                                f+=1

    # 计算出来 相邻坐标的列表为空，就看是否存在不相邻的坐标
    if len(y)==0:
        return xx,'需要广播次数：',len(xx)
    # 计算相邻坐标，相邻的聚集,使用字典，具有相同坐标的作为key,延伸的作为value
    d={}
    for p in y:
        if p[0] not in d.keys():
            d[p[0]]=[]
            d[p[0]].append(p[1])
        else:
            d[p[0]].append(p[1])
        if p[1] not in d.keys():
            d[p[1]]=[]
            d[p[1]].append(p[0])
        else:
            d[p[1]].append(p[0])
    # 将 key是value的键值对进行组合
    for k,v in d.items():
        for kk,vv in d.items():
            if k != kk:
                if kk in v:
                    for i in vv:
                        if i not in v:
                            v.append(i)
    yy=[]
    for k,v in d.items():
        # print(k,v)
        yy.append(v)

    # 对处理后的坐标排序
    yy= [sorted(x , key=lambda x: (x[0] , x[1])) for x in yy]
    # 对处理后的坐标根据长度排序，倒序排列
    yy=sorted(yy,key=lambda x:len(x),reverse=True)
    yyy=[]
    yyy.append(yy[0])
    for i in yy:
        for k in i:
            # 判断坐标组成的集合里面是否与最长的坐标集重复，如果不重复，那么就单独存储
            if k not in yy[0]:
                if i not in yyy:
                    yyy.append(i)
    return '最后广播次数：',len(yyy)+len(xx)



s="1 0 0 1\n" \
  "1 0 1 1\n" \
  "0 1 1 1"
print(Broadcast(3,3,s))
s="1 0 0 1\n" \
  "1 0 1 1\n" \
  "0 1 1 1\n"\
  "1 1 1 1"
print(Broadcast(4,4,s))
s="1 0 0 1\n" \
  "1 0 1 1\n" \
  "0 0 0 0\n"\
  "1 1 1 1"
print(Broadcast(4,4,s))

s="1 0 0 0\n" \
  "0 0 0 0\n" \
  "0 0 0 0\n"\
  "0 0 0 0"
print(Broadcast(4,4,s))

s="1 0 0 0\n" \
  "0 0 1 0\n" \
  "0 0 0 0\n"\
  "0 0 0 1"
print(Broadcast(4,4,s))

s="1 1 1 1\n" \
  "1 1 1 1\n" \
  "0 1 0 0\n"\
  "1 1 1 1"
print(Broadcast(4,4,s))

s="1 1 1 1\n" \
  "1 0 1 1\n" \
  "0 0 0 0\n"\
  "1 1 1 1"
print(Broadcast(4,4,s))





# 用任意你熟悉的编程语言（或伪代码）实现如下功能，一串字符串，其中的数字之和。如字符串为：
# a6dc12hah345xh22ee，就是12+345+22之和
def tt(s):
    kk = []
    for i in range(0,len(s)+1):
        for k in range(0 , len(s)+1):
            # if i != k:
                try:
                    if type(int(s[i:k]))==int:
                        zz=s.split(s[i:k])
                        # print(s[i:k])
                        # print(zz)
                        # 判断第一个数字
                        if zz[0]=='':
                            if zz[1][0].isdigit():
                                continue
                            else:
                                kk.append(s[i:k])
                        else:
                            # 判断最后一个数字
                            if zz[1] == '' and len(zz)==2:
                                # print('zz',zz)
                                # print(zz[0][-1].isdigit())
                                if not zz[0][-1].isdigit():
                                    kk.append(s[i:k])

                                    # print(kk)
                            # 不是最后一个数字
                            else:
                                if zz[0][-1].isdigit() or zz[1][0].isdigit():
                                    continue
                                else:
                                    kk.append(s[i:k])

                    # print(kk)
                except Exception:
                    continue
    return kk

s='77a6dc12hah345xh22ee99'
# s='1rre9'
print(tt(s))
print(sum([int(i) for i in tt(s)]))
# 第二种办法

def ss(s):
    for i in s :
        # print(i.isdigit(),i.isalpha())
        if not i.isdigit():
            s=s.replace(i,' ')
    print(s)
    l=s.split(' ')
    print(l)
    return sum([int(i)  for i in l if i !=''])
# s='1rre9'
print(ss(s))