Multiply Strings - Practice Coding Problems

Multiply Strings - Problem

Imagine you're building a calculator for numbers so large that they don't fit in standard integer types! Multiply Strings challenges you to perform multiplication on two non-negative integers represented as strings.

You're given two strings num1 and num2 representing very large numbers, and you need to return their product as a string. The catch? You cannot use built-in BigInteger libraries or convert the strings directly to integers - you must implement the multiplication algorithm yourself!

This problem simulates how computers handle arithmetic operations on numbers that exceed the capacity of primitive data types. Think of it as implementing the multiplication algorithm you learned in elementary school, but in code!

Example: "123" × "456" = "56088"

Input & Output

example_1.py — Basic Multiplication

$ Input: num1 = "2", num2 = "3"

› Output: "6"

💡 Note: Simple single-digit multiplication: 2 × 3 = 6

example_2.py — Multi-digit Numbers

$ Input: num1 = "123", num2 = "456"

› Output: "56088"

💡 Note: Classic long multiplication: 123 × 456 = 56,088. This demonstrates the algorithm handling multiple digits and carries properly.

example_3.py — Zero Edge Case

$ Input: num1 = "123", num2 = "0"

› Output: "0"

💡 Note: Any number multiplied by zero equals zero, regardless of the size of the other number.

Visualization

Tap to expand

Understanding the Visualization

Initialize Result Array

Create an array of size len1+len2 filled with zeros

Multiply Each Digit Pair

For digits at positions i and j, multiply them and add to positions i+j and i+j+1

Handle Carries

When sum at any position ≥ 10, carry the tens digit to the next position

Build Final String

Convert result array to string, skipping leading zeros

Key Takeaway

🎯 Key Insight: Multiplication of digits at positions i and j contributes to positions i+j and i+j+1 in the final result, allowing us to build the answer in a single pass without string concatenations.

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

Single nested loop through both strings, each digit pair processed once

✓ Linear Growth

Space Complexity

O(n+m)

Result array size is at most len(num1) + len(num2)

⚡ Linearithmic Space

Constraints

1 ≤ num1.length, num2.length ≤ 200
num1 and num2 consist of digits only
Both num1 and num2 do not contain any leading zero, except the number 0 itself
Cannot use built-in BigInteger library or convert strings to integers directly

Asked in

f Facebook 42 G Google 38 a Amazon 31 ⊞ Microsoft 24 Apple 18

The optimal approach simulates grade school multiplication using a result array where digits at positions i and j contribute to positions i+j and i+j+1. This achieves O(n×m) time complexity with O(n+m) space, processing each digit pair exactly once while handling carries efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation with String Addition	O(n×m×(n+m))	O(n×m)	Multiply each digit of num1 with entire num2, then add all partial products
Optimized Simulation (Optimal)	O(n×m)	O(n+m)	Simulate grade school multiplication with single result array and immediate carry handling

Simulation with String Addition — Algorithm Steps

For each digit in num1 (from right to left)
Multiply this digit with entire num2
Shift the result by appropriate number of positions
Add all partial products using string addition
Handle leading zeros in final result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set result to '0' and prepare to process each digit of num1

Multiply by each digit

For each digit in num1, multiply entire num2 and shift appropriately

Add partial products

Add each partial product to running total using string addition

Return result

Final sum contains the multiplication result

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* multiply(char* num1, char* num2) {
    int len1 = strlen(num1), len2 = strlen(num2);
    if (len1 == 0 || len2 == 0 || (len1 == 1 && num1[0] == '0') || (len2 == 1 && num2[0] == '0')) {
        char* result = malloc(2);
        strcpy(result, "0");
        return result;
    }
    
    int* result = calloc(len1 + len2, sizeof(int));
    
    for (int i = len1 - 1; i >= 0; i--) {
        for (int j = len2 - 1; j >= 0; j--) {
            int mul = (num1[i] - '0') * (num2[j] - '0');
            int p1 = i + j, p2 = i + j + 1;
            int sum = mul + result[p2];
            
            result[p2] = sum % 10;
            result[p1] += sum / 10;
        }
    }
    
    int start = 0;
    while (start < len1 + len2 && result[start] == 0) start++;
    
    char* str = malloc(len1 + len2 + 1);
    int idx = 0;
    
    for (int i = start; i < len1 + len2; i++) {
        str[idx++] = result[i] + '0';
    }
    
    str[idx] = '\0';
    free(result);
    
    return idx == 0 ? "0" : str;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m×(n+m))

n×m for digit multiplications, each followed by O(n+m) string addition

✓ Linear Growth

Space Complexity

O(n×m)

Storage for multiple partial product strings

⚡ Linearithmic Space

Constraints

1 ≤ num1.length, num2.length ≤ 200
num1 and num2 consist of digits only
Both num1 and num2 do not contain any leading zero, except the number 0 itself
Cannot use built-in BigInteger library or convert strings to integers directly

89.4K Views

High Frequency

~25 min Avg. Time

2.1K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Simulation with String Addition — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler