Life Is Short:

明明就是一个字符串，非分成两个字符串来描述，除了增加读题难度，难道是要考 1+1 等于几么？

def fun(c):
    """
    对16进制字符进行翻转转换
    """
    to2 = format(int(c, 16), 'b').rjust(4, '0')
    to16 = format(int(to2[::-1], 2), 'X')
    return to16

while True:
    try:
        s1, s2 = input().split()
        s = list(s1 + s2)
        hexs = "0123456789abcdefABCDEF"

        #奇子串排序
        s[::2] = sorted(s[::2])
        #偶子串排序
        s[1::2] = sorted(s[1::2])

        for i in range(len(s)):
            if s[i] in hexs:
                s[i] = fun(s[i])

        print(''.join(s))
    except:
        break

JAVA实现
注意 
    1、Integer.toBinaryString 转换后可能不足4位，需要再补齐 2、只有符合16进制的字符才进行转换，G(g)及之后的字母不转换 
import java.util.*;

public class ProcessString {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            //TODO 接收字符串并去掉空格
            String str = sc.nextLine();
            str = str.replaceAll(" ","");
            char[] chars = str.toCharArray();
            //TODO 奇偶下标分别排序再重组
            List list1 = new ArrayList<Character>();
            List list2 = new ArrayList<Character>();
            for(int i=0;i<chars.length;i++){
                if(i%2==0){
                    list1.add(chars[i]);
                }else{
                    list2.add(chars[i]);
                }
            }
            Collections.sort(list1);
            Collections.sort(list2);
            StringBuffer sb = new StringBuffer();
            for(int i=0;i<chars.length;i++){
                if(i%2==0){
                    sb.append(list1.get(i/2));
                }else{
                    sb.append(list2.get(i/2));
                }
            }

            //TODO 对排序后的字符串进行转换
            StringBuffer result = new StringBuffer();
            char[] chs = sb.toString().toCharArray();
            for(char ch:chs){
                //注意只有符合16进制的字符才进行转换，G及之后的字母不转换
                if((ch>='0'&&ch<='9')||(ch>='A'&&ch<='F')||(ch>='a'&&ch<='f')){
                    //用temp接收转换完的2进制字符串
                    String temp = Integer.toBinaryString(Integer.parseInt(ch+"",16));
                    String binaryString = "";
                    //8以下的数转为2进制不够4位，需要补0
                    if(temp.length()<4){
                        for(int i=0;i<4-temp.length();i++){
                            binaryString +="0";
                        }
                    }
                    binaryString += temp;
                    //转换完成的字符串反转，char[]逆序输出
                    char[] temp1 = binaryString.toCharArray();
                    StringBuffer revolveBinaryString = new StringBuffer();
                    for(int i =temp1.length-1;i>=0;i--){
                        revolveBinaryString.append(temp1[i]);
                    }
                    //2进制转为10进制再转为16进制，注意只大写转换部分的字母
                    result.append(Integer.toHexString(Integer.parseInt(revolveBinaryString.toString(),2)).toUpperCase());
                }else{
                    result.append(ch);
                }
            }
            System.out.println(result);
        }
    }
}

while True:
    try:
        str1 = input().split()
        a = str1[0] + str1[1]

        odd = []
        even = []
        result = ''
        result1 = ''
        for i,v in enumerate(a):
            if i % 2 == 0:
                even.append(v)
            else:
                odd.append(v)

        odd.sort()
        even.sort()

        for i in range(len(a)):
            if i % 2 == 0:
                result += even[0]
                even.pop(0)
            else:
                result += odd[0]
                odd.pop(0)
        items = '0123456789abcdefABCDEF'
        #如果字符在'0123456789abcdefABCDEF'，则要改变
        #改变思路：1，先转换为二进制，然后倒置，然后查看如果是数字，输出
        #如果不是数字，都转为大写字母
        for i in result:
            if i not in items:
                result1 += i
            else:
                ss = int(bin(int(i,16)).replace('0b','').rjust(4,'0')[::-1],2)
                if ss == 10:
                    result1 += 'A'
                elif ss == 11:
                    result1 += 'B'
                elif ss == 12:
                    result1 += 'C'
                elif ss == 13:
                    result1 += 'D'
                elif ss == 14:
                    result1 += 'E'
                elif ss == 15:
                    result1 += 'F'
                else:
                    result1 += str(ss)
        print(result1)
    except:
        break

