华为机考-中等（1）

 

 

 

 

 

 

 

 参考答案

"""
其实这题就是0-1背包问题
首先来看一下经典背包问题，稍作修改就可以得出这题的解答
0-1背包问题
问题描述：有一个背包可以装物品的总重量为W，现有N个物品，每个物品中w[i]，价值v[i]，用背包装物品，能装的最大价值是多少？
定义状态转移数组dp[i][j]，表示前i个物品，背包重量为j的情况下能装的最大价值。
例如，dp[3][4]=6，表示用前3个物品装入重量为4的背包所能获得的最大价值为6，此时并不是3个物品全部装入，而是3个物品满足装入背包的条件下的最大价值。
状态转移方程：
dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]]+v[i])
dp[i-1][j]表示当前物品不放入背包，dp[i-1][j-w[i]]+v[i]表示当前物品放入背包，即当前第i个物品要么放入背包，要么不放入背包。
"""
"""
dp = [[0]*(n+1) for _ in range(m+1)]
for i in range(1,m+1):
    for j in range(1,n+1):
        if j-w[i]>=0:
            dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]]+v[i])
        else:
            dp[i][j] = dp[i-1][j]
return dp[m][n]
"""
"""
现在来看下购物车的解题思路
购物车本质上还是0-1背包问题，只不过多了主件和附件。假设先不看附件，那么就和0-1背包一样了。附件不能单独出现，要依赖于主件。
对应于背包问题，主件的个数就是物品的个数，考虑每个主件时要考虑可能出现的情况。
输入例子:
1000 5
800 2 0
400 5 1
300 5 1
400 3 0
500 2 0
在当前的例子当中物品的个数就是3。
考虑每个物品时要考虑每种可能出现的情况，1、主件，2、主件+附件1，3、主件+附件2，4、主件+附件1+附件2，不一定每种情况都出现，
只有当存在附件时才会出现对应的情况。w[i][k]表示第i个物品的第k种情况，k的取值范围0~3，分别对应以上4中情况，
v[i][k]表示第i个物品对应第k种情况的价值，现在就把购物车问题转化为了0-1背包问题。
状态转移方程可以定义为
dp[i][j] = max(dp[i-1][j],dp[i-1][j-w[i][k]]+v[i][k])
dp[i-1][j]表示当前物品不放入背包，w[i][k]表示第i个主件对应第k中情况，即当前第i个物品的4中情况中价值最大的要么放入背包，要么不放入背包。
需要注意：dp[i][j] = max(物品不放入背包，主件，主件+附件1，主件+附件2，主件+附件1+附件2)
"""
"""
dp = [[0]*(n+1) for _ in range(m+1)]
for i in range(1,m+1):
    for j in range(1,n+1):
        max_i = dp[i-1][j]
        for k in range(len(w[i])):
            if j-w[i][k]>=0:
                max_i = max(max_i, dp[i-1][j-w[i][k]]+v[i][k])
        dp[i][j] = max_i
print(dp[m][n])
具体代码如下：

"""

n, m = map(int, input().split())
primary, annex = {}, {}
for i in range(1, m + 1):
    x, y, z = map(int, input().split())
    if z == 0:  # 主件
        primary[i] = [x, y]
    else:  # 附件
        if z in annex:  # 第二个附件
            annex[z].append([x, y])
        else:  # 第一个附件
            annex[z] = [[x, y]]
m = len(primary)  # 主件个数转化为物品个数
dp = [[0] * (n + 1) for _ in range(m + 1)]
w, v = [[]], [[]]
for key in primary:
    w_temp, v_temp = [], []
    w_temp.append(primary[key][0])  # 1、主件
    v_temp.append(primary[key][0] * primary[key][1])
    if key in annex:  # 存在主件
        w_temp.append(w_temp[0] + annex[key][0][0])  # 2、主件+附件1
        v_temp.append(v_temp[0] + annex[key][0][0] * annex[key][0][1])
        if len(annex[key]) > 1:  # 存在两主件
            w_temp.append(w_temp[0] + annex[key][1][0])  # 3、主件+附件2
            v_temp.append(v_temp[0] + annex[key][1][0] * annex[key][1][1])
            w_temp.append(w_temp[0] + annex[key][0][0] + annex[key][1][0])  # 3、主件+附件1+附件2
            v_temp.append(v_temp[0] + annex[key][0][0] * annex[key][0][1] + annex[key][1][0] * annex[key][1][1])
    w.append(w_temp)
    v.append(v_temp)
