Program to generate an array having convolution of two given arrays

// Java program for the above approach
import java.util.*;

class GFG{

static int MOD = 998244353;

// Function to generate a convolution
// array of two given arrays
static void findConvolution(int[] a,
                            int[] b)
{
    
    // Stores the size of arrays
    int n = a.length, m = b.length;

    // Stores the final array
    int[] c = new int[(n + m - 1)];

    // Traverse the two given arrays
    for(int i = 0; i < n; ++i)
    {
        for(int j = 0; j < m; ++j) 
        {
            
            // Update the convolution array
            c[i + j] += (a[i] * b[j]) % MOD;
        }
    }

    // Print the convolution array c[]
    for(int k = 0; k < c.length; ++k)
    {
        c[k] %= MOD;
        System.out.print(c[k] + " ");
    }
}

// Driver Code
public static void main(String args[])
{
    int[] A = { 1, 2, 3, 4 };
    int[] B = { 5, 6, 7, 8, 9 };
  
    findConvolution(A, B);}
}

// This code is contributed by souravghosh0416

import java.math.BigInteger;

public class GFG {
    public static final long mod = 998244353;
    public static final int maxn = 3000000;

    public static long[] a = new long[maxn];
    public static long[] b = new long[maxn];

    // Function to find the next power of 2 using
    // bit masking
    public static int nextPowerOf2(int n)
    {
        // if n is a power of two simply return it
        if ((n & (n - 1)) == 0)
            return n;
        // else set only the left bit of most significant
        // bit as in Java right shift is filled with most
        // significant bit we consider
        return 0x40000000
            >> (Integer.numberOfLeadingZeros(n) - 2);
    }

    // Iterative fft function to compute
    // the DFT of given coefficient vector
    public static void fft(long w0, long n, long[] a)
    {
        // Do bit reversal of the given array
        for (long i = 0, j = 0; i < n; i++) {
            // Swap a[i] and a[j]
            if (i < j) {
                long temp = a[(int)i];
                a[(int)i] = a[(int)j];
                a[(int)j] = temp;
            }

            // Right Shift N by 1
            long bit = n >> 1;
            for (; (j & bit) != 0; bit >>= 1)
                j ^= bit;
            j ^= bit;
        }

        // Perform the iterative fft
        for (long len = 2; len <= n; len <<= 1) {
            long wlen = w0;
            for (long aux = n; aux > len; aux >>= 1) {
                wlen = wlen * wlen % mod;
            }

            for (long bat = 0; bat + len <= n; bat += len) {
                for (long i = bat, w = 1; i < bat + len / 2;
                     i++, w = w * wlen % mod) {
                    long u = a[(int)i],
                         v
                         = w * a[(int)(i + len / 2)] % mod;

                    // Update the value of a[i]
                    a[(int)i] = (u + v) % mod;

                    // Update the value
                    // of a[i + len/2]
                    a[(int)(i + len / 2)]
                        = ((u - v) % mod + mod) % mod;
                }
            }
        }
    }

    // Function to find (a ^ x) % mod
    public static long binpow(long a, long x)
    {
        // Stores the result of a ^ x
        long ans = 1;

        // Iterate over the value of x
        for (; x != 0; x /= 2, a = a * a % mod) {
            // If x is odd
            if ((x & 1) != 0)
                ans = ans * a % mod;
        }

        // Return the resultant value
        return ans;
    }

    // Function to find the
    // inverse of a % mod
    public static long inv(long a)
    {
        return binpow(a, mod - 2);
    }

    // Function to find the
    // convolution of two arrays
    static void FindConvolution(long[] a, long[] b, int n,
                                int m)
    {
        // Stores the first power of 2
        // greater than or equal to n + m
        int _n = nextPowerOf2(n + m);

        // Stores the primitive root
        long w = 15311432;
        for (int aux = 1 << 23; aux > _n; aux >>= 1)
            w = w * w % mod;

        // Convert arrays a[] and b[] to point value form
        fft(w, _n, a);
        fft(w, _n, b);

        // Perform multiplication
        for (int i = 0; i < _n; i++)
            a[i] = a[i] * b[i] % mod;

        // Perform inverse fft to recover final array
        fft(inv(w), _n, a);

        for (int i = 0; i < _n; i++)
            a[i] = a[i] * inv(_n) % mod;

        for (int i = 0; i < n + m - 1; i++)
            System.out.print(a[i] + " ");
    }

    public static void main(String[] args)
    {
        // Given size of the arrays
        int N = 4, M = 5;

        // Fill the arrays
        for (int i = 0; i < N; i++)
            a[i] = i + 1;

        for (int i = 0; i < M; i++)
            b[i] = 5 + i;

        FindConvolution(a, b, N, M);
    }
}