字符串合并处理

# 取二进制
def get_bin(str):
    str_bin = bin(int(str))[2:].rjust(4, "0")
    return str_bin


# 取十六进制
def get_hex(str):
    str_hex = hex(int(str))[2:]
    return str_hex


# 操作
def trans(s):
    # letter位置内容:(0,d)
    letter = [(index, str) for index, str in enumerate(s)]
    # letter
    letter1 = []
    letter2 = []
    sort = ""
    for i in letter:
        if i[0] % 2 == 0:
            letter1.append(i)
        else:
            letter2.append(i)
    sort1 = sorted(letter1, key=lambda x: x[1])
    sort2 = sorted(letter2, key=lambda x: x[1])
    for i in range(len(s)):
        if i % 2 == 0:
            sort += sort1[0][1]
            del sort1[0]
        else:
            sort += sort2[0][1]
            del sort2[0]
    return sort


# 二进制取反转16进制
def rev(s):
    str = ""
    for i in range(len(s) - 1, -1, -1):
        str += s[i]
    str = int(str, 2)
    str = get_hex(str)
    return str


str1, str2 = input().split()
s = str1 + str2
s = trans(s)
str = ""
dic = {
    "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",
}
p=[]
for i in s:
    u = i.upper()
    if u not in dic.keys():
        continue
    p.append( rev(get_bin(int(dic[u]))) )

for i in p:
    print(i.upper(),end="")

str1,str2 = input().split()
s = list(str1+str2)
#字符排序
s1 = s[::2]#偶数
s1.sort()
s2 = s[1::2]#奇数
s2.sort()
s[::2] = s1
s[1::2] = s2
#字符转换
res = []
for i in s:
    if '0'<=i<='9'&nbs***bsp;'a'<=i<='f'&nbs***bsp;'A'<=i<='F':
        j = bin(int(i,16))[2:].zfill(4)
        print(hex(int(j[::-1],2))[2:].upper(),end='')
    else:
        print(i,end='')

这题就是一个没任何算法，主要考逻辑操作的题目
def odd_even_str_sort(s):
    # 将字符串按奇数和偶数索引进行分割
    s_odd = ""
    s_even = ""
    for i, char in enumerate(s):
        if i % 2 == 0:
            s_even += char
        else:
            s_odd += char

    # 对每个部分进行排序
    s_even_sort = sorted(s_even)
    s_odd_sort = sorted(s_odd)

    # 交替组合排序后的结果
    result = ""
    max_length = max(len(s_even_sort), len(s_odd_sort))
    for i in range(max_length):
        if i < len(s_even_sort):
            result += s_even_sort[i]
        if i < len(s_odd_sort):
            result += s_odd_sort[i]

    return result


def zhuanhuan(s):
    # 转换字符串中的字符
    result = ""
    for char in s:
        # 检查是否为十六进制字符
        if char.isdigit()&nbs***bsp;("a" <= char.lower() <= "f"):
            # 将十六进制字符转为二进制
            binary = bin(int(char, 16))[2:].zfill(4)  # 二进制左侧补0
            # 反转二进制
            reversed_binary = binary[::-1]
            # 将反转后的二进制转回十六进制
            reversed_hex = hex(int(reversed_binary, 2))[2:].upper()
            result += reversed_hex
        else:
            result += char

    return result


# 读取输入并移除空白字符
s = "".join(input().split())

# 先进行奇偶排序，再转换字符
sorted_str = odd_even_str_sort(s)
converted_str = zhuanhuan(sorted_str)

# 打印最终结果
print(converted_str)

string = input().replace(' ', '')

list_024 = sorted(string[0::2])
list_135 = sorted(string[1::2])

step_2 = ''
for i in range(len(string)):
    if i % 2 == 0:
        step_2 += list_024[int(i/2)]
    else:
        step_2 += list_135[int((i-1)/2)]

step_3 = ''
for s in step_2:
    if '0' <= s <='9'&nbs***bsp;'A' <= s <= 'F'&nbs***bsp;'a' <= s <= 'f':
        s_10_a = int(s, 16)
        s_2 = bin(s_10_a)[2:].rjust(4, '0')
        s_2_reverse = s_2[::-1]
        s_10_b = int(s_2_reverse, 2)
        s_16 = hex(s_10_b)[2:]
        if s_16.isdigit():
            step_3 += s_16
        else:
            step_3 += s_16.upper()
    else:
        step_3 += s

print(step_3)

# 定义 16进制 和 2进制 转换的字典  方便快速转换
di_2_16, di_16_2 = {}, {}
for i in list(range(16)):
    di_2_16[bin(i)[2:].rjust(4, '0')] = str(i) if i < 10 else chr(i + 55)
    di_16_2[str(i) if i < 10 else chr(i + 55)] = bin(i)[2:].rjust(4, '0')

# 处理键盘输入
s = ''.join(input().split())
s1, s2 = sorted(s[0::2]), sorted(s[1::2])

# 奇偶位置处理
ss = ''
for i in range(len(s2)):
    ss += s1[i] + s2[i]
else:
    ss += '' if len(s1) == len(s2) else s1[-1]

# 逐个转换  利用列表实现逐个替换
ss_li = list(ss)
for i in range(len(ss_li)):
    if ss_li[i].upper() if ss_li[i].islower() else ss_li[i] in list(di_16_2.keys()):
        if ss_li[i].upper() if ss_li[i].islower() else ss_li[i]:
            ss_li[i] = di_2_16.get(di_16_2.get(ss_li[i].upper() if ss_li[i].islower() else ss_li[i])[::-1])
            
print(''.join(ss_li))



