牛客-困难及极难难度python

1 字符串最后一个单词的长度

计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。

def get_length():
    input_str = input()
    str_list = input_str.strip().split()
    if len(str_list) == 0 or len(str_list) > 5000:
         
        return '请重新输入'
    else:
        return len(str_list[-1])
 
print(get_length())

2 计算某字母出现次数

写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字母，然后输出输入字符串中该字母的出现次数。不区分大小写，字符串长度小于500。

import string
 
 
def getCount():
    input_string = input()
    input_target = input()
    # 对字符串进行处理，切分为单个字母
    input_char_list = [j.lower() for i in input_string.split(' ') for j in i if j in string.ascii_letters]
     
    # 统计词频
    count = {}
    for w in input_char_list:
        if w not in count:
            count[w] = 0
        count[w] += 1
    return count.get(input_target.lower(), 0)
print(getCount())

3 明明的随机数

# coding=utf-8
 
def nums():
    while True:
        try:
            n = int(input())
            num_list = [int(input()) for i in range(n)]
            num_list = sorted(list(set(num_list)))
            for i in num_list:
                print(i)
        except:
            break
nums()

4 字符串分隔

连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组；长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。

 coding = utf-8
 
def main(input_string):
    temp = [i for i in input_string]
    if len(temp) <= 8:
        res = ''.join(temp) + '0' * (8 - len(temp))
        print(res)
    else:
        print(''.join(temp[:8]))
        main(temp[8:])
         
         
if __name__ == '__main__':
    while True:
        try:
            input_string = input()
            main(input_string)
        except:
            break

13

将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符

# coding = utf-8
 
 
def main(input_string):
    if len(input_string)<1:
        return '输入错误'
    return ' '.join(input_string.split(' ')[::-1])
 
 
if __name__ == '__main__':
    input_string = input()
    print(main(input_string))

17坐标移动

开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。

while True:
    try:
        val = input()
        tmp = val.split(";")
        x,y = 0,0
        comp = set("1234567890")
        for i in tmp:
            if not i or i[0] not in ["A","D","W","S"] or set(i[1:]).issubset(set("1234567890")) == False:
                continue
            elif i[0] == "A":
                x -= int(i[1:])
            elif i[0] == "S":
                y -= int(i[1:])
            elif i[0] == "W":
                y += int(i[1:])
            elif i[0] == "D":
                x += int(i[1:])
        print(str(x)+","+str(y))
    except:
        break

20密码验证合格程序

def checkLegal(pswd):  
    if len(pswd) <= 8:return False      
    else:
        #最大重复子串长度2+
        sub = []
        for i in range(len(pswd)-2):
            sub.append(pswd[i:i+3])
        if len(set(sub)) < len(sub):return False
        #check type
        type_ = 0
        import re
        Upper = '[A-Z]'
        Lowwer = '[a-z]'
        num = '\d'
        chars = '[^A-Za-z0-9_]'
        patterns = [Upper, Lowwer, num, chars]
        for pattern in patterns:
            pw = re.search(pattern, pswd)
            if pw : type_ += 1
        return True if type_ >= 3 else False
while True:
    try:
        pswd = input()
        print('OK' if checkLegal(pswd) else 'NG')
    except:
        break

23 删除字符串中出现次数最少的字符

# coding = utf-8
 
 
def main(input_string):
    count = {i:input_string.count(i) for i in input_string}
    min_count = min(count.values())
 
    for i in count.keys():
        if count[i] == min_count:
            input_string = input_string.replace(i, '')
    return input_string
 
if __name__ == '__main__':
    while True:
        try:
            input_string = input()
            print(main(input_string))
        except:
            break

24 合唱队

def max_up_arr(arr):
    """查找arr中以i为结尾的最大上升子序列长度"""
    dp = [1]  # 默认为1个
    for i in range(1, len(arr)):
        dp.append(max([1] + [dp[j]+1 for j in range(i) if arr[j] < arr[i]]))
    return dp
  
def func(n, arr):
    a1 = max_up_arr(arr)
    a2 = max_up_arr(arr[::-1])[::-1]
    print(n-max(i+j-1 for i, j in zip(a1, a2)))
  
