(B卷,100分)- IPv4地址转换成整数（Java & JS & Python）

题目描述

存在一种虚拟IPv4地址，由4小节组成，每节的范围为0~255，以#号间隔，虚拟IPv4地址可以转换为一个32位的整数，例如：

• 128#0#255#255，转换为32位整数的结果为2147549183（0x8000FFFF）
• 1#0#0#0，转换为32位整数的结果为16777216（0x01000000）

现以字符串形式给出一个虚拟IPv4地址，限制第1小节的范围为1~128，即每一节范围分别为(1~128)#(0~255)#(0~255)#(0~255)，要求每个IPv4地址只能对应到唯一的整数上。

如果是非法IPv4，返回invalid IP

输入描述

输入一行，虚拟IPv4地址格式字符串

输出描述

输出一行，按照要求输出整型或者特定字符

备注

输入不能确保是合法的IPv4地址，需要对非法IPv4（空串，含有IP地址中不存在的字符，非合法的#分十进制，十进制整数不在合法区间内）进行识别，返回特定错误

用例

题目解析

本题主要注意异常情况的处理，有如下几种异常情况：

• IPv4存在空串，比如1##3#4
• IPv4存在非法字符，比如a#b#c#d
• IPv4组成部分不足，比如1#2#3
• IPv4组成部分的十进制整数，不再合法区间内，比如255#255#255#255

其中，对于存在非法字符的情况，可以转整型时抛出异常的捕获流程中处理。

2023.05.24

本题的Java语言需要注意，最后输出的数可能会超出int类型，因此需要使用Long.parseLong

2023.06.06

如果ip地址如下：

01#01#01#01

应该也要算作非法

Java算法源码

import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println(getResult(sc.nextLine()));
  }

  public static String getResult(String s) {
    String[] ip = s.split("#");

    // ip地址由四部分组成，少于或多于四部分都不合法
    if (ip.length != 4) return "invalid IP";

    // 如果ip地址四部分某部分不合法，则ip不合法
    if (!isValid(ip[0], 1, 128)
        || !isValid(ip[1], 0, 255)
        || !isValid(ip[2], 0, 255)
        || !isValid(ip[3], 0, 255)) {
      return "invalid IP";
    }

    // 这里需要转为long，某些情况使用int会整型溢出
    return Long.parseLong(
            getHexString(ip[0]) + getHexString(ip[1]) + getHexString(ip[2]) + getHexString(ip[3]),
            16)
        + "";
  }

  // ip组成是否合法
  public static boolean isValid(String s, int from, int to) {
    // 如果包含非数字字符，则不合法
    if (!s.matches("^\d+$")) return false;

    // 如果包含前导0，则不和法，如012
    int num = Integer.parseInt(s);
    if (!s.equals(num + "")) return false;

    // 如果不是规定范围，则不合法
    return num >= from && num <= to;
  }

  // 获取十进制数字符串对应的十六进制数字符串
  public static String getHexString(String num) {
    String hexStr = Integer.toHexString(Integer.parseInt(num));
    // 补足前导0
    if (hexStr.length() < 2) hexStr = "0" + hexStr;
    return hexStr;
  }
}

JS算法源码

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

rl.on("line", (line) => {
  console.log(getResult(line));
});

function getResult(s) {
  const ip = s.split("#");

  // ip地址由四部分组成，少于或多于四部分都不合法
  if (ip.length != 4) {
    return "invalid IP";
  }

  // 如果ip地址四部分某部分不合法，则ip不合法
  if (
    !isValid(ip[0], 1, 128) ||
    !isValid(ip[1], 0, 255) ||
    !isValid(ip[2], 0, 255) ||
    !isValid(ip[3], 0, 255)
  ) {
    return "invalid IP";
  }

  // JS的数值安全范围最大时2^53，因此不用担心整型溢出问题
  return parseInt(
    getHexStr(ip[0]) + getHexStr(ip[1]) + getHexStr(ip[2]) + getHexStr(ip[3]),
    16
  );
}

// ip组成是否合法
function isValid(s, from, to) {
  // 如果包含非数字字符，则不合法
  if (/[^0-9]/.test(s)) return false;

  // 如果包含前导0，则不和法，如012
  const num = parseInt(s);
  if (num + "" != s) return false;

  // 如果不是规定范围，则不合法
  return num >= from && num <= to;
}

// 获取十进制数字符串对应的十六进制数字符串
function getHexStr(s) {
  let hexStr = parseInt(s).toString(16);
  // 补足前导0
  if (hexStr.length < 2) hexStr = "0" + hexStr;
  return hexStr;
}

Python算法源码

# 输入获取
s = input()


# 获取十进制数字符串对应的十六进制数字符串
def getHexString(num):
    tmp = hex(int(num))[2:]
    # 补足前导0
    if len(tmp) == 1:
        tmp = "0" + tmp
    return tmp


# ip组成是否合法
def isValid(ipSub, start, end):
    # 如果包含非数字字符，则不合法
    if not ipSub.isdigit():
        return False

    # 如果包含前导0，则不和法，如012
    num = int(ipSub)
    if str(num) != ipSub:
        return False

    # 如果不是规定范围，则不合法
    return start <= num <= end


# 算法入口
def getResult():
    ip = s.split("#")

    # ip地址由四部分组成，少于或多于四部分都不合法
    if len(ip) != 4:
        return "invalid IP"

    # 如果ip地址四部分某部分不合法，则ip不合法
    if not isValid(ip[0], 1, 128) or not isValid(ip[1], 0, 255) or not isValid(ip[2], 0, 255) or not isValid(ip[3], 0, 255):
        return "invalid IP"

    # python支持大数，不需要担心整型溢出
    return str(int(getHexString(ip[0]) + getHexString(ip[1]) + getHexString(ip[2]) + getHexString(ip[3]), 16))


# 算法调用
print(getResult())