# Find the sum between given cells of a 3D Array

Prerequisite: Prefix Sum â€“ 3D

Given a 3-Dimensional array of integers arr[L][R][C] (where L, R, and C are dimensions of the array) and 6 integers D, E, F, X, Y, Z, find the sum of integers between arr[D][E][F] and arr[X][Y][Z] inclusively.

### Example:

Input:
A[L][R][C]:
{{ { 1, 1, 1, 1 }
{ 1, 1, 1, 1 },
{ 1, 1, 1, 1 },
{ 1, 1, 1, 1 } },
{ { 1, 1, 1, 1 }
{ 1, 1, 1, 1 },
{ 1, 1, 1, 1 },
{ 1, 1, 1, 1 } },
{ { 1, 1, 1, 1 }
{ 1, 1, 1, 1 },
{ 1, 1, 1, 1 },
{ 1, 1, 1, 1 } },
{ { 1, 1, 1, 1 }
{ 1, 1, 1, 1 },
{ 1, 1, 1, 1 },
{ 1, 1, 1, 1 } }};

A: 1, B: 1, C: 1, X: 1, Y: 1, Z: 1

Output: 27

Explanation:
The sum between arr(1, 1, 1) and arr(3, 3, 3) is 27

Approach:

• Calculate the prefix sum of given array arr[L][R][C] and store it in a variable prefixSum (see this for reference ).
• Create a variable sum, which will store the answer i.e. sum between arr[D][E][F] and arr[X][Y][Z] and initialise it with the prefixSum till X, Y, Z. So, sum=prefixSum[X][Y][Z].
• Now, just remove the value of the cells not needed in this prefix sum. This can be done by:
• Remove prefix sum till (D-1, Y, Z): To remove the unnecessary cells from the left of the required region.
• Remove prefix sum till (X, E-1, Z): To remove the unnecessary cells from the bottom of each layer, not present in the required region.
• Remove prefix sum till (X, Y, F-1): To remove the unnecessary layers present below the required region.

• Now the region below (D-1, E-1, Z), (X, E-1, F-1), (D-1, Y, F-1) is removed twice. To compensate for this, add the prefix sum till all these points into the sum.

