【编程真题】笔试编程题

快手

返回字符最终输出的串

输入一个字符串序列，可能包含常规字符和回退字符，其中回退字符是可定义的，写一个函数返回最终输出的串。

• 输入描述

输入以；分割，第一个元素表示回退字符，如Y，不可见
第二个元素表示可能包含回退字符的输入串

• 输出描述

输出被回退后的字符串

n=input()
str=input()
a=[]
for i in str:
    if i!=n:
        a.append(i)
    if i==n and a:
        a.pop()
print("".join(a))

输入：
Y
ABYYYYYYCYDDY

输出：
D

统计字符串中字符出现的次数，并按照出现次数降序输出

输入：ababca
输出：a:3,b:2,c:1

string='ababca'
l=list(string)
s=set(l)
a={}
for i in s:
    num=l.count(i)
    a[i]=num
a=sorted(a.items(),key=lambda item:item[1],reverse=True)
print(a)
c=[]
for i in a:
    for j in i:
        c.append(j)
print(c)

res = ''
for i in range(len(c)):
    res += str(c[i])
    if i%2==0:
         res += ':'
    else:
        if i!=len(c)-1:
            res +=','
print(res)

折纸问题

一张纸从左向右对折一次后展开，出现一条凹下去的折痕，如果从左至右连续对折两次后展开，会出现三条折痕，折痕方向分别是上折痕、下折痕、下折痕。给定一个折纸次数N，从左到右打印所有的折痕的方向。

• 输入描述
  从左到右对折次数，如：2
• 输出描述
  从左到右折痕方向：
  up,down,down

输入：1
输出：down

• 解题思路

每折一次，就以上一层二叉树节点为父节点，使其左右节点分别为“上”、“下”，从上到下对折折痕的顺序即为该二叉树按“右子树-父节点-左子树”（中序遍历）的顺序遍历，并把对应的值输出的结果。

每隔一个插入一个，是奇数插入‘up’,偶数插入‘down’

• 算法注意点
  range(1,-1,-1)指的是从1,0,-1这三个数中从1第一个开始输出每一个，最后一个不输出

n=input()
res=['down']
for i in range(int(n)-1):
    for j in range(len(res),-1,-1):
        if j&1:
            res.insert(j,'up')
        else:
            res.insert(j,'down')
for i in res:
    print(i)

源串和目标串

给定一个原串和目标串，能对源串进行如下操作：
1.在给定位置插入一个字符
2.替换任意字符
3.删除任意字符
要求写一个程序，返回最少的操作数，使得源串进行这些操作后等于目标串。源串和目标串长度都小于2000。

• 输入描述
  原串：长度都小于2000的字符串
  目标串：长度都小于2000的字符串
  以英文逗号分隔两个字符串

• 输出描述：
  最小操作数：整数

输入：test，testa
输出：1

哔哩哔哩

输入的字符包含3中规则即可以输出 True

1. 全为大写BILIBILI
2. 全为小写bilibili
3. 首字母为大写Bilibili

n=input()
if n.isupper():
    print('true')
elif n.islower():
    print('true')
elif n[0].isupper() and n[1:].islower():
    print('true')
else:
    print('false')

给定字符串A和字符串B，求在A中包含了B所有字符的最小子串

• 输入描述

输入一行字串（不会为空）
ABAKJSDYUIWNQJNDSAHDBALSDH
输入一个字符集（不会为空，也不会出现重复字符）
ABD

• 输出描述

输出包含了字符集所有字符的第一个最小子串，例如上面的输入对应输出DBA,没有符合条件的子串，则输出#

携程

给定一个数组，和一个值k，数组分成k段。要求这k段子段和最大值最小。求出这个值。

在m个节点的分布式计算系统中，有一批任务需要执行，每个任务需要的时间是array[i],每个节点同一时间只能执行一个任务，每个节点只能执行连续的任务，例如i，i+1，i+2，但是不能执行i，i+2。请问任务完成的最短时间。

• 输入包括两行：
  第一行：空格分割的两个整数m和n,分别表示节点个数和任务个数（m>0,n>=0）
  第二行，空格分割的正整数序列，表示每个任务需要的时间。

• 输出：
  一个整数，表示最短完成时间

• 输入：
  3 5
  1 5 3 4 2

• 输出：
  6

• 解题思路：
  拿样例[1,5,3,4,2]来说，桶的个数为m,桶的容量为s,则最小容量mins=5，最大容量maxs=15。所以桶的容量要介于5-15之间。采用二分法来确定。
  然后对于每种容量确定它的桶数。桶数<=m,maxs=mid，否则mins=mid+1

m=3
n=[1,2,3,4,5,6,7]
a=len(n)
mins=max(n)
maxs=sum(n)
def getrequirePainters(n,a,mid):
    i=0
    total=0
    nums=1
    while imid:
            total=n[i]
            nums+=1
        i+=1
    return nums
while mins

58同城

给出一组字符串，找出其中以小写的d或e字母结尾的单词出现的次数，结果以字典格式打印，其中不以d或e结尾的单词，不在结果统计中出现。

n='abc,head,tail,middle,head,today,tail,rain,end,cup,apple,abc,head,tail,middle,head,today,tail,rain,end,cup,apple,abc,head,tail,middle,head,today,tail,rain,end,cup,apple,abc,head,tail,middle,head,today,tail,rain,end,cup,apple,abc,head,tail,middle,head,today,tail,rain,end,cup,apple,hard,abc,head,tail,middle,head,today,tail,rain,end,cup,apple'
n=n.split(',')
a=[]
for j in n:
    a.append(j)