#include<iostream>
#include<string>
using namespace std;

string ChongpaiStr(string str) //重排序列
{
	int i = 0,lengthstr=0,tmp=0,j=0;
	lengthstr = str.length();
	for (i = 0; i <= lengthstr-2; i+=2)
		for (j = i+2; j <= lengthstr-1; j+=2)
		{
			if (str[i] > str[j])
			{
				tmp = str[j];
				str[j] = str[i];
				str[i] = tmp;
			}
			if (str[i+1] > str[j+1] && j< (lengthstr-1))
			{
				tmp = str[j+1];
				str[j+1] = str[i+1];
				str[i+1] = tmp;
			}
		}
	return str;
}

char TenToH(int num) //十进制转十六进制字符
{
	if(num>=0 && num<=9) return num+'0';
	if (num >= 10 && num <= 15)return num+'A'-10;
}

int ZifuZhuanShuzi(int c) //字符转16进制
{
	if (c >= '0' && c <= '9') return c - '0';
	else if (c >= 'a' && c <= 'f') return c - 'a'+10;
	else return c - 'A' + 10;
}

int WeiDaoxu(int num) //位倒序操作
{
	int j=8,i=0;
	int tmp[4] = { 0 };
	for(i=0;i<4;i++)
	{
		tmp[i] =num%2;
		num /= 2;
	}
	num = 0;
	for (i = 0; i <4; i++)
	{
		num += j * tmp[i];
		j /= 2;
	}
	return num;
}

int main()
{
	string str1, str2,str;
	int lengthStr=0,i=0;
	while (cin >> str1 >> str2)
	{
		str = str1 + str2;
		str = ChongpaiStr(str);//排序完成
		lengthStr = str.length();
		for (i = 0; i < lengthStr; i++)
		{
			if ((str[i] >= '0' && str[i] <= '9') || (str[i] >= 'a' && str[i] <= 'f') || (str[i] >= 'A' && str[i] <= 'F'))
				str[i]=TenToH(WeiDaoxu(ZifuZhuanShuzi(str[i])));
		}
		cout << str << endl;

		lengthStr = 0, i = 0;
		str.erase(0);
		str1.erase(0);
		str2.erase(0);
	}
    return 0;
}

import java.util.*;

public class Main{
      public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String inputStrA = scanner.next();
        String inputStrB = scanner.next();
        // 第一步：合并
        String inputStr = inputStrA + inputStrB;
        // 第二部：排序,使用希尔排序
        // 将字符串转为数组，方便排序
        char[] chars = inputStr.toCharArray();
        // 从第三位开始排序
        for (int i = 2; i < chars.length; i += 2) {
            char temp = chars[i];
            int j = i;
            while (2 <= j && temp < chars[j - 2]) {
                chars[j] = chars[j - 2];
                j -= 2;
            }
            chars[j] = temp;
        }

        // 从第四位开始排序
        for (int i = 3; i < chars.length; i += 2) {
            char temp = chars[i];
            int j = i;
            while (2 <= j && temp < chars[j - 2]) {
                chars[j] = chars[j - 2];
                j -= 2;
            }
            chars[j] = temp;
        }
        //System.out.println("排序过后的字符串为：" + String.valueOf(chars));

        // 第三步：转换
        for (int j = 0; j < chars.length; j++) {
            char aChar = chars[j];
            // 获取对应的二进制字符串
            String bString = getBinaryString(aChar);
            if("".equals(bString)){
                continue;
            }
            // 从尾到头，计算二进制字符串对应的十进制数值
            int finalNum = 0;
            for (int i = 0; i < 4; i++) {
                finalNum = finalNum * 2 + Integer.valueOf(String.valueOf(bString.charAt(3 - i)));
            }
            // 放入chars数组中
            if (finalNum <= 9) {
                chars[j] = (char)(finalNum + '0');
            } else {
                chars[j] = getCharByInt(finalNum);
            }


        }
        //System.out.println("转换过后的字符串为：" + String.valueOf(chars));
         System.out.println(String.valueOf(chars));
    }

    private static char getCharByInt(int finalNum) {
        switch (finalNum) {
            case 10:
                return 'A';
            case 11:
                return 'B';
            case 12:
                return 'C';
            case 13:
                return 'D';
            case 14:
                return 'E';
            case 15:
                return 'F';
            default:
                return ' ';
        }
    }

    private static String getBinaryString(char aChar) {
        switch (aChar) {
            case '1':
                return "0001";
            case '2':
                return "0010";
            case '3':
                return "0011";
            case '4':
                return "0100";
            case '5':
                return "0101";
            case '6':
                return "0110";
            case '7':
                return "0111";
            case '8':
                return "1000";
            case '9':
                return "1001";
            case 'a':
                return "1010";
            case 'A':
                return "1010";
            case 'b':
                return "1011";
            case 'B':
                return "1011";
            case 'c':
                return "1100";
            case 'C':
                return "1100";
            case 'd':
                return "1101";
            case 'D':
                return "1101";
            case 'e':
                return "1110";
            case 'E':
                return "1110";
            case 'f':
                return "1111";
            case 'F':
                return "1111";
        }
        return "";
    }
}

