牛客网华为机试在线训练（三）

1.简单密码
简单字符串变换！把题目读清楚==注意边界字母 'Z’的处理！
还有种简单粗暴的解法，直接将需要变换的字符及其变换后的字符列成两个列表，然后在列表中查找输入字符对应的变换。
⚠️：字符串是不可变的！不能对字符串进行原地修改！可以使用str.replace函数或者将字符串转化为列表进行修改！

while True:
    try:
        n = input()
        l = ''
        for letter in n:
            if letter.isupper():
                if letter == 'Z':
                    l += 'a'
                else:
                    l += chr(ord(letter.lower())+1)
            elif letter in 'abc':
                l += '2'
            elif letter in 'def':
                l += '3'
            elif letter in 'ghi':
                l += '4'
            elif letter in 'jkl':
                l += '5'
            elif letter in 'mno':
                l += '6'
            elif letter in 'pqrs':
                l += '7'
            elif letter in 'tuv':
                l += '8'
            elif letter in 'wxyz':
                l += '9'
            else:
                l += letter
        print(l)
    except:
        break

2.汽水瓶
常规方法按照题目要求一步步计算，取巧方法：平均两个空瓶子可以换1瓶汽水喝。

while True:
    try:
        n = int(input().strip())
        if n == 0:
            break
        else:
            print(n // 2)
    except:
        break

3.删除字符串中出现次数最少的字符
因为字符串只包含小写字母，所以可以采用计数排序的思想。

while True:
    try:
        s = input().strip()
        l = [0 for i in range(26)]
        for letter in s:
            l[ord(letter)-97] += 1
        minn = l[ord(s[0])-97]
        for i in range(1,len(s)):
            if l[ord(s[i])-97] < minn:
                minn = l[ord(s[i])-97]
        for i in range(0,len(s)):
            if l[ord(s[i])-97] > minn:
                if i == len(s)-1:
                    print(s[i])
                else:
                    print(s[i],end = '')
    except:
        break

4.合唱队
计算出列多少位同学，使剩下同学成合唱队队形（从中间像两边身高依次递减T1<T2<......<Ti-1<Ti>Ti+1>......>TK
思路:实际上是一个求最大递增子序列(可以不连续)的问题。先求输入序列的最大递增子序列，得到一个关于输入序列每个元素最大递增序列长度的列表l1，然后求输入序列的反向序列的最大递增子序列（即原输入序列的最大递减子序列），得到列表l2, 然后将两列表中每项相加再减1（每个元素自身被计算了两次），即得到每个元素满足合唱队队形的最长序列长度。
最大递增子序列的求法可以使用动态规划来解决。

def maxx(li):
    f = [ 1 for i in range(len(li))]
    for i in range(len(li)):
        for j in range(i-1,-1,-1):
            if li[i] > li[j] and f[i] < f[j] + 1:
                f[i] = f[j] + 1
    return f

while True:
    try:
        n = int(input().strip())
        l = list(map(int,input().strip().split(' ')))
        l1 = maxx(l)
        l2 = maxx(l[::-1])
        finn = [l1[i] + l2[::-1][i] for i in range(n)]
        print(n - max(finn)+1)
    except:
        break

5.数据分类处理
题目很长，读起来很费时间。。但耐心读下来之后理解题意做起来就比较容易

while True:
    try:
        iseq = input().strip().split(' ')[1:]
        rseq = input().strip().split(' ')[1:]
        #print(iseq,rseq)
        rseq = list(set(rseq))   #将R序列去重
        rseq.sort(key=lambda x: int(x))  #去重后排序
        l = []
        for word in rseq:
            flag = True    #标记R序列中的元素是否有满足条件的I<j>
            s = []
            cunt = 0
            for seq in iseq:
                if word in seq:
                    flag = False
                    cunt += 1
                    s.append(str(iseq.index(seq)))
                    s.append(seq)
            if flag:
                continue
            l.append(word)
            l.append(str(cunt))
            l.extend(s)
        print(len(l),' '.join(l))
    except:
        break

6.字符串排序
基本思路：将字符串中是字母的单独进行排序，然后放回原字符串中保持原输入字符串格式。
大佬思路：不用排序，采用计数的思想

for(int j=0; j<26; j++)
        {
            for(int i=0; i<len; i++)
            {
                if(s[i]-'a'==j||s[i]-'A'==j)
                {
                    tempChar.push_back(s[i]);
                }
            }
        }

while True:
    try:
        s = list(input().strip())
        l = []
        for letter in s:
            if letter.isalpha():
                l.append(letter)
        l.sort(key = lambda x:x.lower())
        j = 0
        for i in range(len(s)):
            if s[i].isalpha():
                s[i] = l[j]
                j += 1
        print(''.join(s))
    except:
        break

7.查找兄弟单词
这道题目比较坑==题目没说清楚。。。
1.abc和abc是相同单词不是兄弟单词
2.找到所有的兄弟单词后，要将这些兄弟单词按照字典的顺序进行排序
3.若要查找的兄弟单词下标超出了整个兄弟单词列表的长度，则只输出兄弟单词列表的长度！

while True:
    try:
        s = input().strip().split(' ')
        index = int(s[-1])
        word = s[-2]
        wl = list(word)
        wl.sort()
        dic = s[1:-2]
        l = []
        for bro in dic:
            brol = list(bro)
            brol.sort()
            if brol == wl and bro != word:
                l.append(bro)
        l.sort()   # 所有兄弟单词按字典顺序进行排序
        print(len(l))
        if index <= len(l):
            print(l[index-1])
    except:
        break

8.素数伴侣
这道题一开始想用动态规划做发现本菜鸡怎么规划都规划不出来==后来看了讨论区大佬，用二分图匹配来做，先将输入整数序列划分为奇数序列和偶数序列，然后使用匈牙利算法来解决。参考链接贴这儿参考这篇大佬博客讲的内容再加上自己画图理解递归过程，总算把这个问题搞清楚了😄

def isprime(number):  
    i = 2
    while i**2 <= number:
        if number % i == 0:
            return False
        i += 1
    return True

def part(x1,jii,use,re):
    for j in range(1,len(jii)+1):
        if isprime(ou[x1-1]+jii[j-1]) and use[j] == 0:
            use[j] = 1
            if re[j] == 0 or part(re[j],jii,use,re):
                re[j] = x1
                return True
    return False

while True:
    try:
        n = int(input().strip())
        l = list(map(int,input().strip().split(' ')))
        ji = []
        ou = []
        for num in l:
            if num % 2 == 0:
                ou.append(num)
            else:
                ji.append(num)
        summ = 0
        result = [0 for i in range(len(ji)+1)]
        for x in range(1,len(ou)+1):  #因为part函数中re[j]==0表示ji列表中下标为j的还没匹配，所以ou序列下标也从1开始，把0的空出来防止混淆。
            used = [0 for j in range(len(ji)+1)]
            if part(x,ji,used,result):
                summ += 1
        print(summ)
    except:
        break

9.字符串加解密
简单的字符串替换，注意边界字符即可
也可以使用字典形式暴力破解哈哈

s1 = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
s2 = 'BCDEFGHIJKLMNOPQRSTUVWXYZAbcdefghijklmnopqrstuvwxyza1234567890'
def en(st):
    r = ''
    for letter in st:
        if letter in s1:
            r += s2[s1.index(letter)]
        else:
            r += letter
    return r

def dec(st1):
    r1 = ''
    for letter1 in st1:
        if letter1 in s2:
            r1 += s1[s2.index(letter1)]
        else:
            r1 += letter1
    return r1
import sys
k = 0
for line in sys.stdin:
    line = line.strip('\n')
    if k%2 == 0:
        print(en(line))
    else:
        print(dec(line))
    k += 1

10.字符串合并处理
将字符串先进行奇偶分组，然后进行排序即可
使用了和第九题一样的方法，但是要注意⚠️不在字典中的字符原样输出！

s1 = '0123456789abcdefABCDEF'
s2 = '084C2A6E195D3B7F5D3B7F'
while True:
    try:
        s = input().split(' ')
        s = s[0] + s[-1]
        ou = []
        ji = []
        for i in range(len(s)):
            if i % 2 == 0:
                ou.append(s[i])
            else:
                ji.append(s[i])
        ou.sort()
        ji.sort()
        l = ''
        j,k=0,0
        for i in range(len(s)):
            if i % 2 == 0:
                if ou[j] not in s1:
                    l += ou[j]
                else:
                    l += s2[s1.index(ou[j])]
                j += 1
            else:
                if ji[k] not in s1:
                    l += ji[k]
                else:
                    l += s2[s1.index(ji[k])]
                k += 1
        print(l)
    except:
        break