# Count of cells in a matrix whose adjacent cells’s sum is prime Number

• Last Updated : 30 Mar, 2022

Given a M x N matrix mat[][], the task is to count the number of cells which have the sum of its adjacent cells equal to a prime number. For a cell x[i][j], only x[i+1][j], x[i-1][j], x[i][j+1] and x[i][j-1] are the adjacent cells.
Examples:

Input : mat[][] = {{1, 3}, {2, 5}}
Output :
Explanation: Only the cells mat and mat satisfying the condition.
i.e for mat:(3+2) = 5, for mat: (3+2) = 5
Input : mat[][] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}
Output :
Explanation: Cells mat, mat, mat, mat, mat and mat are satisfying the condition.

Prerequisites: Sieve of Eratosthenes
Approach:

• Precompute and store the prime numbers using Sieve.
• Iterate the entire matrix and for each cell find the sum of all adjacent cells.
• If the sum of adjacent cells equal to a prime number then increments the count.
• Return the value of the count.

Below is the implementation of the above approach.

## C++

 `// CPP program to find the cells whose``// adjacent cells's sum is prime Number``#include ``using` `namespace` `std;``#define MAX 100005` `bool` `prime[MAX];` `void` `SieveOfEratosthenes()``{``    ``// Create a boolean array "prime[0..MAX-1]"``    ``// and initialize all entries it as true.``    ``// A value in prime[i] will finally``    ``// be false if i is Not a prime, else true.``    ``memset``(prime, ``true``, ``sizeof``(prime));` `    ``prime = prime = ``false``;` `    ``for` `(``int` `p = 2; p * p < MAX; p++) {``        ``// If prime[p] is not changed,``        ``// then it is a prime``        ``if` `(prime[p] == ``true``) {``            ``// Update all multiples of p``            ``// greater than or``            ``// equal to the square of it``            ``// numbers which are multiple of p and are``            ``// less than p^2 are already been marked.``            ``for` `(``int` `i = p * p; i < MAX; i += p)``                ``prime[i] = ``false``;``        ``}``    ``}``}` `// Function to count the cells having``// adjacent cell's sum``// is equal to prime``int` `PrimeSumCells(vector >& mat)``{``    ``int` `count = 0;` `    ``int` `N = mat.size();``    ``int` `M = mat.size();` `    ``// Traverse for all the cells``    ``for` `(``int` `i = 0; i < N; i++) {``        ``for` `(``int` `j = 0; j < M; j++) {` `            ``int` `sum = 0;` `            ``// i-1, j``            ``if` `(i - 1 >= 0)``                ``sum += mat[i - 1][j];` `            ``// i+1, j``            ``if` `(i + 1 < N)``                ``sum += mat[i + 1][j];` `            ``// i, j-1``            ``if` `(j - 1 >= 0)``                ``sum += mat[i][j - 1];` `            ``// i, j+1``            ``if` `(j + 1 < M)``                ``sum += mat[i][j + 1];` `            ``// If the sum is a prime number``            ``if` `(prime[sum])``                ``count++;``        ``}``    ``}` `    ``// Return the count``    ``return` `count;``}` `// Driver Program``int` `main()``{``    ``SieveOfEratosthenes();` `    ``vector > mat = { { 1, 2, 3, 4 },``                                 ``{ 5, 6, 7, 8 },``                                 ``{ 9, 10, 11, 12 } };` `    ``// Function call``    ``cout << PrimeSumCells(mat) << endl;``}`

