Multiply Strings

                                            
class Solution {
public:
    string multiply(string num1, string num2) {
        int m = num1.size();
        int n = num2.size();
        vector<int> result(m + n, 0);
        
        for (int i = m - 1; i >= 0; i--) {
            for (int j = n - 1; j >= 0; j--) {
                int mul = (num1[i] - '0') * (num2[j] - '0');
                int sum = mul + result[i + j + 1];
                
                result[i + j] += sum / 10;
                result[i + j + 1] = sum % 10;
            }
        }
        
        string res;
        for (int num : result) {
            if (!(res.empty() && num == 0)) {
                res.push_back(num + '0');
            }
        }
        
        return res.empty() ? "0" : res;
    }
};

                                            
class Solution {
    public String multiply(String num1, String num2) {
        if (num1.equals("0") || num2.equals("0")) {
            return "0";
        }
        
        int[] result = new int[num1.length() + num2.length()];
        
        for (int i = num1.length() - 1; i >= 0; i--) {
            for (int j = num2.length() - 1; j >= 0; j--) {
                int mul = (num1.charAt(i) - '0') * (num2.charAt(j) - '0');
                int sum = mul + result[i + j + 1];
                
                result[i + j] += sum / 10;
                result[i + j + 1] = sum % 10;
            }
        }
        
        StringBuilder sb = new StringBuilder();
        for (int n : result) {
            if (!(sb.length() == 0 && n == 0)) {
                sb.append(n);
            }
        }
        
        return sb.toString();
    }
}

                                            
class Solution(object):
    def multiply(self, num1, num2):
        res = [0] * (len(num1) + len(num2))
        for i in reversed(range(len(num1))):
            for j in reversed(range(len(num2))):
                mul = (ord(num1[i]) - ord('0')) * (ord(num2[j]) - ord('0'))
                pos1, pos2 = i + j, i + j + 1
                summation = mul + res[pos2]
                res[pos1] += summation // 10
                res[pos2] = summation % 10
        res_str = ''.join(map(str, res)).lstrip('0')
        return res_str if res_str else '0'

                                            
