华为OJ——字符串合并处理

题目描述

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

• 详细描述：

  将输入的两个字符串合并。
  对合并后的字符串进行排序，要求为：下标为奇数的字符和下标为偶数的字符分别从小到大排序。这里的下标意思是字符在字符串中的位置。
  对排序后的字符串进行操作，如果字符为‘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”
  接口设计及说明：
  /*
  功能:字符串处理
  输入:两个字符串,需要异常处理
  输出:合并处理后的字符串，具体要求参考文档
  返回:无
  */
  void ProcessString(char* str1,char str2,char strOutput)
  {
  }

• 输入描述:

  输入两个字符串

• 输出描述:

  输出转化后的结果

• 示例1

  输入
  dec fab
  输出
  5D37BF

代码

package cn.c_shuang.demo30;

import java.util.Scanner;
/**
 * 字符串合并处理
 * @author Cshuang
 *
 */
public class Main {
    public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        while(in.hasNext()){
            String str1=in.next();
            String str2=in.next();
            System.out.println(processString(str1,str2));
        }
        in.close();
    }

    private static String processString(String str1, String str2) {
        String s=str1.concat(str2);
        char[] key=s.toCharArray();
        char temp;
        for (int i = 0; i < key.length-2; i++) {
            for (int j = i+2; j < key.length; j+=2) {
                if(key[i]>key[j]){
                    temp=key[j];
                    key[j]=key[i];
                    key[i]=temp;
                }
            }
        }
        StringBuilder sb=new StringBuilder();
        for (int i = 0; i < key.length; i++) {
            //key[i]>='a'&&key[i]<='f'||key[i]>='A'&&key[i]<='F'||key[i]>='0'&&key[i]<='9'
            if(String.valueOf(key[i]).matches("[A-Fa-f0-9]")){//用正则表达式判断是否在这个范围
                String binStr=Integer.toBinaryString(Integer.valueOf(String.valueOf(key[i]),16));
                if(binStr.length()<4){
                    String res="";
                    //当十进制数值在1-7范围时，转换为二进制时，首位为0，会省略
                    //如1则二进制为0001,但实际上binStr为1而不是0001，所以需要补0
                    for(int j=0;j<4-binStr.length();j++){
                        res+="0";
                    }
                    binStr=res+binStr;
                }
                binStr=rever(binStr);
                //Integer.valueOf(binStr,2)可写成Integer.parseInt(binStr,2)
                String hexStr=Integer.toHexString(Integer.valueOf(binStr,2));
                //判断是否在A-F范围或者在a-f
                if(hexStr.matches("[A-Fa-f]")){//String.valueOf(str[i]).matches("[0-9]")
                    hexStr=hexStr.toUpperCase();
                }
                sb.append(hexStr);
            }else{
                sb.append(key[i]);
            }
        }
        return sb.toString();
    }

    //直接将字符串当做整体放进StringBuilder,而不需要经过循环一位一位的放进去
    private static String rever(String binStr) {
        StringBuilder sb=new StringBuilder();
        return sb.append(binStr).reverse().toString();
    }
}

• 注意
  ①正则表达式来判断范围极大的简化代码量如：String.valueOf(key[i]).matches(“[A-Fa-f0-9]”)
  ②十进制转换为二进制，首位为0，会默认去掉，所以转换完后，需要补零
  ③Integer.valueOf的灵活使用