for i in range(1, m + 1):
    for j in range(10, n + 1, 10):  # 物品的价格是10的整数倍
        max_i = dp[i - 1][j]
        for k in range(len(w[i])):
            if j - w[i][k] >= 0:
                max_i = max(max_i, dp[i - 1][j - w[i][k]] + v[i][k])
        dp[i][j] = max_i
print(dp[m][n])

"""
继续优化
现在的时间复杂度是O(mn)，时间复杂度已经无法优化，空间复杂度O(mn)，可以继续优化到O(n)。
回顾下状态转移方程：
dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]]+v[i])
dp[i]只依赖dp[i-1]，状态转移方程就可以改为：
dp[j] = max(dp_pre[j], dp_pre[j-w[i]]+v[i])
dp_pre[j]存储上一次得到的值，现在只需要2*n的空间就能得到结果。继续观察可以发现，其实只用一个一维dp数组就行，不需要额外的辅助数组。
让j从n到1遍历，此时每次更新的dp[j]时，max函数中dp[j]和 dp[j-w[i]]都是上次保存的值。
状态转移方程变为：
for j in [n...1]:
dp[j] = max(dp[j], dp[j-w[i]]+v[i])
如果从1到n遍历的话dp[j-w[i]]不能保证还是上次的值，这也进一步说明为什么用一维数组时需要从n到1遍历。
优化后的代码如下：
"""

n, m = map(int, input().split())
primary, annex = {}, {}
for i in range(1, m + 1):
    x, y, z = map(int, input().split())
    if z == 0:
        primary[i] = [x, y]
    else:
        if z in annex:
            annex[z].append([x, y])
        else:
            annex[z] = [[x, y]]
dp = [0] * (n + 1)
for key in primary:
    w, v = [], []
    w.append(primary[key][0])  # 1、主件
    v.append(primary[key][0] * primary[key][1])
    if key in annex:  # 存在附件
        w.append(w[0] + annex[key][0][0])  # 2、主件+附件1
        v.append(v[0] + annex[key][0][0] * annex[key][0][1])
        if len(annex[key]) > 1:  # 附件个数为2
            w.append(w[0] + annex[key][1][0])  # 3、主件+附件2
            v.append(v[0] + annex[key][1][0] * annex[key][1][1])
            w.append(w[0] + annex[key][0][0] + annex[key][1][0])  # 4、主件+附件1+附件2
            v.append(v[0] + annex[key][0][0] * annex[key][0][1] + annex[key][1][0] * annex[key][1][1])
    for j in range(n, -1, -10):  # 物品的价格是10的整数倍
        for k in range(len(w)):
            if j - w[k] >= 0:
                dp[j] = max(dp[j], dp[j - w[k]] + v[k])
print(dp[n])

 参考1

 

 

 

#我的
import re
s = input()
ss =s.split(";")
print(ss)
L1=[]
x=0
y=0
powid=(x,y)

for i in ss:
    if re.search('^[ASWD]{1}\d{1,2}$',i):
        L1.append(i)
print(L1)



for j in L1:
    if re.split('\d+',i)[0]=='A':
        x =x-int(re.split('^A')[1])

    elif re.split('\d+',i)[0]=='S':
        y=y-int(re.split('^S')[1])

    elif re.split('\d+',i)[0]=='D':
        x=x+int(re.split('^D')[1])

    elif re.split('\d+',i)[0]=='W':
        y=y+int(re.split('^W')[1])

print(x,y)


####################################################################
import re

coord = input().split(";")
coord = filter(lambda x: re.match("^[ASDW]{1}\d{1,2}$", x), coord)
a, b = 0, 0
for c in coord:
    if c[0] == "W":
        b += int(c[1:])
    elif c[0] == "S":
        b -= int(c[1:])
    elif c[0] == "A":
        a -= int(c[1:])
    elif c[0] == "D":
        a += int(c[1:])

