华为机试题python版节选(基础编程题)

前言

自学python之后,可以借助这些企业招聘时的机考题目来锤炼一下实践能力。。

每道题含要点解析,是按照自己理解梳理的,多个答案的是结合自己的答案+网上的答案,不一定很严谨,请读者自行在编译器中调试!有些题目是至今还没搞出来的,欢迎大家在评论中给出程序~~

本文中不含进阶的算法编程题,均是基础编程题,常规操作!找算法题请转牛客网之类的吧~

Tips:

1、输入一行:a = input() ;一行输入多个值:a,b=input().split(),split里面写分隔的符号;

2、有多组测试用例(输入)情况下,使用while True: ... try:... except:...

3、计数问题:创建defaultdict,将计数值作为key,如果有相同的计数值就可以添加到同一个key中

4、输入一个dict(21)、List(22)的写法

5、熟练掌握排序(sorted)、切片等方法

试题

1.【输入】计算字符串最后一个单词的长度,单词以空格隔开。

输入:hello world   输出:5

a=input().split()  

if(len(a)>=2):
    print(len(a[-1]))
else:
    print(len(a[0]))

这里经过split()后,即按空格分割。a的类型会变成list。输出时不能直接len(a),试一试为什么。

2.【大小写转换】写出一个程序,接受一个由字母和数字组成的字符串,和一个字符,然后输出输入字符串中含有该字符的个数。不区分大小写。

a=input().lower()
b=input().lower()
print(a.count(b))

3.【set概念、排序】明明想在学校中请一些同学一起做一项问卷调查,为了实验的客观性,他先用计算机生成了N个1到1000之间的随机整数(N≤1000),对于其中重复的数字,只保留一个,把其余相同的数去掉,不同的数对应着不同的学生的学号。然后再把这些数从小到大排序,按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作(同一个测试用例里可能会有多组数据,希望大家能正确处理)。

while True:
    try:
        n=int(input()) #读入一个int型:随机整数的个数
        mySet=set()
        for i in range(n):
            mySet.add(int(input())) #每次运行到input()时都会唤起等待用户输入
        
        #列输出:
        for i in sorted(mySet):
            print(i)
            
        #行输出:
        print(sorted(mySet))
    except:
        break

4.【切片】连续输入字符串,请按长度为8拆分每个字符串后输出到新的字符串数组;长度不是8整数倍的字符串请在后面补数字0,空字符串不处理。

def printStr(string):
    if len(string) <= 8:
        print(string + "0" * (8 - len(string)))
    else:
        while len(string) > 8: #用循环处理
            print(string[:8])
            string = string[8:]
        print(string + "0" * (8 - len(string)))
 
a=input()
b=input()
printStr(a)
printStr(b)

此题建议自己写一遍,会有很多收获。比如字符串的乘法的效果。

5.【进制类型转换】写出一个程序,接受一个十六进制的数值字符串,输出该数值的十进制字符串。(支持多组同时输入 )

while True:
    try:
        print(int(input(),16))
    except:
        break

附:python整数之间的进制转换:

  • 10进制转16进制: hex(16)  ==>  0x10
  • 16进制转10进制: int('0x10', 16)  ==>  16

6.输入一个正整数,按照从小到大的顺序输出它的所有质数的因子(如180的质数因子为2 2 3 3 5 ),最后一个数后面也要有空格

a=int(input())
def q(x):
    iszhi=1
    for i in range(2,int(x**0.5+2)):
        if x%i==0:
            iszhi=0
            print(str(i),end=" ")
            q(int(x/i))
            break
    if iszhi==1:
        print(str(x),end=" ")
q(a)

7.【四舍五入】写出一个程序,接受一个正浮点数值,输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整;小于5,则向下取整。

即:print(round(float(input())+0.001))

注:据称,由于python对于浮点数存储有点抽风(4.5会存储成4.4999999),所以要加上0.001

8.数据表记录包含表索引和数值,请对表索引相同的记录进行合并,即将相同索引的数值进行求和运算,输出按照key值升序进行输出。

