Fast Fourier Transform - Problem

Implement the Fast Fourier Transform (FFT) algorithm to efficiently multiply two polynomials represented as coefficient arrays.

Given two polynomials A(x) and B(x) represented by their coefficient arrays, compute their product C(x) = A(x) * B(x) and return the coefficients of the resulting polynomial.

For polynomial A(x) = a₀ + a₁x + a₂x² + ... + aₙxⁿ, the coefficient array is [a₀, a₁, a₂, ..., aₙ].

Note: The degree of the product polynomial C(x) will be deg(A) + deg(B), so if A has degree n and B has degree m, then C will have degree n+m.

Input & Output

Example 1 — Basic Linear Polynomials

$ Input: polyA = [1, 2], polyB = [3, 4]

› Output: [3, 10, 8]

💡 Note: (1 + 2x)(3 + 4x) = 1×3 + 1×4x + 2x×3 + 2x×4x = 3 + 4x + 6x + 8x² = 3 + 10x + 8x²

Example 2 — Constant and Linear

$ Input: polyA = [5], polyB = [2, 1]

› Output: [10, 5]

💡 Note: 5 × (2 + x) = 5×2 + 5×1×x = 10 + 5x

Example 3 — Quadratic Multiplication

$ Input: polyA = [1, 0, 1], polyB = [1, 1]

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

💡 Note: (1 + x²)(1 + x) = 1×1 + 1×x + x²×1 + x²×x = 1 + x + x² + x³

Constraints

1 ≤ polyA.length, polyB.length ≤ 10⁴
-1000 ≤ polyA[i], polyB[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 A Apple 12 f Meta 8

The key insight is converting convolution to multiplication using frequency domain. FFT approach transforms polynomials to point-value representation, multiplies point-wise, then transforms back. Time: O(n log n), Space: O(n)

Common Approaches

✓ Fast Fourier Transform (FFT)

⏱️ Time: O(n log n) Space: O(n)

Transform both polynomials to frequency domain using FFT, perform point-wise multiplication, then use inverse FFT to get result coefficients.

Naive Polynomial Multiplication

⏱️ Time: O(n²) Space: O(n + m)

Multiply each coefficient of the first polynomial with each coefficient of the second polynomial, then sum up terms with the same degree.

Fast Fourier Transform (FFT) — Algorithm Steps

Step 1: Pad both polynomials to next power of 2
Step 2: Apply FFT to convert to point-value representation
Step 3: Multiply corresponding point-values
Step 4: Apply inverse FFT to get result coefficients

Visualization

Tap to expand

Step-by-Step Walkthrough

Transform

Convert coefficients to frequency domain using FFT

Multiply

Point-wise multiplication in frequency domain

Inverse

Convert back to coefficients using inverse FFT

Code -

solution.c — C

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

typedef double complex cplx;

int nextPowerOf2(int n) {
    int p = 1;
    while (p < n) p <<= 1;
    return p;
}

void fft(cplx a[], int n, int inverse) {
    if (n <= 1) return;
    
    // Bit-reversal permutation
    for (int i = 1, j = 0; i < n; i++) {
        int bit = n >> 1;
        for (; j & bit; bit >>= 1) j ^= bit;
        j ^= bit;
        if (i < j) {
            cplx temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    }
    
    // FFT computation
    for (int len = 2; len <= n; len <<= 1) {
        double angle = 2 * M_PI / len * (inverse ? -1 : 1);
        cplx wlen = cos(angle) + I * sin(angle);
        
        for (int i = 0; i < n; i += len) {
            cplx w = 1;
            for (int j = 0; j < len / 2; j++) {
                cplx u = a[i + j];
                cplx v = a[i + j + len / 2] * w;
                a[i + j] = u + v;
                a[i + j + len / 2] = u - v;
                w *= wlen;
            }
        }
    }
    
    if (inverse) {
        for (int i = 0; i < n; i++) {
            a[i] /= n;
        }
    }
}

int* solution(int* polyA, int sizeA, int* polyB, int sizeB, int* returnSize) {
    if (sizeA == 0 || sizeB == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    *returnSize = sizeA + sizeB - 1;
    int size = nextPowerOf2(*returnSize);
    
    cplx* fa = (cplx*)calloc(size, sizeof(cplx));
    cplx* fb = (cplx*)calloc(size, sizeof(cplx));
    
    for (int i = 0; i < size; i++) {
        fa[i] = (i < sizeA) ? polyA[i] : 0;
        fb[i] = (i < sizeB) ? polyB[i] : 0;
    }
    
    fft(fa, size, 0);
    fft(fb, size, 0);
    
    for (int i = 0; i < size; i++) {
        fa[i] *= fb[i];
    }
    
    fft(fa, size, 1);
    
    int* result = (int*)malloc(*returnSize * sizeof(int));
    for (int i = 0; i < *returnSize; i++) {
        result[i] = (int)round(creal(fa[i]));
    }
    
    free(fa);
    free(fb);
    return result;
}

int parseArray(char* line, int** arr) {
    int count = 0;
    int capacity = 10;
    *arr = (int*)malloc(capacity * sizeof(int));
    
    char* ptr = strchr(line, '[');
    if (!ptr) return 0;
    ptr++;
    
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        if (count >= capacity) {
            capacity *= 2;
            *arr = (int*)realloc(*arr, capacity * sizeof(int));
        }
        (*arr)[count++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    return count;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int* polyA;
    int* polyB;
    int sizeA = parseArray(line1, &polyA);
    int sizeB = parseArray(line2, &polyB);
    
    int returnSize;
    int* result = solution(polyA, sizeA, polyB, sizeB, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(polyA);
    free(polyB);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

FFT operations divide-and-conquer with log n levels, n work per level

⚠ Quadratic Growth

Space Complexity

O(n)

Extra arrays for FFT computation and complex number storage

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~45 min Avg. Time

856 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

Fast Fourier Transform - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Fast Fourier Transform (FFT) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler