Add Strings

                                            
class Solution {
public:
    string addStrings(string num1, string num2) {
        string result = "";
        int i = num1.size() - 1;
        int j = num2.size() - 1;
        int carry = 0;
        
        while (i >= 0 || j >= 0 || carry > 0) {
            int sum = 0;
            if (i >= 0) {
                sum += num1[i] - '0';
                i--;
            }
            if (j >= 0) {
                sum += num2[j] - '0';
                j--;
            }
            sum += carry;
            carry = sum / 10;
            sum %= 10;
            result = to_string(sum) + result;
        }
        
        return result;
    }
};

                                            
class Solution {
    public String addStrings(String num1, String num2) {
        StringBuilder result = new StringBuilder();
        int carry = 0;
        int i = num1.length() - 1;
        int j = num2.length() - 1;
        
        while (i >= 0 || j >= 0 || carry > 0) {
            int sum = carry;
            if (i >= 0) {
                sum += num1.charAt(i) - '0';
                i--;
            }
            if (j >= 0) {
                sum += num2.charAt(j) - '0';
                j--;
            }
            result.insert(0, sum % 10);
            carry = sum / 10;
        }
        
        return result.toString();
    }
}

                                            
class Solution(object):
    def addStrings(self, num1, num2):
        res = []
        carry = 0
        i = len(num1) - 1
        j = len(num2) - 1
        
        while i >= 0 or j >= 0 or carry:
            if i >= 0:
                carry += int(num1[i])
                i -= 1
            if j >= 0:
                carry += int(num2[j])
                j -= 1
            res.append(str(carry % 10))
            carry //= 10
        
        return ''.join(res[::-1])

                                            
public class Solution {
    public string AddStrings(string num1, string num2) {
        string result = "";
        int i = num1.Length - 1, j = num2.Length - 1;
        int carry = 0;

        while (i >= 0 || j >= 0 || carry > 0) {
            int sum = carry;
            if (i >= 0) {
                sum += num1[i] - '0';
                i--;
            }
            if (j >= 0) {
                sum += num2[j] - '0';
                j--;
            }
            carry = sum / 10;
            result = (sum % 10).ToString() + result;
        }

        return result;
    }
}

                                            
/**
 * @param {string} num1
 * @param {string} num2
 * @return {string}
 */
var addStrings = function(num1, num2) {
    let i = num1.length - 1, j = num2.length - 1;
    let carry = 0;
    let result = '';
    
    while (i >= 0 || j >= 0 || carry > 0) {
        const digit1 = i < 0 ? 0 : parseInt(num1[i]);
        const digit2 = j < 0 ? 0 : parseInt(num2[j]);
        
        const sum = digit1 + digit2 + carry;
        result = `${sum % 10}${result}`;
        carry = Math.floor(sum / 10);
        
        i--;
        j--;
    }
    
    return result;
};

                                            
function addStrings(num1: string, num2: string): string {
    let i = num1.length - 1;
    let j = num2.length - 1;
    let carry = 0;
    let result = '';

    while (i >= 0 || j >= 0 || carry > 0) {
        const digit1 = i >= 0 ? parseInt(num1[i]) : 0;
        const digit2 = j >= 0 ? parseInt(num2[j]) : 0;
        const sum = digit1 + digit2 + carry;
        result = `${sum % 10}${result}`;
        carry = Math.floor(sum / 10);
        i--;
        j--;
    }

    return result;
};

                                            
class Solution {
    /**
     * @param String $num1
     * @param String $num2
     * @return String
     */
    function addStrings($num1, $num2) {
        $res = "";
        $i = strlen($num1) - 1;
        $j = strlen($num2) - 1;
        $carry = 0;
        
        while ($i >= 0 || $j >= 0 || $carry > 0) {
            $n1 = $i >= 0 ? (int)$num1[$i] : 0;
            $n2 = $j >= 0 ? (int)$num2[$j] : 0;
            $sum = $n1 + $n2 + $carry;
            $res = ($sum % 10) . $res;
            $carry = intdiv($sum, 10);
            $i--;
            $j--;
        }
        
        return $res;
    }
}

                                            
class Solution {
    func addStrings(_ num1: String, _ num2: String) -> String {
        var i = num1.count - 1
        var j = num2.count - 1
        var carry = 0
        var result = ""
        
        while i >= 0 || j >= 0 || carry > 0 {
            let digit1 = i >= 0 ? Int(String(num1[num1.index(num1.startIndex, offsetBy: i)]))! : 0
            let digit2 = j >= 0 ? Int(String(num2[num2.index(num2.startIndex, offsetBy: j)]))! : 0
            
            let sum = digit1 + digit2 + carry
            carry = sum / 10
            result = "\(sum % 10)" + result
            
            i -= 1
            j -= 1
        }
        
        return result
    }
}

                                            
class Solution {
    fun addStrings(num1: String, num2: String): String {
        var i = num1.length - 1
        var j = num2.length - 1
        var carry = 0
        var result = StringBuilder()

        while (i >= 0 || j >= 0 || carry > 0) {
            val x = if (i >= 0) num1[i] - '0' else 0
            val y = if (j >= 0) num2[j] - '0' else 0
            val sum = x + y + carry
            result.insert(0, sum % 10)
            carry = sum / 10
            i--
            j--
        }

        return result.toString()
    }
}

                                            
class Solution {
  String addStrings(String num1, String num2) {
    int i = num1.length - 1;
    int j = num2.length - 1;
    int carry = 0;
    StringBuffer result = StringBuffer();

    while (i >= 0 || j >= 0 || carry > 0) {
      int sum = carry;
      if (i >= 0) {
        sum += int.parse(num1[i]);
        i--;
      }
      if (j >= 0) {
        sum += int.parse(num2[j]);
        j--;
      }
      carry = sum ~/ 10;
      result.write((sum % 10).toString());
    }

    return result.toString().split('').reversed.join();
  }
}

                                            
func addStrings(num1 string, num2 string) string {
    result := ""
    carry := 0
    i, j := len(num1)-1, len(num2)-1

    for i >= 0 || j >= 0 || carry > 0 {
        x, y := 0, 0
        if i >= 0 {
            x = int(num1[i] - '0')
        }
        if j >= 0 {
            y = int(num2[j] - '0')
        }

        sum := x + y + carry
        result = string(sum%10+'0') + result
        carry = sum / 10

        i--
        j--
    }

    return result
}

                                            
# @param {String} num1
# @param {String} num2
# @return {String}
def add_strings(num1, num2)
    i = num1.length - 1
    j = num2.length - 1
    carry = 0
    result = ''

    while i >= 0 || j >= 0 || carry > 0
        sum = carry
        sum += num1[i].to_i if i >= 0
        sum += num2[j].to_i if j >= 0

        result = (sum % 10).to_s + result
        carry = sum / 10

        i -= 1
        j -= 1
    end

    return result
