Multiply Two Polynomials - Practice Coding Problems

Multiply Two Polynomials - Problem

Array Math Hard

Polynomial Multiplication Challenge

You're working with mathematical polynomials represented as integer arrays. Given two polynomials A(x) and B(x) where each array element at index i represents the coefficient of xⁱ, your task is to compute their product R(x) = A(x) × B(x).

Example: If poly1 = [1, 2, 3] represents A(x) = 1 + 2x + 3x² and poly2 = [4, 5] represents B(x) = 4 + 5x, then their product should be R(x) = 4 + 13x + 22x² + 15x³, returned as [4, 13, 22, 15].

Your goal: Return an integer array representing the coefficients of the product polynomial, where the result has length (poly1.length + poly2.length - 1).

Input & Output

example_1.py — Basic Multiplication

$ Input: poly1 = [1, 2, 3], poly2 = [4, 5]

› Output: [4, 13, 22, 15]

💡 Note: A(x) = 1 + 2x + 3x², B(x) = 4 + 5x. Product: (1×4) + (1×5 + 2×4)x + (2×5 + 3×4)x² + (3×5)x³ = 4 + 13x + 22x² + 15x³

example_2.py — Single Coefficient

$ Input: poly1 = [1, 2], poly2 = [3]

› Output: [3, 6]

💡 Note: A(x) = 1 + 2x, B(x) = 3. Product: 3(1 + 2x) = 3 + 6x

example_3.py — Zero Coefficient

$ Input: poly1 = [0, 1], poly2 = [1, 0, 1]

› Output: [0, 0, 1, 0]

💡 Note: A(x) = x, B(x) = 1 + x². Product: x(1 + x²) = x + x³, represented as [0, 1, 0, 1] but result length is 4

Constraints

1 ≤ poly1.length, poly2.length ≤ 100
-100 ≤ poly1[i], poly2[i] ≤ 100
Both input arrays represent valid polynomials

Visualization

Tap to expand

Understanding the Visualization

Setup Result Array

Prepare slots for all possible power combinations (0 to n+m-2)

Distribute Pairs

Each student from class 1 dances with each student from class 2

Accumulate Contributions

All pairs contributing to same power level combine their scores

Final Result

Each position contains the sum of all contributions to that power

Key Takeaway

🎯 Key Insight: When multiplying polynomials, each coefficient pair contributes to exactly one power of x, determined by adding their positions (i + j). This natural mapping makes the nested loop approach both intuitive and optimal!

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 Apple 12

The optimal solution uses nested loops to multiply each coefficient from the first polynomial with every coefficient from the second polynomial. The key insight is that xⁱ × x^j = x^(i+j), so we accumulate products at the correct result index. Time complexity is O(n×m) which is optimal for general polynomial multiplication.

Common Approaches

Approach	Time	Space	Notes
✓ Nested Loops (Standard Approach)	O(n×m)	O(n+m)	Multiply each coefficient from first polynomial with each coefficient from second polynomial

Nested Loops (Standard Approach) — Algorithm Steps

Initialize result array of size (len1 + len2 - 1) with zeros
For each coefficient at position i in first polynomial
For each coefficient at position j in second polynomial
Multiply coefficients and add to result[i + j]
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Result Array

Create array of size (3+2-1)=4 filled with zeros

Multiply 1×4

poly1[0] × poly2[0] = 1×4 = 4, add to result[0+0] = result[0]

Multiply 1×5

poly1[0] × poly2[1] = 1×5 = 5, add to result[0+1] = result[1]

Continue Pattern

Each poly1[i] × poly2[j] contributes to result[i+j]

Code -

solution.c — C

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

int* multiplyPolynomials(int* poly1, int n, int* poly2, int m, int* resultSize) {
    if (n == 0 || m == 0) {
        *resultSize = 0;
        return NULL;
    }
    
    *resultSize = n + m - 1;
    int* result = (int*)calloc(*resultSize, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            result[i + j] += poly1[i] * poly2[j];
        }
    }
    
    return result;
}

int main() {
    int poly1[] = {1, 2, 3};
    int poly2[] = {4, 5};
    int resultSize;
    int* result = multiplyPolynomials(poly1, 3, poly2, 2, &resultSize);
    
    for (int i = 0; i < resultSize; i++) {
        printf("%d ", result[i]);
    }
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

We need to multiply each of n coefficients with each of m coefficients

✓ Linear Growth

Space Complexity

O(n+m)

Result array size is (n + m - 1) to store all possible powers

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Constraints

Visualization

Related Problems

Common Approaches

Nested Loops (Standard Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler