首页 > 试题广场 >

字符串合并处理

[编程题]字符串合并处理
  • 热度指数:189116 时间限制:C/C++ 1秒,其他语言2秒 空间限制:C/C++ 32M,其他语言64M
  • 算法知识视频讲解

按照指定规则对输入的字符串进行处理。

详细描述:

第一步:将输入的两个字符串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"。


数据范围:输入的字符串长度满足



输入描述:

样例输入两个字符串,用空格隔开。



输出描述:

输出转化后的结果。

示例1

输入

dec fab

输出

5D37BF
示例2

输入

ab CD

输出

3B5D

说明

合并后为abCD,按奇数位和偶数位排序后是CDab(请注意要按ascii码进行排序,所以C在a前面,D在b前面),转换后为3B5D          
示例3

输入

123 15

输出

88C4A

提供一下我的python解法,比较简单易懂吧。

while True:
    try:

        dic = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"]
        s = input().replace(" ", "")  #s是输入的合并后的字符串
        ss = ""  #ss为最终返回的字符串
        odd, even = "", ""  # 字符串的奇数子串和偶数子串
        # 经过下面的循环,提取奇数与偶数的子串。
        for i, v in enumerate(s):
            if i % 2 == 0:
                even += v
            else:
                odd += v
        # 奇数与偶数部分排序        
        odd = "".join(sorted(odd))
        even = "".join(sorted(even))

        # 如果字符串在0123456789abcdefABCDEF范围内,对其做变换,否则不做任何处理。
        for i in range(len(even)):
            if even[i] in "0123456789abcdefABCDEF":
                ss += dic[int(bin(dic.index(even[i].upper())).replace("0b", "").rjust(4, "0")[::-1], 2)]
            else:
                ss += even[i]
            if len(odd) != i:   #注意偶数串可能比奇数串长一个字符,所以要做一下判断。
                if odd[i] in "0123456789abcdefABCDEF":
                    ss += dic[int(bin(dic.index(odd[i].upper())).replace("0b", "").rjust(4, "0")[::-1], 2)]
                else:
                    ss += odd[i]
        print(ss)
    except:
        break
编辑于 2017-09-07 21:56:39 回复(15)
try:
    while True:
        alphabet = '0123456789ABCDEF'
        string = list(input().replace(' ',''))
        temp1 = sorted(string[::2])
        temp2 = sorted(string[1::2])
        temp = []
        while temp1 or temp2:
            if temp1:
                temp.append(temp1.pop(0))
            if temp2:
                temp.append(temp2.pop(0))
        result = ''
        for i in temp:
            if i.isdigit():
                result += alphabet[int('{:0>4}'.format(bin(int(i))[2:])[::-1],2)]
            elif 'a' <= i <= 'f' or 'A' <= i <= 'F':
                i = ord(i.upper())-55
                result += alphabet[int('{:0>4}'.format(bin(i)[2:])[::-1],2)]
            else:
                result += i
        print(result)

except Exception:
    pass
编辑于 2018-11-06 09:34:01 回复(1)
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;

const string ss = "abcedfABCEDF0123456789";
const string sa = "5D37BF5D37BF084C2A6E19";

string DealWith_str(string str)
{
	string s1, s2;
	string s;
	for (int i = 0; i < str.length();++i)
	{
		if (i & 0x1) s1 += str[i]; //s1 j shu
		else s2 += str[i];  //s2 o shu
	}


	sort(s1.begin(),s1.end());
	sort(s2.begin(), s2.end());
	
	
	for (int i = 0; i < str.length()/2;++i)
	{
		s += s2[i];
		s += s1[i];
	}
	
	if (s2.length()>s1.length()) s += s2[s2.length()-1];

	for (int i = 0; i<s.length();++i)
	{
		for (int j = 0; j <22 ;++j)
		{
			if (s[i] == ss[j]) 
			{
				s[i] = sa[j];
				break;
			}
		}
	}

	return s;
}
int main()
{
	string s1;
	string s2;
	while (cin>>s1>>s2)
	{
		string s3 = s1 + s2;
		s3 = DealWith_str(s3);
		cout << s3 << endl;
	}

	//system("pause");
	return 0;
}


发表于 2017-09-15 19:25:57 回复(0)
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
/*
功能:字符串处理
输入:两个字符串,需要异常处理
输出:合并处理后的字符串,具体要求参考文档
返回:无
*/