from collections import defaultdict
while True:
    try:
        a=int(input('请输入键值对的个数...'))
        dic=defaultdict(int) #指定字典的值为int
        for i in range(a):
            key,val=map(int,input().split())  
            dic[key] += val # 为什么这么写?改成 dic[key] = val 试一试!
        for i in sorted(dic.keys()):
            print(str(i)+" "+str(dic[i]))
    except:
        break

输入字典的写法:key,val=input().split();根据key进行排序:sorted(dic.keys())

map : 将函数一次作用到每个元素 (可以是列表、字符串……等Iterable的容器)

collections 集合类:使用dict类型时,如果引用的key不存在就会抛出KeyError。如果key不存在返回一个默认值,则用defaultdict。

9.【倒序切片】输入一个int型整数,按照从右向左的阅读顺序,返回一个不含重复数字的新的整数。

result=""
for i in input()[::-1]:
    if i not in result: #去除重复
        result+=i
print(result)

10.编写一个函数,计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计。

a = input()
count = 0

for i in a:
    if ord(i) in range(128):
        count += 1
        
print(count)

注:ord(i),获取ASCII编码;range(128)不含128(不含上界)。

11.输入一个整数,将这个整数以字符串的形式逆序输出,程序不考虑负数的情况,若数字含有0,则逆序形式也含有0,如输入为100,则输出为001

12.写出一个程序,接受一个字符串,然后输出该字符串反转后的字符串。例如:abcd---------dcba

直接倒序输出了。print(input()[::-1])。参见第9题。

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

print(" ".join(input().split()[::-1]))

14.给定n个字符串,请对n个字符串按照字典序排列。

num = int(input())
s = []
for i in range(num):
    s.append(input())
s.sort()
for i in s:
    print (i)

15.输入一个int型的正整数,计算出该int型数据在内存中存储时1的个数。

a=int(input())
print(bin(a).replace("0b","").count("1"))

在内存中存储及机器语言二进制形式。bin()转int为二进制,ob开头。所以先把ob删掉。

16.求最小公倍数

def gcd(a, b):
    """最大公约数."""
    while b:
        a, b = b, a % b
    return a
def lcm(a, b):
    """最小公倍数."""
    return a * b // gcd(a, b)  #//表示整数除法
while True:
    try:
        a,b=map(int,input().split())
        print(lcm(a,b))
    except:
        break

最大公因数的算法:辗转相除法。

有两整数a和b:

① a%b得余数c

② 若c=0,则b即为两数的最大公约数

③ 若c≠0,则a=b,b=c,再回去执行①

19.从输入任意个整型数,统计其中的负数个数并求所有非负数的平均值

a=input().split()
fu=[]
zheng=[]
for i in a:
    if int(i)<0:
        fu.append(int(i))
    else:
        zheng.append(int(i))
print(len(fu))
print(round(sum(zheng)/len(zheng),1))

注:最后四舍五入保留一位小数,round(n,1)

21.【列表型字典、排序】输入一个字符串,对字符中的各个英文字符,数字,空格进行统计(可反复调用)按照统计个数由多到少输出统计结果,如果统计的个数相同,则按照ASII码由小到大排序输出。

可反复调用一定要用到 while True:...try:...except:...结构了。

from collections import defaultdict
while True:
    try:
        dd, s, res = defaultdict(list), input(), "" #创建一个字典,输入一个字符串s,开辟一个字符串初始化为空
        for i in set(s):
            dd[s.count(i)].append(i)
        for i in sorted(dd.keys(), reverse=True):
            res += "".join(sorted(dd[i], key=ord))
        print(res)
    except:
        break

这个答案给得比较简洁。先是创建一个字典dd,输入一个字符串s,开辟一个字符串res存放结果。

其中:set() 函数创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。举例:

华为机试题python版节选(基础编程题)_第1张图片

遍历set(s)中的字符,s.count(i)是计算s中包含i的次数,dd[s.count(i)]是以次数为key,取对应的值。这里将其赋值(更准确地说是添加一个值,因为dd生成时指定了存放类型为list)为这个字符:

华为机试题python版节选(基础编程题)_第2张图片

