Java 使用字符串的大加法

给定两个数字作为输入，返回这些数字的总和。请注意，数字可能非常大，因此作为字符串提供

样本输入#1：

样本输出#1：

实施：

public String add(String str1, String str2) {

    int max = str1.length() > str2.length() ? str1.length() : str2.length();
    int n1[] = new int[max];
    int n2[] = new int[max];
    for (int i = 0; i < str1.length(); i++) {
        n1[i] = str1.charAt(str1.length() - 1 - i);

    }
    for (int i = 0; i < str2.length(); i++) {
        n2[i] = str2.charAt(str2.length() - 1 - i);
    }
    int carry = 0;
    int sum[] = new int[max + 1];
    int k = 0;
    for (k = 0; k < max; k++) {
        sum[k] = (n1[k] + n2[k] + carry) % 10;
        if ((n1[k] + n2[k] + carry) >= 10) {
            carry = 1;
        } else {
            carry = 0;
        }
    }
    sum[max] = carry;
    String result = "";
    return result;

}

公共字符串添加（字符串str1、字符串str2）{
int max=str1.length（）>str2.length（）？str1.length（）：str2.length（）；
int n1[]=新int[max]；
int n2[]=新的int[max]；
对于（int i=0；i=10）{
进位=1；
}否则{
进位=0；
}
}
总和[最大值]=进位；
字符串结果=”；
返回结果；
}

---

我已经实现了我的逻辑，但我不知道如何以字符串的形式获取输出。

为什么不使用

biginger

这更简单，而且还是本地java

private static String add(String s1, String s2)
{
    BigInteger n1 = new BigInteger(s1);
    BigInteger n2 = new BigInteger(s2);
    return n1.add(n2).toString();
}

无论如何，代码中有一个bug。不要将

char

转换为

int

使用了ascii值，这是错误的。使用

Character.getNumericValue（）解析它

如果您已经这样做了，您可以将
sum
数组按相反顺序压缩为字符串

解决方案：

public static String add(String str1, String str2) {

    int max = str1.length() > str2.length() ? str1.length() : str2.length();
    int n1[] = new int[max];
    int n2[] = new int[max];
    for (int i = 0; i < str1.length(); i++) 
    {
        // conver char to int
        n1[i] = Character.getNumericValue(str1.charAt(str1.length() - 1 - i));
    }
    for (int i = 0; i < str2.length(); i++) {
        // conver char to int
        n2[i] = Character.getNumericValue(str2.charAt(str2.length() - 1 - i));
    }
    int carry = 0;
    int sum[] = new int[max + 1];
    int k = 0;
    for (k = 0; k < max; k++) {
        sum[k] = (n1[k] + n2[k] + carry) % 10;
        if ((n1[k] + n2[k] + carry) >= 10) {
            carry = 1;
        } else {
            carry = 0;
        }
    }
    sum[max] = carry;
    // concat array in reverse order
    StringBuilder sb = new StringBuilder();
    for(int i = sum.length - 1; i >= 0; i--)
        sb.append(sum[i]);
    return sb.toString();
}

输出

10000000000000000000002354714123671245

为什么不使用
biginger
这更简单，而且还是本地java

private static String add(String s1, String s2)
{
    BigInteger n1 = new BigInteger(s1);
    BigInteger n2 = new BigInteger(s2);
    return n1.add(n2).toString();
}

无论如何，代码中有一个bug。不要将
char
转换为
int
使用了ascii值，这是错误的。使用
Character.getNumericValue（）解析它

如果您已经这样做了，您可以将
sum
数组按相反顺序压缩为字符串

解决方案：

public static String add(String str1, String str2) {

    int max = str1.length() > str2.length() ? str1.length() : str2.length();
    int n1[] = new int[max];
    int n2[] = new int[max];
    for (int i = 0; i < str1.length(); i++) 
    {
        // conver char to int
        n1[i] = Character.getNumericValue(str1.charAt(str1.length() - 1 - i));
    }
    for (int i = 0; i < str2.length(); i++) {
        // conver char to int
        n2[i] = Character.getNumericValue(str2.charAt(str2.length() - 1 - i));
    }
    int carry = 0;
    int sum[] = new int[max + 1];
    int k = 0;
    for (k = 0; k < max; k++) {
        sum[k] = (n1[k] + n2[k] + carry) % 10;
        if ((n1[k] + n2[k] + carry) >= 10) {
            carry = 1;
        } else {
            carry = 0;
        }
    }
    sum[max] = carry;
    // concat array in reverse order
    StringBuilder sb = new StringBuilder();
    for(int i = sum.length - 1; i >= 0; i--)
        sb.append(sum[i]);
    return sb.toString();
}

输出

10000000000000000000002354714123671245

您可以使用将
int[]
中的所有数字从
max
追加到
0

StringBuilder sb = new StringBuilder();
for (int i=max; i>=0; i--)
{
   sb.append(String.valueOf(sum[i]));
}  
String result = sb.toString();

如果需要，您还可以对此进行改进，以跳过前导零：

boolean leadingZero = true;
StringBuilder sb = new StringBuilder();
for (int i=max; i>=0; i--)
{
   if (sum[i] != 0)
   {
        leadingZero=false;
   }
   if (!leadingZero)
   {
        sb.append(String.valueOf(sum[i]));
   }
}  
String result = sb.toString();

您可以使用将
int[]
中的所有数字从
max
追加到
0

StringBuilder sb = new StringBuilder();
for (int i=max; i>=0; i--)
{
   sb.append(String.valueOf(sum[i]));
}  
String result = sb.toString();

如果需要，您还可以对此进行改进，以跳过前导零：

boolean leadingZero = true;
StringBuilder sb = new StringBuilder();
for (int i=max; i>=0; i--)
{
   if (sum[i] != 0)
   {
        leadingZero=false;
   }
   if (!leadingZero)
   {
        sb.append(String.valueOf(sum[i]));
   }
}  
String result = sb.toString();

代码中有一个逻辑错误：您正在添加每个整数的
char
值，而不是整数本身。可以使用获取字符的数值

然后，您可以通过在
sum
数组上循环来构造结果字符串。循环必须以相反的顺序进行（以获得正确的顺序）。注意第一个值
sum[max]
，如果它是0，我们不能将其添加到字符串中（否则，我们将得到一个填充有0的值）：

与

代码中有一个逻辑错误：您正在添加每个整数的
char
值，而不是整数本身。可以使用获取字符的数值

然后，您可以通过在
sum
数组上循环来构造结果字符串。循环必须以相反的顺序进行（以获得正确的顺序）。注意第一个值
sum[max]
，如果它是0，我们不能将其添加到字符串中（否则，我们将得到一个填充有0的值）：

与

我修改了一些代码：（可以避免创建数组）

公共静态字符串添加（字符串str1、字符串str2）{
整数进位=0；
StringBuilder总和=新的StringBuilder（）；
int l1=str1.length（）；
int l2=str2.length（）；
而（l1>0&&l2>0）{
int s=Character.getNumericValue（str1.charAt（--l1））+Character.getNumericValue（str2.charAt（--l2））+进位；
如果（s0）{
而（l2>0）{
int s=Character.getNumericValue（str2.charAt（--l2））+进位；
如果（s0）{
而（l2>0）{
int s=Character.getNumericValue（str1.charAt（--l1））+进位；
如果（s0）{
总和。追加（进位）；
}
返回sum.reverse（）.toString（）；
}
我修改了一些代码：（可以避免创建数组）

公共静态字符串添加（字符串str1、字符串str2）{
整数进位=0；
StringBuilder总和=新的StringBuilder（）；
int l1=str1.length（）；
int l2=str2.length（）；
而（l1>0&&l2>0）{
int s=Character.getNumericValue（str1.charAt（--l1））+Character.getNumericValue（str2.charAt（--l2））+进位；
如果（s0）{
而（l2>0）{
int s=Character.getNumericValue（str2.charAt（--l2））+进位；
如果（s0）{
而（l2>0）{
int s=Character.getNumericValue（str1.charAt（--l1））+进位；
如果（s0）{
总和。追加（进位）；
}
返回sum.reverse（）.toString（）；
}
<代码>查看<代码> BigInteger <代码>：考虑填充两个“代码>字符串< /代码> s，以使它们长度相同。（通过将
0
s添加到最小的
String
的开头，它应该能够跟踪索引easier@NicholasRobinson使用biginteger没有任何帮助，因为我试图用逻辑纠正我的程序。@nisha你认为你实现了逻辑，那么结果存储在哪里？在和数组中？@kai，这就是我得到stuc的地方K，这就是为什么我需要帮助。看看<代码> BigInteger <代码>：考虑填充两个“代码>字符串 s，以使它们长度相同。（通过将
0
s添加到最小的
String
的开头，它应该能够跟踪索引easier@NicholasRobinson使用biginteger没有任何帮助，因为我试图用逻辑纠正我的程序。@nisha你认为你实现了逻辑，那么结果存储在哪里？在和数组中？@kai，这就是我得到stuc的地方k，这就是我需要帮助的原因。使用bigInteger不会有帮助，因为我试图以逻辑方式实现它。使用bigInteger不会有帮助，因为我试图以逻辑方式实现它。如何删除零？@nisha查看我的答案（以及代码中的一个错误）。@Tunaki是的，您的代码工作正常，我检查了我的代码我还编辑了我的代码n1[i]-
int max = Math.max(str1.length(), str2.length());

public static String add(String str1, String str2) {
    int carry=0;
    StringBuilder sum=new StringBuilder();

    int l1=str1.length();
    int l2=str2.length();

    while(l1>0 && l2>0){
        int s=Character.getNumericValue(str1.charAt(--l1))+Character.getNumericValue(str2.charAt(--l2))+carry;
        if(s<10){
           sum.append(s);
        }else{
            sum.append(s%10);
            carry=s/10;
        }

    }
    if(l2>0){
        while(l2>0){

             int s=Character.getNumericValue(str2.charAt(--l2))+carry;
                if(s<10){
                   sum.append(s);
                }else{
                    sum.append(s%10);
                    carry=s/10;
                }

        }


    }
    if(l1>0){
        while(l2>0){
             int s=Character.getNumericValue(str1.charAt(--l1))+carry;
                if(s<10){
                   sum.append(s);
                }else{
                    sum.append(s%10);
                    carry=s/10;
                }

        }
    }

    if(carry>0){
         sum.append(carry);
    }
    return sum.reverse().toString();

}