/* 方法一:非查表法
// 化为16进制数,位反转,转换为字符.不在范围内的字符,原样输出
char dochange(char ch)
{
  char temp = ch;

  int num = -1;
  if(ch >= '0' && ch <= '9')
      num = ch - '0';
    else if( (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F'))
      num = tolower(ch) - 'a' + 10;
  if(num != -1)
  {
      int bit[4];   // 16以内,4位
      for(int i = 0; i < 4; i++)
      {
            bit[i] = num%2;  // 从下标0开始存,已经反转了
            num /= 2;
      }
      num = bit[0]*8 + bit[1]*4 + bit[2]*2 + bit[3]*1;  // 这个数的范围是在0-16之间,用16进制表示它
      if(num <= 9 && num >= 0)
         temp  =  num + '0';
      else if (num >= 10 && num <= 16)
         temp = 'A' + num - 10;
  }
  return temp;
}
*/

// 方法2
// 化为16进制数,位反转,转换为字符, 不在范围的字符不需要处理,保持原样
char dochange(char ch)
{
    char temp = ch;
  switch(ch)
            {
                case '0':
                    temp = '0';
                    break;
                case '1':
                    temp = '8';
                    break;
                case '2':
                    temp = '4';
                    break;
                case '3':
                    temp = 'C';
                    break;
                case '4':
                    temp = '2';
                    break;
                case '5':
                    temp = 'A';
                    break;
                case '6':
                    temp = '6';
                    break;
                case '7':
                    temp = 'E';
                    break;
                case '8':
                    temp = '1';
                    break;
                case '9':
                    temp = '9';
                    break;
                case 'a':
                case 'A':
                     temp = '5';
                    break;
                case 'b':
                case 'B':
                     temp = 'D';
                    break;
                case 'c':
                case 'C':
                     temp = '3';
                    break;
                case 'd':
                case 'D':
                     temp = 'B';
                    break;
                case 'e':
                case 'E':
                     temp = '7';
                    break;
                case 'f':
                case 'F':  
                     temp = 'F';
                    break;
                default:
                    break;
            }
    return temp;
}


void ProcessString(string str1,string str2,string & strOutput)
{
    // 合并排序
    strOutput = str1 + str2;
    str1 = "";
    str2 = "";
    int totsize = strOutput.size();
    for(int i = 0; i < totsize; i++)
    {
        if(i%2 == 0)
            str1 += strOutput[i];
        else
            str2 += strOutput[i];
    }
    sort(str1.begin(),str1.end());
    sort(str2.begin(),str2.end());
    int i1 = 0, i2 = 0;
    for(int i = 0; i < totsize; i++)
    {
        if(i%2 == 0)
        {
            strOutput[i] = str1[i1];
            i1++;
        }
        else
        {
            strOutput[i] = str2[i2];
            i2++;
        }
    }
    
    // 转换为相应的大写字母
    for(int i = 0; i < totsize; i++)
    {
        strOutput[i] = dochange(strOutput[i]);
    }
}

int main()
{
    string s1;
    string s2;
    while(cin >> s1 >> s2)
    {
        string strOutput = "";
        ProcessString(s1,s2,strOutput);
        cout << strOutput << endl;
    }
}

编辑于 2017-07-03 10:06:36 回复(1)

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
发表于 2021-08-16 16:52:21 回复(3)
这道题感觉出的有点憨憨,绕来绕去的
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

/**
 * @author Yuliang.Lee
 * @version 1.0
 * @date 2021/9/8 12:25
 * 字符串合并处理:
    将输入的两个字符串合并。
    对合并后的字符串进行排序,要求为:下标为奇数的字符和下标为偶数的字符分别从小到大排序。这里的下标意思是字符在字符串中的位置。
    对排序后的字符串进行操作,如果字符为‘0’——‘9’或者‘A’——‘F’或者‘a’——‘f’,则对他们所代表的16进制的数进行BIT倒序的操作,并转换为相应的大写字符。如字符为‘4’,为0100b,则翻转后为0010b,也就是2。转换后的字符为‘2’; 如字符为‘7’,为0111b,则翻转后为1110b,也就是e。转换后的字符为大写‘E’。

 * 举例:
    输入str1为"dec",str2为"fab",合并为“decfab”,分别对“dca”和“efb”进行排序,排序后为“abcedf”,
    转换后为“5D37BF”
 */
