字符串与整数系列

港控/mmm° 2022-12-17 15:59 55阅读 0赞

### 文章目录 ###

*  字符串与整数问题
 *   *  把数字翻译为字符串
     *   *  动态规划理解
     *  字符串相加
     *  字符串相乘
     *  判断字符串是不是整数
     *  字符串转化为整数

此篇文章收录在Maycope的个人Github上[May-Nodes][]

# 字符串与整数问题 #

## 把数字翻译为字符串 ##

[把数字翻译成为字符串][Link 1]

### 动态规划理解 ###

还是之前的那句话：**对于求最后的数量的问题一般都能够转化成为`动态规划`来进行求解，对于求路径，最后的结果集等，可以转换成为`深度和广度`**

这里我们采用动态规划的思想进行解决：

对于一个数`num[i]`,我们可以进行两种选择：

*  只翻译自己，就是和前面的不进行关联处理。
 *  和前面的数字进行组合翻译，前提是，两者组合完成之后在范围之内。

`dp[i]`: 表示对于数组的前`i`个进行翻译时候能够翻译的个数。

1.  对于只翻译自己的情况而言,对于`12258`来说，若是对于8来说进行单独的翻译，会发现，只是结果与`dp[i-1]`相同，因为不能进行任何其他的组合操作，只不过在原来的基础上的最后添加一个数字。
2.  若是考虑和之前的进行结合的时候，例如`58`进行结合，我们有两方面的考虑：
    
    1.  对于 将两者看成是一个整体时候，表示最后的两个数结合在一起，此时就是相当于没有进行任何其他的变化。所以结果还是`dp[i-1]`。
    2.  往前看时候，对于最后一个数何其前一个绑定之后，两者就不能和其他的进行组合操作，所以就是相当于对于`122` 进行一个翻译,此时就是计算`dp[i-2]`的值。
    
    所以最后两者相加即可。

public int translateNum(int num) { 
    
    String s = String.valueOf(num);
            int[] dp = new int[s.length()+1];
            dp[0] = 1;
            dp[1] = 1;
            for(int i = 2; i <= s.length(); i ++){ 
                String temp = s.substring(i-2, i);
                if(temp.compareTo("10") >= 0 && temp.compareTo("25") <= 0)
                    dp[i] = dp[i-1] + dp[i-2];
                else
                    dp[i] = dp[i-1];
            }
            return dp[s.length()];
        }

## 字符串相加 ##

[字符串相加][Link 2]

对于字符串的相加与相乘需要解决的都是对于`String`来说进行转换为单个的字

**思路**：对于将两个`String`的单个字符拿出来，进行比较，在对于出现一个较长一个较短的情况下，进行补为`0`,最后再判断进位是不是1，判断是否再需要放入到结果中。

private static String addStrings(String num1, String num2) { 
            if(num1.equals("0")&& num2.equals("0"))
                return  "0";
            StringBuilder stringBuilder = new StringBuilder();
            int  len1 = num1.length();
            int  len2 = num2.length();
            int flag = 0;
            while(len1>=0 || len2 >= 0){ 
                int i =len1>0 ? num1.charAt(len1-1)-'0':0;
                int j= len2>0 ? num2.charAt(len2-1)-'0':0;
                stringBuilder.append((i+j+flag)%10);
                flag = (i+j+flag)/10;
                len1--;
                len2--;
            }
            if(flag ==1)
                stringBuilder.append(1);
            return  stringBuilder.reverse().toString().replaceFirst("^0*", "");
        }

## 字符串相乘 ##

[字符串相乘][Link 3]

**思路**：先将所有的相乘的结果计算保存下来，同字符串相加一样，对进位进行一个对应的标志位处理，然后添加到结果中。

