总结说明：这里使用到字符串快速拼接StringBuild，如果可以确定拼接长度的话，建议创建的时候就初始化好空间，减少频繁扩容操作。

算法题二：校验和

内容中每个字节用2位十六进制数字表达，处理规则如下：

(1) 待校验和字节长度不是4的倍数，就在尾部加0xFF字节补齐成4的倍数，最多可加3字节；

(2) 若补齐后是4的倍数，那么除以4得到一个正整数n

1)n=1,那么补齐后的校验和就是结果(16进制)

2)n>1,先取开头4字节与第5~8字节进行异或运算，然后得到的结果再与随后4字节进行异或运算，直到最后，得到的结果就是校验和(16进制4字节)。

例子1：

输入：43 66 53 74 34 39 42 2A 21 AC 11

输出：56F300A1

说明：1)输入报文长度是11，那么补齐4的倍数为43 66 53 74 34 39 42 2A 21 AC 11 FF，倍数n=3 >1

2)每次取4个字节，第一个0x43665374，与第二个0x3439422A，异或运算结果为0x775f115e，再与第三个0x21AC11FF异或运算结果为0x56F300A1，那么最终输出结果为56F300A1。

例子2：

输入：32

输出：32FFFFFF

说明：1)输入报文长度是1，那么补齐4的倍数为32 FF FF FF，倍数n=1==1，那么得到的校验和即为32FFFFFF。

解题思路：

1)考点是16进制异或运算

2)每4个字节进行异或运算，注意数值前面要加0x表示16进制。

 1     public static void getResult(String s) {2         int len = s.length();3         int n = len % 8 == 0 ? len >> 3 : (len >> 3) + 1;4         String resTmp = StringUtils.rightPad(s, n<<3, "F");5         if (n == 1) {6             System.out.println(resTmp);7         } else {8             String tmp = resTmp.substring(0, 8);9             for (int i=1; i< n; i++) {
10                 int idx = i << 3;
11                 tmp = Integer.toHexString(Integer.valueOf(tmp,16) ^ Integer.valueOf(resTmp.substring(idx, idx+8),16));
12             }
13             System.out.println(StringUtils.leftPad(tmp, 8, "0").toUpperCase());
14         }
15     }

总结说明：

(1) 这里使用到>>移位操作符，其实>>3意义就是除以8，每移一位就是2的次幂。含义可详见前面进制知识。总结说明：

(2) 还用到或运算^和java中进制相互转换的方法。

(3)字符串左补齐leftPad或者右补齐rightPad方法，再JDK中是不存在，需要添加相应的jar包才可以实现，当然，也可以自己实现方法。

算法题三：编码格式处理

题目大概意思是这样的，一个特殊的编码格式，各字节按照以下规则：

1)单字节(n=1)，字节第一位0，其余为有效位

2)多字节(n>1且n<=6)，第一个字节前n位都为1，第n+1位为0；后面每个字节前2位都为10，其余是有效位。

二进制规则格式如下：

N=1：0xxxxxxx

N=2：110xxxxx 10xxxxxx

N=3：1110xxxx 10xxxxxx 10xxxxxx

…

N=6：1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx

其中x表示有效位，从左边开始将所有字节有效位拼接，形成的十进制为结果。

若合法，返回该字符的结果；否则，返回-1。

例子1：

输入：F1B180A5

输出：462885

说明：1)输入长度为n=3，第一字节E9为11101001，第二个字节80为10000000，第三个字节A5为10100101。

那么二进制表示：11110001 10110001 10000000 10100101

有效位拼接为：1001 000000 100101 ，那么十进制为462885。

例子2：

输入：C1C2

输出：-1

说明：1)输入长度为n=2，第一个字节C0为11000001，第二个字节C0为11000010

那么二进制表示：11000001 11000010，那么第二位不是10开头，不合法。

解题思路：

1)判断：取出某几位方法使用按位与运算，把无关的位都置成0，然后用移位操作把几个需要的位移到最低位置。