上述代码哪里有问题呀 ......就是通不过全部......
哪位大佬给看看, 不胜感激, 

def fn(s):   # 字符转换
    k = ord(s)
    if k>=48 and k<=57&nbs***bsp;k>=65 and k<=70&nbs***bsp;k>=97 and k<=102:
        a = int(s,16)
        l = ['0','0','0','0']
        if a >= 8:
            a %= 8
            l[3] = '1'
        if a >= 4:
            a %= 4
            l[2] = '1'
        if a >= 2:
            a %= 2
            l[1] = '1'
        if a == 1:
            l[0] = '1'
        a_new = int(''.join(l),2)
        s_new = hex(a_new)[-1].upper()
        return s_new
    else:
        return s

line = input().split(' ')
line = list(line[0]+line[1])

lo = []
lj = []

for i in range(len(line)):
    if i % 2 == 0:
        lo.append(line[i])
    else:
        lj.append(line[i])
lo.sort()
lj.sort()
line1 = []
for i in range(len(lo)):
    line1.append(lo[i])
    if i < len(lj):
        line1.append(lj[i])
for i in range(len(line1)):
    line1[i] = fn(line1[i])

print(''.join(line1))

import sys


d = {'10':'A','11':'B','12':'C','13':'D','14':'E','15':'F',\
     'A':10,'B':11,'C':12,'D':13,'E':14,'F':15}
s1 = ""
s2 = ""
l1 = [] # 奇数
l2 = [] # 偶数
s = input().strip().split()
s = s[0]+s[1]


# 按下表拆解排序/枚举
for i,j in enumerate(s):
    # 奇偶判断
    if i&1 == 1: # 奇数
        l1.append(j)
    else:
        l2.append(j)
# 排序
l1.sort()
l2.sort()

# 合并
for i,j in zip(l2,l1):
    s1=s1+i+j
# l1,l2长度不一样，会丢失一个元素 
if len(l1)>len(l2):
    s1+=l1[-1]
elif len(l2)>len(l1):
    s1+=l2[-1]


for i in s1:
    if i.isdigit():
        m = int(str(bin(int(i))).replace('0b','').rjust(4,'0')[::-1],2)
        if m>=10:
            s2 += d[str(m)]
        else:
            s2+=str(m)

    elif i in "ABCDEFabcdef":
        i = i.upper()
        n = int(str(bin(int(d[i]))).replace('0b','').rjust(4,'0')[::-1],2)
        if n>=10:
            s2+= d[str(n)]
        else:
            s2+=str(n)
    else:
        s2+=i

print(s2)

def reverse_hex(char:str):
    if char in 'abcdefABCDEF'&nbs***bsp;char.isdigit():
        num_b = bin(int(char, base=16))[2:].zfill(4)[::-1]
        num_h = hex(int(num_b, base=2))[2:].upper()
        return num_h
    else: return char

strs = list(input().replace(' ', '')) #字串合并
strs[::2] = sorted(strs[::2]) #偶数索引字串排序
strs[1::2] = sorted(strs[1::2]) #奇数索引字串排序
f_res = ''.join([reverse_hex(c) for c in strs]) #转16进制
print(f_res)

# 第一步：
s = ''.join(input().split())
# 第二步：
ou_li = [i for idx, i in enumerate(s) if idx % 2 == 0]
ji_li = [i for idx, i in enumerate(s) if idx % 2 == 1]
sort_list = [0] * len(s)
# 考虑 不相等元素序列
for idx, o in zip(range(0, len(s), 2), sorted(ou_li)):
    sort_list[idx] = o
for idx, j in zip(range(1, len(s), 2), sorted(ji_li)):
    sort_list[idx] = j
# 新字符串
new_s = ''.join(sort_list)
# 第三步：
ret = ''
for i in new_s.upper():
    x1 = int(i, 16)  # 将字符转换为16进制
    x2 = bin(x1)[2:].zfill(4)  # 将10进制转换为2进制,去除前2个符号，并保留4位
    x3 = x2[::-1]  # 字符串倒序
    x4 = int(x3, 2)  # 将二进制转换为10进制
    x5 = hex(x4)[2:]  # 将10进制在转换16进制,去除前2个符号
    ret += x5.upper()  # 将结果转换为大写字母，拼到结果字符串
print(ret)

# 输入两个字符串再合并
str1, str2 = input().split()
str3 = str1 + str2
# 下标奇偶数分别从小到大排序，再按奇偶数拼接字符串(奇数odd偶数even)
even = sorted(str3[::2])
odd = sorted(str3[1::2])
str4 = "".join(e + o for e, o in zip(even,odd))
# (e + o)是表达式，指在for循环中的变量进行拼接;(for e,o in zip(even,odd))指循环从zip中并列取两个字符,然后运行e+o进行拼接
if len(str3) % 2 != 0:
    str4 += even[-1]

# 字符转换规则：(字符,十六进制)转换成二进制再倒序，倒序后的二进制转换成十六进制大写字符
str5 = ""
for i in str4:
    if (i >= '0' and i <= '9')&nbs***bsp;(i >= 'A' and i <= 'F')&nbs***bsp;(i >= 'a' and i <= 'f'):
        int2 = bin(int(i, 16))[2:].zfill(4)[::-1]   # int整形,bin转换二进制且结果以'0b'开头需去掉,zfill二进制不足4位填充,[::-1]倒序排序
        int16 = hex(int(int2,2))[2:].upper()    # hex转换十六进制,upper转换大写字母
        str5 += "".join(int16)
    else:
        str5 += "".join(i)

# 转换完成后的字符拼接输出
print(str5)