print("{},{}".format(a, b))
####################################################################
input_list = input().split(';')
initial = [0,0]

for item in input_list:
    if not 2 <= len(item) <= 3:
        continue

    try:
        direction = item[0]
        step = int(item[1:])
        if direction in ['A', 'D', 'W', 'S']:
            if 0 <= step <= 99:
                if direction == 'A':
                    initial[0] -= step
                elif direction == 'D':
                    initial[0] += step
                elif direction == 'S':
                    initial[1] -= step
                elif direction == 'W':
                    initial[1] += step
    except:
        continue

print(str(initial[0]) + ',' + str(initial[1]))

###########################################################

#不成熟
import re
d = input().split(";")
result = [0,0]

regex = re.compile(r'1[1-9]?[0-9]$')
l = []
for s in d:
    if regex.match(s):
        l.append(s)
for item in l:
    letter = item[0]
    if letter == "A":
        result[0] = result[0]-int(item[1:])
    elif letter == "D":
        result[0] = result[0]+int(item[1:])
    elif letter == "S":
        result[1] = result[1]-int(item[1:])
    else: result[1] = result[1]+int(item[1:])

print(str(result[0]) + ',' + str(result[1]))

 

 

 

 

 

def check(s):
    if len(s) <= 8:
        return 0
    a, b, c, d = 0, 0, 0, 0
    for item in s:
        if ord('a') <= ord(item) <= ord('z'):
            a = 1
        elif ord('A') <= ord(item) <= ord('Z'):
            b = 1
        elif ord('0') <= ord(item) <= ord('9'):
            c = 1
        else:
            d = 1
    if a + b + c + d < 3:
        return 0
    for i in range(len(s)-3):
        if len(s.split(s[i:i+3])) >= 3:
            return 0
    return 1

while 1:
    try:
        print('OK' if check(input()) else 'NG')
    except:
        break

#########################################################
#这个还是对那个重复性不一定就是3，每处理好

def check(pw):
    if len(pw) <= 8:  # 判断密码的长度
        return False

    checks = [0, 0, 0, 0]  # 四种情况满足三种的辅助列表
    for c in pw:
        if c.isupper():  # 大写字母
            checks[0] = 1
        elif c.islower():  # 小写字母
            checks[1] = 1
        elif c.isdigit():  # 数字
            checks[2] = 1
        else:  # 其他字符
            checks[3] = 1
    if sum(checks) < 3:
        return False

    for i in range(len(pw) - 2):  # 循环遍历找到子字符串的起点
        if pw[i:i + 3] in pw[i + 3:]:  # 在剩下的字符串中顺序查找匹配当前字符串
            return False

    return True


while True:
    try:
        pw = input()
        if check(pw):
            print('OK')
        else:
            print('NG')
    except:
        break
#########################################################

def CheckPasswd(passwd):
    # 检查长度
    if len(passwd) <= 8:
        return "NG"
    # 检查字符类型
    hasNum = 0
    hasLowercase = 0
    hasUppercase = 0
    hasOther = 0
    for i in range(len(passwd)):
        ascaii = ord(passwd[i])
        if ascaii >= ord('0') and ascaii <= ord('9'):
            hasNum = 1
        elif ascaii >= ord('a') and ascaii <= ord('z'):
            hasLowercase = 1
        elif ascaii >= ord('A') and ascaii <= ord('Z'):
            hasUppercase = 1
        else:
            hasOther = 1
    types = hasNum + hasLowercase + hasUppercase + hasOther
    if types < 3:
        return "NG"

    # 检查长度大于2的重复子串
    for i in range(len(passwd) - 3):  # 检查每个长度为3的子串是否重复出现即可
        substr = passwd[i:i + 3]
        if len(passwd.split(substr)) > 2:
            return "NG"
    return "OK"  # 三项条件都满足


while 1:
    try:
        passwd = input().strip()
        print(CheckPasswd(passwd))
    except EOFError:
        break

################################################################3333

def check(sub_pswd):
    if len(sub_pswd) <=8:
         return False
    flag =[0,0,0,0]
    for i in sub_pswd:
        if '0'<= i <='9':
            flag[0] = 1
        elif 'A'<= i <='Z':
            flag[1] = 1
        elif 'a'<= i <='z':
            flag[2] = 1
        else:
            flag[3] = 1
    if sum(flag) >=3 :
        for i in range(len(sub_pswd)-3):
            if sub_pswd.count(sub_pswd[i:i+3]) >=2:
                return False
        return True
    else:
        return False