然后按key来排序:dd.keys()取出所有key形成一个列表,sorted功能强大,key=ord表示按照ASCII码升序排列,如果加reverse=True就变成降序排列(即由多到少)。

join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。即 list → str 。如:

华为机试题python版节选(基础编程题)_第3张图片

那么sorted(dd[i], key=ord)的结果是:(i在key中遍历,本例中即1,3,5,6)

华为机试题python版节选(基础编程题)_第4张图片

如果我们直接相加,就会变成:

华为机试题python版节选(基础编程题)_第5张图片

用了join()后,逗号被""取代连接成字符串了。所以输出是一个字符串。这个可以根据题目要求来。

更好理解的一种答案:

from collections import defaultdict
while True: #可反复调用
    try:
        dic = defaultdict(list) #指定存放类型
        s = input() #输入一个字符串s
        result = [] #开辟一个空list存放结果
        for i in set(s):  #用set排除重复元素 筛选出key
             dic[s.count(i)] += i  #计数值作为key,如果有相同的计数值就可以添加到同一个key中(重要!)
        for i in sorted(dic.keys(),reverse=True): 
            result += sorted( dic[i],key=ord )
        print(result)
    except:
        break

输入结果为:

22.【输入List】输入整型数组和排序标识,对其元素按照升序或降序进行排序(一组测试用例可能会有多组数据)

while True:
    try:
#        myList=int( input('请输入一个数组:').split() )这样写错误
        myList=map(int,input('请输入一个数组:').split()) #正确写法
        urType=int(input('请输入排序标志(0或1):'))
        if urType == 0:
            print(sorted(myList,reversed=False))
        if urType == 1:
            print(sorted(myList,reversed=True))
    except:
        break

输入一个整型的List的写法:myList=map(int,input('请输入一个数组:').split())

23.功能:等差数列 2,5,8,11,14。。。。输入:正整数N >0,输出:求等差数列前N项和。


while True:
    try:
        n=int(input('请输入项数n')) 
        print('sum = ', 2*n+n*(n-1)*3*0.5)
    except:
        break

需要了解等差数列求和公式。

24.【int和str转换、比较】自守数是指一个数的平方的尾数等于该数自身的自然数。例如:25^2 = 625,76^2 = 5776,9376^2 = 87909376。请求出n以内的自守数的个数。

最简单直白的,依题意用切片方法:

while True:
    try:
        count=0
        n=int(input('请输入n,求n以内的自守数个数:\n'))
        for i in range(n):
            
            pf = i*i  #平方数
            pf_str = str(pf) #转为字符串
            index = len(str(i)) #长度
            if pf_str[-index:] == str(i):  #用切片方法比较
                count +=1
        print(count)
    except:
        break

字符串比较方法:

while True:
    try:
        a, res = int(input()), 0
        for i in range(0, a):
            if str(i ** 2).endswith(str(i)):
                res += 1
        print(res)
    except:
        break

endswith() 方法用于判断字符串是否以指定后缀结尾,如果以指定后缀结尾返回True,否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。

类型转换:string-->int

1、10进制string转化为int

  int('12')

2、16进制string转化为int

  int('12', 16)

int-->string

1、int转化为10进制string

  str(18)

2、int转化为16进制string

  hex(18)

26.【保留小数位数、占位符】首先输入要输入的整数个数n,然后输入n个整数。输出为n个整数中负数的个数,和所有正整数的平均值,结果保留一位小数。

n = int(input("输入整数个数"))
myList = map(int,input().split()) #输入整型list
posCount,negCount,posSum = 0,0,0
for number in myList:
    if number < 0 :
        negCount += 1
    if number > 0 :
        posCount += 1
        posSum += number
posAver = posSum/posCount
print('负数个数%d:,正数平均值:%.1f'%(negCount,posAver))

华为机试题python版节选(基础编程题)_第6张图片

27.【字符串替换】将一个字符中所有出现的数字前后加上符号“*”,其他字符保持不变

这里有不同理解方法。我的理解是:若输入s180sa9,输出s*1*8*0*sa*9*:

a = input()
resStr = ''
for i in a:
    if i.isdigit():
        i='*'+i+'*'
    else:
        pass
    resStr += i