while True:
    try:
        s = list(input())
        s.remove(' ')

        s1 = [s[i] for i in range(0, len(s), 2)]
        s2 = [s[i] for i in range(1, len(s), 2)]
        s1.sort()
        s2.sort()

        s = []
        for i in range(len(s2)):
            s.append(s1[i])
            s.append(s2[i])
        if len(s1) > len(s2):
            s.append(s1[len(s1) - 1])

        q = []
        for i in s:
            if i in ['a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F'] + [str(x) for x in range(0, 9)]:
                tmp = bin(int(i, 16))
                tmp = list(tmp)
                tmp.pop(0)
                tmp.pop(0)
                if len(tmp) < 4:
                    for i in range(4 - len(tmp)):
                        tmp.insert(0, '0')
                tmp = tmp[::-1]
                tmp = ''.join(tmp)
                re = hex(int(tmp, 2))
                re = list(re)
                re.pop(0)
                re.pop(0)
                re = list(''.join(re).upper())
                q += re
            else:
                q.append(i)
        print(''.join(q))
    except:
        break

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {
    // 映射表（缓存）
    public static Map<Character, Character> map = new HashMap<>();
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            System.out.println(merge(sc.next(), sc.next()));
        }
    }

    public static String merge(String str1, String str2) {
        // 字符串合并
        str1 += str2;
        // 排序
        char[] chars = sort(str1);
        // 字符转换
        String result = "";
        for (char c : chars) {
            if (map.containsKey(c)) {
                result += map.get(c);
            } else {
                result += transform(c);
            }
        }
        return result;
    }

    // 字符串排序（选择排序）
    public static char[] sort(String str) {
        char[] chars = str.toCharArray();
        int index;
        for (int i=0; i<chars.length; i++) {
            index = i;
            for (int j=i+2; j<chars.length; j+=2) {
                if (chars[j] < chars[index]) {
                    index = j;
                }
            }
            if (index != i) {
                char temp = chars[i];
                chars[i] = chars[index];
                chars[index] = temp;
            }
        }
        return chars;
    }

    // 字符转换
    public static char transform(char c) {
        // 16转10
        int temp;
        if (c >= '0' && c<='9') {
            temp = c - 48;
        } else if (c >= 'A' && c <= 'F'){
            temp = c - 65 + 10;
        } else if (c >= 'a' && c <= 'f') {
            temp = c - 97 + 10;
        } else {
            return c;
        }
        // 10转2，顺便翻转2进制
        String binStr = "";
        while (temp != 0) {
            binStr += temp % 2;
            temp /= 2;
        }
        // 补0
        while (binStr.length() < 4) {
            binStr += "0";
        }
        // 2转10
        int pow = 0;
        int num = 0;
        for (int i=binStr.length()-1; i>=0; i--) {
            if (binStr.charAt(i) == '1') {
                num += Math.pow(2, pow);
            }
            pow ++;
        }
        // 10转16（并将结果加入映射表【缓存】）
        char result;
        if (num < 10) {
            result =  (char)(num + 48);
        } else {
            result = (char)(num + 65 - 10);
        }
        map.put(c, result);
        return result;
    }
}

这个人太笨了，写了一百行

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

string printbinary(int val)
{
    string res;
    for(int i = 3; i >= 0; i--)
    {
        if(val & (1 << i))
            res += '1';
        else
            res += '0';
    }
    return res;
}