while True:
    try:
        pswd = input()
        print('OK' if check(pswd) else 'NG')
    except:
        break

########################################################################

 

import re

def check(password):
    if len(password) <=8:
        return 0

    a,b,c,d=0,0,0,0

    for i in password:
        if re.search('[0-9]', i):
            a=1
        elif re.search('[A-Z]', i):
            b=1
        elif re.search('[a-z]', i):
            c=1
        elif re.search('[^A-Za-z0-9 \f\n\r\t\v]', i):
            d=1

    if a+b+c+d<3:
        return 0

    for j in range(3, len(password)):
        if len(password.split(password[j:j + 3])) >= 3:
            return 0
    return 1

while True:
    try:
        password = input()
        print('Ok' if check(password) else 'NG')
    except:
        break
        
####################################################3
import re
password = input()

if len(password) >8:
    print('OK')
else:
    print('NG')

L1=[]  #数字
L2=[] #大写字母
L3=[] #小写字母
L4=[] #其他字符


for i in password:
    if re.search('[0-9]',i):
        L1.append(i)
    elif  re.search('[A-Z]',i):
        L2.append(i)
    elif  re.search('[a-z]',i):
        L3.append(i)
    elif re.search('[^0-9a-zA-Z]', i):
        #[^A-Za-z0-9 \f\n\r\t\v]
        L4.append(i)

if (len(L1) and len(L2) and len(L3)) == True:
    print('OK')
elif (len(L1) and len(L2) and len(L4)) == True:
    print('OK')
elif (len(L1) and len(L3) and len(L4)) == True:
    print('OK')
elif (len(L2) and len(L3) and len(L4)) == True:
    print('OK')
elif (len(L1) and len(L2) and len(L3) and len(L4)) == True:
    print('OK')
else:
    print('NG')


for j in range(len(password)):
    for k in range(3,len(password)+1):
        if password[j:j+3]==password[k:k+3]:

            print(password[j:j+3])

 

 

 

 

"""
#合唱队#
此题是最长递增子序列的变体，基本思路是对原序列从左到右和从右到左分别求出到每个元素的最长递增子序列的长度。
例如，原序列为长度为N的序列[8,20,12,15,10,9]，从左至右的到序列里每个元素的最长递增子序列为l1=[1,2,2,3,2,2]，
从右至左为l2=[1,4,3,3,2,1]，l1+l2=[2,6,5,6,4,3]。
那么合唱队最长队伍是L = max(l1+l2)-1，减1是因为计算l1和l2时重复计算了一次元素本身。
因此最少出列人数为原序列长度N-L。
此题关键在于求出l1，l2。可由动态规划求出。用dp[i]表示从左至右到原序列第i个元素的最长递增子序列的长度，
从第i个元素往回遍历更新dp[i]的值。由于每个元素都需要往回遍历一次，时间复杂度是o(n^2)。
往回遍历如何更新dp[i]的值在其他题解已有很好的介绍，这里主要写用二分法代替往回遍历的过程，时间复杂度是o(nlogn)。
二分法的过程为：首先创建数组arr=[ele_1]，ele_1是原序列第一个元素，然后从第二个元素开始从左至右遍历原序列
如果ele_i > max(arr)，将ele_i加到arr最后
如果ele_i <= max(arr)，用二分法找到arr中第一个比ele_i大（或相等）的元素并用ele_i替换
遍历完成后arr的长度即为最长递增子序列的长度（但arr不是最长递增子序列）。
第二步替换是因为为遍历到的元素可能会有比ele_i大但比替换元素小的元素，比如原序列为[2,5,8,3,4,6]。

"""

import bisect
def inc_max(l):
    dp = [1]*len(l) # 初始化dp，最小递增子序列长度为1
    arr = [l[0]] # 创建数组
    for i in range(1,len(l)): # 从原序列第二个元素开始遍历
        if l[i] > arr[-1]:
            arr.append(l[i])
            dp[i] = len(arr)
        else:
            pos = bisect.bisect_left(arr, l[i]) # 用二分法找到arr中第一个比ele_i大（或相等）的元素的位置
            arr[pos] = l[i]
            dp[i] = pos+1
    return dp

