华为机试题: IPv6地址压缩

题目

IPv6 的地址格式如下：
XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX的格式，它是128位的，用":"分成8段，每段包含4个X是一个16进制数(0-9,A-F),全部大写,如下就是一个IPv6地址：

IPv6地址一般较长，IPv6提供了一些规则来压缩地址，规则如下：
-规则1：丢弃前导零。
-规则2：如果两个或者多个块包含连续零，则省略它们，并用::替换。连续的零块只能被::替换一次，优先优化左侧的。如果地址中仍有零块，它们可以缩小到一个零。

补充规则

以下内容是IPv6的规则，原题中表述不清楚

②双冒号只能使用一次，因此我们压缩最长的全0组
比如：2001:0db8:0000:0000:1:0000:0000:0000
我们压缩为2001:db8:0:0:1::，而非2001:db8::1:0:0:0

③双冒号只能只用一次，因此我们在我们遇到地址中多个连续全0组长度相同时，我们压缩最前面的一个。
2001:0db8:0000:0000:ffff:0000:0000:1
压缩为2001:db8::ffff:0:0:1，而非2001:db8:0:0:ffff::1

测试用例

输入 2001:0000:3238:DFE1:0063:0000:0000:FEFB
输出 2001:0:3238:DFE1:63::FEFB

输入 0000:0000:0000:0000:0000:0000:0000:0000
输出 ::

输入 0000:0000:0000:0000:0000:0000:0000:0001
输出 ::1

输入 FF01:0000:0000:0000:0000:0000:0000:1101
输出 FF01::1101

输入 2001:0DB8:0000:0023:0008:0800:200C:417A
输出 2001:DB8:0:23:8:800:200C:417A

输入 2001:0db8:0000:0000:0001:0000:0000:0000
输出 2001:DB8:0:0:1::

输入 2001:0db8:0000:0000:ffff:0000:0000:0001
输出 2001:DB8::FFFF:0:0:1

代码

import java.util.Arrays;
import java.util.Scanner;
import java.util.StringJoiner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            String rawIpv6 = in.next();
            System.out.println(compressIpv6(rawIpv6));
        }
    }

    private static String compressIpv6(String rawIpv6) {
        if (rawIpv6.length() != 39) {
            return "error";
        }
        int[] segments = Arrays.stream(rawIpv6.split(":")).mapToInt(s -> Integer.valueOf(s, 16)).toArray();

        // 寻找连续零区间的下标
        int[] index = startIndexAndLengthOfContinuousZero(segments);
        int startIndex = index[0];
        int endIndex = index[0] + index[1] - 1;

        StringJoiner joiner = new StringJoiner(":");
        for (int i = 0; i < segments.length; i++) {

            if (segments[i] == 0 && i >= startIndex && i <= endIndex) {
                // 连续零的一部分
                if (i == 0 || i == segments.length - 1) {
                    // 如果是连续零下标是首个或者最后一个时，补空字符串
                    joiner.add("");
                }
                if (i == endIndex) {
                    // 表示连续零的压缩
                    joiner.add("");
                }
                continue;
            }
            joiner.add(Integer.toHexString(segments[i]) + "");
        }
        return joiner.toString().toUpperCase();
    }

    private static int[] startIndexAndLengthOfContinuousZero(int[] segments) {
        int maxZeroLen = 0;
        int zeroStart = -1;
        int subLen = 0;
        int subStart = -1;
        for (int i = 0; i < segments.length; i++) {
            if (segments[i] == 0) {
                if (subLen == 0) {
                    // 连续零的第一个零出现
                    subStart = i;
                }
                subLen++;
                if (subLen > maxZeroLen) {
                    // 连续串长度超过了原来的最大串, 覆写结果
                    maxZeroLen = subLen;
                    zeroStart = subStart;
                }
            } else {
                subLen = 0;
                subStart = -1;
            }
        }
        if (maxZeroLen > 1) {
            return new int[]{zeroStart, maxZeroLen};
        } else {
            // 仅有一个0不算连续零
            return new int[]{-1, 0};
        }
    }
}