• Now, while compensating the cell removed twice, cells below (D-1, E-1, F-1) are considered again. Remove them to get the final answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach.` `#include ` `using` `namespace` `std;`   `// Declaring size of the array` `#define L 4 // Layer` `#define R 4 // Row` `#define C 4 // Column`   `// Calculating prefix sum array` `void` `prefixSum3d(` `    ``vector > >& arr,` `    ``vector > >& prefixSum)` `{` `    ``// Step 0:` `    ``prefixSum[0][0][0] = arr[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++)` `        ``prefixSum[i][0][0]` `            ``= prefixSum[i - 1][0][0] + arr[i][0][0];`   `    ``for` `(``int` `i = 1; i < R; i++)` `        ``prefixSum[0][i][0]` `            ``= prefixSum[0][i - 1][0] + arr[0][i][0];`   `    ``for` `(``int` `i = 1; i < C; i++)` `        ``prefixSum[0][0][i]` `            ``= prefixSum[0][0][i - 1] + arr[0][0][i];`   `    ``// Step 2: Filling the cells` `    ``// of sides(made up using cells)` `    ``// which have common element arr[0][0][0].` `    ``// using prefix sum on 2d array` `    ``for` `(``int` `k = 1; k < L; k++) {` `        ``for` `(``int` `i = 1; i < R; i++) {` `            ``prefixSum[k][i][0]` `                ``= arr[k][i][0] + prefixSum[k - 1][i][0]` `                  ``+ prefixSum[k][i - 1][0]` `                  ``- prefixSum[k - 1][i - 1][0];` `        ``}` `    ``}` `    ``for` `(``int` `i = 1; i < R; i++) {` `        ``for` `(``int` `j = 1; j < C; j++) {` `            ``prefixSum[0][i][j]` `                ``= arr[0][i][j] + prefixSum[0][i - 1][j]` `                  ``+ prefixSum[0][i][j - 1]` `                  ``- prefixSum[0][i - 1][j - 1];` `        ``}` `    ``}` `    ``for` `(``int` `j = 1; j < C; j++) {` `        ``for` `(``int` `k = 1; k < L; k++) {` `            ``prefixSum[k][0][j]` `                ``= arr[k][0][j] + prefixSum[k - 1][0][j]` `                  ``+ prefixSum[k][0][j - 1]` `                  ``- prefixSum[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++) {` `                ``prefixSum[k][i][j]` `                    ``= arr[k][i][j]`   `                      ``+ prefixSum[k - 1][i][j]` `                      ``+ prefixSum[k][i - 1][j]` `                      ``+ prefixSum[k][i][j - 1]`   `                      ``- prefixSum[k - 1][i - 1][j]` `                      ``- prefixSum[k][i - 1][j - 1]` `                      ``- prefixSum[k - 1][i][j - 1]`   `                      ``+ prefixSum[k - 1][i - 1][j - 1];` `            ``}` `        ``}` `    ``}` `}`   `int` `calculateSum(` `    ``vector > >& arr,` `    ``vector > >& prefixSum,` `    ``int` `D, ``int` `E, ``int` `F, ``int` `X, ``int` `Y, ``int` `Z)` `{`   `    ``// store prefix sum up to arr[X][Y][Z]:` `    ``int` `sum = prefixSum[X][Y][Z];`   `    ``// Remove prefix sum till D, E, F.` `    ``if` `(D > 0) {` `        ``sum -= prefixSum[D - 1][Y][Z];` `    ``}` `    ``if` `(E > 0) {` `        ``sum -= prefixSum[X][E - 1][Z];` `    ``}` `    ``if` `(F > 0) {` `        ``sum -= prefixSum[X][Y][F - 1];` `    ``}`   `    ``// Add to compensate cells removed multiple times.` `    ``if` `(D > 0 && E > 0) {` `        ``sum += prefixSum[D - 1][E - 1][Z];` `    ``}` `    ``if` `(E > 0 && F > 0) {` `        ``sum += prefixSum[X][E - 1][F - 1];` `    ``}` `    ``if` `(F > 0 && D > 0) {` `        ``sum += prefixSum[D - 1][Y][F - 1];` `    ``}`   `    ``// Removing cells added twice in the above step.` `    ``if` `(D > 0 && E > 0 && F > 0) {` `        ``sum -= prefixSum[D - 1][E - 1][F - 1];` `    ``}`   `    ``return` `sum;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given 3D array:` `    ``vector > > arr(` `        ``L, vector >(R, vector<``int``>(C)));` `    ``arr = { { { 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 } },`   `            ``{ { 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 } },`   `            ``{ { 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 } },`   `            ``{ { 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 } } };`   `    ``// To store the prefixSum` `    ``vector > > prefixSum(` `        ``L, vector >(R, vector<``int``>(C)));`   `    ``// To calculate the prefixSum` `    ``prefixSum3d(arr, prefixSum);` `    ``int` `D, E, F, X, Y, Z;` `    ``D = 1;` `    ``E = 1;` `    ``F = 1;` `    ``X = 3;` `    ``Y = 3;` `    ``Z = 3;`   `    ``cout << calculateSum(arr, prefixSum, D, E, F, X, Y, Z);` `    ``return` `0;` `}`

