Count distinct elements after adding each element of First Array with Second Array

// C# program for the above approach
using System;
using System.Linq;

class GFG{

// Function to find Occurrence of each
// element from 1 to 2*MAX
static void findCount(int[] Arr1, int[]Arr2)
{
    
    // Initialise MAX
    int MAX = Math.Max(Arr1.Max(), Arr2.Max());

    // Count vector to store count of
    // each element from 1 to 2*MAX
    int[] Count = new int[2 * MAX + 1];

    // Size of Arr1 and Arr2
    int n = Arr1.Length, m = Arr2.Length;

    // Find the elements of arr3[] and
    // increase count of element by 1
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < m; j++)
        {
            int element = Arr1[i] + Arr2[j];
            Count[element]++;
        }
    }

    // Print the result
    for(int i = 1; i <= 2 * MAX; i++)
    {
        if (Count[i] > 0)
        {
            Console.Write(i + "->" + 
                   Count[i] + "\n");
        }
    }
}

// Driver Code
public static void Main(String[] args)
{
    
    // Given arrays arr1[] and arr2[]
    int[] arr1 = { 1, 2 };
    int[] arr2 = { 1, 2, 1 };

    // Function call
    findCount(arr1, arr2);
}
}

// This code is contributed by Princi Singh 

using System;
using System.Linq;
using System.Collections.Generic;

// Complex class definition
class Complex {
    // Data members
    public double real, imag;

    // Constructor
    public Complex(double real, double imag)
    {
        this.real = real;
        this.imag = imag;
    }

    // Method to Add two Complex objects
    public Complex Add(Complex other)
    {
        return new Complex(real + other.real,
                           imag + other.imag);
    }

    // Method to subtract two Complex objects
    public Complex Subtract(Complex other)
    {
        return new Complex(real - other.real,
                           imag - other.imag);
    }

    // Method to multiply two Complex objects
    public Complex Multiply(Complex other)
    {
        double re = real * other.real - imag * other.imag;
        double im = real * other.imag + imag * other.real;
        return new Complex(re, im);
    }

    // Method to divide two Complex objects
    public Complex Divide(Complex other)
    {
        double denom = other.real * other.real
                       + other.imag * other.imag;
        double re = (real * other.real + imag * other.imag)
                    / denom;
        double im = (imag * other.real - real * other.imag)
                    / denom;
        return new Complex(re, im);
    }
}

class GFG {
    // Function to implement the FFT
    public static void fft(List<Complex> a, bool invert)
    {
        int n = a.Count;
        if (n == 1)
            return;

        List<Complex> a0 = new List<Complex>();
        List<Complex> a1 = new List<Complex>();
        for (int i = 0; 2 * i < n; i++) {
            a0.Add(a[2 * i]);
            a1.Add(a[2 * i + 1]);
        }

        // Recursively find fft
        fft(a0, invert);
        fft(a1, invert);

        double ang = 2 * Math.PI / n * (invert ? -1 : 1);

        Complex w = new Complex(1, 0);
        Complex wn
            = new Complex(Math.Cos(ang), Math.Sin(ang));

        for (int i = 0; 2 * i < n; i++) {
            a[i] = a0[i].Add(w.Multiply(a1[i]));
            a[i + n / 2]
                = a0[i].Subtract(w.Multiply(a1[i]));
            if (invert) {
                a[i] = a[i].Divide(new Complex(2, 0));
                a[i + n / 2] = a[i + n / 2].Divide(
                    new Complex(2, 0));
            }
            w = w.Multiply(wn);
        }
    }

    // Function to multiply two polynomials A(x) and B(x)
    // using FFT
    public static List<int> Multiply(int[] a, int[] b)
    {
        List<Complex> fa = new List<Complex>();
        List<Complex> fb = new List<Complex>();
        for (int i = 0; i < a.Length; i++)
            fa.Add(new Complex(a[i], 0));
        for (int i = 0; i < b.Length; i++)
            fb.Add(new Complex(b[i], 0));

        int n = 1;
        while (n < a.Length + b.Length)
            n <<= 1;

        // Resize fa and fb
        while (fa.Count < n)
            fa.Add(new Complex(0, 0));
        while (fb.Count < n)
            fb.Add(new Complex(0, 0));

        // Assign initially false
        fft(fa, false);
        fft(fb, false);

        for (int i = 0; i < n; i++) {
            fa[i] = fa[i].Multiply(fb[i]);
        }

        fft(fa, true);

        // To store the result
        List<int> result = new List<int>();
        for (int i = 0; i < n; i++) {
            result.Add((int)Math.Floor(fa[i].real));
        }

        // Return result
        return result;
    }

    // Function to find the Count of each
    // element from 1 to 2*MAX
    public static void FindCount(List<int> arr1,
                                 List<int> arr2)
    {
        // Initialise MAX
        int MAX = Math.Max(arr1.Max(), arr2.Max());

        int n = arr1.Count;
        int m = arr2.Count;

        // vector for Polynomial A(x) from Arr1
        int[] A = new int[MAX + 1];

        for (int i = 0; i < n; i++) {
            A[arr1[i]]++;
        }

        // Vector for Polynomial B(x) from Arr2
        int[] B = new int[MAX + 1];

        for (int i = 0; i < m; i++) {
            B[arr2[i]]++;
        }

        // Vector to store the result of
        // multiplication of A(x) and B(x)
        List<int> P = Multiply(A, B);

        // Print the result
        for (int i = 1; i <= 2 * MAX; i++) {
            if (P[i] > 0) {
                Console.WriteLine(i + "->" + P[i]);
            }
        }

        Console.WriteLine(" ");
    }

    // Driver Code
    public static void Main(string[] args)
    {
        // Given arrays arr1[] and arr2[]
        List<int> arr1 = new List<int>();
        arr1.Add(1);
        arr1.Add(2);

        List<int> arr2 = new List<int>();
        arr2.Add(1);
        arr2.Add(2);
        arr2.Add(1);

        // Function Call
        FindCount(arr1, arr2);
    }
}