public class Solution {
    public string Multiply(string num1, string num2) {
        if (num1.Equals("0") || num2.Equals("0")) {
            return "0"; 
        }
        
        int m = num1.Length, n = num2.Length;
        int[] pos = new int[m + n];
        
        for (int i = m - 1; i >= 0; i--) {
            for (int j = n - 1; j >= 0; j--) {
                int mul = (num1[i] - '0') * (num2[j] - '0');
                int p1 = i + j, p2 = i + j + 1;
                int sum = mul + pos[p2];
                
                pos[p1] += sum / 10;
                pos[p2] = (sum) % 10;
            }
        }
        
        StringBuilder result = new StringBuilder();
        foreach (int p in pos) {
            if (!(result.Length == 0 && p == 0)) {
                result.Append(p);
            }
        }
        
        return result.Length == 0 ? "0" : result.ToString();
    }
}

                                            
function multiply(num1: string, num2: string): string {
    if (num1 === "0" || num2 === "0") return "0";
    
    const m = num1.length, n = num2.length;
    const result = new Array(m + n).fill(0);

    for (let i = m - 1; i >= 0; i--) {
        for (let j = n - 1; j >= 0; j--) {
            const mul = (num1.charCodeAt(i) - '0'.charCodeAt(0)) * (num2.charCodeAt(j) - '0'.charCodeAt(0));
            const sum = mul + result[i + j + 1];
            result[i + j] += Math.floor(sum / 10);
            result[i + j + 1] = sum % 10;
        }
    }

    return result.join('').replace(/^0+/, '') || "0";
};

                                            
class Solution {
    /**
     * @param String $num1
     * @param String $num2
     * @return String
     */
    function multiply($num1, $num2) {
        $len1 = strlen($num1);
        $len2 = strlen($num2);
        $result = array_fill(0, $len1 + $len2, 0);
        
        for ($i = $len1 - 1; $i >= 0; $i--) {
            for ($j = $len2 - 1; $j >= 0; $j--) {
                $mul = intval($num1[$i]) * intval($num2[$j]);
                $sum = $mul + $result[$i + $j + 1];
                $result[$i + $j] += intdiv($sum, 10);
                $result[$i + $j + 1] = $sum % 10;
            }
        }
        
        $res = ltrim(implode("", $result), '0');
        return $res === "" ? "0" : $res;
    }
}

                                            
class Solution {
    func multiply(_ num1: String, _ num2: String) -> String {
        if num1 == "0" || num2 == "0" {
            return "0"
        }
        
        let m = num1.count
        let n = num2.count
        var result = Array(repeating: 0, count: m + n)
        
        let num1Array = Array(num1.reversed())
        let num2Array = Array(num2.reversed())
        
        for i in 0..<m {
            for j in 0..<n {
                let digit1 = Int(String(num1Array[i]))! 
                let digit2 = Int(String(num2Array[j]))!
                let product = digit1 * digit2
                let sum = product + result[i + j]
                
                result[i + j] = sum % 10
                result[i + j + 1] += sum / 10
            }
        }
        
        var finalResult = ""
        for digit in result.reversed() {
            if !(finalResult.isEmpty && digit == 0) {
                finalResult.append(String(digit))
            }
        }
        
        return finalResult
    }
}

                                            
class Solution {
    fun multiply(num1: String, num2: String): String {
        if (num1 == "0" || num2 == "0") {
            return "0"
        }
        
        val m = num1.length
        val n = num2.length
        val result = IntArray(m + n)
        
        for (i in m - 1 downTo 0) {
            for (j in n - 1 downTo 0) {
                val mul = (num1[i] - '0') * (num2[j] - '0')
                val sum = mul + result[i + j + 1]
                result[i + j] += sum / 10
                result[i + j + 1] = sum % 10
            }
        }
        
        val sb = StringBuilder()
        for (num in result) {
            if (!(sb.isEmpty() && num == 0)) {
                sb.append(num)
            }
        }
        
        return sb.toString()
    }
}

                                            
class Solution {
  String multiply(String num1, String num2) {
      if (num1 == "0" || num2 == "0") {
          return "0";
      }
      
      int m = num1.length;
      int n = num2.length;
      List<int> result = List<int>.filled(m + n, 0);
      
      for (int i = m - 1; i >= 0; i--) {
          int x = int.parse(num1[i]);
          for (int j = n - 1; j >= 0; j--) {
              int y = int.parse(num2[j]);
              int product = x * y;
              int p1 = i + j;
              int p2 = i + j + 1;
              int sum = product + result[p2];
              
              result[p1] += sum ~/ 10;
              result[p2] = sum % 10;
          }
      }
      
      String res = "";
      for (int digit in result) {
          if (res.isEmpty && digit == 0) {
              continue;
          }
          res += digit.toString();
      }
      
      return res;
  }
}

                                            
func multiply(num1 string, num2 string) string {
    if num1 == "0" || num2 == "0" {
        return "0"
    }

    m, n := len(num1), len(num2)
    res := make([]int, m+n)

    for i := m - 1; i >= 0; i-- {
        for j := n - 1; j >= 0; j-- {
            mul := int((num1[i] - '0') * (num2[j] - '0'))
            sum := mul + res[i+j+1]
            res[i+j] += sum / 10
            res[i+j+1] = sum % 10
        }
    }

    result := ""
    for _, digit := range res {
        if !(len(result) == 0 && digit == 0) {
            result += strconv.Itoa(digit)
        }
    }

    return result
}

                                            
# @param {String} num1
# @param {String} num2
# @return {String}
def multiply(num1, num2)
    if num1 == "0" || num2 == "0"
        return "0"
    end
    
    m = num1.length
    n = num2.length
    pos = Array.new(m + n, 0)
    
    (m - 1).downto(0) do |i|
        (n - 1).downto(0) do |j|
            mul = (num1[i].ord - '0'.ord) * (num2[j].ord - '0'.ord)
            p1 = i + j
            p2 = i + j + 1
            sum = mul + pos[p2]
            
            pos[p1] += sum / 10
            pos[p2] = sum % 10
        end
    end
    
    pos.each_with_index do |num, i|
        if num != 0 || i == m + n - 1
            return pos[i..].join
        end
    end
