字符串：字符串变形、最长公共前缀、大数加法和验证IP地址

一、字符串变形

1.1 题目

1.2 题解

思路：先遍历一遍字符串转换大小写，然后将整个字符串逆置，最后再分别逆置每个单词

代码：

public  static String trans(String s, int n) {
        if(s==null||s.length()==0) return null;
        StringBuffer ret=new StringBuffer();
        for(int i=0;i<n;i++){
            //大小写转换
            if(s.charAt(i)>='a' && s.charAt(i)<='z'){
                ret.append((char)(s.charAt(i)-'a'+'A'));
            }else if(s.charAt(i)>='A' && s.charAt(i)<='Z'){
                ret.append((char)(s.charAt(i)-'A'+'a'));
            }else {
                //如果是空格直接追加
                ret.append(s.charAt(i));
            }
        }
        ret.reverse();
        for(int i=0;i<n;i++){
            int j=i;
            //注意:这里是ret.charAt(j)而不是s.charAt(j)
            while(j<n && ret.charAt(j)!=' '){
                j++;
            }
            //逆转单个单词
            String tmp=ret.substring(i,j);
            StringBuffer sb=new StringBuffer(tmp);
            sb.reverse();
            tmp=sb.toString();
            ret.replace(i,j,tmp);
            i=j;
        }
        return ret.toString();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

二、最长公共前缀

2.1 题目

2.2 题解

2.2.1 解法一：遍历查找

思路：以第一个字符为标杆，从第一个字符开始，逐位比较每个位，找出最长公共前缀

具体步骤：

step1：以第一个字符串为标杆，逐位取出第一个字符串的每个字符
step2：遍历后续字符串，依次比较后续字符串中相应位置的字符是否与刚取出的字符相等，如果全部都相等，循环继续，只要遇到不相等或长度不足的字符串，说明从第i位开始不同，前面的都是公共前缀
step3：遍历结束，如果都相同，最长公共前缀最长是第一个字符串

代码：

public String longestCommonPrefix (String[] strs) {
       if(strs==null || strs.length==0) return "";
        int row=strs.length;
        int col=strs[0].length();
        for(int i=0;i<col;i++){
           char tmp=strs[0].charAt(i);
            for(int j=1;j<row;j++){
                if(i==strs[j].length() || strs[j].charAt(i)!=tmp){
                    return strs[0].substring(0,i);
                }
            }
            
        }
        return strs[0];  
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.2.2 解法二：排序后字串纵向查找

思路：将字符串数组按照字典序方式排序，排序后第一个字符串与最后一个字符串的公共前缀就是所有字符串的最长公共前缀

代码：

  public String longestCommonPrefix (String[] strs) {
        if(strs==null || strs.length==0)return "";
        Arrays.sort(strs);
        for(int i=0;i<strs[0].length();i++){
            String str=strs[strs.length-1];
            if(strs[0].charAt(i)!=str.charAt(i)){
               return strs[0].substring(0,i); 
            }
        }
        return strs[0];
    }
1
2
3
4
5
6
7
8
9
10
11

三、大数加法

3.1 题目

3.2 题解

3.2.1 模拟法

具体步骤：

step1：让s指向较长的字符串，t指向较短的字符串
step2：定义两个指针i，j，从尾部开始计算两个字符串各位相加的结果，变量carry保存进位的值
step3：各个位都计算完成后，如果carry等于1，在字符串的头部加1即可

代码：

   public String solve (String s, String t) {
       if(s==null && t==null) return null;
       if(s==null && t!=null) return t;
       if(t==null && s!=null) return s;
       if(t.length()>s.length()){
           String tmp=t;
           t=s;
           s=tmp;
       }
     char[] ret=new char[s.length()];
       int carry=0;
       for(int i=s.length()-1;i>=0;i--){
        int j=i+t.length()-s.length();
        int tmp=s.charAt(i)-'0'+carry;
        if(j>=0){
           tmp+=t.charAt(j)-'0';
        }
         carry=tmp/10;
         ret[i]=(char)(tmp%10+'0');
       }
     String ans=String.valueOf(ret);
     if(carry==1){
         ans='1'+ans;
     }
     return ans;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

四、验证IP地址

4.1 题目

4.2 题解

思路：对IP字符串进行分割，然后依次判断分割后的每个子串是否符合要求

具体步骤：
（1）判断是否为IPv4

step1：先判断IP字符串中是否含有字符 ’ . ‘，如果没有一定是false
step2：按字符’ . '对IP字符串进行分割，将分割后的字串放在一个字符串数组中
step3：判断字符串数组的长度，如果不是4，一定不是IPv4
step4：遍历数组，判断每个子串是否符合要求，根据规定，每个子串的长度应该在0-3之间，不能有前缀0，子串的数字范围应该是0-255

（2）判断是否为IPv6

step1：先判断IP字符串中是否含有字符 ’ : ‘，如果没有一定是false
step2：按字符’ : '对IP字符串进行分割，将分割后的字串放在一个字符串数组中
step3：判断字符串数组的长度，如果不是8，一定不是IPv6
step4：遍历数组，判断每个子串是否符合要求，根据规定，每个子串的长度应该在0-4之间，不能有前缀0，子串中的字符只能是数字或a-f，或A-F组成

代码：

  public  static boolean isIPv4(String IP){
        if(IP.indexOf('.')==-1){
            return false;
        }
        String[] s=IP.split("\\.",-1);
        if(s.length!=4){
            return false;
        }
        for(int i=0;i<s.length;i++){
            if(s[i].length()==0) return false;
            if(s[i].length()< 0||s[i].length()>3 || (s[i].charAt(0)=='0' && s[i].length()!=1)){
                return false;
            }
            int num=0;
            for(int j=0;j<s[i].length();j++){
                char tmp=s[i].charAt(j);
                if(tmp<'0'|| tmp>'9') return false;

                num=num*10+(int)(tmp-'0');
                if(num<0 || num> 255) return false;
            }

        }
        return true;
    }
    public  static boolean isIPv6(String IP){
        if(IP.indexOf(':')==-1) return false;
        String[] s=IP.split(":",-1);
        if(s.length!=8) return false;
        for(int i=0;i<s.length;i++){
            if(s[i].length()==0 || s[i].length()>4) return false;
            for(int j=0;j<s[i].length();j++){
                char tmp=s[i].charAt(j);
                boolean flag=(tmp>='0'&& tmp<='9')||(tmp>='a'&&tmp<='f')||
                        (tmp>='A'&& tmp<='F');
             if(!flag){
                 return false;
             }
            }
        }

        return true;
    }
    public  static String solve (String IP) {

        if(isIPv4(IP))
            return "IPv4";
        else if(isIPv6(IP))
            return "IPv6";
        return "Neither";

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

【补充】：split方法