resStr = resStr.replace('**','*')
print(resStr)

判断是否是数字:a.isdigit()、替换字符串:str.replace('a','A')

网上另一种理解方式给的答案,试一试它的答案是什么样子的吧:

while True:
    try:
        a, res, isNum = input(), "", False
        for i in a:
 
            if i.isdigit():
                if not isNum:
                    res = res + "*" + i
                else:
                    res += i
                isNum = True
            else:
                if isNum:
                    res = res + "*" + i
                else:
                    res += i
                isNum = False
        if a[-1].isdigit():
            res+="*"
        print(res)
 
 
    except:
        break

29.【计数器Counter】计票统计

输入:候选人的人数,第二行输入候选人的名字,第三行输入投票人的人数,第四行输入投票。

输出:每行输出候选人的名字和得票数量。

from collections import Counter
while True:
    try:
        a=input()
        b=input().split() #输入list
        c=input()
        d=input().split() #输入list
#        invalid=0  #计无效票,if need
        cc = Counter(d)
        for i in b:
            print(i + " : " + str(cc[i]))
#            invalid+=cc[i]
#        print("Invalid : " + str(len(d)-invalid))
    except:
        break

关于counter:计数器,统计一个list中某个值出现的次数。

mylist = ['aaa','s','vvv','ss','aaa','s','a','vvv','vv','bb','bb']
cc = Counter(mylist)
print(cc)

输出为:Counter({'aaa': 2, 's': 2, 'vvv': 2, 'bb': 2, 'ss': 1, 'a': 1, 'vv': 1})

30.编写一个函数,传入一个int型数组,返回该数组能否分成两组,使得两组中各元素加起来的和相等,并且,所有5的倍数必须在其中一个组中,所有3的倍数在另一个组中(不包括5的倍数),能满足以上条件,返回true;不满足时返回false。

有点难。。写了一点还没想好后面怎么做。。请大家指点!

myIntList=map(int,input().split()) #输入int list
sum1 = sum2 = 0
elseList  = [] #用于存放不能被3和5整除的数

for i in myIntList:
    if int(i) % 5 == 0:
        sum1 += int(i)
    elif int(i) % 3 == 0:
        sum2 += int(i)
    else:
        elseList.append(int(i))

if not elseList and (sum1-sum2 == 0):
    print('true')   #已经没有其余数了,且sum1=sum2
elif not elseList and (sum1-sum2):
    print('false')   #已经没有其余数了,但是还是不等
else:
    #还有其余数
    #先计算差值
    d_value = abs(sum1-sum2)
    if sum(elseList) < d_value:
        print('false') #如果剩下的值都不够填平二者差值 那就没啥好算的了
    else:
        
        if (sum(elseList) - d_value)%2 != 0:
            print('false')   #如果是奇数肯定不能对半分了
        else:
            pass  #...还没写完
            print('true')

31.【判断数字】在字符串中找出连续最长的数字字符串。

输入:一个字符串。输出:字符串中最长的数字字符串和它的长度。如果有相同长度的串,则要一块儿输出,但是长度还是一串的长度

while True:
    try:
        a = input()
        maxLen, maxStrs, curLen, curStr = 0, [], 0, ""
        for i, v in enumerate(a):
            if v.isnumeric():
                curLen += 1
                curStr += v
                if curLen > maxLen:
                    maxLen = curLen
                    maxStrs = [curStr]
                elif curLen == maxLen:
                    maxStrs.append(curStr)
            else:
                curLen = 0
                curStr = ""
        print("".join(maxStrs) + "," + str(maxLen))
    except:
        break

判断数字,isdecimal()换isdigit()应该也可以。这二者是有些区别的,一般用isdigit(),isdecimal()针对unicode数字。(参考资料)

isdigit()
True: Unicode数字,byte数字(单字节),全角数字(双字节),罗马数字
False: 汉字数字
Error: 无

isdecimal()
True: Unicode数字,,全角数字(双字节)
False: 罗马数字,汉字数字
Error: byte数字(单字节)