end

                                            
object Solution {
    def multiply(num1: String, num2: String): String = {
        if (num1 == "0" || num2 == "0") return "0"
        
        val len1 = num1.length
        val len2 = num2.length
        val result = Array.fill(len1 + len2)(0)
        
        for {
            i <- (len1 - 1 to 0 by -1)
            j <- (len2 - 1 to 0 by -1)
        } {
            val mul = (num1(i) - '0') * (num2(j) - '0')
            val sum = mul + result(i + j + 1)
            
            result(i + j) += sum / 10
            result(i + j + 1) = sum % 10
        }
        
        result.mkString("").dropWhile(_ == '0')
    }
}

                                            
impl Solution {
    pub fn multiply(num1: String, num2: String) -> String {
        if num1 == "0" || num2 == "0" {
            return "0".to_string();
        }
        
        let m = num1.len();
        let n = num2.len();
        let mut res = vec![0; m + n];
        
        let num1 = num1.chars().rev().collect::<Vec<char>>();
        let num2 = num2.chars().rev().collect::<Vec<char>>();
        
        for i in 0..m {
            for j in 0..n {
                let product = (num1[i].to_digit(10).unwrap() as i32) * (num2[j].to_digit(10).unwrap() as i32);
                let sum = product + res[i + j];
                res[i + j] = sum % 10;
                res[i + j + 1] += sum / 10;
            }
        }
        
        while res.len() > 1 && res[res.len() - 1] == 0 {
            res.pop();
        }
        
        res.iter().rev().map(|&x| char::from_digit(x as u32, 10).unwrap()).collect()
    }
}

                                            
(define/contract (multiply num1 num2)
  (-> string? string? string?)
  (number->string (* (string->number num1) (string->number num2))))

                                            
defmodule Solution do
  @spec multiply(num1 :: String.t, num2 :: String.t) :: String.t
  def multiply(num1, num2) do
    result = Integer.to_string(String.to_integer(num1) * String.to_integer(num2))
    result
  end
end

To solve this coding challenge, we need to multiply two non-negative integers represented as strings and return the product as a string. We cannot use any built-in BigInteger libraries or directly convert strings to integers, which means we have to perform the multiplication manually, similar to how we might do it on paper.

Explanation

The main challenge here is to implement the multiplication process manually without using any direct integer conversions. We can break down the multiplication process into smaller steps, similar to multiplying numbers by hand:

Initialize a Result Array : Given the lengths of the two numbers (num1 and num2), we know that the maximum length of the product will be
len(num1) + len(num2)

, so we initialize an array to store the results.
Iterate and Multiply : We need to iterate over each digit in num1 and num2 from right to left (least significant digit to most significant). For each pair of digits, multiply them, and add the result to the appropriate position in the result array, considering any carry from previous calculations.
Manage Carry : If the result of a multiplication is greater than or equal to 10, we need to manage the carry appropriately. This means dividing the result by 10 and adding the quotient to the next higher position.
Convert Result to String : Once all multiplications and carry adjustments are made, the result array contains the product in reverse order. Convert the result array to a string, ensuring to remove any leading zeros.
Edge Cases : Handle edge cases such as multiplying by zero, which should immediately return "0".

Step-by-Step Explanation of the Solution:

Initial Setup :

Create a result array with a length of
len(num1) + len(num2)

filled with zeros.

Main Loop :

Iterate over each digit of num1 from right to left.
For each digit in num1, iterate over each digit in num2, also from right to left.
Compute the product of the current digits from num1 and num2.
Add this product to the appropriate position in the result array, considering any previous carry.

Update Result Array :

For each product computation and position update in the result array, calculate the sum with the current value in the result array.
Update the result array with the new value and carry if necessary.

Convert Result Array to String :

Join the result array into a string, while ensuring to strip leading zeros.
If the final result is empty (which happens if the product is zero), return "0".

Detailed Steps in Pseudocode:

                                            
# Pseudocode for multiplying two strings num1 and num2

# Step 1: Initialize result array
length1 = length of num1
length2 = length of num2
result = array of zeroes with size (length1 + length2)

# Step 2: Reverse iterate over num1 and num2
for i from length1-1 to 0:
    for j from length2-1 to 0:
        # Calculate the product of the corresponding digits
        digit_product = (ascii value of num1[i] - ascii value of '0') * (ascii value of num2[j] - ascii value of '0')
        
        # Determine position in the result array
        pos1 = i + j
        pos2 = i + j + 1
        
        # Add the product to the current value with carry consideration
        sum_with_carry = digit_product + result[pos2]
        
        # Update the result array
        result[pos2] = sum_with_carry % 10  # Ones place
        result[pos1] += sum_with_carry // 10  # Tens place

# Step 3: Create the final product string
final_product = join elements of result array into a string

# Step 4: Remove leading zeros
final_product = remove leading zeros from final_product

# Step 5: Return final product or "0" if the product is an empty string
if final_product is empty:
    return "0"
else:
    return final_product

In this pseudocode,

ascii value of num[i] - ascii value of '0'

is used to convert the character to its corresponding integer value. The steps include initializing the result array, performing multiplication, managing carries, and converting the result array back into the desired string format. This ensures that the solution is efficient and handles different edge cases appropriately.