private static String multiply(String num1, String num2) { 
            int len1 = num1.length();
            int len2 = num2.length();
    
            int [] result = new int [len1+len2+1];
            for(int i= 0;i<len1;i++){ 
                for(int j= 0;j<len2;j++){ 
                    int p = num1.charAt(i)-'0';
                    int q = num2.charAt(j)-'0';
                    result[i+j]+=(p*q);
                }
            }
            StringBuilder stringBuilder =new StringBuilder();
            int plug = 0;
            for(int i =len1+len2-2;i>=0;i--){ 
                stringBuilder.append((result[i]+plug)%10);
                plug = (result[i]+plug)/10;
            }
            while(plug!=0){ 
                stringBuilder.append(plug%10);
                plug=plug/10;
            }
            return  stringBuilder.reverse().toString();
        }

## 判断字符串是不是整数 ##

[判断字符串是不是数字][Link 4]

**思路**：利用标志位，对各种情况进行判断，先判断出比较有标志性的情况，其余不满足的情况都返回`false`；

public boolean isNumber(String s) { 
            boolean ie = false; // 表示的是对于 e 有没有出现。
            boolean isnum = false; // 表示的是对于 字符有没有出现。
            boolean isdian = false;// 表示 对于. 有没有出现。
            char  [] chars = s.trim().toCharArray();
            if(chars.length==0)
            return false;
            for(int i= 0;i<chars.length;i++){  
               if('0'<=chars[i]&&chars[i]<='9'){ 
                    isnum = true;
                }
               else  if(chars[i] == '.')
                { 
                    if(isdian || ie)
                        return  false;
                    isdian = true;
                }
          
              
               else  if(chars[i] == 'e' || chars[i] =='E')
                 { 
                    if(!isnum|| ie)
                    return false;
                    ie = true;
                    isnum  = false;
                }
              else  if(chars[i] == '+' || chars[i] == '-'){ 
    
                 if(i!=0 && chars[i-1]!='e' && chars[i-1]!='E')
                    return false;
                }
    
              else return false;
            }
            return  isnum;
        }

## 字符串转化为整数 ##

[字符串转化为整数][Link 5]

**思路**： 对出现的情况进行具体情况具体分析即可。

public int strToInt(String str) { 
          String s = str.trim(); 
       if(s==null|| s.length()==0)
            return 0;
            boolean flag = false;
            char c = s.charAt(0);
            int i=0;
            StringBuilder stringBuilder = new StringBuilder();
            if (c == '-')
                flag = true;
            if(c== '+')
                s=s.substring(1,s.length());
            else if (!Character.isDigit(c)&& c!='+' && c!= '-')
                return 0;
            if(flag) { 
               i = 1;
            }
                for (;i < s.length(); i++) { 
                    if (Character.isDigit(s.charAt(i))) { 
                        stringBuilder.append(s.charAt(i));
                    } else
                        break;
                }
    
            char[] temp = stringBuilder.toString().toCharArray();
            int p = 0;
            long result = 0;
            for (int j = temp.length - 1; j >= 0; j--) { 
    
                result += (temp[j]-'0') * Math.pow(10, p);
                p++;
            }
            if (flag && result > Integer.MAX_VALUE )
                return Integer.MIN_VALUE;
            else if(!flag && result>Integer.MAX_VALUE)
                return  Integer.MAX_VALUE;
            else if(flag)
                return  -(int)result;
            else
                return  (int)result;
        }

[May-Nodes]: https://github.com/maycope/May-Nodes
[Link 1]: https://leetcode-cn.com/problems/ba-shu-zi-fan-yi-cheng-zi-fu-chuan-lcof/
[Link 2]: https://leetcode-cn.com/problems/add-strings/
[Link 3]: https://leetcode-cn.com/problems/multiply-strings/
[Link 4]: https://leetcode-cn.com/problems/biao-shi-shu-zhi-de-zi-fu-chuan-lcof/
[Link 5]: https://leetcode-cn.com/problems/ba-zi-fu-chuan-zhuan-huan-cheng-zheng-shu-lcof/submissions/