HJ18 识别有效的 IP 地址和掩码并进行分类统计

HJ18 识别有效的 IP 地址和掩码并进行分类统计

描述

请解析 IP 地址和对应的掩码，进行分类识别。要求按照 A/B/C/D/E 类地址归类，不合法的地址和掩码单独归类。

所有的 IP 地址划分为 A,B,C,D,E 五类

A类地址从1.0.0.0到126.255.255.255;

B类地址从128.0.0.0到191.255.255.255;

C类地址从192.0.0.0到223.255.255.255;

D类地址从224.0.0.0到239.255.255.255；

E类地址从240.0.0.0到255.255.255.255

私网 IP 范围是：

从10.0.0.0到10.255.255.255

从172.16.0.0到172.31.255.255

从192.168.0.0到192.168.255.255

子网掩码为二进制下前面是连续的 1，然后全是 0。（例如：255.255.255.32 就是一个非法的掩码）
（注意二进制下全是 1 或者全是 0 均为非法子网掩码）

注意：

1. 类似于【0...】和【127...】的 IP 地址不属于上述输入的任意一类，也不属于不合法 ip 地址，计数时请忽略
2. 私有 IP 地址和 A,B,C,D,E 类地址是不冲突的

输入描述：

多行字符串。每行一个 IP 地址和掩码，用~隔开。
请参考帖子https://www.nowcoder.com/discuss/276处理循环输入的问题。

输出描述：

统计 A、B、C、D、E、错误 IP 地址或错误掩码、私有 IP 的个数，之间以空格隔开。

示例 1

输入：
10.70.44.68~255.254.255.0
1.0.0.1~255.0.0.0
192.168.0.2~255.255.255.0
19..0.~255.255.255.0
输出：
1 0 1 0 0 2 1

说明：
10.70.44.68~255.254.255.0 的子网掩码非法，19…0.~255.255.255.0 的 IP 地址非法，所以错误 IP 地址或错误掩码的计数为 2；
1.0.0.1~255.0.0.0 是无误的 A 类地址；
192.168.0.2~255.255.255.0 是无误的 C 类地址且是私有 IP；
所以最终的结果为 1 0 1 0 0 2 1

示例 2

输入：
0.201.56.50~255.255.111.255
127.201.56.50~255.255.111.255
输出：
0 0 0 0 0 0 0

说明：
类似于【0...】和【127...】的 IP 地址不属于上述输入的任意一类，也不属于不合法 ip 地址，计数时请忽略

题解

import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            List <String> list = new ArrayList<>();
            int a = 0;
            int b = 0;
            int c = 0;
            int d = 0;
            int e = 0;
            int f = 0;
            int g = 0;
            // 多行字符串。每行一个IP地址和掩码，用~隔开。
            // 请参考帖子https://www.nowcoder.com/discuss/276处理循环输入的问题。
            while (sc.hasNextLine()) {
                String str = sc.nextLine();
                list.add(str);
            }
            for (String l : list) {
                // ip 地址
                String ip = l.split("~")[0];
                // 掩码
                String  ym = l.split("~")[1];

                String[] s1 = ip.split("\\.");
                String[] s2 = ym.split("\\.");


                int ip1 = Integer.parseInt(s1[0]);
                int ip2 = Integer.parseInt(s1[1]);
                // 类似于【0.*.*.*】和【127.*.*.*】的IP地址不属于上述输入的任意一类，也不属于不合法ip地址，计数时请忽略
                if (ip1 == 0 || ip1 == 127) {
                    continue;
                }


                // f  错误IP地址或者错误掩码
                //     子网掩码为二进制下前面是连续的1，然后全是0。（例如：255.255.255.32就是一个非法的掩码）
                //    （注意二进制下全是1或者全是0均为非法子网掩码）
                if (ipInvalid(s1)) {
                    f++;
                    continue;
                }
                if (maskInvalid(s2)) {

                    f++;
                    continue;
                }




                // A A类地址从1.0.0.0到126.255.255.255;
                if (ip1 >= 1 && ip1 <= 126  ) {
                    a++;
                }
                // B B类地址从128.0.0.0到191.255.255.255;
                if (ip1 >= 128 && ip1 <= 191) {
                    b++;
                }
                // C C类地址从192.0.0.0到223.255.255.255;
                if (ip1 >= 192 && ip1 <= 223) {
                    c++;
                }
                // D D类地址从224.0.0.0到239.255.255.255；
                if (ip1 >= 224 && ip1 <= 239) {
                    d++;
                }
                // E E类地址从240.0.0.0到255.255.255.255
                if (ip1 >= 240 && ip1 <= 255) {
                    e++;
                }



                // g 私网IP范围是：
                // 从10.0.0.0到10.255.255.255
                if (ip1 == 10) {
                    g++;
                }
                if (ip1 == 172 && ip2 >= 16 && ip2 <= 31) {
                    g++;
                }
                if ( ip1 == 192 && ip2 == 168) {
                    g++;
                }
                // 从172.16.0.0到172.31.255.255
                // 从192.168.0.0到192.168.255.255


            }

            // 统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数，之间以空格隔开。
            System.out.print(a + " ");
            System.out.print(b + " ");
            System.out.print(c + " ");
            System.out.print(d + " ");
            System.out.print(e + " ");
            System.out.print(f + " ");
            System.out.println(g);

        }

    }
    public static String addZero(String s) {
        while (s.length() < 8) {
            s = "0" + s;
        }
        return s;
    }
    public static boolean maskInvalid(String[] str) {
        if (str.length != 4) {
            return true;
        }
        // 二进制下前面全是1 后面是0
        String r1 = Integer.toBinaryString(Integer.parseInt(str[0]));
        String r2 = Integer.toBinaryString(Integer.parseInt(str[1]));
        String r3 = Integer.toBinaryString(Integer.parseInt(str[2]));
        String r4 = Integer.toBinaryString(Integer.parseInt(str[3]));
        // 补0
        r1 = addZero(r1);
        r2 = addZero(r2);
        r3 = addZero(r3);
        r4 = addZero(r4);
        String r = r1 + r2 + r3 + r4;
        if (!r.matches("[1]{1,}[0]{1,}")) {
            return true;
        }
        return false;

    }
    public static boolean ipInvalid(String[] str) {
        if (str.length != 4) {
            return true;
        }
        if (Integer.valueOf(str[0]) > 255 ||
                Integer.valueOf(str[1]) > 255 ||
                Integer.valueOf(str[2]) > 255 ||
                Integer.valueOf(str[3]) > 255
           ) {
            return true;
        }
        return false;
    }
}