37.【连续字符的表达、int转二进制】功能: 求一个byte数字对应的二进制数字中1的最大连续数,例如3的二进制为00000011,最大连续2个1

res, a = 0, bin(int(input())).replace("0b", "")
for i in range(1, len(a) + 1):
    if "1" * i in a:
        res = i
    else:
        break
print(res)

bin()的作用:将int转为二进制字符串。如bin(123)结果是 '0b1111011'。

注意这里 '1'*i 的用法,可以快捷地表达连续的字符。

39.【判断大写】找出给定字符串中大写字符(即'A'-'Z')的个数

count=0
for a in input('请输入一个字符串'):
    for i in a:
        if i.isupper():
            count+=1
print(count)

判断某个字符是否大写:i.isupper() ,主要有个is开头。如果是大小写转换的话,没有is。

41.【set的性质】字符串匹配:判断短字符串中的所有字符是否在长字符串中全部出现

shortStr = input()
longStr = input()
shortSet = set(shortStr)
longSet = set(longStr)
if(shortSet == longSet):
    print('True!')
else:
    print('False!')

42.【排序、set性质、list转字符串】将两个整型数组按照升序合并,并且过滤掉重复数组元素

a,b=list(map(int,input().split())),list(map(int,input().split()))   #输入两个数组
print(map(sorted(list(set(a+b)))))  #以数组形式输出
print(''.join(map(sorted(list(set(a+b)))))  )#以String形式输出 ''.join(List)

43.计算字符串的相似度(题目不全 看代码学习一下~)

def editDistance(str1, str2):
    len1, len2 = len(str1) + 1, len(str2) + 1
    dp = [[0 for i in range(len2)] for j in range(len1)]
    for i in range(len1):
        dp[i][0] = i
    for j in range(len2):
        dp[0][j] = j
    for i in range(1, len1):
        for j in range(1, len2):
            dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (str1[i - 1] != str2[j - 1]))
    return dp[-1][-1]
 
while True:
    try:
        print("1/" + str(editDistance(input(), input()) + 1))
    except:
        break

44.请设计一个算法完成两个超长正整数的加法。(“超长”的含义?)

网上的答案:(但是结果和直接加是一样的,应该是不对的)

while True:
    try:
        a = input()
        b = input()
        print(str(int(a) + int(b)))
    except:
        break

如果换成float(a)+float(b),结果精度会更高一些。

个人认为应该把input转为str后,诸位计算,满十进一,得到最后的字符串。因为字符串可以是很长的,所以结果展示形式上就像是完成了超长数的相加。

45.【矩阵求解法】计算两个字符串的最大公共字串的长度,字符不区分大小写

def find_lcsubstr(s1, s2):  
    m=[[0 for i in range(len(s2)+1)]  for j in range(len(s1)+1)]  #生成0矩阵,为方便后续计算,比字符串长度多了1个裕量 
    mmax=0   #最长匹配的长度 
    for i in range(len(s1)): 
        for j in range(len(s2)): 
            if s1[i]==s2[j]: 
                m[i+1][j+1]=m[i][j]+1 
                if m[i+1][j+1]>mmax: 
                    mmax=m[i+1][j+1] 
    return mmax   #返回最长相同子串的长度 
 
while True:
    try:
        a,b=input(),input()
        print(find_lcsubstr(a,b))
    except:
        break

这道题解法中巧妙地借助矩阵来记录信息。

51.实现删除字符串中出现次数最少的字符,若多个字符出现次数一样,则都删除。输出删除这些单词后的字符串,字符串中其它字符保持原来的顺序。

思路一:计数题型,用defaultdict,这里key是字符,value是出现的次数。

from collections import defaultdict
while True:
    try:
        a = input()
        dd = defaultdict(int)
        for i in a:
            dd[i] += 1 #统计每个字符出现的个数
        for i in dd.keys():  #遍历key
            if dd[i] == min(dd.values()):
                a = a.replace(i, "")
        print(a)
    except:
        break

思路二:直接用Counter:

from collections import Counter

myStr = input()
cc = Counter(myStr)
for i in cc.keys():  #遍历key
    if cc[i] == min(cc.values()):
        myStr = myStr.replace(i, "")