public class Main {
    public static void main(String[] args) {
        // 映射表的定义
        char[] mapped = new char[16];
        // 运行得到十六进制的转换映射结果
        for (int i = 0; i < 16; i++) {
            int result = Integer.parseInt(new StringBuilder(String.format("%04d", Integer.parseInt(Integer.toBinaryString(i)))).reverse().toString(), 2);
            // 转换为大写字母
            if (result >= 10 && result <= 15) {
                result += 55;
            }
            // 转换为字符型的数字
            else {
                result += 48;
            }
            mapped[i] = (char) result;
        }
        // 正式开始对题目的输入进行处理
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            String str = in.next().concat(in.next());
            // 偶数下标的字符 0,2,4,6...
            List<Character> list1 = new ArrayList<>();
            // 奇数下标的字符 1,3,5,7...
            List<Character> list2 = new ArrayList<>();
            for (int i = 0; i < str.length(); i = i + 2) {
                list1.add(str.charAt(i));
                if (i + 1 < str.length()) {
                    list2.add(str.charAt(i+1));
                }
            }
            // 完成奇偶两边的排序并再次合并
            Collections.sort(list1);
            Collections.sort(list2);
            char[] arr3 = new char[str.length()];
            int k = 0;
            for (int j = 0; j < str.length() / 2 + 1; j++) {
                if (j < list1.size()) {
                    arr3[k] = list1.get(j);
                }
                if (j < list2.size()) {
                    arr3[k + 1] = list2.get(j);
                }
                k += 2;
            }
            // 转十六进制,并做倒序处理(实际上对照映射表的缓存读取即可)
            for (int i = 0; i < arr3.length; i++) {
                if (arr3[i] >= '0' && arr3[i] <= '9') {
                    arr3[i] = mapped[arr3[i] - 48];
                } else if (arr3[i] >= 'A' && arr3[i] <= 'F') {
                    arr3[i] = mapped[arr3[i] - 55];
                } else if (arr3[i] >= 'a' && arr3[i] <= 'f') {
                    arr3[i] = mapped[arr3[i] - 87];
                }
                System.out.print(arr3[i]);
            }
            System.out.println();
        }
    }
}


发表于 2021-09-08 17:53:18 回复(0)
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);
        }
    }
}

发表于 2020-10-25 00:56:43 回复(1)
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
只想说,做了三个小时的题,最终还是选择了笨方法,聪明方法不会呀。
编辑于 2020-03-23 19:34:37 回复(2)
#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;
}


编辑于 2020-02-24 23:54:08 回复(0)
  1. ‘0’——‘9’或者‘A’——‘F’或者‘a’——‘f’之外的字符不做任何改变
  2. 对于转为二进制之后的字符串,如果长度不够4、四位,则需要在前面补四个0然后再从后往前剪切四位;例如‘4’转为二进制后为"100",则需要变成“0000100”然后再从后往前剪切出四位得到“0100”,再将“0100”反转得到“0010”,转为十进制后为‘2’;
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            String str=sc.next();
            str=str+sc.next();
            int len=str.length();
            char[] odd=new char[len/2];
            char[] even=new char[len/2+len%2];
            int index=0;
            for(int i=0;i<len;i++){
                if(i%2!=0){
                    odd[index]=str.charAt(i);//奇数
                    index++;
                }
            }
            index=0;
            for(int i=0;i<len;i++){
                if(i%2==0){
                    even[index]=str.charAt(i);//偶数
                    index++;
                }
            }
            Arrays.sort(odd);
            Arrays.sort(even);
            StringBuffer merge=new StringBuffer();
            merge.append(String.valueOf(even));
            index=0;
            for(int i=0;i<len;i++){
                if(i%2!=0){
                    merge.insert(i, odd[index]);//奇偶数组合并
                    index++;
                }
            }
            StringBuffer sb=new StringBuffer();
            for(int i=0;i<merge.length();i++){
                char cur=merge.charAt(i);
                sb.append(turn(cur));		
            }
            System.out.println(sb.toString());
        }
    }
    
    public static char turn(char cur1){
        char result=cur1;
        String temp="";
        if(cur1>='0'&&cur1<='9'){
            temp=Integer.toBinaryString(cur1-48);			
        }else if(cur1>='a'&&cur1<='f'){
            temp=Integer.toBinaryString(cur1-87);
        }else if(cur1>='A'&&cur1<='F'){
            temp=Integer.toBinaryString(cur1-55);
        }
        if(temp!=""){
            temp="0000"+temp;
            temp=temp.substring(temp.length()-4);
            StringBuffer sb=new StringBuffer();
            sb.append(temp);
            temp=sb.reverse().toString();
            int binToInt=Integer.parseInt(temp,2);
            if(binToInt<10){
                result=(char)(binToInt+48);
            }else{
                result=(char)(binToInt+55);
            }
        }
        return result;
    }