2)输出：把几个位的数据复制到待输出数据的指定位置上，则可先统移位操作把几个位移到对应位置，然后通过按位或运算是的结果包含这几个位。这种也可以使用字符串截取、拼接完成得到结果。

 1     public static void getResult(String s) {2         int len = s.length();3         int n = len % 8 == 0 ? len >> 3 : (len >> 3) + 1;4         String resTmp = StringUtils.rightPad(s, n<<3, "F");5         if (n == 1) {6             System.out.println(resTmp);7         } else {8             String tmp = resTmp.substring(0, 8);9             for (int i=1; i< n; i++) {
10                 int idx = i << 3;
11                 tmp = Integer.toHexString(Integer.valueOf(tmp,16) ^ Integer.valueOf(resTmp.substring(idx, idx+8),16));
12             }
13             System.out.println(StringUtils.leftPad(tmp, 8, "0").toUpperCase());
14         }
15     }

思路二： 

可以使用进制与或运算，消除无效位置数字

1)消除有效位，只保留首位几个判断位，分别进行判断，是否合规；

2)消除判断位，保留有效位，拼接得到最终结果。

 1     public static int getEncode(String encode) {2         int len = encode.length() >> 1;3         int byteNum = len;4         String tmpEncode = encode;5         StringBuilder sb = new StringBuilder(48);6         while (byteNum > 0) {7             Integer tmp = Integer.valueOf(tmpEncode.substring((byteNum - 1) << 1), 16);8             if (byteNum == 1) {9                 Integer subTmp = Integer.valueOf((tmp & ((1 << len) - 1) << (8 - len))) >> (7 - len);
10                 if (subTmp != (((1 << len) - 1) << 1)) {
11                     return -1;
12                 }
13                 sb.insert(0, Integer.toBinaryString(tmp & ((1 << (7 - len)) - 1)));
14             } else {
15                 Integer subTmp = Integer.valueOf((tmp & ((1 << 7) | (1 << 6))) >> 6);
16                 if (subTmp != 2) {
17                     return -1;
18                 }
19                 sb.insert(0, strRightPad(Integer.toBinaryString(tmp & ((1 << 6) - 1)), 6, '0'));
20             }
21             tmpEncode = tmpEncode.substring(0, (byteNum - 1) << 1);
22             byteNum--;
23         }
24         return Integer.valueOf(sb.toString(), 2);
25     }
26 
27     private static String strRightPad(String str, int size, char cha) {
28         if (str == null || str.length() >= size) {
29             return str;
30         }
31         StringBuilder sb = new StringBuilder();
32         char[] chars = str.toCharArray();
33         int idx = str.length();
34         for (int i = size; i > 0; i--) {
35             if (idx > 0) {
36                 sb.insert(0, chars[i - 1]);
37                 idx--;
38             } else {
39                 sb.insert(0, cha);
40             }
41         }
42         return sb.toString();
43     }

拓展延伸题： 

算法题目三，是先判断字符是否满足特殊格式要求，满足后提取有效位进行拼接获取结果。然而，如果现在提供有效位，按照这种特殊格式进行拼接，获取拼接后的结果该如何做？

题目大概意思差不多：

1)单字节(n=1)，字节第一位1，其余为有效位

2)多字节(n>1且n<=6)，第一个字节前n位都为0，第n+1位为1；后面每个字节前2位都为01，其余是有效位。

二进制规则格式如下：

N=1：1xxxxxxx

N=2：001xxxxx 01xxxxxx

N=3：0001xxxx 01xxxxxx 01xxxxxx

…

N=6：0000001x 01xxxxxx 01xxxxxx 01xxxxxx 01xxxxxx 01xxxxxx

输入10进制数据，输出16进制结果(偶数位)，不足首位补0(即：右对齐，左侧补0)

例子1：

输入：34625

输出：185d41

解释：

字符34625按照特殊格式处理的编码需要3个字节：把它转化为2进制1000011101000001，那么按照规则依次填充有效位，如下：

34625： 1000 011101 000001

填充：  00011000 01011101 01000001

那么填充后结果为：185d41

那么该题如何解答呢？如果是按照字节截取再拼接的话，判断逻辑的代码会很多，圈度复杂度肯定很大，最好的方式可以借鉴题三的第二个思路解答，逻辑处理非常简单，大家可以试试。欢迎留言，给出你们的答案。如有需要答案，也可联系我。

更多精彩关注wx公众号：