while True:
    try:
        n = int(input())
        arr = list(map(int, input().split()))
        func(n, arr)
    except EOFError: break

25数据分类处理

采集输入大数据和分类规则，通过大数据分类处理程序，将大数据分类输出。

while True:
    try:
        I=input().split()#按空格分成列表
        R=input().split()
        m=int(I.pop(0))#取第一个元素作为个数
        n=int(R.pop(0))
        for i in range(n):#字符串->整数，为了后面的排序
            R[i]=int(R[i])
        R=set(R)#去重
        R=sorted(R)#排序
        count=0#记录R中的元素在I中出现的总次数
        num=0#记录R中有几个元素是I中元素的子串
        flag0=False#标识位，标识当前R中元素是否是I中某元素的子串
        for i in R:
            for j in I:
                if str(i) in j:
                    flag0=True#说明该元素至少是I中一个元素的子串
                    count+=1
            if flag0:
                num+=1
                flag0=False#每次循环结束置为false，为了下一个元素的判断
        count=(count+num)*2#要输出的第一个数，表示后面元素的个数
        #输出时，因为有位置信息所以count*2，又要输出元素和总次数
        #因此num*2
        print(count,end='')#按格式输出，以‘’结尾，下次输出紧跟着
        for i in R:
            num=0
            for j in I:
                if str(i) not in j:
                    continue
                flag0=True#说明该元素至少是I中一个元素的子串，有效
                num+=1#num记录当前元素是几个元素的子串
            if not flag0:#如果该元素无效，跳过
                continue
            print(' '+str(i)+' '+str(num),end='')#按格式
            for index,j in enumerate(I):
                if str(i) in j:
                    print(' '+str(index)+' '+j,end='')
            flag0=False#同样置false，为了下个元素的判断
        print()#这是为了换行，不然会过不了测试
    except:
        break

29字符串加解密

while True:
    try:
        s1=input()
        s2=input()
        list1=[]
        #加密
        for i in s1:
            if i.isalpha() and i not in ['z','Z'] :
                if i.islower():
                    list1.append(chr(ord(i.upper())+1))
                else:
                    list1.append(chr(ord(i.lower())+1))
            elif i=="z":
                 list1.append("A")
            elif i=="Z":
                 list1.append("a")
            elif i.isdigit() and i!='9':
                 list1.append(str(int(i)+1))
            elif i=='9':
                 list1.append("0")
            else:
                 list1.append(i)
        res1="".join(list1)
        #解密：
        list2=[]
        #加密
        for j in s2:
            if j.isalpha() and j not in ['a','A'] :
                if j.islower():
                    list2.append(chr(ord(j.upper())-1))
                else:
                    list2.append(chr(ord(j.lower())-1))
            elif j=="a":
                 list2.append("Z")
            elif j=="A":
                 list2.append("z")
            elif j.isdigit() and j!='0':
                 list2.append(str(int(j)-1))
            elif j=='0':
                 list2.append("9")
            else:
                 list2.append(j)
        res2="".join(list2)
  
        print(res1)
        print(res2)
    except:
        break

30 字符串合并处理

import re
  
# 构造函数加密字符，如果是[0-9A-Fa-f]则按规则返回加密值，否则返回原始值
def encrypt(x):
    if re.search(r'[0-9A-Fa-f]', x):
        return hex(int(bin(int(x, 16))[2:].rjust(4, '0')[::-1], 2))[2:].upper()
        """
        1. int(x, 16) - 将字符x转成16进制
        2. bin(int(x, 16))[2:].rjust(4,'0')[::-1] - 继续将十六进制转成二进制，并去除二进制开头"0b"，如果二进制长度小于4，则在前面补0至四位,然后再倒序。
        比如bin(int('7', 16))输出0b111,[2:]去除0b后为111，rjust(4,'0')左侧补0则变为0111，[::-1]倒序后变为二进制的1110
        3. hex(int(i,2)[2:].upper() - 其中i表示注释2的内容。这一步是将上一步获取的二进制转成十六进制，并去除开头的"0x",最后再将其转成大写。
        """
    else:
        return x
  