char printdec(string s)
{
    int res = 0;
    int multi = 1;
    for(int i = 3; i >=0; --i)
    {
        res = res + ((s[i] - '0') * multi);
        multi = multi << 1;
    }
    if(res <= 9)
        return res + '0';
    else
        return res - 10 + 'a';
}

string mysort(string s)
{
    string s1, s2;
    int flag = 0;
    for(char c : s)
    {
        if(flag % 2 == 0)
            s1 += c;
        else s2 += c;
        ++flag;
    }
    sort(s1.begin(), s1.end());
    sort(s2.begin(), s2.end());
    s.clear();
    flag = 1;
    for(char c : s2)
    {
        s1.insert(s1.begin() + flag, c);
        flag += 2;
    }
    return s1;
}

int main()
{
    string s1, s2;
    while(cin >> s1)
    {
        cin >> s2;
        string newstring = s1 + s2;
        string newsortstring = mysort(newstring);
        string output;
        for(char c : newsortstring)
        {
            int ctoi;
            int change = 0;
            if(isdigit(c))
            {
                ctoi = c - '0';
                change = 1;
            }
            else
            {
                if(c >= 'A' && c <= 'F') {
                    ctoi = c - 'A' + 10;
                    change = 1;
                }
                else if(c >= 'a' && c <= 'f')
                {
                    ctoi = c - 'a' + 10;
                    change = 1;
                }

            }
            char newc;
            if(change)
            {
                string bin = printbinary(ctoi);
                reverse(bin.begin(), bin.end());
                newc = printdec(bin);
                output += toupper(newc);
            }
            else output += c;

        }
        cout << output << endl;
    }
    return 0;
}

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main() {
	//字符串转换映射表
	string source = "0123456789abcdefABCDEF";
	string target = "084C2A6E195D3B7F5D3B7F";
	string s1, s2;
	while (cin >> s1 >> s2) {
		string s = s1 + s2;
		string sOdd{ "" };
		string sEven{ "" };
		//字符串按奇偶分开
		for (int i = 0; i < s.size(); i++) {
			if (i % 2) {
				sOdd += s[i];
			}
			else
				sEven += s[i];
		}
		//排序并合并
		sort(sOdd.begin(), sOdd.end());
		sort(sEven.begin(), sEven.end());
		for(int i =0;i<s.size();i++){
			if (i % 2) {
				s[i] = sOdd[i / 2];
			}
			else
				s[i] = sEven[i / 2];
		}
		//字符串映射
		for (int i = 0; i < s.size();i++) {
			if (source.find(s[i]) != string::npos) {
				s[i]=target[source.find(s[i])];
			}
		}
		cout << s << endl;
	}
}