print(myStr)

Counter相当于进化版的专门用于计数的字典。

52.【检测字母或数字、倒排】对字符串中的所有单词进行倒排。(非构成单词的字符均视为单词间隔符)


myStr = input()
for i in myStr:
    if not i.isalnum:
        myStr = myStr.replace(i,' ') #过滤,非字母或数字都替换为空格,即视为分隔符
mylist = myStr.split().reverse() #转为list再来倒序才能保证单词内部不倒序,直接对string倒序的话整个字符串都会倒序
newStr = ' '.join(mylist) #list转string
print(newStr)

isalnum:检测字符串是否只有字母或数字组成。

isalpha():检测字符串是否只有字母组成。

.reverse():倒排。注意区分倒排和倒序。

53.【判断包含字符】输入一个范围,输出7有关数字的个数。包括7的倍数,还有包含7的数字(如17,27,37...70,71,72,73...)的个数(一组测试用例里可能有多组数据,请注意处理)

while True: 
    try:
        a=int(input())
        count=0 
        for i in range(a+1):  #右边是开区间。这句话也可以写成:for i in range(7,a+1):#右边是开区间
            if "7" in str(i) or i%7==0:
                count+=1
        print(count)
    except:
        break

54.输入n个整数,输出其中最小的k个。

k=int(input())
numList=map(int,input().split())
print(" ".join(map(str,sorted(numList)[:k])))

55.【Counter计数器】找出字符串中第一个只出现一次的字符

from collections import Counter
#先统计各个字符的次数
myStr = input()
cc = Counter(myStr)
#找到出现次数为1的字符
for i in cc:
    if cc[i] == 1:
        print(i)

56.任意一个偶数(大于2)都可以由2个素数组成,组成偶数的2个素数有很多种情况,本题目要求输出组成指定偶数的两个素数差值最小的素数对。

 
import math
 
def isPrime(n):
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False #不能被这个范围内的数整除说明是质数,否则是素数
    return True
 
while True:
    try:
        num ,start= int(input()) // 2,1
        if num%2==1:
            start=0
        for i in range(start, num, 2):
            a, b = num + i, num - i
            if isPrime(a) and isPrime(b):
                print(b)
                print(a)
                break
 
    except:
        break

需要了解求素(质)数的方法。由于求差值最小,故从算术平均值作为起点开始遍历。

58.【字符计数】一个DNA序列由A/C/G/T四个字母的排列组合组成。G和C的比例(定义为GC-Ratio)是序列中G和C两个字母的总的出现次数除以总的字母数目(也就是序列长度)。在基因工程中,这个比例非常重要。因为高的GC-Ratio可能是基因的起始点。给定一个很长的DNA序列,以及要求的最小子序列长度,研究人员经常会需要在其中找出GC-Ratio最高的子序列。

while True:
    try:
        a, b = input(), int(input())
        maxStr, maxCnt = a[:b], a[:b].count("C") + a[:b].count("G")
        for i in range(0, len(a) - b):
            if a[i:i + b].count("C") + a[i:i + b].count("G") > maxCnt:
                maxCnt = a[i:i + b].count("C") + a[i:i + b].count("G")
                maxStr = a[i:i + b]
        print(maxStr)
    except:
        break

掌握.count('a')的用法,来找到字符串中某字符的个数。

这道题中其实不用算比率,因为分母(最小子序列长度)是一定的,直接算C+G的总数来比较就可以了。

59.【统计字母、数字、其他字符……】输入一行字符,分别统计出包含英文字母、空格、数字和其它字符的个数。

while True:
    try:
        a=input()
        char,space,number,other=0,0,0,0
        for i in a:
            if i==" ":space+=1
            elif i.isnumeric():
                number+=1
            elif i.isalpha():char+=1
            else:other+=1
        print(char)
        print(space)
        print(number)
        print(other)
    except:
        break

61.【数列找规律】有一只兔子,从出生后第3个月起每个月都生一只兔子,小兔子长到第三个月后每个月又生一只兔子,假如兔子都不死,问每个月的兔子总数为多少?

a=int(input())
arr=[1,1]
while len(arr)