## Java

 `// Java program to find the cells whose``// adjacent cells's sum is prime Number``class` `GFG{``static` `final` `int` `MAX = ``100005``;` `static` `boolean` `[]prime = ``new` `boolean``[MAX];` `static` `void` `SieveOfEratosthenes()``{``    ``// Create a boolean array "prime[0..MAX-1]"``    ``// and initialize all entries it as true.``    ``// A value in prime[i] will finally``    ``// be false if i is Not a prime, else true.``    ``for` `(``int` `i = ``0``; i < prime.length; i++)``    ``prime[i] = ``true``;` `    ``prime[``0``] = prime[``1``] = ``false``;` `    ``for` `(``int` `p = ``2``; p * p < MAX; p++)``    ``{``        ``// If prime[p] is not changed,``        ``// then it is a prime``        ``if` `(prime[p] == ``true``)``        ``{``            ``// Update all multiples of p``            ``// greater than or``            ``// equal to the square of it``            ``// numbers which are multiple of p and are``            ``// less than p^2 are already been marked.``            ``for` `(``int` `i = p * p; i < MAX; i += p)``                ``prime[i] = ``false``;``        ``}``    ``}``}` `// Function to count the cells having``// adjacent cell's sum``// is equal to prime``static` `int` `PrimeSumCells(``int` `[][]mat)``{``    ``int` `count = ``0``;` `    ``int` `N = mat.length;``    ``int` `M = mat[``0``].length;` `    ``// Traverse for all the cells``    ``for` `(``int` `i = ``0``; i < N; i++)``    ``{``        ``for` `(``int` `j = ``0``; j < M; j++)``        ``{``            ``int` `sum = ``0``;` `            ``// i-1, j``            ``if` `(i - ``1` `>= ``0``)``                ``sum += mat[i - ``1``][j];` `            ``// i+1, j``            ``if` `(i + ``1` `< N)``                ``sum += mat[i + ``1``][j];` `            ``// i, j-1``            ``if` `(j - ``1` `>= ``0``)``                ``sum += mat[i][j - ``1``];` `            ``// i, j+1``            ``if` `(j + ``1` `< M)``                ``sum += mat[i][j + ``1``];` `            ``// If the sum is a prime number``            ``if` `(prime[sum])``                ``count++;``        ``}``    ``}` `    ``// Return the count``    ``return` `count;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``SieveOfEratosthenes();` `    ``int` `[][]mat = { { ``1``, ``2``, ``3``, ``4` `},``                    ``{ ``5``, ``6``, ``7``, ``8` `},``                    ``{ ``9``, ``10``, ``11``, ``12` `} };` `    ``// Function call``    ``System.out.print(PrimeSumCells(mat) + ``"\n"``);``}``}` `// This code is contributed by sapnasingh4991`

## Python3

 `# Python 3 program to``# find the cells whose``# adjacent cells's``# sum is prime Number``MAX` `=` `100005``prime ``=` `[``True``] ``*` `MAX` `def` `SieveOfEratosthenes():` `    ``# Create a boolean array "prime[0..MAX-1]"``    ``# and initialize all entries it as true.``    ``# A value in prime[i] will finally``    ``# be false if i is Not a prime, else true.``    ``global` `prime``    ` `    ``prime[``0``] ``=` `prime[``1``] ``=` `False` `    ``p ``=` `2``    ``while` `p ``*` `p < ``MAX``:``      ` `        ``# If prime[p] is not changed,``        ``# then it is a prime``        ``if` `(prime[p] ``=``=` `True``):``          ` `            ``# Update all multiples of p``            ``# greater than or``            ``# equal to the square of it``            ``# numbers which are multiple of``            ``# p and are less than p^2 are``            ``# already been marked.``            ``for` `i ``in` `range` `(p ``*` `p, ``MAX``, p):``                ``prime[i] ``=` `False`               `        ``p ``+``=` `1``      ` `# Function to count the``# cells having adjacent``# cell's sum is equal to prime``def` `PrimeSumCells(mat):` `    ``count ``=` `0``    ``N ``=` `len``(mat)``    ``M ``=` `len``(mat[``0``])` `    ``# Traverse for all the cells``    ``for` `i ``in` `range` `(N):``        ``for` `j ``in` `range` `(M):` `            ``sum` `=` `0` `            ``# i - 1, j``            ``if` `(i ``-` `1` `>``=` `0``):``                ``sum` `+``=` `mat[i ``-` `1``][j]` `            ``# i + 1, j``            ``if` `(i ``+` `1` `< N):``                ``sum` `+``=` `mat[i ``+` `1``][j]` `            ``# i, j - 1``            ``if` `(j ``-` `1` `>``=` `0``):``                ``sum` `+``=` `mat[i][j ``-` `1``]` `            ``# i, j + 1``            ``if` `(j ``+` `1` `< M):``                ``sum` `+``=` `mat[i][j ``+` `1``]` `            ``# If the sum is a prime number``            ``if` `(prime[``sum``]):``                ``count ``+``=` `1``   ` `    ``# Return the count``    ``return` `count` `# Driver code``if` `__name__ ``=``=``"__main__"``:``      ` `    ``SieveOfEratosthenes()``    ``mat ``=` `[[``1``, ``2``, ``3``, ``4``],``           ``[``5``, ``6``, ``7``, ``8``],``           ``[``9``, ``10``, ``11``, ``12``]]` `    ``# Function call``    ``print` `(PrimeSumCells(mat))``    ` `# This code is contributed by Chitranayal`

