Find Array obtained after adding terms of AP for Q queries

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

class GFG{

// Function to find array after performing
// the given query to the array elements
public static void addAP(int[] A, int Q, 
                         int[,] operations) 
{
    
    // Traverse the given query
    for(int j = 0; j < 2; ++j) 
    {
        int L = operations[j, 0], R = operations[j, 1], 
            a = operations[j, 2], d = operations[j, 3];
        int curr = a;

        // Traverse the given array
        for(int i = L - 1; i < R; i++)
        {
            
            // Update the value of A[i]
            A[i] += curr;

            // Update the value of curr
            curr += d;
        }
    }

    // Print the array elements
    for(int i = 0; i < 4; ++i)
        Console.Write(A[i] + " ");
}

// Driver code
public static void Main(string[] args)
{
    int[] A = { 5, 4, 2, 8 };
    int Q = 2;
    int[,] query = { { 1, 2, 1, 3 },
                     { 1, 4, 4, 1 } };

    // Function Call
    addAP(A, Q, query);
}
}

// This code is contributed by avijitmondal1998

using System;

class MainClass {
    static void Mysolution(int[] arr, int[][] query)
    {
        int n = arr.Length;

        // array used to simulate extra addition
        // (d1 + d2 + d3 + d4...) we perform with every
        // increment
        int[] collective_D = new int[n + 1];

        /*
        When we reach the end of AP
        we make correction of the extire sum of AP
        for the element that sum is useless
        but because it is part of
        S (variable we are using to take collective sum)
        so we make correction for the new index.
        */

        int[] S_collective_correction = new int[n + 1];
        int l, r, d, a, X = 0, S = 0;

        /* Here X variable used keeps track of d1 + d2 + d3
        ... numbers of parrarel AP we are using because if
        we look carefully next element difference with
        current element is X (d1 + d2 + d3 ... numbers of
        parrarel AP) */

        /* The other part of sum is captured by S and
        we make collective correction at the end of AP */

        foreach(int[] q in query)
        {
            l = q[0];
            r = q[1];
            a = q[2];
            d = q[3];
            r--;
            collective_D[l] += d;
            collective_D[r + 1] -= d;
            S_collective_correction[l - 1] += a;
            S_collective_correction[r + 1]
                -= a + (r + 1 - l) * d;
        }

        for (int i = 0; i < n; i++) {
            X += collective_D
                [i]; // X denotes the current D (d1 + d2 +
                     // d3..) that are running in parallel.
            S += S_collective_correction
                [i]; // If some AP starts or ends this makes
                     // necessary correction.
            S += X; // S is the (a1 + a2 + a3) + (n1*d1 +
                    // n2*d2 + n3*d3)
            arr[i] += S;
        }

        foreach(int i in arr) Console.Write(i + " ");
        Console.WriteLine();
    }

    public static void Main()
    {
        int[] v = { 5, 4, 2, 8 };

        // query format {l r, a, d}
        int[][] query
            = new int[][] { new int[] { 1, 2, 1, 3 },
                            new int[] { 1, 4, 4, 1 } };
        Mysolution(v, query);
    }
}