import java.util.Scanner;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Arrays;
import java.lang.String;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            String s1 = in.next();
            String s2 = in.next();
            String s = s1+s2;
            ArrayList<String> list1 = new ArrayList();   // 存放偶数下标的字符
            ArrayList<String> list2 = new ArrayList();   // 存放奇数下标的字符
            for(int i=0;i<s.length();i++){
                if(i%2 == 0){
                    list1.add(s.substring(i,i+1));
                }else{
                    list2.add(s.substring(i,i+1));
                }
            }
            Collections.sort(list1);   // 升序排序
            Collections.sort(list2);   // 升序排序
            String ss = "";            // 存放最终排序的字符串
            for(int i=0,j=0,k=0;i<s.length();i++){  // 拼接排序后的字符串
                if(i%2 == 0){
                    ss += list1.get(j++);
                }else{
                    ss += list2.get(k++);
                }
            }
            ////////////////////////////////// 开始转换 ///////////////////////
            for(int i=0;i<ss.length();i++){
                if((ss.charAt(i)>='0'&&ss.charAt(i)<='9')||(ss.charAt(i)>='a'&&ss.charAt(i)<='f')||(ss.charAt(i)>='A'&&ss.charAt(i)<='F')){
                    String str = Integer.toBinaryString(Integer.parseInt(ss.substring(i,i+1),16));  // 得到16进制的01字符串
                    int z = 0, p[]={8,4,2,1}, u=0;
                    for(int j=str.length()-1;j>=0;j--){
                        z += Integer.parseInt(str.substring(j,j+1))*p[u++];  // 计算倒序后的值
                    }
                    switch(z){                                 // 输出倒序后的值
                        case 10:System.out.print("A");break;
                        case 11:System.out.print("B");break;
                        case 12:System.out.print("C");break;
                        case 13:System.out.print("D");break;
                        case 14:System.out.print("E");break;
                        case 15:System.out.print("F");break;
                        default:System.out.print(z);break;
                    }
                }else{
                    System.out.print(ss.charAt(i));             // 非16进制的字符原样输出
                }
            }
            System.out.println();
        }
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char func(char str)
{
    int temp;
    if(str<='9'&&str>='0')
    {
        temp=str-'0';
    }
    else if(str<='f'&&str>='a')
    {
        temp=str-'a'+10;
    }
    else if(str<='F'&&str>='A')
    {
        temp=str-'A'+10;
    }
    int bin[4]={0};
    int i=0;
    while(temp!=0)
    {
        bin[i++]=temp%2;
        temp/=2;
    }
    temp=bin[0]*pow(2,3)+bin[1]*pow(2,2)+bin[2]*pow(2,1)+bin[3]*pow(2,0);
    char result;
    if(temp>9)
    {
        result=temp-10+'A';
    }
    else
    {
        result=temp+'0';
    }
    return result;
}
int main()
{
    char input[1000];
    int i,j;
    while(gets(input))
    {
        int len=strlen(input);
        for(i=0;i<len;i++)
        {
            if(input[i]==' ')
            {
                for(j=i;j<len-1;j++)
                {
                    input[j]=input[j+1];
                }
                input[len-1]='\0';
                break;
            }
        }
        len=strlen(input);
        for(i=0;i<len-2;i=i+2)
        {
            for(j=0;j<len-2-i;j=j+2)
            {
                if(input[j]>input[j+2])
                {
                    char temp;
                    temp=input[j];
                    input[j]=input[j+2];
                    input[j+2]=temp;
                }
            }
        }
        for(i=0;i<len-2;i=i+2)
        {
            for(j=1;j<len-2-i;j=j+2)
            {
                if(input[j]>input[j+2])
                {
                    char temp;
                    temp=input[j];
                    input[j]=input[j+2];
                    input[j+2]=temp;
                }
            }
        }
        for(i=0;i<len;i++)
        {
            if((input[i]<='9'&&input[i]>='0')||(input[i]<='f'&&input[i]>='a')||(input[i]<='F'&&input[i]>='A'))
            {
                input[i]=func(input[i]);
            }
        }
        printf("%s\n",input);
    }
    return 0;
}

#include<iostream>
#include<string>
using namespace std;
const string before = "0123456789abcdefABCDEF";
const string after = "084C2A6E195D3B7F5D3B7F";
int main()
{
    string str1,str2;
    while(cin>>str1>>str2)
    {
        string str=str1+str2;
        for(int i=0;i<str.length();i++)
            for(int j=i+2;j<str.length();j+=2)
                if(str[i]>str[j])
                    swap(str[i],str[j]);
        for(int i=0;i<str.length();i++)
            for(int j=0;j<22;j++)
                if(str[i]==before[j])
                {
                    str[i]=after[j];
                    break;
                }
        cout << str <<endl;
    }
    return 0;
}

while True:
    try:
        s = list(input().replace(' ', ''))
        s[::2] = sorted(s[::2])
        s[1::2] = sorted(s[1::2])
        result = ''
        l = '0123456789ABCDEFabcdef'
        for i in s:
            if i in l:
                    result += str(hex(int(str('{:04b}'.format(int(i, 16)))[::-1], 2)))[2:].upper()
            else:
                result += i
        print(result)
    except:
        break

while 1:
    try:
        a,b=input().split()
        c=a+b
        js=''
        os=''
        for i in range(0, len(c)):
            if i%2==0:
                js += c[i]
            else:
                os += c[i]
        js=sorted(js)
        os=sorted(os)
        new=[]
        for j in range(1, len(c)+1):
            if j%2==1:
                new.append(js[j//2])
            else :
                new.append(os[j//2-1])
        new1=[]
        for i in new:
            if  'a'<=i<='f' or '0'<=i<='9' or 'A'<=i<='F':
                t=len((bin(int(i, 16))[2:][::-1]))
                new1.append(('0'*(4-t)+bin(int(i, 16))[2:])[::-1])
            else:
                new1.append(i)
        s=''
        for i in new1:
            if 'F'<i<='Z' or 'f'<i<='z':
                s += i
            else:
                s += hex(int(i, 2))[2:].upper()

        print (s)
    except:
        break