while True:
    try:
        N = int(input())
        s = list(map(int, input().split()))
        left_s = inc_max(s) # 从左至右
        right_s = inc_max(s[::-1])[::-1] # 从右至左
        sum_s = [left_s[i]+right_s[i]-1 for i in range(len(s))] # 相加并减去重复计算
        print(str(N-max(sum_s)))
    except:
        break

#######################################3
#参考了高赞的回答，为了加深自己的理解，手撸了一遍二分查找的代码。总的来说还是要自己敲一遍，一行行理解的快一些。
#二分查找，其中ls是从左到右升序
def find_pos(ls, num,start = 0, end = None):
    if end == None:
        end = len(ls)
    while start < end:
        index = (start+end)//2
        if ls[index]<num:
            start = index+1
        else:
            end = index
    return start

def dplist(raw_list):
    dp = [1]*len(raw_list)
    stu_list = [raw_list[0]]
    for i in range(1,len(raw_list)):
        if raw_list[i] > stu_list[-1]:
            stu_list.append(raw_list[i])
            dp[i] = len(stu_list)
        else:
            index = find_pos(stu_list,raw_list[i])
            stu_list[index] = raw_list[i]
            dp[i] = index+1
    return dp

while True:
    try:
        num =int(input())
        ls = list(map(int,input().split()))
        l_ls = dplist(ls)
        r_ls = dplist(ls[::-1])[::-1]
        total_ls = [l_ls[i]+r_ls[i]-1 for i in range(len(ls))]
        print(num-max(total_ls))
    except EOFError:
        break

import sys


# 获取最大增长子序列
def get_max_up_sub_arr(count, arr):
    up_arr = [1 for x in range(count)]
    for i in range(count):
        for j in range(i):
            if arr[j] < arr[i]:
                up_arr[i] = max(up_arr[i], up_arr[j]+1)
    return up_arr


while True:
    try:
        count = int(input())
        arr = list(map(int, input().split(' ')))
        left_up_arr = get_max_up_sub_arr(count, arr)
        right_up_arr = get_max_up_sub_arr(count, arr[::-1])[::-1]
        print(count - max(i + j - 1 for i, j in zip(left_up_arr, right_up_arr)))
    except EOFError:
        break


#######################################
# 动态规划
def lengthOfLIS(lst):
    dp = []
    for i in range(len(lst)):
        dp.append(1)
        for j in range(i):
            if lst[i] > lst[j]:
                dp[i] = max(dp[i], dp[j] + 1)
    return dp # 每人左边可以站的人数

while True:
    try:
        n, heights = int(input()), list(map(int, input().split()))
        # dp1:每人左边可以站的人数，dp2:每人右边可以站的人数
        dp1, dp2 = lengthOfLIS(heights), lengthOfLIS(heights[::-1])[::-1]
        res = []
        for i in range(len(dp1)):
            res.append(dp1[i] + dp2[i] - 1)
        print(n-max(res))
    except:
        break
#############################################################

import bisect #引入二分法
def hcteam(l): #定义一个函数，寻找最长的子序列
    arr = [l[0]] #定义列表，将传入函数的列表第一个元素放入当前元素
    dp = [1]*len(l) #定义一个列表，默认子序列有当前元素1，长度是传入函数的列表长度
    for i in range(1,len(l)): #从第二个元素开始查找
        if l[i] > arr[-1]: #如果元素大于arr列表的最后一个元素，就把它插入列表末尾
            arr.append(l[i])
            dp[i] = len(arr)# 获取这个元素子序列的长度
        else: # 否则，利用二分法找到比元素大的元素的位置，用新的元素替代比它大的那个元素的值，这样就能制造出一个顺序排列的子序列
            pos = bisect.bisect_left(arr, l[i])
            arr[pos] = l[i]
            dp[i] =pos+1 # 获取这个元素子序列的长度
    return dp

while True:
    try:
        n = int(input())
        sg = list(map(int,input().split()))
        left_t = hcteam(sg) #向左遍历查找子序列
        right_t = hcteam(sg[::-1])[::-1] #向右遍历查找子序列
        res = [left_t[i]+right_t[i]-1 for i in range(len(sg))] #因为左右都包含原元素，所以需要减1 ；得到各元素能得到的子序列的最大长度
        print(n-max(res)) # 源列表长度-可以生成的最长子序列长度  得到需要剔除的最小人数
    except:
        break
#############################################################


def find_len(b):
    nums = b
    if not nums:
        return 0
    dp = [1] * len(nums)#先初始化dp值，初始全设为1，初始只有自己
    for i in range(1, len(nums)):#从初始的右边的人开始
        for j in range(i):#从初始（第0个）到第j个人的左边
            if nums[i] > nums[j] and dp[i] < dp[j] + 1: #若是第i个人的身高大于第j个人，而且自己的左边是j的话[dp[j] + 1]，得到的dp值大于自己本来得到的自己左边可以有多少人的计算[dp[i]]
                dp[i] = dp[j] + 1 #那么i就加入j的排队序列
    return dp
while True:
    try:
        student_num = int(input()) #输入需要排队的学生数
        student_tall = input() #输入所有的学生身高
        student_tall = student_tall.split()
        for i in range(student_num):
            student_tall[i] = int(student_tall[i]) #将输入的字符转化为整数
        len_all = []
        len_1 = find_len(student_tall) #获得正向（从小到大排序的dp），dp值即是每个学生的左边最多有几个人（包括自己）
        len_2 = find_len(student_tall[::-1]) #获得逆向从小到大（从大到小）len_2[::-1]代表每个学生的右边最多有几个人（包括自己）
        len_len_1 = len(len_1)
        len_3 = []
        for i in range(len_len_1):
            len_3.append(len_1[i] + len_2[::-1][i]) #两个相加就是每个学生的左右最多有几个人，结果包含两个自己
        print(student_num - max(len_3) + 1)#按照输出要求，要得到踢出去几个人，所以需要len_3 -1 就是每个学生左右加上自己最多有几个人，取最大的那个学生的值，再用总数减去就是踢出去最少的人
    except:
        break

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]


def binary_search(dataset, find_num):
    print(dataset)

    if len(dataset) > 1:
        mid = int(len(dataset) / 2)
        if dataset[mid] == find_num:  # find it
            print("找到数字", dataset[mid])
        elif dataset[mid] > find_num:  # 找的数在mid左面
            print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])
            return binary_search(dataset[0:mid], find_num)
        else:  # 找的数在mid右面
            print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])
            return binary_search(dataset[mid + 1:], find_num)
    else:
        if dataset[0] == find_num:  # find it
            print("找到数字啦", dataset[0])
        else:
            print("没的分了,要找的数字[%s]不在列表里" % find_num)


binary_search(data, 66)

 

 

 

import re
while 1:
    try:
        s=input().strip()
        #把字母取出来，然后去重，排序，得到了字母序列
        sl=sorted(set([i.lower() for i in s if i.isalpha()]))
        #字母序列
        ll=[]
        for i in sl:
            ll+=re.findall(i,s,re.I)  #从字母表SL中取i,（同时忽略大小写）与原字符串匹配，找到了，就加入到新的字符串中，
        #字符串出现的每种字母按原序列添加到列表中
        for j in range(len(s)):
            if not s[j].isalpha():
                ll.insert(j,s[j])  #将原来的非字母，插入到新字符串的在原字符串中的位置
        print(''.join(ll))
        #将非字母出现的位置设为原来的字符
    except:
        break

#########################################################
while True:
    try:
        a = input()
        zimu=''
        for i in a:
            if i.isalpha(): #至少有一个字符且所有字符为字母时返回True
                zimu+=i
        zmpx=sorted(zimu,key=str.upper)#以字母转为大写后字符串升序排序的索引排列原字符串
        f=''
        idx=0
        for i in range(len(a)):
            if a[i].isalpha():
                f+=zmpx[idx]
                idx+=1
            else:
                f+=a[i]
        print(f)
    except(EOFError,KeyboardInterrupt):
        break