发表于 2019-09-07 10:03:50 回复(0)
#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
using namespace std;
int ch2num(char ch)
{
int num;
if (ch=='a'||ch=='A')
num=10;
else if (ch=='b'||ch=='B')
num=11;
else if (ch=='c'||ch=='C')
num=12;
else if (ch=='d'||ch=='D')
num=13;
else if (ch=='e'||ch=='E')
num=14;
else if (ch=='f'||ch=='F')
num=15;
else
num=ch-'0';
return num;
}
char num2ch(int num)
{
char ch;
if (num==10)
ch='A';
else if (num==11)
ch='B';
else if (num==12)
ch='C';
else if (num==13)
ch='D';
else if (num==14)
ch='E';
else if (num==15)
ch='F';
else
ch=num+'0';
return ch;
}
char revs(char ch)
{       //字符满足一定条件要进行转换
if(ch>='0'&&ch<='9' || ch>='A'&&ch<='F' || ch>='a'&&ch<='f')
{
int num=ch2num(ch);//字符对应的十六进制值
int ret=0;
int j=3;//十六进制只有4个bit位
while(num)
{
int b=num%2;
num/=2;

ret+=b*pow((double)2,(int)j);
--j;
}
ch=num2ch(ret);//位转换后值对应的字符

}
return ch;

}
int main()
{
string str1;
string str2;
while(cin>>str1>>str2)
{
string str=str1+str2;
vector<char> vec1;
vector<char> vec2;
string sstr;
for(int i=0;i<str.length();i++)
{
if(i%2==0)
vec1.push_back(str[i]);
else
vec2.push_back(str[i]);
}
sort(vec1.begin(),vec1.end());
sort(vec2.begin(),vec2.end());
while (!vec1.empty())//i最多比j大一个
{
sstr+=revs(vec1.front());
vec1.erase(vec1.begin());
if(!vec2.empty())
{
sstr+=revs(vec2.front());
vec2.erase(vec2.begin());
}
}
cout<<sstr;
}

return 0;
}

有问题的可以私信
发表于 2016-08-30 11:13:44 回复(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 "";
    }
}
发表于 2022-06-21 20:24:54 回复(0)
改了无数次终于写出来了
dic = {'a': '10', 'b': '11', 'c': '12', 'd':'13', 'e': '14', 'f': '15',
      '0':'0','1':'1','2':'2','3':'3','4':'4','5':'5','6':'6','7':'7',
      '8':'8','9':'9'}
strs = input().split(' ')
new_strs = strs[0] + strs[1]
odd, even = [], []
for i in range(len(new_strs)):
    if i%2 == 0:
        odd.append(new_strs[i])
    else:
        even.append(new_strs[i])
odd.sort()
even.sort()
s = ''
i, j = 0, 0
while i<len(odd) and j<len(even):
    s = s+odd[i]
    s = s+even[j]
    i = i+1
    j = j+1
if len(odd) != len(even):
    s= s+odd[-1]
result = ''
for char in s:
    if char in 'ABCDEF':
        char = char.lower()
    if char in dic:
        char =dic[char]
        char = bin(int(char))[2:]
    
        if len(char) < 4:
            char = '0'* (4-len(char)) +char
        char = str(int(char[::-1],2))
        for key, value in dic.items():
            if char == value:
                char = key.upper()
                result = result + str(char)
    else:
        result = result+char
print(result)


发表于 2022-06-16 03:39:32 回复(0)
这样的也能解吗
发表于 2022-03-17 19:35:00 回复(0)
题目读懂就不难了,重点在于要让二进制保留4位
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

发表于 2021-12-06 14:45:28 回复(0)
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;
    }
}

发表于 2021-11-17 12:45:54 回复(0)

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


#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;
}


发表于 2021-08-31 09:39:41 回复(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;
	}
}

发表于 2021-08-16 02:11:28 回复(0)
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();
        }
    }
}

发表于 2021-08-11 16:55:27 回复(0)
#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;
}

发表于 2021-07-15 15:18:04 回复(1)