题解 | #字符串合并处理#

def merge_strings(str1, str2):
    """第一步：合并字符串"""
    return str1 + str2

def sort_by_position(s):
    """第二步：按奇偶位置排序"""
    # 分离奇数位和偶数位字符
    odd_chars = sorted([s[i] for i in range(len(s)) if i % 2 == 0])
    even_chars = sorted([s[i] for i in range(len(s)) if i % 2 == 1])
    
    # 重新组合字符串
    result = []
    odd_idx = 0
    even_idx = 0
    for i in range(len(s)):
        if i % 2 == 0:
            result.append(odd_chars[odd_idx])
            odd_idx += 1
        else:
            result.append(even_chars[even_idx])
            even_idx += 1
    return ''.join(result)

def convert_char(c):
    """转换字符
    1. 数字：直接转二进制
    2. 字母：先转为对应的十六进制值(a-f:10-15, A-F:10-15)，再转二进制
    3. 翻转二进制，转回十六进制
    """
    if c > 'f' and c <= 'z' or c > 'F' and c <= 'Z':
        return c;
    if c.isdigit():
        binary = format(int(c), '04b')
    else:
        # 字母转为对应的十六进制值(0-15)
        val = int(c, 16) if c.lower() <= 'f' else ord(c.lower()) - ord('a')
        binary = format(val, '04b')
    
    # 翻转二进制并转为十六进制
    reversed_val = int(binary[::-1], 2)
    return format(reversed_val, 'X')

def process_string(str1, str2):
    # 第一步：合并字符串
    merged = str1 + str2
    
    # 第二步：奇偶位置分别排序
    odd_pos = sorted(merged[::2])
    even_pos = sorted(merged[1::2])
    
    # 重新组合
    result = ''
    i, j = 0, 0
    for k in range(len(merged)):
        if k % 2 == 0:
            result += odd_pos[i]
            i += 1
        else:
            result += even_pos[j]
            j += 1
    
    # 第三步：进制转换
    return ''.join(convert_char(c) for c in result)

while True:
    try:
        str1, str2 = input().split()
        print(process_string(str1, str2))
    except EOFError:
        break

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

string mergeStrings(const string& str1, const string& str2) {
    return str1 + str2;
}

string sortByPosition(const string& s) {
    vector<char> odd_chars, even_chars;
    for (int i = 0; i < s.length(); i++) {
        if (i % 2 == 0) odd_chars.push_back(s[i]);
        else even_chars.push_back(s[i]);
    }
    
    sort(odd_chars.begin(), odd_chars.end());
    sort(even_chars.begin(), even_chars.end());
    
    string result;
    int odd_idx = 0, even_idx = 0;
    for (int i = 0; i < s.length(); i++) {
        if (i % 2 == 0) result += odd_chars[odd_idx++];
        else result += even_chars[even_idx++];
    }
    return result;
}

char convertChar(char c) {
    if (c > 'f' && c <= 'z' || c > 'F' && c <= 'Z') {
        return c;
    }
    int val;
    if (isdigit(c)) {
        val = c - '0';
    } else {
        // 将字母转换为对应的十六进制值
        if (tolower(c) <= 'f') {
            string hex_str(1, c);
            val = stoi(hex_str, nullptr, 16);
        } else {
            val = tolower(c) - 'a';
        }
    }
    
    // 转为4位二进制并翻转
    string binary = bitset<4>(val).to_string();
    reverse(binary.begin(), binary.end());
    
    // 转回十六进制
    int reversed_val = bitset<4>(binary).to_ulong();
    if (reversed_val < 10) {
        return '0' + reversed_val;
    } else {
        return 'A' + (reversed_val - 10);
    }
}

string processString(const string& str1, const string& str2) {
    string merged = mergeStrings(str1, str2);
    string sorted = sortByPosition(merged);
    string result;
    for (char c : sorted) {
        result += convertChar(c);
    }
    return result;
}

int main() {
    string str1, str2;
    while (cin >> str1 >> str2) {
        cout << processString(str1, str2) << endl;
    }
    return 0;
}

import java.util.*;

public class Main {
    private static String mergeStrings(String str1, String str2) {
        return str1 + str2;
    }
    
    private static String sortByPosition(String s) {
        List<Character> oddChars = new ArrayList<>();
        List<Character> evenChars = new ArrayList<>();
        
        for (int i = 0; i < s.length(); i++) {
            if (i % 2 == 0) oddChars.add(s.charAt(i));
            else evenChars.add(s.charAt(i));
        }
        
        Collections.sort(oddChars);
        Collections.sort(evenChars);
        
        StringBuilder result = new StringBuilder();
        int oddIdx = 0, evenIdx = 0;
        for (int i = 0; i < s.length(); i++) {
            if (i % 2 == 0) result.append(oddChars.get(oddIdx++));
            else result.append(evenChars.get(evenIdx++));
        }
        return result.toString();
    }
    
    private static char convertChar(char c) {
        if (c > 'f' && c <= 'z' || c > 'F' && c <= 'Z') {
            return c;
        }
        int val;
        if (Character.isDigit(c)) {
            val = c - '0';
        } else {
            // 将字母转换为对应的十六进制值
            if (Character.toLowerCase(c) <= 'f') {
                val = Integer.parseInt(String.valueOf(c), 16);
            } else {
                val = Character.toLowerCase(c) - 'a';
            }
        }
        
        // 转为4位二进制并翻转
        String binary = String.format("%4s", Integer.toBinaryString(val)).replace(' ', '0');
        String reversed = new StringBuilder(binary).reverse().toString();
        
        // 转回十六进制
        int reversedVal = Integer.parseInt(reversed, 2);
        return reversedVal < 10 ? (char)('0' + reversedVal) : (char)('A' + (reversedVal - 10));
    }
    
    private static String processString(String str1, String str2) {
        String merged = mergeStrings(str1, str2);
        String sorted = sortByPosition(merged);
        StringBuilder result = new StringBuilder();
        for (char c : sorted.toCharArray()) {
            result.append(convertChar(c));
        }
        return result.toString();
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String str1 = sc.next();
            String str2 = sc.next();
            System.out.println(processString(str1, str2));
        }
    }
}