###########################################
while True:
    try:
        letter = input()
        letter_list = sorted([i for i in letter if i.isalpha()],key=lambda x:x.lower())
        print(*(letter_list.pop(0) if v.isalpha() else v for i,v in enumerate(letter)),sep='')
    except:
        break

###########################################
while True:
    try:
        s = input()
        already, lst, dic = [], [], {}
        # 连接相同的字母（忽略大小写)，将其添加到lst中，如['Bb', 'aA']
        # 同时用dic记录非字母字符的位置
        for i in range(len(s)):
            if not s[i].isalpha():
                dic[i] = s[i]
                continue
            if s[i].lower() not in already:
                already.append(s[i].lower())
                temp = s[i]
                for j in range(i+1, len(s)):
                    if s[i].lower() == s[j].lower():
                        temp += s[j]
                lst.append(temp)
        # 对lst进行冒泡排序
        for i in range(len(lst)-1):
            for j in range(i+1, len(lst)):
                if lst[i].lower() > lst[j].lower():
                    lst[i], lst[j] = lst[j], lst[i]
        # 将非字母字符插入到原来位置
        lst = list(''.join(lst))
        for i in dic.keys():
            lst.insert(i, dic[i])
        print(''.join(lst))
    except:
        break


#######################################################

while True:
    try:
        a = input()
        a = list(a)
        s = []
        s_result = [0]*len(a)
        b = []
        for i in range(len(a)):
            if(a[i].isupper()): #若是大写字母，放入s
                s.append(a[i])
            elif(a[i].islower()):#小写字母也放入s
                s.append(a[i])
            else:
                b.append(i) #若是其他的符号则标记它在a中的位置
        for i in b:
            s_result[i] = a[i] #在新设置的列表的同一位置放置其他的符号
        s_sort = []
        for i in s:
            s_sort.append([i.lower(),i]) #每一组是【对应的小写字母，字母】
        s_sort.sort(key=lambda ele:ele[0]) #只按照对应的小写字母排序，这样规避了大小写，且同样的字母（不区分大小写）按照输入的顺序排序
        s_new = []
        for i in s_sort:
            s_new.append(i[1]) #去掉对应的小写，保留原来的字母
        j = 0
        for i in range(len(s_result)):
            if(s_result[i] == 0): #在新的列表里若是为初始设置的0，则认为这个位置应该是字母，按照排序后的字母按序插空即可
                s_result[i] = s_new[j]
                j = j + 1
        print(''.join(s_result)) #按要求输出
    except:
        break


###################################################

#先解决仅有大小写字母没有其他字符串的案例
#思路：设计一个包含三个元素（字符，权值，索引）的元组列表，同时对权值和索引排序
#如果如果是非字母，就不添加进元组，直接输出，非字母就添加进元组后再插入

while True:
    try:
        new_string = ''
        string = input()
        d = []
        for i in range(len(string)):
            if string[i].isalpha():
                d.append((string[i],i,ord(string[i].lower())))
        d.sort(key=lambda x:(x[2],x[1]))
        flag =0
        for i in range(len(string)):
            if string[i].isalpha():
                new_string +=d[flag][0]
                flag +=1
            else:
                new_string += string[i]
        print(new_string)
    except:
        break

##################################################
"""
将a-z逐个标记分数0-25, 用space_lis记录非字母的位置,lis收录所有字母,
在收录过程中由lis的最后一个元素开始一直比较到第一个元素逐个比较这些元素和所收录字母的得分大小, 
最后找到比想收录字母得分小或者等于的元素,在那个元素后面插入想收录字母.
 当日想收录字母得分比lis中所有元素小的可能性也应该考虑. 这样保证了所收录字母part按照a-z顺序也让字母大小遵循原sentence.
  最后不要忘记将space_lis中的非字母按照记录的位置加到lis中,
  最开始本来用dictionary来记录非字母位置后来发现直接用元组逐个记录要更简单,
  而且dictionary会打乱非字母的记录顺序,这样在还原非字母位置会很麻烦.
"""

l1=string.ascii_lowercase
l2=[x for x in range(26)]
l=dict(zip(l1,l2))
while True:
    try:
        sen=input()
        #string=string.split()
        lis=[]
        space_lis=[]
        for i, part in enumerate(sen):
            if not part.isalpha():
                space_lis.append((part,i))
            else:
                if lis==[]:
                    lis.append(part)
                else:
                    for j in range(1,len(lis)+1):
                        if l[part.lower()]>=l[lis[-j].lower()]:
                            if j==1:
                                lis.append(part)
                                break
                            else:
                                lis.insert(-j+1, part)
                                break
                        else:
                            if j==len(lis):
                                lis.insert(0,part)
                                break
        for n in space_lis:
            lis.insert(n[1], n[0])
        lis=''.join(lis)
        print(lis)
    except:
        break


###############################################################
while True:
    try:
        strs = input()
        NewStr = ""  # 先统计所有的大小写字母
        for x in strs:
            if x.isalpha():
                NewStr += x
        NewList = sorted(NewStr, key=str.lower)  # 字母按A/a-Z/z排序，并放到列表里面

        NewWord = ""  # 要打印的新字符串
        idex = 0  # 用来匹配原字母列表NewList的下标
        for i in range(len(strs)):  # 遍历原字符串，把字母的按NewList进行替换，非字母的不懂
            if strs[i].isalpha():  # 大小写字母，替换成以排序的字符串
                NewWord += NewList[idex]
                idex += 1
            else:  # 非字母（特殊字符、空格、数字等），还是用原字符串的字符
                NewWord += strs[i]
        print(NewWord)
    except:
        break

 

import re

s = input()
# A Famous Saying: Much Ado About Nothing (2012/8).
print(s)

ss=[]
for i in s:
    if i.isalpha() == True:
        ss+=i.upper()
print(ss)
ss=sorted(set(ss))
print(ss)
s_new=[]
for i in ss:
    s_new+=re.findall(i,s,flags=re.I)  #列表的运算
print(s_new)

for j in range(len(s)):
    if s[j].isalpha() == False:
        s_new.insert(j,s[j])

print(s_new)
print(''.join(s_new))

 

 

 

 

 

while True:
    try:
        s = input().split()
        k = int(s[len(s) - 1])
        x = s[len(s) - 2]
        ss = list(set(s[1:len(s) - 2]))
        L_new = []

        for i in ss:
            if len(i) == len(x) and i != x and sorted(i) == sorted(x):
                L_new.append(i)
        print(len(L_new))
        print(sorted(L_new)[k - 1])
    except:
        break

==============================================

while True:
    try:
        s = input().split()
        k = int(s[len(s) - 1])
        x = s[len(s) - 2]
        ss = list(set(s[1:len(s) - 2]))
        L_new = []

        for i in ss:
            if len(i) == len(x) and i != x and ''.join(sorted(i)) == ''.join(sorted(x)):
                L_new.append(i)
        print(len(L_new))
        print(sorted(L_new)[k - 1])
    except:
        break


###########################################################
s = input().split()
print(s)

# 6 cab ad abcd cba abc bca abc 1
# s= ['6', 'cab', 'ad', 'abcd', 'cba', 'abc', 'bca', 'abc', '1']
n = s[0]
# print(n)
k = int(s[len(s) - 1])
# print(k)
ss = list(set(s[1:len(s) - 2]))
print(ss)

x = s[len(s) - 2]
print(x)

L_new = []

for i in ss:
    if len(i) == len(x) and i != x and ''.join(sorted(i)) == ''.join(sorted(x)):
        L_new.append(i)

print(len(L_new))
print(sorted(L_new))
print(sorted(L_new)[k - 1])

#################################################################
while True:
    try:
        #读取输入数据，并且转换为列表
        data1 = input().split()
        #获取单词的个数
        n1 = data1[0]
        #按字典排序的第几个兄弟词
        n2 = data1[-1]
        #获取输入的n个单词
        data2 = data1[1:-2]
        #获取兄弟词
        data3 = data1[-2]

        #用于存储兄弟词的数量
        n3 = 0
        #用于存储兄弟词
        data4 = []

        for word in data2:
            if word == data3:
                continue
            elif sorted(word) == sorted(data3):
                n3 = n3 + 1
                data4.append(word)
        print(n3)
        #将兄弟词按照字典排序
        data5 = sorted(data4)
        print(data5[int(n2)-1])
    except:
        break