Prefix Sum Of 3D Array

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

class GFG{

// Declaring size of the array
static int L = 4; // Layer
static int R = 4; // Row
static int C = 4; // Column

// Calculating prefix sum array
static void prefixSum3d(int [,,]A)
{
    int [,,]pre = new int[L, R, C];

    // Step 0:
    pre[0, 0, 0] = A[0, 0, 0];

    // Step 1: Filling the first row,
    // column, and pile of ceils.
    // Using prefix sum of 1d array
    for(int i = 1; i < L; i++)
        pre[i, 0, 0] = pre[i - 1, 0, 0] + A[i, 0, 0];

    for(int i = 1; i < R; i++)
        pre[0, i, 0] = pre[0, i - 1, 0] + A[0, i, 0];

    for(int i = 1; i < C; i++)
        pre[0, 0, i] = pre[0, 0, i - 1] + A[0, 0, i];

    // Step 2: Filling the cells
    // of sides(made up using cells)
    // which have common element A[0][0][0].
    // using prefix sum on 2d array
    for(int k = 1; k < L; k++) 
    {
        for(int i = 1; i < R; i++) 
        {
            pre[k, i, 0] = A[k, i, 0] + pre[k - 1, i, 0] + 
                                        pre[k, i - 1, 0] - 
                                        pre[k - 1, i - 1, 0];
        }
    }
    for(int i = 1; i < R; i++) 
    {
        for(int j = 1; j < C; j++) 
        {
            pre[0, i, j] = A[0, i, j] + pre[0, i - 1, j] + 
                                        pre[0, i, j - 1] - 
                                        pre[0, i - 1, j - 1];
        }
    }
    for(int j = 1; j < C; j++)
    {
        for(int k = 1; k < L; k++)
        {
            pre[k, 0, j] = A[k, 0, j] + pre[k - 1, 0, j] + 
                                        pre[k, 0, j - 1] - 
                                        pre[k - 1, 0, j - 1];
        }
    }

    // Step 3: Filling value
    // in remaining cells using formula
    for(int k = 1; k < L; k++) 
    {
        for(int i = 1; i < R; i++) 
        {
            for(int j = 1; j < C; j++)
            {
                pre[k, i, j] = A[k, i, j] + pre[k - 1, i, j] + 
                                            pre[k, i - 1, j] + 
                                            pre[k, i, j - 1] - 
                                            pre[k - 1, i - 1, j] - 
                                            pre[k, i - 1, j - 1] - 
                                            pre[k - 1, i, j - 1] + 
                                            pre[k - 1, i - 1, j - 1];
            }
        }
    }

    // Displaying final prefix sum of array
    for(int k = 0; k < L; k++)
    {
        Console.WriteLine("Layer " + k + 1 + ":");
        for(int i = 0; i < R; i++) 
        {
            for(int j = 0; j < C; j++) 
            {
                Console.Write(pre[k, i, j] +" ");
            }
            Console.WriteLine();
        }
        Console.WriteLine();
    }
}

// Driver Code
public static void Main()
{
    int [,,]A = {
        { { 1, 1, 1, 1 }, // Layer 1
          { 1, 1, 1, 1 },
          { 1, 1, 1, 1 },
          { 1, 1, 1, 1 } },

        { { 1, 1, 1, 1 }, // Layer 2
          { 1, 1, 1, 1 },
          { 1, 1, 1, 1 },
          { 1, 1, 1, 1 } },

        { { 1, 1, 1, 1 }, // Layer 3
          { 1, 1, 1, 1 },
          { 1, 1, 1, 1 },
          { 1, 1, 1, 1 } },

        { { 1, 1, 1, 1 }, // Layer 4
          { 1, 1, 1, 1 },
          { 1, 1, 1, 1 },
          { 1, 1, 1, 1 } }
    };

    prefixSum3d(A);
}
}

// This code is contributed by SURENDRA_GANGWAR