c=list(set(a))

d={}   
for i in range(len(c)):
    if c[i].endswith('d') or c[i].endswith('e'):
        d[c[i]]=0

for i in d.keys():
    d[i]=a.count(i)
print(d)
# 输出d为{'apple': 6, 'end': 6, 'middle': 6, 'hard': 1, 'head': 12}       

for i in range(len(d)):
    num=str(a.count(d[i]))
    d[i]=d[i]+'='+num

#以列表中元素的某部分排序

def elem(d):
    return int(d.split('=')[1])
d.sort(key=elem,reverse=True)
print(dict(d))

找出字符串（全部都是小写的英文字母）中的重叠子串

计算各个字母对应的重叠子串的长度之和，并按照出现次数从大到小进行输出。

• 输入：aaabcccaddfffaa
• 输出：重叠的字母为Key,字母个数为value，中间用冒号连接，并按照长度之和从大到小输出

a:5
c:3
f:3
d:2

• 解题思路

将相同的元素一直添加到栈中，直到下一个元素不相等时，这时统计栈的长度，大于1的时候把元素以及个数添加到字典中，如果字典中已经存在这个元素，加上栈的长度即可。

注意要判断最后一个元素栈的长度情况。

n='aaabcccaddfffaa'
stack=[]
dic={}
for i in range(len(n)):
    if not stack or n[i]==stack[-1]:
        stack.append(n[i])
        if i==len(n)-1:
            if len(stack)>1:
                if stack[-1] not in dic.keys():
                    dic[stack[-1]]=len(stack)
                else:
                    dic[stack[-1]]+=len(stack)
    elif n[i]!=stack[-1]:
        if len(stack)>1:
            if stack[-1] not in dic.keys():
                dic[stack[-1]]=len(stack)
            else:
                dic[stack[-1]]+=len(stack)
        stack=[]
        stack.append(n[i])
#将字典按值排序，返回的是一个列表
dic=sorted(dic.items(),key=lambda item:item[1] ,reverse=True)
for i in dic:
    print(i[0]+':'+str(i[1]))

道通科技

输入一个16进制数，将其转换为二进制，然后每9位是一项配置，位不足时用0补齐，9位中每三位代表一个十进制数，组合起来就是一项位置的代码。比如23 CF，转换为二进制100011 11001111，位数不足用0补齐000 010 001 111 001 111，转化为十进制代号为021 717.

#n=input().split(' ')
n='23 CF'
n=n.split(' ')
s=''
for i in n:
    i=bin(int(i,16))[2:]  #将字符串中16进制的数转化为十进制 
    s+=i
n0=9-len(s)%9
s='0'*n0+s    # 用0补全
a=[]
i=0
while s:      # 每隔3个分割字符串，添加到列表中
    a.append(s[:3])
    s=s[3:]
b=''
d=[]
for i in a:
    i=str(int(i,2))
    b+=i
    d.append(i)
if '0' in d:
    print(None)
c=[]
while b:
    c.append(b[:3])
    b=b[3:]
print(' '.join(c))

cvte

给定一个字符串，将字符串中的每个单词逐个翻转

s="I Am a Programmer!"
s1=s[0:len(s)-1]
s1=s1.split(' ')
a=[]
for i in range(len(s1)):
    a.append(s1[i][::-1])
s2=' '.join(a)
s2=s2+s[-1]
print(s2)

s2=I mA a remmargorP!

编写函数实现累加功能，要求在A[100]中按输入的范围表达式求和

比如，输入：“:3,50,97:”
输出：350 （即1+2+3+50+97+98+99）

n=":3,50,97:"
n1=n.split(',')
a=[]
for i in n1:
    a.append(i)

sum=0
for i in range(len(a)):
    if ':' in a[i] :
        if  a[i][0]==':':
            x = 1
            y=int(a[i].lstrip(':'))
        elif a[i][-1]==':':
            x=int(a[i].strip(':'))
            y = 99
        else:
            x=int(a[i].split(':')[0])
            y=int(a[i].split(':')[1])
        
        for j in range(x,y+1):
            sum+=j
   
    else:
        sum+=int(a[i])
print(sum)

奇安信

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

n='biwgef '
if len(n)<=0:
    print('0/')
n1=[]
n2=[]
for char in n:
    try:
        int(char)
        n1 += char
    except:
        if len(n2) > len(n1):
            pass
        else:
            n2 = n1
            n1 = []
if len(n2)<=0:
    print('0/')
else:
    a=str(len(n2))+'/'+''.join(n2)
    print(a)

度小满

在1-n个数中找出任意连个数，求互为质数的两个数的和的期望

from fractions import Fraction
def zhi(m,n):
    a,b=m,n
    t=0
    while(m>0):
        t=n%m
        n=m
        m=t
    if n==1:
        return a*b
    else:
        return 0
        
    
n=4
sum=0
count=0
for i in range(1,n+1):
    for j in range(i+1,n+1):
        count+=1
        sum+=zhi(i,j)
print(Fraction(sum,count))

马蜂窝

统计旅游目的地

• 输入：用户ID及用户签到的城市名称
• 输出：签到用户最多的前3个目的地及签到用户数（同一个用户多次签到同一个城市，只记一次；签到用户数相同的城市，优先展示拼音排序靠前的城市名）

d = {'banana': 3, 'orange': 5, 'apple': 5,'pear':3}

d=sorted(d.items(),key=lambda x:(-x[1],x[0])) #将字典中的元素先按值的大小排列，值相同的按键的字母顺序排列
print(d)