牛客 HJ39 判断两个IP是否属于同一子网

Posted 2022-09-01 顧棟

描述

IP地址是由4个0-255之间的整数构成的，用"."符号相连。
二进制的IP地址格式有32位，例如：10000011，01101011，00000011，00011000;每八位用十进制表示就是131.107.3.24
子网掩码是用来判断任意两台计算机的IP地址是否属于同一子网络的根据。
子网掩码与IP地址结构相同，是32位二进制数，由1和0组成，且1和0分别连续，其中网络号部分全为“1”和主机号部分全为“0”。
你可以简单的认为子网掩码是一串连续的1和一串连续的0拼接而成的32位二进制数，左边部分都是1，右边部分都是0。
利用子网掩码可以判断两台主机是否在同一子网中。
若两台主机的IP地址分别与它们的子网掩码进行逻辑“与”运算（按位与/AND）后的结果相同，则说明这两台主机在同一子网中。

示例：
IP地址　 192.168.0.1
子网掩码　 255.255.255.0
转化为二进制进行运算：
I P 地址　 11000000.10101000.00000000.00000001
子网掩码　11111111.11111111.11111111.00000000
AND运算 11000000.10101000.00000000.00000000
转化为十进制后为：
192.168.0.0

IP地址　 192.168.0.254
子网掩码　 255.255.255.0
转化为二进制进行运算：
IP地址　11000000.10101000.00000000.11111110
子网掩码 11111111.11111111.11111111.00000000
AND运算 11000000.10101000.00000000.00000000
转化为十进制后为：
192.168.0.0

通过以上对两台计算机IP地址与子网掩码的AND运算后，我们可以看到它运算结果是一样的。均为192.168.0.0，所以这二台计算机可视为是同一子网络。

输入一个子网掩码以及两个ip地址，判断这两个ip地址是否是一个子网络。
若IP地址或子网掩码格式非法则输出1，若IP1与IP2属于同一子网络输出0，若IP1与IP2不属于同一子网络输出2。

注:
有效掩码与IP的性质为：

1. 掩码与IP每一段在 0 - 255 之间
2. 掩码的二进制字符串前缀为网络号，都由‘1’组成；后缀为主机号，都由’0’组成

输入描述：
3行输入，第1行是输入子网掩码、第2，3行是输入两个ip地址
题目的示例中给出了三组数据，但是在实际提交时，你的程序可以只处理一组数据（3行）。

输出描述：
若IP地址或子网掩码格式非法则输出1，若IP1与IP2属于同一子网络输出0，若IP1与IP2不属于同一子网络输出2

示例1

输入：
255.255.255.0
192.168.224.256
192.168.10.4
255.0.0.0
193.194.202.15
232.43.7.59
255.255.255.0
192.168.0.254
192.168.0.1

输出：
1
2
0

说明：
对于第一个例子:
255.255.255.0
192.168.224.256
192.168.10.4
其中IP:192.168.224.256不合法，输出1

对于第二个例子:
255.0.0.0
193.194.202.15
232.43.7.59
2个与运算之后，不在同一个子网，输出2

对于第三个例子，2个与运算之后，如题目描述所示，在同一个子网，输出0

java 实现

package nowcoder.x3x;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class HJ039 
    /**
     * 验证子网掩码
     */
    private static boolean isValidMask(String mask) 
        if (!isValidIp(mask)) 
            return false;
        
        String[] maskTable = mask.split("\\\\.");
        StringBuilder sb = new StringBuilder();
        // 将mask转为32位二进制字符串
        for (int i = 0; i < maskTable.length; i++) 
            maskTable[i] = Integer.toBinaryString(Integer.parseInt(maskTable[i]));
            if (maskTable[i].length() < 8) 
                //不足8位补齐0
                for (int j = 0; j < 8 - maskTable[i].length(); j++) 
                    sb.append("0");
                
            
            sb.append(maskTable[i]);
        
        // 最后一个1在第一个0之前，有效，否则无效
        return sb.toString().lastIndexOf("1") < sb.toString().indexOf("0");
    

    /**
     * 检验IP
     */
    private static boolean isValidIp(String ip) 
        String[] ipTable = ip.split("\\\\.");
        if (ipTable.length != 4) 
            return false;
        
        for (String s : ipTable) 
            if ("".equals(s) || Integer.parseInt(s) < 0 || Integer.parseInt(s) > 255) 
                return false;
            
        
        return true;
    

    public static void main(String[] args) throws IOException 
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String str;
        while (null != (str = bf.readLine())) 
            if (isValidMask(str)) 
                String ip1 = bf.readLine();
                String ip2 = bf.readLine();
                if (!isValidIp(ip1) || !isValidIp(ip2)) 
                    System.out.println("1");
                    continue;
                
                String[] arr = str.split("\\\\.");
                String[] ip1Arr = ip1.split("\\\\.");
                String[] ip2Arr = ip2.split("\\\\.");

                if ((Integer.parseInt(arr[0]) & Integer.parseInt(ip1Arr[0])) ==
                        (Integer.parseInt(ip2Arr[0]) & Integer.parseInt(arr[0]))
                        && (Integer.parseInt(arr[1]) & Integer.parseInt(ip1Arr[1])) ==
                        (Integer.parseInt(ip2Arr[1]) & Integer.parseInt(arr[1]))
                        && (Integer.parseInt(arr[2]) & Integer.parseInt(ip1Arr[2])) ==
                        (Integer.parseInt(ip2Arr[2]) & Integer.parseInt(arr[2]))
                        && (Integer.parseInt(arr[3]) & Integer.parseInt(ip1Arr[3])) ==
                        (Integer.parseInt(ip2Arr[3]) & Integer.parseInt(arr[3]))
                ) 
                    System.out.println("0");
                 else 
                    System.out.println("2");
                
             else 
            	// 本组的子网不正确，将剩下两个ip直接过滤掉
                bf.readLine();
                bf.readLine();
                System.out.println("1");
            
        
        bf.close();