62.有这样一道智力题:“某商店规定:三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶,她最多可以换多少瓶汽水喝?”答案是5瓶,方法如下:先用9个空瓶子换3瓶汽水,喝掉3瓶满的,喝完以后4个空瓶子,用3个再换一瓶,喝掉这瓶满的,这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水,喝掉这瓶满的,喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶,最多可以换多少瓶汽水喝?

解法令人震惊:

a=int(input())
if a!=0:
   print(a//2)

注:通过数学分析,最后获得的饮料数是总空瓶数整除2 。。。

63.【正则表达式】密码验证合格:

1.长度超过8位

2.包括大小写字母.数字.其它符号,以上四种至少三种

3.不能有相同长度超2的子串重复

网上一种答案:

import re
import sys
for i in sys.stdin.readlines():
    print("OK" if len(i.strip())>8 and sum([1 if re.search(r"[A-Z]",i.strip()) else 0,1 if re.search(r"[a-z]",i.strip()) else 0,1 if re.search(r"[0-9]",i.strip()) else 0,1 if re.search(r"[^0-9a-zA-Z]",i.strip()) else 0])>2 and sum(map(lambda c:i.strip().count(i.strip()[c:c+3])>1,range(1,len(i.strip())-3)))==0 else "NG")

re模块(regular expression)很重要!参考《python正则表达式:re模块(regular expression)》

64.简单密码破解

大家都知道手机上的字母: 1--1, abc--2, def--3, ghi--4, jkl--5, mno--6, pqrs--7, tuv--8 wxyz--9, 0--0,就这么简单,渊子把密码中出现的小写字母都变成对应的数字,数字和其他的符号都不做变换,
 

d={
    "abc":2,
    "def":3,
    "ghi":4,
    "jkl":5,
    "mno":6,
    "pqrs":7,
    "tuv":8,
    "wxyz":9,
}
while True:
    try:
        a,res=input(),""
        for i in a:
            if i.islower():
                for j in d.keys():
                    if i in j:
                        res+=str(d[j])
                        break
            else:
                res+=i
        print(res)
 
    except:
        break

69.输入一个字符串,输出:返回有效密码串的最大长度(密码是对称的)

def longestPalindrome(s):
    if s==s[::-1]:return len(s)
    maxLen=0
    for i in range(len(s)):
        if i-maxLen>=1 and s[i-maxLen-1:i+1]==s[i-maxLen-1:i+1][::-1]:
            maxLen+=2
            continue
        if i-maxLen>=0 and s[i-maxLen:i+1]==s[i-maxLen:i+1][::-1]:
            maxLen+=1
    return maxLen
while True:
    try:
        a=input()
        if a:
            print(longestPalindrome(a))
 
    except:
        break

70.名字的漂亮程度:给出一个名字,该名字有26个字符串组成,定义这个字符串的“漂亮度”是其所有字母“漂亮度”的总和。
每个字母都有一个“漂亮度”,范围在1到26之间。没有任何两个字母拥有相同的“漂亮度”。字母忽略大小写。
给出多个名字,计算每个名字最大可能的“漂亮度”。

其实就是计数,然后算总分。

from collections import Counter
while True:
    try:
        a=int(input())
        for i in range(a):
            c,start,res=Counter(input()),26,0
            for j in c.most_common():
                res+=j[1]*start
                start-=1
            print(res)
 
    except:
        break

注:most_comman返回一个TopN列表。如果n没有被指定,则返回所有元素。当多个元素计数值相同时,排列是无确定顺序的

71.查找和排序

def rank_record(inp_num,rank_rule):
    dic_name=[]
    while(inp_num>0):
        inp_name=input()
        dic_name.append(inp_name)
        inp_num-=1
    inp_name_sort=sorted(dic_name,key=lambda a:int(a.split(' ')[1]),reverse=(rank_rule-1))
    return inp_name_sort
     
while True:
    try:
        inp_num=int(input())
        rank_rule=int(input())
        for i in rank_record(inp_num,rank_rule):
            print (i)
    except:
        break

 

你可能感兴趣的:(Python,各大厂算法方向编程机考题合集)