华为机试（python）:字符串1
HJ5 进制转换
题目：
写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。
输入描述：
输入一个十六进制的数值字符串。
输出描述：
输出该数值的十进制字符串。不同组的测试用例用\n隔开。
while True:
try:
number = input()
n = len(number)
dic = {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'A':10,'B':11,'C':12,'D':13,'E':14,'F':15}
final = 0
#输入字符串从前往后遍历
for i in range(2,n):
final += dic[number[i]]*(16**(n-i-1))
print(final)
except:
break更简洁的方法：
while True:
try:
print(int(input(),16))
except:
break
HJ10 字符个数统计
题目：
编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3 。
输入描述：
输入一行没有空格的字符串。
输出描述：
输出 输入字符串 中范围在(0~127，包括0和127)字符的种数。
思路：运用集合的性质，即集合中没有重复元素。
while True:
try:
print(len(set(list(input()))))
except:
break
HJ11 数字颠倒/HJ12 字符串反转
题目：
输入一个整数，将这个整数以字符串的形式逆序输出
程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001
输入描述：
输入一个int整数
输出描述：
将这个整数以字符串的形式逆序输出
while True:
try:
print(input()[::-1])
except:
break
HJ14 字符串排序
题目：
给定 n 个字符串，请对 n 个字符串按照字典序排列。
输入描述：
输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。
输出描述：
数据输出n行，输出结果为按照字典序排列的字符串。
while True:
try:
n = int(input())
##决定一次输入多少
list = [input() for i in range(n)]
list.sort()
for j in list:
print(j)
except:
break
HJ20 密码验证合格程序
题目：
密码要求:
1.长度超过8位
2.包括大小写字母.数字.其它符号,以上四种至少三种 （列出四种形式）
3.不能有长度大于2的不含公共元素的子串重复 （注：其他符号不含空格或换行）（将所有长度为3的子串列出来）
输入描述：
一组字符串。
输出描述：
如果符合要求输出：OK，否则输出NG
import re
def checkLegal(pswd):
if len(pswd) <= 8:
return False
else:
sub = []
for i in range(len(pswd)-2):
#生成长度为3的子串
sub.append(pswd[i:i+3])
#如果所有子串中有重复的，经过set处理后，长度一定会变小
if len(set(sub)) < len(sub):
return False
type_ = 0
##使用正则表达式
Upper = '[A-Z]'
Lowwer = '[a-z]'
num = '\d'#数字
chars = '[^A-Za-z0-9]'
patterns = [Upper,Lowwer,num,chars]
for pattern in patterns:
#在pswd中搜索pattern
pw = re.search(pattern,pswd)
if pw:
type_ += 1
if type_ >= 3:
return True
else:
return False
while True:
try:
pswd = input()
print('OK' if checkLegal(pswd) else 'NG')
except:
break
HJ21 简单密码
题目：
大家都知道手机上的字母： 1--1， abc--2, def--3, ghi--4, jkl--5, mno--6, pqrs--7, tuv--8 wxyz--9, 0--0,就这么简单，渊子把更简单的密码中出现的小写字母都变成对应的数字，数字和其它的符号都不做变换，
输入描述：
输入包括多个测试数据。输入是一个明文，密码长度不超过100个字符，输入直到文件结尾
输出描述：
真正的密文
声明：密码中没有空格，而密码中出现的大写字母则变成小写之后往后移一位，如：X ，先变成小写，再往后移一位，不就是 y 了嘛，简单吧。记住，Z 往后移是 a 哦。
##小写字母变成数字
##大写字母变成小写字母，再向后移动一位
##数字和其它符号不变换
while True:
try:
a = input()
length = len(a)
for i in range(length):
if a[i].isalpha():
if a[i].lower() == a[i]:
if a[i] == 'a' or 'b' or 'c':
a[i] = 2
elif a[i] == 'd' or 'e' or 'f':
a[i] = 3
elif a[i] == 'g' or 'h' or 'i':
a[i] = 4
elif a[i] == 'j' or 'k' or 'l':
a[i] = 5
elif a[i] == 'm' or 'n' or 'o':
a[i] = 6
elif a[i] == 'p' or 'q' or 'r' or 's':
a[i] = 7
elif a[i] == 't' or 'u' or 'v':
a[i] = 8
else:
a[i] = 9
else:
n = ord(a[i])-64
a[i] = chr(n).lower()
print(a)
except:
break
结果没有出现！！
while True:
try:
s = input()
res = []
for i in s:
if i.isdigit():
res.append(i)
elif i.isupper() and i != 'Z':
res.append(chr(ord(i.lower()) + 1))
elif i == 'Z':
res.append('a')
else:
if i in 'abc':
res.append('2')
elif i in 'def':
res.append('3')
elif i in 'ghi':
res.append('4')
elif i in 'jkl':
res.append('5')
elif i in 'mno':
res.append('6')
elif i in 'pqrs':
res.append('7')
elif i in 'tuv':
res.append('8')
else:
res.append('9')
print(''.join(res))
except:
break
HJ23 删除字符串中出现次数最少的字符
题目：
实现删除字符串中出现次数最少的字符，若出现次数最少的字符有多个，则把出现次数最少的字符都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。
输入描述：
字符串只包含小写英文字母, 不考虑非法输入，输入的字符串长度小于等于20个字节。
输出描述：
删除字符串中出现次数最少的字符后的字符串。
思路一：元素列表与计数列表的索引对应
while True:
try:
a = list(input())
o = []
#获得承载每一元素个数的列表
for i in range(0,len(a)):
o.append(a.count(a[i]))
#得到个数列表中的最小值
min_num = min(o)
#获得个数列表最小值的索引，逆序的索引应该与原列表中的逆序索引一致
index_list=list(filter(lambda x: o[x]==min_num, list(range(len(o)))))
#只有逆序删除才不会打乱原列表元素的顺序
for j in index_list[::-1]:
a.pop(j)
print(''.join(a))
except:
break思路二：字典
import collections
while True:
try:
a = input()
res = ''
dict = collections.Counter(a)
min_num = min(dict.values())
for i in a:
#字典的值不等于最小值，其name就会加入空列表中
if dict[i] != min_num:
res += i
print(res)
except:
break
HJ26 字符串排序
题目：
编写一个程序，将输入字符串中的字符按如下规则排序。
规则 1 ：英文字母从 A 到 Z 排列，不区分大小写。
如，输入： Type 输出： epTy
规则 2 ：同一个英文字母的大小写同时存在时，按照输入顺序排列。
如，输入： BabA 输出： aABb
规则 3 ：非英文字母的其它字符保持原来的位置。
如，输入： By?e 输出： Be?y
输入描述：
输入字符串
输出描述：
输出字符串
while True:
try:
s = input()
a = ''
for i in s:
if i.isalpha():
a += i
b = sorted(a, key=str.upper)
index = 0
d = ''
for i in range(len(s)):
if s[i].isalpha():
d += b[index]
index += 1
else:
d += s[i]
print(d)
except:
break
HJ27 查找兄弟单词
题目：
定义一个单词的“兄弟单词”为：交换该单词字母顺序（注：可以交换任意次），而不添加、删除、修改原有的字母就能生成的单词。
兄弟单词要求和原来的单词不同。例如： ab 和 ba 是兄弟单词。 ab 和 ab 则不是兄弟单词。
现在给定你 n 个单词，另外再给你一个单词 str ，让你寻找 str 的兄弟单词里，按字典序排列后的第 k 个单词是什么？
注意：字典中可能有重复单词。
输入描述：
先输入单词的个数n，再输入n个单词。 再输入一个单词，为待查找的单词x 最后输入数字k
输出描述：
输出查找到x的兄弟单词的个数m 然后输出查找到的按照字典顺序排序后的第k个兄弟单词，没有符合第k个的话则不用输出。
from itertools import permutations
##递归求排列组合
def permute(nums):
result = []
for i in permutations(nums,len(nums)):
result.append(list(i))
return result
while True:
try:
a = input().split()
nums = a[0]
k = a[-1]
word = a[-2]
words = a[1:len(a)-2]
# abc一共的组合数
n_words = []
#将排列组合中各个元素变成字符串
for i in permute(word):
n_words.append(''.join(i))
#去掉与给定单词重复的元素
for re in n_words:
if re == word:
n_words.remove(re)
n = 0
bro = []
#计算给定单词列表中属于兄弟单词的个数以及存储兄弟单词
for j in words:
if j in n_words:
n += 1
bro.append(j)
bro = sorted(bro,key = str.upper)
print(n)
#取出想要的第k个兄弟单词，注下标一定是整数
bro_k = bro[int(k)-1]
print(bro_k)
except:
break
HJ31 单词倒排
题目：
对字符串中的所有单词进行倒排。
说明：
1、构成单词的字符只有26个大写或小写英文字母；
2、非构成单词的字符均视为单词间隔符；
3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符；
4、每个单词最长20个字母；
输入描述：
输入一行以空格来分隔的句子
输出描述：
输出句子的逆序
import re
while True:
try:
data = input()
sp_data = re.split('[^a-zA-Z]+',data)
# 刚开始提交后会报90% 格式错误
# 因为可能存在开头结尾是非字母的情况，所以需要去掉开头结尾的空字符
print(' '.join(sp_data[::-1]).strip())
except:
breakHJ32 密码截取
题目：Catcher是MCA国的情报员，他工作时发现敌国会用一些对称的密码进行通信，比如像这些ABBA，ABA，A，123321，但是他们有时会在开始或结束时加入一些无关的字符以防止别国破解。比如进行下列变化 ABBA->12ABBA,ABA->ABAKK,123321->51233214 。因为截获的串太长了，而且存在多种可能的情况（abaaab可看作是aba,或baaab的加密形式），Cathcer的工作量实在是太大了，他只能向电脑高手求助，你能帮Catcher找出最长的有效密码串吗？
输入描述：
输入一个字符串（字符串的长度不超过2500）
输出描述：
返回有效密码串的最大长度
def helper(s,l,r):
while l >= 0 and r < len(s) and s[l] == s[r]:
l -= 1
r += 1
return s[1+l:r]
def max_list(s):
res = ''
for i in range(len(s)):
tmp = helper(s,i,i)
if len(tmp) > len(res):
res = tmp
tmp = helper(s,i,i+1)
if len(tmp) > len(res):
res = tmp
print(len(res))
while True:
try:
s = input()
max_list(s)
except:
break
HJ40 统计字符
输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。
数据范围：输入的字符串长度满足 1 \le n \le 1000 \1≤n≤1000
输入描述：
输入一行字符串，可以有空格
输出描述：
统计其中英文字符，空格字符，数字字符，其他字符的个数
while True:
try:
a = input()
English = 0
blank = 0
digit = 0
others =0
for i in a:
if i.isalpha():
English += 1
elif i.isdigit():
digit += 1
elif i.isspace():
blank += 1
else:
others += 1
print(English)
print(blank)
print(digit)
print(others)
except:
break
while True:
try:
s=input()
l=[0,0,0]
for i in s:
l[0]+=int(i.isalpha())
l[1]+=int(i==' ')
l[2]+=int(i.isnumeric())
print(l[0])
print(l[1])
print(l[2])
print(len(s)-l[0]-l[1]-l[2])
except:
breakHJ41 称砝码
现有一组砝码，重量互不相等，分别为 m1,m2,m3…mn ；
每种砝码对应的数量为 x1,x2,x3...xn 。现在要用这些砝码去称物体的重量(放在同一侧)，问能称出多少种不同的重量。
注：
称重重量包括 0
输入描述：
对于每组测试数据：
第一行：n --- 砝码的种数(范围[1,10])
第二行：m1 m2 m3 ... mn --- 每种砝码的重量(范围[1,2000])
第三行：x1 x2 x3 .... xn --- 每种砝码对应的数量(范围[1,10])
输出描述：
利用给定的砝码可以称出的不同的重量数
各种排列组合
while True:
try:
n = int(input())
m = list(map(int,input().split()))
x = list(map(int,input().split()))
except:
break
else:
amount = []
weights = {0,}
for i in range(n):
for j in range(x[i]):
amount.append(m[i])
for i in amount:
for j in list(weights):
weights.add(i+j)
print(len(weights))HJ45 名字的漂亮度
给出一个名字，该名字有26个字符组成，定义这个字符串的“漂亮度”是其所有字母“漂亮度”的总和。
每个字母都有一个“漂亮度”，范围在1到26之间。没有任何两个不同字母拥有相同的“漂亮度”。字母忽略大小写。
给出多个名字，计算每个名字最大可能的“漂亮度”。
本题含有多组数据。
输入描述：
整数N，后续N个名字
输出描述：
每个名称可能的最大漂亮程度
最大可能的漂亮度：每个名字中出现次数最多的字母漂亮度越大。
import sys
while True:
try:
#输入
length = int(input())
list_name = [str(i) for i in sys.stdin.read().split()]
for name in list_name:
temp = list(set(name))
n = []
for char in temp:
n.append(name.count(char))
##必须对字母出现次数从大到小排序
n.sort(reverse = True)
nums = 0
for beauty in range(len(n)):
nums += (26-beauty)*n[beauty]
print(nums)
#字母出现次数越多漂亮度越大
# nums = []
# for i in list_name:
# num = list(i)
# beauty = 0
# for j in num:
# beauty += ord(j.lower())-96
# nums.append(beauty)
# print(nums)
except:
break
HJ36 字符串加密
题目：有一种技巧可以对数据进行加密，它使用一个单词作为它的密匙。下面是它的工作原理：首先，选择一个单词作为密匙，如TRAILBLAZERS。如果单词中包含有重复的字母，只保留第1个，将所得结果作为新字母表开头，并将新建立的字母表中未出现的字母按照正常字母表顺序加入新字母表。如下所示：
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
T R A I L B Z E S C D F G H J K M N O P Q U V W X Y (实际需建立小写字母的字母表，此字母表仅为方便演示）
上面其他用字母表中剩余的字母填充完整。在对信息进行加密时，信息中的每个字母被固定于顶上那行，并用下面那行的对应字母一一取代原文的字母(字母字符的大小写状态应该保留)。因此，使用这个密匙， Attack AT DAWN (黎明时攻击)就会被加密为Tpptad TP ITVH。
请实现下述接口，通过指定的密匙和明文得到密文。
输入描述：
先输入key和要加密的字符串
输出描述：
返回加密后的字符串
while True:
try:
key = input()
s = input()
#生成字母表
l = []
for i in range(26):
l.append(chr(ord('a')+i))
#生成密匙
new = []
#除去key中的重复数据
for i in key:
if i not in new:
new.append(i)
#将key以外的字母表字母填入密匙中
for i in l:
if i not in new:
new.append(i)
#与正常字母顺序表进行对照 即正常字母表作为name，新字母表作为value
m = dict(zip(l,new))
print(m)
#最终结果是要加密的字母在字母表中的索引对应新字母表的字母
res = []
for i in s:
res.append(m[i])
print(''.join(res))
except:
break
HJ65 查找两个字符串a,b中的最长公共子串
查找两个字符串a,b中的最长公共子串。若有多个，输出在较短串中最先出现的那个。
注：子串的定义：将一个字符串删去前缀和后缀（也可以不删）形成的字符串。请和“子序列”的概念分开！
输入描述：
输入两个字符串
输出描述：
返回重复出现的字符
##先找出所有公共字符串，再选择其中最长的字符串
# while True:
# try:
# a = input()
# b = input()
# commen = []
# c = str()
# for i in range(len(a)):
# for j in range(len(b)):
# if a[i] == b[j]:
# c = c + a[i]
# else:
# commen.append(c)
# c = str()
# print(commen)
# except:
# break
while True:
try:
a,b = input(),input()
temp = ""
count = 0
#比较字符串长度，将短字符串赋给a
if len(a) > len(b):
temp = a
a = b
b = temp
#双循环遍历字符串a
commen = []
for i in range(len(a)):
for j in range(i,len(a)):
#查找b中公共子字符串
if a[i:j+1] not in b:
break
else:
#筛选出最长的公共子串
if count < j-i+1:
count = j-i+1
temp = a[i:j+1]
print(temp)
except:
break
HJ57 高精度整数加法
题目：输入两个用字符串 str 表示的整数，求它们所表示的数之和。
输入描述：
输入两个字符串。保证字符串只含有'0'~'9'字符
输出描述：
输出求和后的结果
while True:
try:
a = input()
b = input()
print(int(a)+int(b))
except:
break还有一种方法：
while True:
try:
s1 = list(map(int, input()))[::-1]
s2 = list(map(int, input()))[::-1]
res = ""
i = 0 # 遍历指针
addd = 0 # 进位
summ = 0 # 和
while i < max(len(s1), len(s2)): # 开始遍历
a = 0 if i >= len(s1) else s1[i] # 获取s1中的一位数字
b = 0 if i >= len(s2) else s2[i] # 获取s2中的一位数字
summ = (addd + a + b) % 10 # 计算和
addd = (addd + a + b) // 10 # 计算进位
res = str(summ) + res # 组织到输出字符串中
i += 1
if addd > 0: # 处理最后一位
res = "1" + res
print(res) # 输出
except:
breakHJ59 找出字符串中第一个只出现一次的字符
找出字符串中第一个只出现一次的字符
输入描述：
输入一个非空字符串
输出描述：
输出第一个只出现一次的字符，如果不存在输出-1
while True:
try:
# a = input()
# nums = []
# for i in range(len(a)):
# c = a.count(a[i])
# nums.append(c)
#print(a[nums.index(1)]if else '-1')
while True:
try:
s = input()
for i in s:
if s.count(i) == 1:
count = i
break#得到结果，及时退出循环。
else:
count = -1
print(count)#只输出一个结果，可以将结果存储于一个变量中。
except:
break
HJ63 DNA序列
一个 DNA 序列由 A/C/G/T 四个字母的排列组合组成。 G 和 C 的比例（定义为 GC-Ratio ）是序列中 G 和 C 两个字母的总的出现次数除以总的字母数目（也就是序列长度）。在基因工程中，这个比例非常重要。因为高的 GC-Ratio 可能是基因的起始点。
给定一个很长的 DNA 序列，以及限定的子串长度 N ，请帮助研究人员在给出的 DNA 序列中从左往右找出 GC-Ratio 最高且长度为 N 的第一个子串。
DNA序列为 ACGT 的子串有: ACG , CG , CGT 等等，但是没有 AGT ， CT 等等
输入描述：
输入一个string型基因序列，和int型子串的长度
输出描述：
找出GC比例最高的子串,如果有多个则输出第一个的子串
while True:
try:
DNA = input()
num = int(input())
substring = []
#列出所有子串
for i in range(len(DNA)-num+1):
substring.append(DNA[i:i+num])
sum = []
#得出每一子串中CG的个数
for j in substring:
sum.append(j.count('C') + j.count('G'))
print(substring[sum.index(max(sum))])
except:
break
还可以
while True:
try:
DNA = input()
length = int(input())
max_counts = 0
max_DNA = []
for i in range(len(DNA)-length+1):
GC_counts = DNA.count('G',i,i+length) + DNA.count('C',i,i+length)
if GC_counts > max_counts:
max_counts = GC_counts
max_DNA = DNA[i:i+length]
print(max_DNA)
except:
breakHJ66 配置文件恢复
有6条配置命令，它们执行的结果分别是：
| 命 令 | 执 行 |
| reset | reset what |
| reset board | board fault |
| board add | where to add |
| board delete | no board at all |
| reboot backplane | impossible |
| backplane abort | install first |
| he he | unknown command |
为了简化输入，方便用户，以“最短唯一匹配原则”匹配（注：需从首字母开始进行匹配）：
1、若只输入一字串，则只匹配一个关键字的命令行。例如输入：r，根据该规则，匹配命令reset，执行结果为：reset what；输入：res，根据该规则，匹配命令reset，执行结果为：reset what；
2、若只输入一字串，但匹配命令有两个关键字，则匹配失败。例如输入：reb，可以找到命令reboot backpalne，但是该命令有两个关键词，所有匹配失败，执行结果为：unknown command
3、若输入两字串，则先匹配第一关键字，如果有匹配，继续匹配第二关键字，如果仍不唯一，匹配失败。
例如输入：r b，找到匹配命令reset board 和 reboot backplane，执行结果为：unknown command。
例如输入：b a，无法确定是命令board add还是backplane abort，匹配失败。
4、若输入两字串，则先匹配第一关键字，如果有匹配，继续匹配第二关键字，如果唯一，匹配成功。例如输入：bo a，确定是命令board add，匹配成功。
5、若输入两字串，第一关键字匹配成功，则匹配第二关键字，若无匹配，失败。例如输入：b addr，无法匹配到相应的命令，所以执行结果为：unknow command。
6、若匹配失败，打印“unknown command”
注意：有多组输入。
输入描述：
多行字符串，每行字符串一条命令
输出描述：
执行结果，每条命令输出一行
while True:
try:
m=input().strip().split()##批量处理
key=["reset","reset board","board add","board delete","reboot backplane","backplane abort"]
value=["reset what","board fault","where to add","no board at all","impossible","install first"]
#key[2][:3] 'boa'
if len(m)<1 or len(m)>2:
print("unknown command")
elif len(m)==1:
if m[0]==key[0][:len(m[0])]:##由于输入字母顺序不变，所有可直接在已有的关键字中截取前几个
print(value[0])
else:
print("unknown command")
else:
index=[]
#除一个关键词外，遍历其余几个关键词
for i in range(1,len(key)):
a=key[i].split()
#print(a[0][:3])
if m[0]==a[0][:len(m[0])] and m[1]==a[1][:len(m[1])]:
index.append(i)
if len(index)!=1:#不能同时匹配两个
print("unknown command")
else:
print(value[index[0]])
except:
break
HJ46 截取字符串
输入一个字符串和一个整数 k ，截取字符串的前k个字符并输出
输入描述：
1.输入待截取的字符串
2.输入一个正整数k，代表截取的长度
输出描述：
截取后的字符串
while True:
try:
s = input()
k = int(input())
print(s[:k])
except:
breakHJ30 字符串合并处理
按照指定规则对输入的字符串进行处理。
详细描述：
第一步：将输入的两个字符串str1和str2进行前后合并。如给定字符串 "dec" 和字符串 "fab" ， 合并后生成的字符串为 "decfab"
第二步：对合并后的字符串进行排序，要求为：下标为奇数的字符和下标为偶数的字符分别从小到大排序。这里的下标的意思是字符在字符串中的位置。注意排序后在新串中仍需要保持原来的奇偶性。例如刚刚得到的字符串“decfab”，分别对下标为偶数的字符'd'、'c'、'a'和下标为奇数的字符'e'、'f'、'b'进行排序（生成 'a'、'c'、'd' 和 'b' 、'e' 、'f'），再依次分别放回原串中的偶数位和奇数位，新字符串变为“abcedf”
第三步：对排序后的字符串中的'0'~'9'、'A'~'F'和'a'~'f'字符，需要进行转换操作。
转换规则如下：
对以上需要进行转换的字符所代表的十六进制用二进制表示并倒序，然后再转换成对应的十六进制大写字符（注：字符 a~f 的十六进制对应十进制的10~15，大写同理）。
如字符 '4'，其二进制为 0100 ，则翻转后为 0010 ，也就是 2 。转换后的字符为 '2'。
如字符 ‘7’，其二进制为 0111 ，则翻转后为 1110 ，对应的十进制是14，转换为十六进制的大写字母为 'E'。
如字符 'C'，代表的十进制是 12 ，其二进制为 1100 ，则翻转后为 0011，也就是3。转换后的字符是 '3'。
根据这个转换规则，由第二步生成的字符串 “abcedf” 转换后会生成字符串 "5D37BF"。
输入描述:
样例输入两个字符串，用空格隔开。
输出描述：
输出转化后的结果。
##但没有运行下来
while True:
try:
##从字符串中挑出来奇数、偶数分别排序
##再将两个字符串隔着合并在一起
##再翻转
str1,str2 =map(str,input().split(' '))
str0 = str1+str2
#将合并后的字符串按下标的奇偶性分成两个字符串
odd = ''
even = ''
for i in range(len(str0)):
if i%2 == 0:
odd += str0[i]
else:
even += str0[i]
odd = sorted(odd)
even = sorted(even)
str_new =['0']*len(str0)
for i in range(len(odd)):
#str_new.insert(2*i, odd[i])
str_new[2*i] = odd[i]
for j in range(len(even)):
#str_new.insert(2*i-1, even[i])
str_new[2*j+1] = even[j]
#print(str_new)
res = ''
#print(int(bin(int('7')).replace('0b','0')[::-1],2))
# print(int(bin(int('d',16)).replace('0b','')[::-1],2))
# print(hex(11).replace('0x','').upper())
#[5, 13, 3, 7, 11, 15]
for s in str_new:
if s in ['0','1','2','3','4','5','6','7','8','9']:
r = int(bin(int(s)).replace('0b','')[::-1],2)
if r > 9:
res += hex(r).replace('0x','').upper()
else:
res += str(r)
elif s in ['a','b','c','d','e','f','A','B','C','D','E','F']:
r = int(bin(int(s,16)).replace('0b','')[::-1],2)
if r <= 9:
res += str(r)
else:
res += hex(r).replace('0x','').upper()
print(res)
except:
break
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
HJ50 四则运算
描述
输入一个表达式（用字符串表示），求这个表达式的值。
保证字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。且表达式一定合法。
输入描述：
输入一个算术表达式
输出描述：
得到计算结果
while True:
try:
s=input()
s=s.replace('{', '(')
s=s.replace("}",")")
s=s.replace("[","(")
s=s.replace("]",")")
print(int(eval(s)))
except:
breakpython中eval函数作用如下：
1、计算字符串中有效的表达式，并返回结果。
2、将字符串转成相应的对象（如list、tuple、dict和string之间的转换）。
3、将利用反引号转换的字符串再反转回对象。
HJ42 学英语
描述
Jessi初学英语，为了快速读出一串数字，编写程序将数字转换成英文：
具体规则如下:
1.在英语读法中三位数字看成一整体，后面再加一个计数单位。从最右边往左数，三位一单位，例如12,345 等
2.每三位数后记得带上计数单位 分别是thousand, million, billion.
3.公式：百万以下千以上的数 X thousand X, 10亿以下百万以上的数：X million X thousand X, 10 亿以上的数：X billion X million X thousand X. 每个X分别代表三位数或两位数或一位数。
4.在英式英语中百位数和十位数之间要加and，美式英语中则会省略，我们这个题目采用加上and，百分位为零的话，这道题目我们省略and
下面再看几个数字例句：
22: twenty two
100: one hundred
145: one hundred and forty five
1,234: one thousand two hundred and thirty four
8,088: eight thousand (and) eighty eight (注:这个and可加可不加，这个题目我们选择不加)
486,669: four hundred and eighty six thousand six hundred and sixty nine
1,652,510: one million six hundred and fifty two thousand five hundred and ten
说明：
数字为正整数，不考虑小数，转化结果为英文小写；
保证输入的数据合法
关键字提示：and，billion，million，thousand，hundred。
输入描述：
输入一个long型整数
输出描述：
输出相应的英文写法
num1 = ['zero','one','two','three','four','five','six','seven','eight','nine','ten','eleven','twelve','thirteen','fourteen','fifteen','sixteen','seventeen','eighteen','nineteen']
num2 = [0,0,'twenty','thirty','forty','fifty','sixty','seventy','eighty','ninety']
##先把特殊的摆出来
##100以内
def hundred(n):
if n>0:
if n<20:
word.append(num1[n])
else:
word.append(num2[n//10])#取整
if n%10 != 0:
word.append(num1[n%10])#取余
#1000以内
def thousand(n):
if n>=100:
word.append(num1[n//100])
word.append('hundred')
if n % 100 != 0:
word.append('and')
hundred(n%100)
while True:
try:
n = int(input())
except:
break
else:
word = []
a = n%1000
b = (n//1000)%1000
c = (n//1000000)%1000
d = n//1000000000
if d > 0:
thousand(d)
word.append('billion')
if c>0:
thousand(c)
word.append('million')
if b>0:
thousand(b)
word.append('thousand')
if a >0:
thousand(a)
print(' '.join(word))