字符串的算法题目2-字符串

题目：验证IP地址

描述
编写一个函数来验证输入的字符串是否是有效的 IPv4 或 IPv6 地址

IPv4 地址由十进制数和点来表示，每个地址包含4个十进制数，其范围为 0 - 255， 用(“.”)分割。比如，172.16.254.1；
同时，IPv4 地址内的数不会以 0 开头。比如，地址 172.16.254.01 是不合法的。

IPv6 地址由8组16进制的数字来表示，每组表示 16 比特。这些组数字通过 (“:”)分割。比如, 2001:0db8:85a3:0000:0000:8a2e:0370:7334 是一个有效的地址。而且，我们可以加入一些以 0 开头的数字，字母可以使用大写，也可以是小写。所以， 2001:db8:85a3:0:0:8A2E:0370:7334 也是一个有效的 IPv6 address地址 (即，忽略 0 开头，忽略大小写)。

然而，我们不能因为某个组的值为 0，而使用一个空的组，以至于出现 (:😃 的情况。 比如， 2001:0db8:85a3::8A2E:0370:7334 是无效的 IPv6 地址。
同时，在 IPv6 地址中，多余的 0 也是不被允许的。比如， 02001:0db8:85a3:0000:0000:8a2e:0370:7334 是无效的。

说明: 你可以认为给定的字符串里没有空格或者其他特殊字符。

算法
1.分别验证IPv4和IPv6
2.注意事项
2.1 分割字符串时，使用limit = -1的split函数，使得字符串末尾或开头有一个’.‘或’:'也能分割出空的字符串
2.2 使用Integer.parseInt()函数检查异常，这个很重要

package day01;


public class Test06 {
    public static void main(String[] args) {
        Test06 test06 = new Test06();
        String solve = test06.solve("0db8:0db8:85a3:0000:0000:8a2e:0370:7334");
        System.out.println(solve);
    }

    /**
     * 验证IP地址
     * @param IP string字符串 一个IP地址字符串
     * @return string字符串
     */
    public String solve (String IP) {
        // write code here
        return validIPv4(IP) ? "IPv4" : (validIPv6(IP) ? "IPv6" :"Neither");
    }

    //分类验证的方法：是不是ipv4
    private boolean validIPv4(String IP){
        String[] strs = IP.split("\\.", -1);
        if(strs.length != 4 ) //4个长度
            return false;

        for (String str : strs) {
            if(str.startsWith("0")){
                return false;
            }
            //验证十进制
            try {
                int i = Integer.parseInt(str);
                if(i>255 || i<0){
                    return false;
                }
            }catch (NumberFormatException exception){
                return false;//如果转换异常，也是false
            }
        }
        return true;//其他情况返回true
    }

    private boolean validIPv6(String IP){
        String[] strs = IP.split(":", -1);
        //验证是8位
        if(strs.length!=8)
            return false;

        for (String str : strs) {
            //出现 (::) 的情况不合法。
            if(str.length() ==0 || str.length()>4){
                return false;
            }

            try {
                //多余的 0 也是不被允许的,一个0是可以的
                if(str.length()>1 && Integer.parseInt(str,16)==0)
                    return false;
                //int i = Integer.parseInt(str,16);//16进制的
            }catch (NumberFormatException e){
                return false;
            }
        }
        return true;
    }

}

题目二：大数加法

思路：

大整数相加，就可以按照整数相加的方式，从个位开始，逐渐往上累加，换到字符串中就是从两个字符串的末尾开始相加。

具体做法:

step 1：若是其中一个字符串为空，直接返回另一个，不用加了。
step 2：交换两个字符串的位置，我们是s为较长的字符串，t为较短的字符串，结果也记录在较长的字符串中。
step 3：从后往前遍历字符串s，每次取出字符转数字，加上进位制计算，将下标转换为字符串t中从后往前相应的下标，如果下标为非负数则还需要加上字符串t中相应字符转化的数字。
step 4：整型除法取进位，取模算法去掉十位，将计算后的结果放入较长数组对应位置。
step 5：如果遍历结束，进位值还有，则需要直接在字符串s前增加一个字符‘1’。

描述
以字符串的形式读入两个数字，编写一个函数计算它们的和，以字符串形式返回。

import java.util.*;
public class Solution {
    public String solve (String s, String t) {
         //若是其中一个为空，返回另一个
        if(s.length()<=0)
            return t;
        if(t.length()<=0)
            return s;
        //让s为较长的，t为较短的
        if(s.length() < t.length()){ 
            String temp = s;
            s = t;
            t = temp;
        }
        int carry = 0; //进位标志
        char[] res = new char[s.length()];
        //从后往前遍历较长的字符串
        for(int i = s.length() - 1; i >= 0; i--){ 
            //转数字加上进位
            int temp = s.charAt(i) - '0' + carry; 
            //转较短的字符串相应的从后往前的下标
            int j = i - s.length() + t.length(); 
            //如果较短字符串还有
            if(j >= 0) 
                //转数组相加
                temp += t.charAt(j) - '0'; 
            //取进位
            carry = temp / 10; 
            //去十位
            temp = temp % 10; 
            //修改结果
            res[i] = (char)(temp + '0'); 
        }
        String output = String.valueOf(res);
        //最后的进位
        if(carry == 1) 
            output = '1' + output;
        return output;
    }
}

方法二：借助数组来模拟加法运算；

package test;

public class BigAdd {
    public static void main(String[] args) {
        BigAdd bigAdd = new BigAdd();
        String solve = bigAdd.solve("459309139", "733064366");
        System.out.println(solve);
    }
    //大数加法，借助数组完成，使用数学模拟法
    public static String solve (String s, String t) {
        int longLen = s.length() >= t.length() ? s.length() :t.length();
        //设置一个存最终结果的数组，其长度是最大字符串长度加一
        int[] res = new int[longLen+1];//[0,0,0,0]
        int up = 0;//进位
        //反转字符串

        String shotStr = s.length() < t.length() ? s :t ;
        String longStr = s.length() >= t.length() ? s :t ;
        StringBuffer shortBuffer = new StringBuffer(shotStr).reverse(); //短字符串
        StringBuffer longBuffer = new StringBuffer(longStr).reverse(); //短字符串
        for (int i = shotStr.length(); i < longLen; i++) {
            shortBuffer.append("0");
        }

        for (int i = 0; i < longLen ; i++) {

            res[i] = (longBuffer.charAt(i) - 48) + (shortBuffer.charAt(i) - 48) + up;
            up = res[i] / 10;  //0
            res[i] = res[i] % 10; //进位后的当前位置数字  //7
        }
        //最后的进位
        if(up != 0){
            res[longLen] = up;
        }

        //将数字变成字符串
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < res.length; i++) {
            sb.append(res[i]);
        }
        String toString = sb.reverse().toString();

        //去掉前导0
        if(toString.charAt(0) =='0'){
            return toString.substring(1);
        }else{
            return toString;
        }

    }
}