while True:
    try:
        a = list(input().replace(" ", "")) # 去除输入中的空格，并将输入的字符处理成列表
        a[::2] = sorted(a[::2])  # 奇数位置从小到大排序
        a[1::2] = sorted(a[1::2])  # 偶数位置从小到大排序
        res = ""
        for i in a:
            res += encrypt(i) # 调用加密函数，遍历输出结果
        print(res)
    except:
        break

32密码截取

while True:
    try:
        s = input()
        def findlen(s):
            n = len(s)
            if n < 2:
                return s
            maxlen = 1
            def finder(left, right):
                nonlocal maxlen
                while left >= 0 and right < n and s[left] == s[right]:
                    left -= 1
                    right += 1
                # 退出循环的时候正面两边不满足条件，但是left和right需要用扩展前的
                if right - left - 1 > maxlen:
                    maxlen = right - left - 1
  
            for i in range(n):
                finder(i, i)
                finder(i, i + 1)
            return maxlen
        ret = findlen(s)
        print(ret)
    except:
        break

33 整数与IP地址间的转换

while True:
    try:
        ip = str(input()).split('.')
        num = int(input())
        res1 = ''
        res2 = []
        for i in ip:
            res1 += "{:08b}".format(int(i))
        print(int(res1, base=2))
  
        temp = "{:032b}".format(num)
        for i in range(4):
            res2.append(str(int(temp[:8], base=2)))
            temp = temp[8:]
        print('.'.join(res2))
    except:
        break

39 判断两个IP是否属于同一子网

import sys
#判断ip是否合法,判断每段是否在0-255之间
def check_ip(ip):
    ips = list(map(int,ip.split('.')))
    if len(ips) < 4:
        return False
    for i in ips:
        if i < 0 or i > 255:
            return False
    return True
  
#判断掩码是否合法
#先判断是否每段在0-255之间
def check_mask(mask):
    if not check_ip(mask):
        return False
    masks = list(map(int, mask.split('.')))
    mask_str = ""
    for m in masks:
        #转成二进制形式的字符串,注意左边要用0补够8位
        mask_str += bin(m)[2:].rjust(8,'0')
    index = mask_str.index('0')
#     print(mask_str)
#     print(index)
    #如果0后面还有1,就是非法
    if -1 != index:
        if '1' in mask_str[index:]:
            return False
    return True
  
def convert_int(ipstr):
    ips = list(map(int, ipstr.split('.')))
    ipnum = 0
    for ip in ips:
        ipnum = ip + (ipnum << 8)
    return ipnum
  
#判断是否同一子网
#ip分别与掩码与,再对比
def check_ziwang(mask, ip1, ip2):
    mm = convert_int(mask)
    ipnum1 = convert_int(ip1)
    ipnum2 = convert_int(ip2)
#     print(mm & ipnum1)
#     print(mm & ipnum2)
    return (mm & ipnum1) == (mm & ipnum2)
  
while True:
    try:
        mask = input()
        ip1 = input()
        ip2 = input()
        if not check_ip(ip1) or not check_ip(ip2) or not check_mask(mask):
            print("1")
        elif check_ziwang(mask, ip1, ip2):
            print("0")
        else:
            print("2")
    except:
#         print(sys.exc_info())
        break

41 称砝码

# 第二行：m1 m2 m3 ... mn --- 每个砝码的重量(范围[1,2000]) 每种吧？！
# 第三行：x1 x2 x3 .... xn --- 每个砝码的数量(范围[1,6])
while 1:
    try:
        n=int(input())
        zl=list(map( int, input().split() ) )
        sl=list(map( int, input().split() ) )
        n_class = len(zl)
        if n_class==1:
            print(sl[0]+1)
            continue
        big_lt=[
                [zl[i]*s for s in range(0, sl[i]+1) ] for i in range(n_class)  
                ]
  
        for i in range(n_class-2):
#           merge_two_lt
            merged=set((0,))
            #这里如果用list存数据，超时。可能是因为多了一个判断 :是否在list里
            #用set则将原本的2s，缩短至50ms左右。
            for ele_q in big_lt[0]:
                for ele_h in big_lt[1]:
                    merged.add(ele_q+ele_h)
            big_lt.pop(0)
            big_lt[0] = merged
  
        merged=set((0,))
        for ele_q in big_lt[0]:
            for ele_h in big_lt[1]:
                merged.add(ele_q+ele_h)
  
        print(len(merged))
  
    except Exception as e:
        if not isinstance(e,EOFError):
            print('leo_you_have_Error:  '  , e)
        break