end

                                            
object Solution {
    def addStrings(num1: String, num2: String): String = {
        var i = num1.length - 1
        var j = num2.length - 1
        var carry = 0
        var result = ""
        
        while (i >= 0 || j >= 0 || carry > 0) {
            val sum = (if (i >= 0) num1(i) - '0' else 0) + (if (j >= 0) num2(j) - '0' else 0) + carry
            result = (sum % 10).toString + result
            carry = sum / 10
            i -= 1
            j -= 1
        }
        
        result
    }
}

                                            
impl Solution {
    pub fn add_strings(num1: String, num2: String) -> String {
        let num1_chars: Vec<char> = num1.chars().collect();
        let num2_chars: Vec<char> = num2.chars().collect();
        let mut result = String::new();
        let (mut carry, mut i, mut j) = (0, num1.len() as i32 - 1, num2.len() as i32 - 1);
        
        while i >= 0 || j >= 0 || carry > 0 {
            if i >= 0 {
                carry += num1_chars[i as usize].to_digit(10).unwrap();
                i -= 1;
            }
            if j >= 0 {
                carry += num2_chars[j as usize].to_digit(10).unwrap();
                j -= 1;
            }
            result.insert(0, ((carry % 10) as u8 + '0' as u8) as char);
            carry /= 10;
        }
        
        result
    }
}

                                            
(define/contract (add-strings num1 num2)
  (-> string? string? string?)
  (number->string (+ (string->number num1) (string->number num2))))

To solve this coding challenge, we need to implement a function that adds two non-negative integers represented as strings, without using built-in methods that handle large integers directly or simply converting the strings into integers.

# Explanation

The task requires a clear understanding of how manual addition (as we learned in primary school) works but applied to strings representing large numbers. The key concepts involve working from the least significant digit (rightmost) to the most significant digit (leftmost) and managing the carry overflow that results from summing two digits that exceed 9.

Detailed Steps in Pseudocode

Initialize Variables :

Create a list or string to store the results.
Initialize a carry variable to 0.
Set up pointers to traverse the two input strings from right to left.

Traverse the Strings :

Use a loop that continues until all digits in both strings have been processed and there is no carry left.
For each iteration, add the equivalent digits from the two strings and the carry.
Calculate the new digit to add to the result list, which is the current total modulo 10.
Update the carry using integer division by 10.
Append the digit to the result list.

Construct the Result :

Once all digits have been processed and added, reverse the result list.
Convert the list to a string and return it.

Pseudocode

Initialize Variables

                                            
# Initialize result as an empty list to store resulting digits
result = []
# Initialize carry to 0
carry = 0
# Pointers for traversing num1 and num2 from the end (least significant digit)
index_num1 = length of num1 - 1
index_num2 = length of num2 - 1

Traverse the Strings

                                            
# Loop until both indexes are out of bounds and there is no carry
while index_num1 >= 0 or index_num2 >= 0 or carry > 0:
# Sum the digits and the carry
if index_num1 >= 0:
carry += character value of num1 at index_num1
index_num1 = index_num1 - 1   # Move to the next digit to the left
if index_num2 >= 0:
carry += character value of num2 at index_num2
index_num2 = index_num2 - 1   # Move to the next digit to the left

# Calculate the digit to append to result
result.append(character of (carry % 10))
# Update the carry
carry = carry // 10

Construct the Result

                                            
# The result list is in reverse order so reverse it
result.reverse()
# Join all characters in the result list to form the final string
final_result = join all characters in result as a string
# Return the final result
return final_result

In-Depth Explanation

Initialize Variables :

We start with an empty list
result

to store the individual digits of our sum.
carry

is set to 0, which will help us handle sums greater than 9 (i.e., it will carry over the extra digit to the next positional sum).
index_num1

and
index_num2

are initialized to the last index of
num1

and
num2

respectively, allowing us to traverse the strings from the least significant to the most significant digit.

Traverse the Strings :

The loop condition ensures we continue adding digits as long as there's a digit left in either string or there's a carry to be processed.
Inside the loop, we add the numeric value of each string's current digit (if within bounds). This is converted by subtracting '0' from the character.
The digit to add to the result is determined by
carry % 10

, ensuring we only capture the unit place digit.
The carry itself is updated using integer division by 10. This prepares the carry for the next digit to the left.

Construct the Result :

After exiting the loop, the
result

list contains the sum digits in reverse order, so we reverse it.
Finally, we join the list into a single string and return it as the final result.

This step-by-step explanation and pseudocode should provide a comprehensive understanding of how to implement the addition of large numbers represented as strings.