## Java

 `// Java program for the above approach.` `import` `java.util.*;`   `class` `GFG{`   `// Declaring size of the array` `static` `final` `int` `L = ``4``; ``// Layer` `static` `final` `int` `R = ``4``; ``// Row` `static` `final` `int` `C = ``4``; ``// Column`   `// Calculating prefix sum array` `static` `void` `prefixSum3d(` `    ``int` `[][][] arr,` `    ``int` `[][][] prefixSum)` `{` `    ``// Step 0:` `    ``prefixSum[``0``][``0``][``0``] = arr[``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++)` `        ``prefixSum[i][``0``][``0``]` `            ``= prefixSum[i - ``1``][``0``][``0``] + arr[i][``0``][``0``];`   `    ``for` `(``int` `i = ``1``; i < R; i++)` `        ``prefixSum[``0``][i][``0``]` `            ``= prefixSum[``0``][i - ``1``][``0``] + arr[``0``][i][``0``];`   `    ``for` `(``int` `i = ``1``; i < C; i++)` `        ``prefixSum[``0``][``0``][i]` `            ``= prefixSum[``0``][``0``][i - ``1``] + arr[``0``][``0``][i];`   `    ``// Step 2: Filling the cells` `    ``// of sides(made up using cells)` `    ``// which have common element arr[0][0][0].` `    ``// using prefix sum on 2d array` `    ``for` `(``int` `k = ``1``; k < L; k++) {` `        ``for` `(``int` `i = ``1``; i < R; i++) {` `            ``prefixSum[k][i][``0``]` `                ``= arr[k][i][``0``] + prefixSum[k - ``1``][i][``0``]` `                  ``+ prefixSum[k][i - ``1``][``0``]` `                  ``- prefixSum[k - ``1``][i - ``1``][``0``];` `        ``}` `    ``}` `    ``for` `(``int` `i = ``1``; i < R; i++) {` `        ``for` `(``int` `j = ``1``; j < C; j++) {` `            ``prefixSum[``0``][i][j]` `                ``= arr[``0``][i][j] + prefixSum[``0``][i - ``1``][j]` `                  ``+ prefixSum[``0``][i][j - ``1``]` `                  ``- prefixSum[``0``][i - ``1``][j - ``1``];` `        ``}` `    ``}` `    ``for` `(``int` `j = ``1``; j < C; j++) {` `        ``for` `(``int` `k = ``1``; k < L; k++) {` `            ``prefixSum[k][``0``][j]` `                ``= arr[k][``0``][j] + prefixSum[k - ``1``][``0``][j]` `                  ``+ prefixSum[k][``0``][j - ``1``]` `                  ``- prefixSum[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++) {` `                ``prefixSum[k][i][j]` `                    ``= arr[k][i][j]`   `                      ``+ prefixSum[k - ``1``][i][j]` `                      ``+ prefixSum[k][i - ``1``][j]` `                      ``+ prefixSum[k][i][j - ``1``]`   `                      ``- prefixSum[k - ``1``][i - ``1``][j]` `                      ``- prefixSum[k][i - ``1``][j - ``1``]` `                      ``- prefixSum[k - ``1``][i][j - ``1``]`   `                      ``+ prefixSum[k - ``1``][i - ``1``][j - ``1``];` `            ``}` `        ``}` `    ``}` `}`   `static` `int` `calculateSum(` `    ``int` `[][][] arr,` `    ``int` `[][][] prefixSum,` `    ``int` `D, ``int` `E, ``int` `F, ``int` `X, ``int` `Y, ``int` `Z)` `{`   `    ``// store prefix sum up to arr[X][Y][Z]:` `    ``int` `sum = prefixSum[X][Y][Z];`   `    ``// Remove prefix sum till D, E, F.` `    ``if` `(D > ``0``) {` `        ``sum -= prefixSum[D - ``1``][Y][Z];` `    ``}` `    ``if` `(E > ``0``) {` `        ``sum -= prefixSum[X][E - ``1``][Z];` `    ``}` `    ``if` `(F > ``0``) {` `        ``sum -= prefixSum[X][Y][F - ``1``];` `    ``}`   `    ``// Add to compensate cells removed multiple times.` `    ``if` `(D > ``0` `&& E > ``0``) {` `        ``sum += prefixSum[D - ``1``][E - ``1``][Z];` `    ``}` `    ``if` `(E > ``0` `&& F > ``0``) {` `        ``sum += prefixSum[X][E - ``1``][F - ``1``];` `    ``}` `    ``if` `(F > ``0` `&& D > ``0``) {` `        ``sum += prefixSum[D - ``1``][Y][F - ``1``];` `    ``}`   `    ``// Removing cells added twice in the above step.` `    ``if` `(D > ``0` `&& E > ``0` `&& F > ``0``) {` `        ``sum -= prefixSum[D - ``1``][E - ``1``][F - ``1``];` `    ``}`   `    ``return` `sum;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  `  `    ``// Given 3D array:` `    ``int` `[][][] arr = { { { ``1``, ``1``, ``1``, ``1` `},` `              ``{ ``1``, ``1``, ``1``, ``1` `},` `              ``{ ``1``, ``1``, ``1``, ``1` `},` `              ``{ ``1``, ``1``, ``1``, ``1` `} },`   `            ``{ { ``1``, ``1``, ``1``, ``1` `},` `              ``{ ``1``, ``1``, ``1``, ``1` `},` `              ``{ ``1``, ``1``, ``1``, ``1` `},` `              ``{ ``1``, ``1``, ``1``, ``1` `} },`   `            ``{ { ``1``, ``1``, ``1``, ``1` `},` `              ``{ ``1``, ``1``, ``1``, ``1` `},` `              ``{ ``1``, ``1``, ``1``, ``1` `},` `              ``{ ``1``, ``1``, ``1``, ``1` `} },`   `            ``{ { ``1``, ``1``, ``1``, ``1` `},` `              ``{ ``1``, ``1``, ``1``, ``1` `},` `              ``{ ``1``, ``1``, ``1``, ``1` `},` `              ``{ ``1``, ``1``, ``1``, ``1` `} } };`   `    ``// To store the prefixSum` `    ``int` `[][][] prefixSum= ``new` `int``[L][R][C];`   `    ``// To calculate the prefixSum` `    ``prefixSum3d(arr, prefixSum);` `    ``int` `D, E, F, X, Y, Z;` `    ``D = ``1``;` `    ``E = ``1``;` `    ``F = ``1``;` `    ``X = ``3``;` `    ``Y = ``3``;` `    ``Z = ``3``;`   `    ``System.out.print(calculateSum(arr, prefixSum, D, E, F, X, Y, Z));` `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the above approach.`   `# Declaring size of the array` `L ``=` `4`  `# Layer` `R ``=` `4`  `# Row` `C ``=` `4`  `# Column`   `# Calculating prefix sum array` `def` `prefixSum3d(arr, prefixSum):`   `        ``# Step 0:` `    ``prefixSum[``0``][``0``][``0``] ``=` `arr[``0``][``0``][``0``]`   `    ``# Step 1: Filling the first row,` `    ``# column, and pile of ceils.` `    ``# Using prefix sum of 1d array` `    ``for` `i ``in` `range``(``1``, L):` `        ``prefixSum[i][``0``][``0``] ``=` `prefixSum[i ``-` `1``][``0``][``0``] ``+` `arr[i][``0``][``0``]`   `    ``for` `i ``in` `range``(``1``, R):` `        ``prefixSum[``0``][i][``0``] ``=` `prefixSum[``0``][i ``-` `1``][``0``] ``+` `arr[``0``][i][``0``]`   `    ``for` `i ``in` `range``(``1``, C):` `        ``prefixSum[``0``][``0``][i] ``=` `prefixSum[``0``][``0``][i ``-` `1``] ``+` `arr[``0``][``0``][i]`   `        ``# Step 2: Filling the cells` `        ``# of sides(made up using cells)` `        ``# which have common element arr[0][0][0].` `        ``# using prefix sum on 2d array` `    ``for` `k ``in` `range``(``1``, L):` `        ``for` `i ``in` `range``(``1``, R):` `            ``prefixSum[k][i][``0``] ``=` `arr[k][i][``0``] ``+` `prefixSum[k ``-` `1``][i][``0``] ``+` `\` `                ``prefixSum[k][i ``-` `1``][``0``] ``-` `prefixSum[k ``-` `1``][i ``-` `1``][``0``]`   `    ``for` `i ``in` `range``(``1``, R):` `        ``for` `j ``in` `range``(``1``, C):` `            ``prefixSum[``0``][i][j] ``=` `arr[``0``][i][j] ``+` `prefixSum[``0``][i ``-` `1``][j] ``+` `\` `                ``prefixSum[``0``][i][j ``-` `1``] ``-` `prefixSum[``0``][i ``-` `1``][j ``-` `1``]`   `    ``for` `j ``in` `range``(``1``, C):` `        ``for` `k ``in` `range``(``1``, L):` `            ``prefixSum[k][``0``][j] ``=` `arr[k][``0``][j] ``+` `prefixSum[k ``-` `1``][``0``][j] ``+` `\` `                ``prefixSum[k][``0``][j ``-` `1``] ``-` `prefixSum[k ``-` `1``][``0``][j ``-` `1``]`   `        ``# Step 3: Filling value` `        ``# in remaining cells using formula` `    ``for` `k ``in` `range``(``1``, L):` `        ``for` `i ``in` `range``(``1``, R):` `            ``for` `j ``in` `range``(``1``, C):` `                ``prefixSum[k][i][j] ``=` `arr[k][i][j] ``+` `prefixSum[k ``-` `1``][i][j] ``+` `prefixSum[k][i ``-` `1``][j] ``+` `prefixSum[k][i][j ``-` `1``] ``-` `\` `                    ``prefixSum[k ``-` `1``][i ``-` `1``][j] ``-` `prefixSum[k][i ``-` `1``][j ``-` `1``] ``-` `\` `                    ``prefixSum[k ``-` `1``][i][j ``-` `1``] ``+` `prefixSum[k ``-` `1``][i ``-` `1``][j ``-` `1``]`     `def` `calculateSum(arr, prefixSum, D, E, F, X, Y, Z):`   `        ``# store prefix sum up to arr[X][Y][Z]:` `    ``sum` `=` `prefixSum[X][Y][Z]`   `    ``# Remove prefix sum till D, E, F.` `    ``if` `(D > ``0``):` `        ``sum` `-``=` `prefixSum[D ``-` `1``][Y][Z]`   `    ``if` `(E > ``0``):` `        ``sum` `-``=` `prefixSum[X][E ``-` `1``][Z]`   `    ``if` `(F > ``0``):` `        ``sum` `-``=` `prefixSum[X][Y][F ``-` `1``]`   `    ``# Add to compensate cells removed multiple times.` `    ``if` `(D > ``0` `and` `E > ``0``):` `        ``sum` `+``=` `prefixSum[D ``-` `1``][E ``-` `1``][Z]`   `    ``if` `(E > ``0` `and` `F > ``0``):` `        ``sum` `+``=` `prefixSum[X][E ``-` `1``][F ``-` `1``]`   `    ``if` `(F > ``0` `and` `D > ``0``):` `        ``sum` `+``=` `prefixSum[D ``-` `1``][Y][F ``-` `1``]`   `    ``# Removing cells added twice in the above step.` `    ``if` `(D > ``0` `and` `E > ``0` `and` `F > ``0``):` `        ``sum` `-``=` `prefixSum[D ``-` `1``][E ``-` `1``][F ``-` `1``]`   `    ``return` `sum`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``# Given 3D array:`   `    ``arr ``=` `[[[``1``, ``1``, ``1``, ``1``],` `            ``[``1``, ``1``, ``1``, ``1``],` `            ``[``1``, ``1``, ``1``, ``1``],` `            ``[``1``, ``1``, ``1``, ``1``]],`   `           ``[[``1``, ``1``, ``1``, ``1``],` `            ``[``1``, ``1``, ``1``, ``1``],` `            ``[``1``, ``1``, ``1``, ``1``],` `            ``[``1``, ``1``, ``1``, ``1``]],`   `           ``[[``1``, ``1``, ``1``, ``1``],` `            ``[``1``, ``1``, ``1``, ``1``],` `            ``[``1``, ``1``, ``1``, ``1``],` `            ``[``1``, ``1``, ``1``, ``1``]],`   `           ``[[``1``, ``1``, ``1``, ``1``],` `            ``[``1``, ``1``, ``1``, ``1``],` `            ``[``1``, ``1``, ``1``, ``1``],` `            ``[``1``, ``1``, ``1``, ``1``]]]`   `    ``# To store the prefixSum` `    ``prefixSum ``=` `[[[``0` `for` `_ ``in` `range``(C)] ``for` `_ ``in` `range``(R)] ``for` `_ ``in` `range``(L)]`   `    ``# To calculate the prefixSum` `    ``prefixSum3d(arr, prefixSum)` `    ``D ``=` `1` `    ``E ``=` `1` `    ``F ``=` `1` `    ``X ``=` `3` `    ``Y ``=` `3` `    ``Z ``=` `3`   `    ``print``(calculateSum(arr, prefixSum, D, E, F, X, Y, Z))`   `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# program for the above approach.` `using` `System;`   `public` `class` `GFG{`   `// Declaring size of the array` `static` `readonly` `int` `L = 4; ``// Layer` `static` `readonly` `int` `R = 4; ``// Row` `static` `readonly` `int` `C = 4; ``// Column`   `// Calculating prefix sum array` `static` `void` `prefixSum3d(` `    ``int` `[,,] arr,` `    ``int` `[,,] prefixSum)` `{` `    ``// Step 0:` `    ``prefixSum[0,0,0] = arr[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++)` `        ``prefixSum[i,0,0]` `            ``= prefixSum[i - 1,0,0] + arr[i,0,0];`   `    ``for` `(``int` `i = 1; i < R; i++)` `        ``prefixSum[0,i,0]` `            ``= prefixSum[0,i - 1,0] + arr[0,i,0];`   `    ``for` `(``int` `i = 1; i < C; i++)` `        ``prefixSum[0,0,i]` `            ``= prefixSum[0,0,i - 1] + arr[0,0,i];`   `    ``// Step 2: Filling the cells` `    ``// of sides(made up using cells)` `    ``// which have common element arr[0,0,0].` `    ``// using prefix sum on 2d array` `    ``for` `(``int` `k = 1; k < L; k++) {` `        ``for` `(``int` `i = 1; i < R; i++) {` `            ``prefixSum[k,i,0]` `                ``= arr[k,i,0] + prefixSum[k - 1,i,0]` `                  ``+ prefixSum[k,i - 1,0]` `                  ``- prefixSum[k - 1,i - 1,0];` `        ``}` `    ``}` `    ``for` `(``int` `i = 1; i < R; i++) {` `        ``for` `(``int` `j = 1; j < C; j++) {` `            ``prefixSum[0,i,j]` `                ``= arr[0,i,j] + prefixSum[0,i - 1,j]` `                  ``+ prefixSum[0,i,j - 1]` `                  ``- prefixSum[0,i - 1,j - 1];` `        ``}` `    ``}` `    ``for` `(``int` `j = 1; j < C; j++) {` `        ``for` `(``int` `k = 1; k < L; k++) {` `            ``prefixSum[k,0,j]` `                ``= arr[k,0,j] + prefixSum[k - 1,0,j]` `                  ``+ prefixSum[k,0,j - 1]` `                  ``- prefixSum[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++) {` `                ``prefixSum[k,i,j]` `                    ``= arr[k,i,j]`   `                      ``+ prefixSum[k - 1,i,j]` `                      ``+ prefixSum[k,i - 1,j]` `                      ``+ prefixSum[k,i,j - 1]`   `                      ``- prefixSum[k - 1,i - 1,j]` `                      ``- prefixSum[k,i - 1,j - 1]` `                      ``- prefixSum[k - 1,i,j - 1]`   `                      ``+ prefixSum[k - 1,i - 1,j - 1];` `            ``}` `        ``}` `    ``}` `}`   `static` `int` `calculateSum(` `    ``int` `[,,] arr,` `    ``int` `[,,] prefixSum,` `    ``int` `D, ``int` `E, ``int` `F, ``int` `X, ``int` `Y, ``int` `Z)` `{`   `    ``// store prefix sum up to arr[X,Y,Z]:` `    ``int` `sum = prefixSum[X,Y,Z];`   `    ``// Remove prefix sum till D, E, F.` `    ``if` `(D > 0) {` `        ``sum -= prefixSum[D - 1,Y,Z];` `    ``}` `    ``if` `(E > 0) {` `        ``sum -= prefixSum[X,E - 1,Z];` `    ``}` `    ``if` `(F > 0) {` `        ``sum -= prefixSum[X,Y,F - 1];` `    ``}`   `    ``// Add to compensate cells removed multiple times.` `    ``if` `(D > 0 && E > 0) {` `        ``sum += prefixSum[D - 1,E - 1,Z];` `    ``}` `    ``if` `(E > 0 && F > 0) {` `        ``sum += prefixSum[X,E - 1,F - 1];` `    ``}` `    ``if` `(F > 0 && D > 0) {` `        ``sum += prefixSum[D - 1,Y,F - 1];` `    ``}`   `    ``// Removing cells added twice in the above step.` `    ``if` `(D > 0 && E > 0 && F > 0) {` `        ``sum -= prefixSum[D - 1,E - 1,F - 1];` `    ``}`   `    ``return` `sum;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  `  `    ``// Given 3D array:` `    ``int` `[,,] arr = { { { 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 } },`   `            ``{ { 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 } },`   `            ``{ { 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 } },`   `            ``{ { 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 },` `              ``{ 1, 1, 1, 1 } } };`   `    ``// To store the prefixSum` `    ``int` `[,,] prefixSum= ``new` `int``[L,R,C];`   `    ``// To calculate the prefixSum` `    ``prefixSum3d(arr, prefixSum);` `    ``int` `D, E, F, X, Y, Z;` `    ``D = 1;` `    ``E = 1;` `    ``F = 1;` `    ``X = 3;` `    ``Y = 3;` `    ``Z = 3;`   `    ``Console.Write(calculateSum(arr, prefixSum, D, E, F, X, Y, Z));` `}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`27`

Time Complexity: O(L*R*C)
Auxiliary Space: O(L*R*C)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next