精华内容
下载资源
问答
  • 笔记-TCP/IP IP地址字符串表示最大长度IPv4IPv6 IPv4 定义在 <netinet/in.h> 中: #define INET_ADDRSTRLEN 16 IPv4地址字符串表示: 192.168.100.100 32位(bits)IPv4地址,使用10进制+句点表示时,所占用...

    笔记-TCP/IP IP地址字符串表示最大长度

    IPv4

    定义在 <netinet/in.h> 中:

    #define INET_ADDRSTRLEN 16
    
    IPv4地址字符串表示: 192.168.100.100
    

    32位(bits)IPv4地址,使用10进制+句点字符串表示时,所占用的char数组的长度为16,包括最后一个NULL(‘\0’)结束符。

    IPv6

    定义在 <netinet/in.h> 中:

    #define INET6_ADDRSTRLEN 46
    

    128位(bits)IPv6地址,使用8组16进制字符串表示。

    IPv6地址字符串的几种长度较长的表示方式:

    表示方法 地址 长度 描述
    一般表示 ABCD:EF01:2345:6789:ABCD:EF01:2345:6789 40 = 8*4 + 7 + 1 8组4位,7个:,1个NULL
    混合表示 ABCD:EF01:2345:6789:ABCD:EF01:192.168.100.100 46 = 6*4 + 6 + 15 + 1 6组4位,6个:,IPv4,1个NULL

    46 here is to support ipv4-mapped-on-ipv6.

    展开全文
  • Java - 判断字符串是否为IP地址

    千次阅读 2020-08-06 12:07:34
    文章目录Java - 判断字符串是否为IP地址1、代码2、CommonUtils 工具类3、NumberUtils 工具类 Java - 判断字符串是否为IP地址 1、代码 主要就是这么几个条件 非空 长度符合 0.0.0.0 - 255.255.255.255 包含分隔符 ...

    Java - 判断字符串是否为IP地址


    1、代码

    主要就是这么几个条件

    • 非空
    • 长度符合 0.0.0.0 - 255.255.255.255
    • 包含分隔符 且 个数正确
    • 四个全部是数字,且都在合理的范围内
      /**
       * 判断某个字符串是否是一个 IP 地址
       *
       * @param str 字符串
       */
      public static boolean isIpStr(String str) {
        // 非空
        // boolean notBlank = StringUtils.isNotBlank(str);
        // 长度符合  0.0.0.0 - 255.255.255.255
        // boolean length = CommonUtils.isNumberBetween(str.length(),7,15);
    
        if (StringUtils.isNotBlank(str) && CommonUtils.isNumberBetween(str.length(), 7, 15)) {
          String regex = ".";
          // 包含分隔符 且 个数正确
          if (str.contains(regex) && str.split(regex).length == 4) {
            boolean legalNumber = true;
            // 四个全部是数字,且都在合理的范围内
            for (String obj : Lists.newArrayList(str.split(regex))) {
              if (NumberUtils.isDigit(obj)) {
                Integer value = Integer.parseInt(obj);
                legalNumber = CommonUtils.isNumberBetween(value, 0, 255);
              } else {
                // 任意一个不是数字,不合法
                legalNumber = false;
                break;
              }
            }
            return legalNumber;
          }
        }
        return false;
      }
    

    2、CommonUtils 工具类

    package cn.zjcs.common.util;
    
    import cn.hutool.core.util.ReUtil;
    import lombok.AccessLevel;
    import lombok.Getter;
    import lombok.NoArgsConstructor;
    
    import java.math.BigDecimal;
    import java.math.RoundingMode;
    
    /**
     * @author Created by 谭健 on 2019/6/11. 星期二. 15:20.
     * © All Rights Reserved.
     */
    
    @NoArgsConstructor(access = AccessLevel.PRIVATE)
    public class CommonUtils {
    
    
      /**
       * 是否为 null
       *
       * @param o
       * @return null返回 true
       */
      public static boolean isNull(Object o) {
        return o == null;
      }
    
      /**
       * 是否不为 null
       *
       * @param o
       * @return 不为 null 返回 true
       */
      public static boolean isNotNull(Object o) {
        return !isNull(o);
      }
    
      /**
       * 是否是0 ,
       *
       * @param bigDecimal
       * @return 0 返回true
       */
      public static boolean isZeroDecimal(BigDecimal bigDecimal) {
        return isNotNull(bigDecimal) && bigDecimal.compareTo(BigDecimal.ZERO) == 0;
      }
    
      /**
       * 是否不是 0
       *
       * @param bigDecimal
       * @return 不是0 返回true
       */
      public static boolean isNotZeroDecimal(BigDecimal bigDecimal) {
        return !isZeroDecimal(bigDecimal);
      }
    
      /**
       * 是否是 1
       *
       * @param bigDecimal
       * @return 是 1 返回true
       */
      public static boolean isOneDecimal(BigDecimal bigDecimal) {
        return isNotNull(bigDecimal) && bigDecimal.compareTo(BigDecimal.ONE) == 0;
      }
    
      /**
       * 是否不是 1
       *
       * @param bigDecimal
       * @return 不是 1 返回true
       */
      public static boolean isNotOneDecimal(BigDecimal bigDecimal) {
        return bigDecimal.compareTo(BigDecimal.ONE) != 0;
      }
    
      /**
       * 是否是 0 long
       *
       * @param l
       * @return 是 0 long 返回 true
       */
      public static boolean isZeroLong(Long l) {
        return l != null && l.equals(0L);
      }
    
      /**
       * 是否不是 0 long
       *
       * @param l
       * @return 不是 0 long 返回 true
       */
      public static boolean isNotZeroLong(Long l) {
        return !isZeroLong(l);
      }
    
      /**
       * 是否是 0 int
       *
       * @param l
       * @return 是 0 int 返回 true
       */
      public static boolean isZeroInt(Integer l) {
        return l != null && l.equals(0);
      }
    
      /**
       * 是否不是 0 int
       *
       * @param l
       * @return 不是 0 int 返回 true
       */
      public static boolean isNotZeroInt(Integer l) {
        return !isZeroInt(l);
      }
    
      /**
       * 两个 decimal 是否相等
       *
       * @param i
       * @param j
       * @return 相等返回 true
       */
      public static boolean isSameDecimal(BigDecimal i, BigDecimal j) {
        return i.compareTo(j) == 0;
      }
    
      /**
       * 第一个 decimal 是否大于 第二个 decimal
       *
       * @param i
       * @param j
       * @return 大于 返回true
       */
      public static boolean isDecimalGt(BigDecimal i, BigDecimal j) {
        return i.compareTo(j) > 0;
      }
    
      /**
       * 第一个 decimal 是否小于 第二个 decimal
       *
       * @param i
       * @param j
       * @return 小于 返回true
       */
      public static boolean isDecimalLt(BigDecimal i, BigDecimal j) {
        return i.compareTo(j) < 0;
      }
    
      /**
       * 特殊字符串处理
       *
       * @param character
       * @return
       */
      public static String replaceSpecialCharacter(String character) {
        String regEx = "[`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~!@#¥%……&*()——+|{}【】‘;:”“’。,、?]";
        return ReUtil.replaceAll(character, regEx, "");
      }
    
      /**
       * 数据分比切割
       * <p>
       * 比如 p 为 2,要做千分切割,则 h 值为 "1000.00"
       * 得到值为 0.002
       *
       * @param p 输入值
       * @param h 切割值
       * @return 切割后的值
       */
      public static BigDecimal percentFormat(Integer p, String h) {
        return new BigDecimal(String.valueOf(p)).divide(new BigDecimal(h), 4, RoundingMode.HALF_UP).setScale(4, BigDecimal.ROUND_HALF_UP);
      }
    
      public static boolean orEq(Object... o) {
        if (o.length < 2) {
          throw new NullPointerException("长度不足");
        }
        Object o1 = o[0];
        for (int i = 1; i < o.length - 1; i++) {
          if (o1.equals(o[i])) {
            return true;
          }
        }
        return false;
      }
    
      /**
       * 包含边界值
       *
       * @param number 检查值
       * @param min    最小
       * @param max    最大
       */
      public static boolean isNumberBetween(Number number, Number min, Number max) {
        return number.longValue() >= min.longValue() && number.longValue() <= max.longValue();
      }
    
    
      /**
       * 标准数学计算
       */
      @NoArgsConstructor(access = AccessLevel.PRIVATE)
      public static class Math {
    
        /**
         * 精确的表示分数的数学计算,因为使用double 等会丢失精度
         */
        @SuppressWarnings("rawtypes")
        @Getter
        public static class Fraction extends Number implements Comparable {
          private static final long serialVersionUID = 2330398718018182597L;
          /**
           * 定义分子
           */
          private long numerator = 0;
          /**
           * 定义分母
           */
          private long denominator = 1;
    
          public Fraction() {
            this(0, 1);
          }
    
          public Fraction(long numerator, long denominator) {
            long gcd = gcd(numerator, denominator);
            this.numerator = ((denominator > 0) ? 1 : -1) * numerator / gcd;
            this.denominator = java.lang.Math.abs(denominator) / gcd;
          }
    
          /**
           * 求最大公约数
           */
          private long gcd(long f, long s) {
            long fAbs = java.lang.Math.abs(f);
            long sAbs = java.lang.Math.abs(s);
            // 学术名称 Gcd
            int _Gcd = 1;
            // 欧几里德算法
            for (int i = 1; i <= fAbs && i <= sAbs; i++) {
              if (fAbs % i == 0 && sAbs % i == 0) {
                _Gcd = i;
              }
            }
            return _Gcd;
          }
    
          /**
           * 分数的加法
           *
           */
          public Fraction add(Fraction secondRational) {
            long n = numerator * secondRational.getDenominator() + denominator * secondRational.getNumerator();
            long d = denominator * secondRational.getDenominator();
            return new Fraction(n, d);
          }
    
          /**
           * 分数的减法
           *
           */
          public Fraction subtract(Fraction secondRational) {
            long n = numerator * secondRational.getDenominator() - denominator * secondRational.getNumerator();
            long d = denominator * secondRational.getDenominator();
            return new Fraction(n, d);
          }
    
          /**
           * 分数乘法
           *
           */
          public Fraction mulitiply(Fraction secondRational) {
            long n = numerator * secondRational.getNumerator();
            long d = denominator * secondRational.getDenominator();
            return new Fraction(n, d);
          }
    
          /**
           * 分数除法
           *
           */
          public Fraction divide(Fraction secondRational) {
            long n = numerator * secondRational.getDenominator();
            long d = denominator * secondRational.numerator;
            return new Fraction(n, d);
          }
    
          @Override
          public String toString() {
            if (denominator == 1) {
              return numerator + "";
            } else {
              return numerator + "/" + denominator;
            }
    
          }
    
          @SuppressWarnings("all")
          @Override
          public boolean equals(Object parm1) {
            return (this.subtract((Fraction) (parm1))).getNumerator() == 0;
          }
    
          @Override
          public int compareTo(Object o) {
            if ((this.subtract((Fraction) o)).getNumerator() > 0) {
              return 1;
            } else if ((this.subtract((Fraction) o)).getNumerator() > 0) {
              return -1;
            } else {
              return 0;
            }
    
          }
    
          @Override
          public double doubleValue() {
            return numerator * 1.0 / denominator;
          }
    
          @Override
          public float floatValue() {
            return (float) doubleValue();
          }
    
          @Override
          public int intValue() {
            return (int) doubleValue();
          }
    
          @Override
          public long longValue() {
            return (long) doubleValue();
          }
        }
    
    
        /**
         * @param dividend 被除数
         * @param divisor  除数
         * @param accuracy 精度
         */
        public static BigDecimal divide(BigDecimal dividend, BigDecimal divisor, int accuracy) {
          // 0 除以任何数 = 无穷大,任何数除以 0 无法除,都会抛出错误
          if (isZeroDecimal(divisor) || isZeroDecimal(dividend)) {
            return BigDecimal.ZERO;
          }
          return dividend.divide(divisor, 16, RoundingMode.HALF_UP).setScale(accuracy, RoundingMode.HALF_UP);
        }
    
        /**
         * @param f        .
         * @param s        .
         * @param accuracy 精度
         */
        public static BigDecimal multiply(BigDecimal f, BigDecimal s, int accuracy) {
          // 0 * 任何数 = 0
          if (isZeroDecimal(f) || isZeroDecimal(s)) {
            return BigDecimal.ZERO;
          }
          return f.multiply(s).setScale(accuracy, RoundingMode.HALF_UP);
        }
    
        /**
         * 开多次方根
         *
         */
        public static BigDecimal pow(BigDecimal f, BigDecimal s) {
          // 防止出现 Infinity 的情况
          if (isZeroDecimal(f) && isDecimalLt(s, BigDecimal.ZERO)) {
            return BigDecimal.ZERO;
          }
          return new BigDecimal(String.valueOf(java.lang.Math.pow(f.doubleValue(), s.doubleValue())));
        }
    
        /**
         * 获取分数值
         *
         */
        public static BigDecimal fraction(Fraction f) {
          long denominator = f.getDenominator();
          long numerator = f.getNumerator();
          return divide(new BigDecimal(String.valueOf(numerator)), new BigDecimal(String.valueOf(denominator)), 16);
        }
    
      }
    }
    
    

    3、NumberUtils 工具类

    package cn.zjcs.common.util;
    
    import lombok.AccessLevel;
    import lombok.NoArgsConstructor;
    
    import java.math.BigDecimal;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    /**
     * @author ..
     */
    @NoArgsConstructor(access = AccessLevel.PRIVATE)
    public class NumberUtils {
    
      private static final Pattern DIGIT_PATTERN = Pattern.compile("[0-9]*");
    
      /**
       * 判断 某个 decimal 是否等于 0
       *
       * @param decimal BigDecimal 数字
       * @return 等于0 返回 true
       */
      public static boolean isZeroDecimal(BigDecimal decimal) {
        return decimal == null || decimal.compareTo(BigDecimal.ZERO) == 0;
      }
    
      /**
       * 判断 某个 decimal 是否不等于 0
       *
       * @param decimal BigDecimal 数字
       * @return 不等于0 返回 true
       */
      public static boolean isNotZeroDecimal(BigDecimal decimal) {
        return decimal != null && decimal.compareTo(BigDecimal.ZERO) != 0;
      }
    
      /**
       * 判断一个字符串是否是数字
       *
       * @param var 字符串
       * @return 是数字返回 true
       */
      public static boolean isDigit(String var) {
        Matcher isNum = DIGIT_PATTERN.matcher(var);
        return isNum.matches();
      }
    
      public static boolean isEmptyNumber(Number number) {
        return number == null
                || number.intValue() == 0
                || number.longValue() == 0
                || number.doubleValue() == 0.00
                || number.byteValue() == 0
                || number.floatValue() == 0.0
                || number.shortValue() == 0;
      }
    
      public static boolean isNotEmptyNumber(Number number) {
        return !isEmptyNumber(number);
      }
    
      public static boolean isNotZeroLong(Long something) {
        if (something == null) {
          return false;
        }
        return !something.equals(0L);
      }
    }
    
    
    展开全文
  • IP地址字符串转无符号整型uint

    千次阅读 2015-09-01 11:26:57
    对于ip,就只有两个状态,要么是正在输入数字,要么是正在输入点,至于点和数字的个数以及数字大小等情况可以另外优化。 如果当前状态是正在输入数字,那么接下来的输入应该是数字,如果是数字则转入正在输入点的
    
    考虑到转换的过程是处理数字和点,可以使用自动机的思想;
    自动机的思想就是整一个状态-转移表,根据输入自动判断,
    说白了就是正则表达式,在同一个状态下,不同的输入会转到不同的状态上去。
    对于ip,就只有两个状态,要么是正在输入数字,要么是正在输入点,至于点和数字的个数以及数字大小等情况可以另外优化。
    如果当前状态是正在输入数字,那么接下来的输入应该是数字,如果是数字则转入正在输入点的状态,否则返回错误。
    如果当前的状态是正在输入点,则接下来的输入应该是点,如果是点则转入正在输入数字状态;如果是数字,
    则说明数字还未接受结束,继续接受,然后维持该状态;如果是结束符则结算,否则返回错误。
    
    
    #include <iostream>
    #include <string>
    using namespace std;
    
    #define IPLEN 16  // 设输入ip地址长度不超过16
    
    enum STATECODE    // 状态
    {
    	ERROR = -1,
    	SUCCESS,
    	READING_DOT,
    	READING_NUM
    };
    
    /* ip to unint
     * 一般返回一个int作为errorCode,真正的返回值放在参数里
     * para: ip,ip字符串; result,计算结果
     * return: ERROR & SUCCESS
     */
    int ipToUnint(char * ip, unsigned int & result)
    {
    	if(NULL == ip)
    	{
    		return ERROR;
    	}
    
    	unsigned int digit = 0; // ip地址的每个整数
    	int dotNum = 0;         // num of dot
    	int digitNum = 0;       // num of digit
    	char input = 0;         // 当前输入字符
    	int state = READING_NUM; // state
    
    	for(int i = 0; ; ++i)
    	{
    		input = ip[i];
    		if(state == READING_NUM) // 状态 reading num
    		{
    			if(input >= '0' && input <= '9')
    			{
    				state = READING_DOT;
    				digit = input - '0';
    			}else
    			{
    				return ERROR;
    			}
    		}else   // 状态 reading dot
    		{
    			if(input >= '0' && input <= '9')
    			{
    				digit = digit * 10 + (input-'0');
    				if(digit > 255 || digit < 0)
    				{
    					return ERROR;
    				}
    			}else if(input == '.')
    			{
    				if(dotNum == 3)
    				{
    					return ERROR;
    				}
    				++dotNum;
    				result = (result<<8) + digit;
    				digit = 0;
    				state = READING_NUM;
    			}else if(input == '\0')
    			{
    				if(dotNum != 3)
    				{
    					return ERROR;
    				}
    				result = (result<<8) + digit;
    				return SUCCESS;
    			}else
    			{
    				return ERROR;
    			}
    		}
    	}
    }
    
    void main()
    {
    	char ipStr[IPLEN] = {0};
    
    	string input = "";
    	cin>>input;
    	sscanf(input.c_str(), "%15s", ipStr);
    
    	unsigned int result = 0;
    	if(ipToUnint(ipStr, result) != ERROR)
    	{
    		printf("result: %d\n", result);
    	}else
    	{
    		printf("ERROR!\n");
    	}
    }
    
    展开全文
  • 数字字符串转化成 IP 地址

    千次阅读 2020-09-21 11:01:58
    现在有一个只包含数字的字符串,将该字符串转化成IP地址的形式,返回所有可能的情况。 例如: 给出的字符串为"25525511135", 返回["255.255.11.135", "255.255.111.35"](顺序没有关系) 示例 输入 "25525511135" ...

    数字字符串转化成 IP 地址

    1、参考资料

    https://www.nowcoder.com/practice/ce73540d47374dbe85b3125f57727e1e

    2、题目要求

    题目描述

    现在有一个只包含数字的字符串,将该字符串转化成IP地址的形式,返回所有可能的情况。

    例如:

    给出的字符串为"25525511135",

    返回["255.255.11.135", "255.255.111.35"](顺序没有关系)

    示例

    输入

    "25525511135"
    

    输出

    ["255.255.11.135","255.255.111.35"]
    

    3、代码思路

    深度优先搜索

    1. 这种题其实和迷宫问题类似,我当前搜寻的路径是否能组成有效的 IP 地址,必须要递归到最深层(递归到 IP 地址中最后一段地址),才能知道是否为有效的 IP 地址
    2. 每个地址段由 1~3 个数字组成,所以我们需要用个 for 循环来搜索这三种情况:for (int i = startIndex; i < startIndex + 3 && i < str.length(); i++) {,即该地址段可能由 1 个数字组成,也可能是 2 个,也有可能是 3
    3. 那么我们回过头来再想想,递归函数的形参到底需要什么参数呢?源字符串 String str 肯定需要,每一段 IP 地址都需要在源字符串中有个起始索引 int startIndex,还需要有个当前搜索路径记录每段的 IP 地址 List<String> paths,最后的结果(所有合法的 IP 地址)我们使用类变量 ArrayList<String> result 存储
    4. 我们定义 void restoreIpAddresses(String str, int startIndex, List<String> paths) { 函数,其目的是将数字字符串转换为 IP 地址,二话不说,写递归先写回溯条件:当凑出有效的 IP 地址回溯,即 paths.size() == 4 回溯;或者是当前的 IP 地址不符合要求时开始回溯(不在 0~255 范围之间,这点在写代码的过程中才能想得到)
    5. 每个 IP 地址段的长度可能为 1~3,所以我们需要搜索这三种可能性,使用 for 循环:if (paths.size() == 4) {,在 for 循环里面有一些细节要处理:如果当前 IP 地址段是最后一段,则直接截取字符串的剩余部分(str.substring(startIndex, str.length())),做合法性判断之后,直接跳出 for 循环(因为最后一段地址只有一种可能);否则按照正常处理逻辑,即使用循环变量 i+1 作为 IP 地址段的右边界(str.substring(startIndex, i + 1))
    6. 由于 List<String> paths 对象属于引用传递,所以整个递归过程中 paths 对象只有一份,我们在进入递归之前,将当前合法的 IP 地址段添加至 paths 中:paths.add(subNum.toString());;然后进入递归:restoreIpAddresses(str, i + 1, paths);;最后恢复现场:paths.remove(paths.size() - 1);。这都是写递归的套路啊,详细可以参考我的博客:组合总和全排列
    7. 还有就是之前说的:当前的 IP 地址不符合要求时开始回溯(不在 0~255 范围之间),因为这种情况下不能搜索出合法的 IP 地址,所以直接回溯至上一层,然后继续搜索

    4、代码实现

    代码

    class Solution {
        ArrayList<String> result = new ArrayList<>();
    
        public ArrayList<String> restoreIpAddresses(String str) {
            restoreIpAddresses(str, 0, new ArrayList<>());
            return result;
        }
    
        private void restoreIpAddresses(String str, int startIndex, List<String> paths) {
            // 当凑出有效的 IP 地址回溯,即 paths.size() == 4 回溯
            if (paths.size() == 4) {
                result.add(paths.get(0) + "." + paths.get(1) + "." + paths.get(2) + "." + paths.get(3));
                return;
            }
    
            // 每个 IP 地址段的长度可能为 1~3,所以我们需要搜索这三种可能性
            for (int i = startIndex; i < startIndex + 3 && i < str.length(); i++) {
                // 截取当前 IP 字符串
                String subStr = (paths.size() == 3) ? str.substring(startIndex, str.length()) : str.substring(startIndex, i + 1);
                // 解析当前 IP 地址值
                Integer subNum = Integer.parseInt(subStr);
                // 如果 IP 地址合法
                if (subNum >= 0 && subNum <= 255) {
                    // 将当前合法的 IP 地址段添加至 paths 中
                    paths.add(subNum.toString());
                    // 递归搜索
                    restoreIpAddresses(str, i + 1, paths);
                    // 恢复现场
                    paths.remove(paths.size() - 1);
                } else {
                    // 当前的 IP 地址不符合要求时开始回溯(不在 0~255 范围之间)
                    return;
                }
                if (paths.size() == 3) {
                    break;
                }
            }
        }
    }
    

    说明:我不知道牛客网对于 0 的处理是什么方式,反正我就是将字符串 subStr 解析成整形数值 subNum,然后调用 subNum.toString() 去除前导零

    image-20200921110035855

    展开全文
  • 算法—判断字符串是否为IP地址

    千次阅读 多人点赞 2020-08-04 10:21:18
    今天在这里和小伙伴记录一下判断字符串是否是IP地址的算法, 实现该算法我们首先应该知道,IP地址应该依据哪些条件: 判断原则: 判断该字符长度是否是7-15位之间(0.0.0.0-255.255.255.255.255) 是否能...
  • 题目:输入一个字符串判断字符串是否为有效ip地址,  ip地址的形式为XXX.XXX.XXX.XXX。对于XXX表示为0-256的数,但是如果第一位是0而且整数不为0则是...不允许使用strip等函数,只允许使用strlen得到字符串长度
  • IP地址字符串和DWORD互转(VC)

    千次阅读 2015-08-12 15:21:14
    转自:http://blog.sina.com.cn/s/blog_7d0544020100xjd7.html #include BOOL StrAddr2Dword(CHAR* lpStrAddr, DWORD* pdwAddr) { ... //指向当前操作的字符  int nN
  • 在看高性能MySQL第3版(4.1.7节)时,作者建议当存储IPv4地址时,应该使用32位的无符号整数(UNSIGNED INT)来存储IP地址,而不是使用字符串。但是没有给出具体原因。为了搞清楚这个原因,查了一些资料,记录下来。 ...
  • 判断输入的字符串是否为合法IP地址的程序今天写一个IP地址冲突检测程序的时候,写完之后用测试用例测试,发现所写程序没有判断所输入的ip地址是否为合法的IP地址,因此自己写了一个判断输入字符串是否为合法IP地址的...
  • 自创一个可逆的字符串长度压缩算法

    千次阅读 热门讨论 2020-08-19 17:26:07
    自己想出来LZW算法(其他算法压缩出来的长度可能更长),在我们这里并不需要每次都动态生成字符串映射表,只需要提前设定好一个表用于所有的压缩和解压缩过程就行,不过想了一下,这个表会比较庞大,也挺麻烦(陷入...
  • 如何判断一个字符串是否为合法的IP地址。 import java.util.Scanner; public class MyTest { public static void main(String[] args) { /* * 如何判断一个字符串是否为合法的IP地址。 */ Scanner sc=...
  • 判断一个字符串是否是Ip地址

    千次阅读 2019-03-20 11:40:46
    * 判断一个字符串是否是一个合法的ip地址: * 1 首先检查字符串长度 最短应该是0.0.0.0 7位 最长 000.000.000.000 15位 * 2 尝试按.符号进行拆分 拆分结果应该是4段 * 3 查看拆分到的每一个子字符串,...
  • 一个刚结束的笔试题目,简单贴一下吧,下面是具体实现: #!usr/bin/env python #encoding:utf-8 ...__Author__:沂水寒城 功能:判断一个字符串是否是合法IP地址 ... 判断一个字符串是否是合法IP地址
  • 在不规则字符串中提取ip地址一、ip地址正则表达式二、提取ipip地址提取中可能出现的错误ip地址提取思路三、完整代码 ipv4地址总长度为32位,共4段,每段8位,以‘.’分割,每段为0~255的十进制数字 一、ip地址正则...
  • 给定一个数字字符串,要求将这个数字字符串进行分割,使得分割的结果为有效的IP地址。 样例输入: 25525511135 样例输出: 255.255.11.135, 255.255.111.35 这道题其实可以看做是字符串分段问题,再输入...
  • 本题源自LeetCode ------------------------------------------------...用三重循环遍历字符串,每个段的长度不能超过三, java代码: public ArrayList restoreIpAddresses(String s) { ArrayList result=new A
  • Java判断一个字符串是不是IP地址

    千次阅读 2018-12-31 00:38:15
    面试的时候遇到的,当时时间不够...1.常规思路,仅用判断是不是IP地址的格式即可 package com.wmmx.test; public class TestIP { public static void main(String[] args) { Solution solution = new Solution(...
  • 在shell中如何判断字符串是否为有效的IP地址_echoisecho_新浪博客 http://blog.sina.com.cn/s/blog_53a844e50100xxus.html 近来需要写个小shell判断用户输入的字符串是否为有效的ip地址,简单排除了以下几种情况: ...
  • 项目中使用了lua,需要判断一个字符串是否是正确的ip格式.记录下写出的判断函数.合法返回原ip字符串,不合法返回false --判断ip是否合法 function JudgeIPString(ipStr) if type(ipStr) ~= "string" then return ...
  • leet_table = ''.maketrans('EIOBT','31087') # Python maketrans() 方法用于创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的...
  • 字符串-06. IP地址转换(20)(Y)

    千次阅读 2014-11-30 17:14:55
    字符串-06. IP地址转换(20) 时间限制 400 ms 内存限制 65536 kB 代码长度限制 8000 B 判题程序 Standard 一个IP地址是用四个字节(每个字节8个位)的二进制...
  • 判断一个字符串是否是ip地址

    千次阅读 2019-05-13 20:23:00
    IP的格式:(1-255).(0-255).(0-255).(0-255) public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String ipStr = scanner.next(); boolean isIpLegal =...
  • d) 函数 INET_ATON(expr ) 函数使用说明:给出一个作为字符串的网络地址的点地址表示,返回一个代表该地址数值的 整数。地址可以是 4 或 8 比特地址。 e) 函数 INET_NTOA(expr ) 函数使用说明:给定一个数字...
  • 当时面试上机的想法是,直接使用uint32_t变量来存ip地址,遍历字符串带".",然后去值,利用移位来将这个值填到uint32_t对应的位置上。这样的麻烦之处在于: 1,遍历字符串,还得记录每个"."出现的位置
  • Restore IP Addresses Given a string containing only digits, restore it by returning all possible valid IP address combinations. For example: Given "25525511135", return ["255.255.11.135...
  • 给定一个只包含数字的字符串,复原它并返回所有可能的 IP 地址格式。 示例: 输入: “25525511135” 输出: [“255.255.11.135”, “255.255.111.35”]
  • sqlldr默认字符串最大长度 1、sqlldr入库对字段长度进行的限制,默认是255。如果超出了255应该怎么办呢? 很简单:直接在列名后面修改默认长度,如:地址字段长度300 address char(300)  2、sqlldr入clob字段...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 145,027
精华内容 58,010
关键字:

ip地址字符串长度