華為機試題: 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};
        }
    }
}