## C#

 `// C# program to find the cells whose``// adjacent cells's sum is prime Number``using` `System;``class` `GFG{``    ` `static` `readonly` `int` `MAX = 100005;``static` `bool` `[]prime = ``new` `bool``[MAX];` `static` `void` `SieveOfEratosthenes()``{``    ``// Create a bool array "prime[0..MAX-1]"``    ``// and initialize all entries it as true.``    ``// A value in prime[i] will finally``    ``// be false if i is Not a prime, else true.``    ``for` `(``int` `i = 0; i < prime.Length; i++)``    ``prime[i] = ``true``;` `    ``prime = prime = ``false``;` `    ``for` `(``int` `p = 2; p * p < MAX; p++)``    ``{``        ``// If prime[p] is not changed,``        ``// then it is a prime``        ``if` `(prime[p] == ``true``)``        ``{``            ``// Update all multiples of p``            ``// greater than or``            ``// equal to the square of it``            ``// numbers which are multiple of p and are``            ``// less than p^2 are already been marked.``            ``for` `(``int` `i = p * p; i < MAX; i += p)``                ``prime[i] = ``false``;``        ``}``    ``}``}` `// Function to count the cells having``// adjacent cell's sum``// is equal to prime``static` `int` `PrimeSumCells(``int` `[,]mat)``{``    ``int` `count = 0;` `    ``int` `N = mat.GetLength(0);``    ``int` `M = mat.GetLength(1);` `    ``// Traverse for all the cells``    ``for` `(``int` `i = 0; i < N; i++)``    ``{``        ``for` `(``int` `j = 0; j < M; j++)``        ``{``            ``int` `sum = 0;` `            ``// i-1, j``            ``if` `(i - 1 >= 0)``                ``sum += mat[i - 1, j];` `            ``// i+1, j``            ``if` `(i + 1 < N)``                ``sum += mat[i + 1, j];` `            ``// i, j-1``            ``if` `(j - 1 >= 0)``                ``sum += mat[i, j - 1];` `            ``// i, j+1``            ``if` `(j + 1 < M)``                ``sum += mat[i, j + 1];` `            ``// If the sum is a prime number``            ``if` `(prime[sum])``                ``count++;``        ``}``    ``}` `    ``// Return the count``    ``return` `count;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``SieveOfEratosthenes();` `    ``int` `[,]mat = { { 1, 2, 3, 4 },``                   ``{ 5, 6, 7, 8 },``                   ``{ 9, 10, 11, 12 } };` `    ``// Function call``    ``Console.Write(PrimeSumCells(mat) + ``"\n"``);``}``}` `// This code is contributed by sapnasingh4991`

## Javascript

 ``

Output:

`6`

Time Complexity: O(N*M)

Auxiliary Space: O(MAX)

My Personal Notes arrow_drop_up