42 学英语

#有些地方还有些迷糊，先MARK一下
def dps(n):
   m1 = 'one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thirteen,fourteen,fifteen,sixteen,seventeen,eighteen,nineteen'.split(',')
   m2 = 'twenty,thirty,forty,fifty,sixty,seventy,eighty,ninety'.split(',')
   if(n<20):
       return m1[n-1:n]
   if(n<100):
       return [m2[n//10-2]] + dps(n%10)
   if(n<1000):
       return [m1[n//100-1]]+['hundred']+['and']+dps(n%100)
   else:
       for w,p in enumerate(('thousand','million','billion'),1):
           if(n<1000**(w+1)):
               return dps(n//(1000**w))+[p]+dps(n%1000**w)
def question():
   n = int(input())
   return ' '.join(dps(n)) or 'error'
while(True):
   try:
       print(question())
   except:
       break

51 输出单向链表中倒数第k个结点

class Node(object):
  
    def __init__(self, val=0):
        self.val = val
        self.next = None
  
  
while True:
    try:
        l, s, k, head = int(input()), list(map(int, input().split())), int(input()), Node()
        while k:
            head.next = Node(s.pop())
            head = head.next
            k -= 1
        print(head.val)
    except:
        break

58 输入n个整数，输出其中最小的k个

# coding = utf-8
 
def main(num_list, k):
    num_list.sort()
    return ' '.join([str(i) for i in num_list[:k]])
 
 
if __name__ == '__main__':
    while True:
        try:
            nums, k = map(int, input().split())
            num_list = [int(i) for i in input().split()]
            print(main(num_list, k))
             
        except:

68 成绩排序

def main(N, M, name_dict):
    if M == 0:
        name_list = sorted(name_dict.items(), key = lambda x:int(x[-1][-1]), reverse = True)
        for i in name_list:
            for j in name_list:
                if i[-1][-1] == j[-1][-1]:
                    if i[0] < j[0]:
                        i,j = j,i
    else:
        name_list = sorted(name_dict.items(), key = lambda x:int(x[-1][-1]))
        for i in name_list:
            for j in name_list:
                if i[-1][-1] == j[-1][-1]:
                    if i[0] > j[0]:
                        i,j = j,i
    # [(0, ['fang', '90']), (2, ['ning', '70']), (1, ['yang', '50'])]
    return name_list
  
if __name__ == '__main__':
    while True:
        try:
            N = int(input())
            M = int(input())
            name_dict = {}
            for i in range(N):
                name_dict[i] = input().split()
            name_list = main(N, M, name_dict)
            for i in name_list:
                print(i[-1][0]+' '+i[-1][-1])
        except:
            break

77 火车进站

def cal(x,s):
    if x == 1:
        return [[s[0],s[0]]]    #只有一辆车时递归终止
    else:
        res = []
        for i in cal(x-1,s[0:x-1]):
            add = i.index(s[x-2])    #获得x-1辆车的操作序列中第x-1辆车编号第一次出现时的下标
            for j in range(add+1,len(i)+1):    #在第x-1辆车编号第一次出现之后的任意位置均可插入连续的第x辆车编号获得新序列
                temp = i[:]
                temp.insert(j,s[x-1])
                temp.insert(j,s[x-1])
                res.append(temp)
        return res
while True:
    try:
        n = int(input())
        sou = [int(x) for x in input().split()]
        ans = cal(n,sou)    #得到操作序列
        for i in ans:
            for j in range(1,n+1):
                i.remove(j)    #删除每辆车编号的第一次出现
        ans.sort()
        for i in ans:
            print(' '.join([str(x) for x in i]))
    except:
        break

80 整型数组合并

while True:
    try:
        n1=int(input())
        s1=list(map(int,input().split()))
        n2=int(input())
        s2=list(map(int,input().split()))
        #s1.extend(s2)
        print(''.join(map(str,sorted(list(set(s1+s2))))))
    except:
        break

81 字符串字符匹配

判断短字符串中的所有字符是否在长字符串中全部出现。

while True:
    try:
        input_string1 = input()
        input_string2 = input()
        if len(input_string1) > len(input_string2):
            input_string1, input_string2 = input_string2, input_string1
        input_string1_list = list(set(list(input_string1)))
        flag = 0
        for i in input_string1_list:
            if i not in input_string2:
                flag = 1
        if flag == 1:
            print('false')
        else:
            print('true')
    except:
        break

92 在字符串中找出连续最长的数字串

#coding = utf-8
import re
 
 
def main(input_string):
    nums_dict = {}
    tmp = re.findall(r'\d+', input_string)
    for i in tmp:
        nums_dict[i] = len(i)
    nums_dict = sorted(nums_dict.items(), key = lambda x:x[-1], reverse = True)
    # 找到相同长度的最长串
    res = []
    for i in nums_dict:
        if i[-1] == nums_dict[0][-1]:
            res.append(i)
    return res
 
 
if __name__ == '__main__':
    while True:
        try:
            input_string = input()
            res = main(input_string)
            tmp = ''
            for i in res:
                tmp += str(i[0])
            print(tmp+','+str(res[0][-1]))
        except:
            break

93 数组分组

输入int型数组，询问该数组能否分成两组，使得两组中各元素加起来的和相等，并且，所有5的倍数必须在其中一个组中，所有3的倍数在另一个组中（不包括5的倍数），能满足以上条件，输出true；不满足时输出false。

while True:
    try:
        n=int(input())
        s=input().strip().split(' ')
        s5=[]
        s3=[]
        ss=[]
        flag='false'
        for i in range(n):
            if int(s[i])%5==0:
                s5.append(int(s[i]))
            elif int(s[i])%3==0:
                s3.append(int(s[i]))
            else:
                ss.append(int(s[i]))
        a5=sum(s5)
        a3=sum(s3)
        m=len(ss)
        if a5==0 and a3==0 and m==0:
            flag='true'
        for j in range(m):
            for k in range(m-j):
                if a5+sum(ss[k:k+j+1])==a3+sum(ss)-sum(ss[k:k+j+1]):
                    flag='true'
        print(flag)
    except:
        break

94 记票统计

# coding = utf-8
 
def main(n, name_list, people, vote_list):
    ticket_dict = dict(zip(name_list, [0 for i in range(len(name_list))]))
    for i in vote_list:
        if i in ticket_dict.keys():
            ticket_dict[i] += 1
    # 统计有效投票和无效投票
    valid = sum(list(ticket_dict.values()))
    invalid = people - valid
    # 输出
    for k, v in ticket_dict.items():
        print(k,':',v)
    print('Invalid :',invalid)
 
 
if __name__ == '__main__':
    while True:
        try:
            n = int(input())
            name_list = input().split()
            people = int(input())
            vote_list = input().split()
            main(n, name_list, people, vote_list)
        except:
            break

95人民币转换

def func(x)->str:
    res = []
    zero_pre = False # 确保在连续‘0’的情况下，只有一个'零'
    for i, xi in enumerate(x[::-1]): # 倒着转化
        if xi=='0':
            if not zero_pre:
                res.append(num[int(xi)])
                zero_pre = True
        else:
            zero_pre = False
            res.extend([pro[i], num[int(xi)]])
    res = res[::-1]
#     print(res)
    while res[-1]=='零':# 去掉后面所有的 ”零“
        res.pop()
    return ''.join(res).replace('壹拾', '拾')
  
num = ['零','壹','贰','叁','肆','伍','陆','柒','捌','玖']
pro = ['', '拾','佰','仟','万','亿','元','角','分','整']
while True:
    try:
        n, m = input().strip().split('.')
  
        res = ['人民币']
        if len(n)>8:
            res.append(func(n[:-8])+'亿')
        if len(n)>4:
            res.append(func(n[-8:-4])+'万')
        if n!='0':
            res.append(func(n[-4:])+'元')
  
        if m=='00':
            res.append('整')
        else:
            if m[0]>'0':
                res.append(num[int(m[0])]+'角')
            if m[1]>'0':
                res.append(num[int(m[1])]+'分')
  
        print(''.join(res))
    except:
        break

97记负均正

# codig = utf-8
def main(n, nums_list):
    pos = []
    neg = []
    for i in nums_list:
        if i>0:
            pos.append(i)
        if i <0 :
            neg.append(i)
#     print(neg)
#     print(pos)
    print(len(neg), round(sum(pos)/len(pos),1))
 

if __name__ == '__main__':
    while True:
        try:
            n = int(input())
            nums_list = list(map(int, input().split()))
            main(n, nums_list)
        except:
            break

101 输入整型数组和排序标识，对其元素按照升序或降序进行排序

# coding = utf-8
 
def main(nums_list, target):
    if target == 0:
        return sorted(nums_list)
    if target == 1:
        return sorted(nums_list, reverse = True)
     
     
if __name__ == '__main__':
    while True:
        try:
            n = int(input())
            nums_list = list(map(int, input().split()))
            target = int(input())
            res = main(nums_list, target)
            print(*res)
        except:
            break

105记负均正II

从输入任意个整型数，统计其中的负数个数并求所有非负数的平均值，结果保留一位小数，如果没有非负数，则平均值为0

# coding=utf-8
 
def main():
    pos_list = []
    neg_list = []
    while True:
        try:
            num = int(input())
            if num<0:
                neg_list.append(num)
            if num>0:
                pos_list.append(num)
        except:
            break
    if len(pos_list) == 0:
        print(len(neg_list))
        print('0.0')
    else:
        print(len(neg_list))
        print(round(sum(pos_list)/len(pos_list),1))
 
if __name__ == '__main__':
    main()

---

18 识别有效的IP地址和掩码并进行分类统计

import re
  
error_pattern = re.compile(r'1+0+')
A_pattern = re.compile(r'((12[0-6]|1[0-1]\d|[1-9]\d|[1-9])\.)((1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d)\.){2}(1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d)')
B_pattern = re.compile(r'(12[8-9]|1[3-8]\d|19[0-1])\.((1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d)\.){2}(1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d)')
C_pattern = re.compile(r'(19[2-9]|2[0-1]\d|22[0-3])\.((1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d)\.){2}(1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d)')
D_pattern = re.compile(r'(22[4-9]|23\d)\.((1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d)\.){2}(1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d)')
E_pattern = re.compile(r'(24\d|25[0-5])\.((1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d)\.){2}(1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d)')
self_pattern = re.compile(r'((10\.((1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d)\.){2}(1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d))|(172\.(1[6-9]|2\d|3[0-1])\.(1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d)\.(1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d))|(192\.168\.(1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d)\.(1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d)))')
escape = re.compile(r'((0|127)\.((1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d)\.){2}(1\d\d|2[0-4]\d|25[0-5]|[1-9]\d|\d))')
def judge_error(line):
    if line == '255.255.255.255' or line == '0.0.0.0':
        return 0
    judge = line.split('.')
    res = ''
    for j in judge:
        res += '{:0>8b}'.format(int(j))
    res = re.fullmatch(error_pattern, res)
    if res == None:
        return 0
    else:
        return 1
  
def judge(pattern, line):
    if re.fullmatch(pattern, line) != None:
        return 1
    else:
        return 0
  
stack = [0]*7
while True:
    try:
        line = input().split('~')
        if judge_error(line[1]):
            if judge(self_pattern, line[0]):
                stack[6] += 1
            if judge(A_pattern, line[0]):
                stack[0] += 1
            elif judge(B_pattern, line[0]):
                stack[1] += 1
            elif judge(C_pattern, line[0]):
                stack[2] += 1
            elif judge(D_pattern, line[0]):
                stack[3] += 1
            elif judge(E_pattern, line[0]):
                stack[4] += 1
            elif judge(escape, line[0]):
                continue
            else:
                stack[5] += 1
        else:
            stack[5] += 1
    except:
        print(' '.join([str(i) for i in stack]))
        break

19 简单错误记录

dic = {}
rank = 1
while True:
    try:
        file = input().split("\\")[-1].split()
        filename, line = file[0], int(file[1])
        if (filename, line) not in dic:
            dic[(filename, line)] = [1, rank]
            rank += 1
        else:
            dic[(filename, line)][0] += 1
  
    except:
        # print("dic", dic)
        # res = sorted(dic.items(),reverse=True) # 按照value进行升序排列
        # reversedic = dict(([v, k] for (k, v) in dic.items())) 这是字典key，value两者之间的翻转
        newdic = sorted(dic.items(), key = lambda x:x[1][1])[-8:] # 按照输入顺序升序排列，越早输入的越在前，并且选择后8个就行
        # print(newdic)
        i = 0
        for key, value in newdic: # 遍历即可
            i += 1
            if i > 8:
                break
            else:
                print(key[0][-16:], key[1], value[0])
        break

27 查找兄弟单词

#判断是否兄弟单词
def checkXD(word, x):
    if len(w) != len(x) or w == x:
        return False
    if sorted(word) == sorted(x):
        return True
    return False
  
while True:
    try:
        ss = input().split()
        n = int(ss[0])
        words = ss[1: n + 1]
        x = ss[n + 1]
        k = int(ss[n + 2])
#         print(n,words,x, k)
  
        xiwords = []
        for w in words:
            if checkXD(w, x):
                xiwords.append(w)
  
        xiwords.sort()
        print(len(xiwords))
        #如果越界,就不输出
        if k <= len(xiwords):
            print(xiwords[k - 1])
  
    except:
        break

28 素数伴侣

def getPrimes(n):
    """获取2~n之间的素数，用于对素数进行判断"""
    primes = [True for _ in range(n+1)]
    for i in range(2, n+1):
        if primes[i]:
            yield i
            for j in range(i+i, n+1, i):
                primes[j] = False
  
def splitNums(nums):
    """用于将数字分为奇数和偶数部分"""
    odd = []
    even = []
    oddLen = 0
    evenLen = 0
    for num in nums:
        if num % 2 == 0:
            even.append(num)
            evenLen += 1
        else:
            odd.append(num)
            oddLen += 1
    return odd, oddLen, even, evenLen
  
def removeValue(data, n, i, k):
    """从data的第i行开始去掉数字i"""
    for j in range(i, n):
        if k in data[j]:
            data[j].remove(k)
    return data
  
def countValue(data, n, i, d):
    """统计data从i行开始，d中的元素总共出现的次数"""
    d = {k: 0 for k in d}
    for j in range(i, n):
        for value in data[j]:
            if value in d:
                d[value] += 1
    return d
  
def func(nums):
    odd, oddLen, even, evenLen = splitNums(nums)
    maxGroup = min(oddLen, evenLen)
    if maxGroup == 0:   # 如果没有奇数或者偶数，那么直接必定不会出现素数伴侣
        return 0
    primes = list(getPrimes(max(odd)+max(even)))
    # 每一行代表1个偶数，每一列代表一个奇数
    # 此处得到每个一行的偶数能和哪几个奇数组成素数伴侣
    data = [[j for j in range(oddLen) if even[i] + odd[j] in primes] for i in range(evenLen)]
    data = [row for row in data if row]  # 去掉不能和任何数字组成伴侣的偶数行
    if not data:  # 为空表示没有任何偶数能和奇数组成伴侣
        return 0
    stack = []  # 存储结果用容器
    n = len(data) 
    for i in range(n-1):
        # 分别对每一行进行迭代，判断改行是否符合一下的某一种情况（最后1行不需要判断，直接取最后1行的第一个数据即可）
        # 1 如果这一行为空，那么直接忽略这一行
        # 2 这一行只能和1个奇数 K 组成伴侣，那么就取这个偶数和K组成伴侣
        # 3 若这一行可以和多个奇数组成伴侣，那么去查找K，要求：后面行重复使用到K的次数最少
        # 4 去掉后面行用到的K
        # 5 若出现情况如：[[1,2], [1], [2, 3], [2, 4]]，避免第一行取到1，
        #    在每一次取数之前，将数据按照候选奇数的多少依次排列
        data = data[:i] + sorted(data[i:], key=lambda x: len(x))
        if len(data[i]) == 0:
            continue
        if len(data[i]) == 1:
            stack.append(data[i][0])
            data = removeValue(data, n, i+1, data[i][0])
            continue
        d = countValue(data, n, i+1, data[i])
        minValue = data[i][0]
        c = d[minValue]
        if c == 0:
            stack.append(data[i][0])
            data = removeValue(data, n, i+1, data[i][0])
            continue
        for k, v in d.items():
            if v < k:
                minValue = k
                c = v
        stack.append(minValue)
        if c == 0:
            continue
        data = removeValue(data, n, i+1, minValue)
    if data[-1]:  # 最后1行不需要判断，直接取最后1行的第一个数据即可
        stack.append(data[-1][0])
    return len(stack)
  
  
while True:
    try:
        n = int(input())
        nums = list(map(int, input().strip().split()))
        print(func(nums))
    except EOFError: break

44Sudoku

def myprint(matrix):
    for i in range(9):
        print(" ".join(list(map(str,matrix[i]))))
  
def find_zeros(matrix):
    result = []
    for i in range(9):
        for j in range(9):
            if matrix[i][j] == 0:
                result.append([i,j])
    return result
  
def isend(matrix):
    for l in matrix:
        if 0 in l:
            return False
    return True
  
def find_neighbors(matrix,i,j):
    result = []
    result.append(matrix[i])
    result.append([matrix[k][j] for k in range(9)])
    result.append([matrix[k][l] for k in range((i//3)*3,(i//3)*3+3) \
        for l in range((j//3)*3,(j//3)*3+3)])
    return result
  
def dfs(matrix, zeros):
    if not zeros:
        myprint(matrix)
        return -1
    n, now = len(zeros), zeros[0]
    neibor = find_neighbors(matrix,now[0],now[1])
    for i in range(1,10):
        if i not in neibor[0] and i not in neibor[1] and i not in neibor[2]:
            matrix[now[0]][now[1]] = i
            y = dfs(matrix, zeros[1:n])
            if y == 0:
                matrix[now[0]][now[1]] = 0
                continue
    return 0
  
  
matrix = []
for i in range(9):
    s = list(map(int,input().split()))
    matrix.append(s)
  
dfs(matrix, find_zeros(matrix))

82将真分数分解为埃及分数

from fractions import Fraction
while True:
    try:
        target = Fraction(input())
        mother = target.denominator
        l = []    #存放埃及分母
        n=2
        while target.numerator != 1:
            if target > Fraction(1,n):
                l.append(str(n))
                target = target - Fraction(1,n)
            if n >= mother:
                n += mother
            else:
                n += 1
        l.append(str(target.denominator))
        print('1/'+'+1/'.join(l))
    except:
        break

89 24点运算

def f(nums, target):
    d = {'3':3, '4':4, '5':5, '6':6, '7':7, '8':8, '9':9,
    '10':10, 'J':11, 'Q':12, 'K':13, 'A':1, '2':2}
    if len(nums) == 1:
        if d[nums[0]] == target:
            res.append(nums[0])
            return True
        else:
            return False
    for i in range(len(nums)):
        a = nums[i]
        b = nums[:i] + nums[i+1:]
        if f(b, target + d[a]):
            res.append('-' + a)
            return True
        elif f(b, target - d[a]):
            res.append('+' + a)
            return True
        elif f(b, target * d[a]):
            res.append('/' + a)
            return True
        elif target % d[a] == 0 and f(b, target // d[a]):
            res.append('*' + a)
            return True
    return False
if __name__ == '__main__':
    while True:
        try:
            nums = input().strip()
            if 'joker' in nums or 'JOKER' in nums:
                print('ERROR')
            else:
                nums = nums.split()
                res = []
                if f(nums, 24):
                    print(''.join(res))
                else:
                    print('NONE')
        except:
            break

31 单词倒排

对字符串中的所有单词进行倒排。

# coding = utf-8
 
def main(input_string):
    for i in input_string:
        if not i.isalpha():
            input_string = input_string.replace(i, ' ')
    string_list = input_string.split()
    string_list.reverse()
    return ' '.join(string_list)
 
if __name__ == '__main__':
    input_string = input()
    print(main(input_string))