Problem of 8 Neighbours of an element in a 2-D Matrix

Given a 2-D Matrix and an integer ‘K’, the task is to predict the matrix after ‘K’ iterations given as follows:

  • An element 1 in current matrix remains 1 in the next iteration only if it is surrounded by A number of 1s; where 0 <= range1a <= A <= range1b.
  • An element 0 in current matrix becomes 1 in the next iteration only if it is surrounded by B number of 1s; where 0 <= range0a <= B <= range0b.

Let’s understand this with an example:



Constraints:
1 <= K <= 100000
0 <= range1a, range1b, range0a, range0b <= 8

  • In the above image for cell(0, 0) the cell was ‘0’ in the first iteration but, since it was surrounded by only one adjacent cell containing ‘1’ which does not fall within the range [range0a, range0b]. So it will continue to remain ‘0’.
  • For second iteration, cell (0, 0) was 0 but this time it is surrounded by two cells containing ‘1’ and two falls withing the range [range0a, range0b] therefore, it becomes ‘1’ in the next (2nd) iteration.

Examples:

Input: range1a = 2
range1b = 2
range0a = 2
range0b = 3
K = 1

Output:
0 1 1 0
0 1 1 1
1 0 0 1
0 0 1 0

Input: range1a = 2
range1b = 2
range0a = 2
range0b = 3
K = 2

Output:
1 0 0 1
1 0 0 0
0 0 0 0
0 1 0 1

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <iostream>
using namespace std;
  
// Dimension of Array
#define N 4
  
void predictMatrix(int arr[N][N],
                   int range1a,
                   int range1b,
                   int range0a,
                   int range0b,
                   int K,
                   int b[N][N])
{
  
    // Count of 1s
    int c = 0;
  
    while (K--) {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                c = 0;
  
                // Counting all neighbouring 1s
  
                if (i > 0 && arr[i - 1][j] == 1)
                    c++;
                if (j > 0 && arr[i][j - 1] == 1)
                    c++;
                if (i > 0 && j > 0
                    && arr[i - 1][j - 1] == 1)
                    c++;
                if (i < N - 1 && arr[i + 1][j] == 1)
                    c++;
                if (j < N - 1 && arr[i][j + 1] == 1)
                    c++;
                if (i < N - 1 && j < N - 1
                    && arr[i + 1][j + 1] == 1)
                    c++;
                if (i < N - 1 && j > 0
                    && arr[i + 1][j - 1] == 1)
                    c++;
                if (i > 0 && j < N - 1
                    && arr[i - 1][j + 1] == 1)
                    c++;
  
                // Comparing the number of
                // neighbouring 1s with
                // given ranges
                if (arr[i][j] == 1) {
                    if (c >= range1a && c <= range1b)
                        b[i][j] = 1;
                    else
                        b[i][j] = 0;
                }
                if (arr[i][j] == 0) {
                    if (c >= range0a && c <= range0b)
                        b[i][j] = 1;
                    else
                        b[i][j] = 0;
                }
            }
        }
  
        // Copying changes to
        // the main matrix
        for (int k = 0; k < N; k++)
            for (int m = 0; m < N; m++)
                arr[k][m] = b[k][m];
    }
}
  
// Driver code
int main()
{
    int arr[N][N] = { 0, 0, 0, 0,
                      0, 1, 1, 0,
                      0, 0, 1, 0,
                      0, 1, 0, 1 };
    int range1a = 2, range1b = 2;
    int range0a = 2, range0b = 3;
    int K = 3, b[N][N] = { 0 };
  
    // Function call to calculate
    // the resultant matrix
    // after 'K' iterations.
    predictMatrix(arr, range1a, range1b,
                  range0a, range0b, K, b);
  
    // Printing Result
    for (int i = 0; i < N; i++) {
        cout << endl;
        for (int j = 0; j < N; j++)
            cout << b[i][j] << " ";
    }
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
public class GFG{
      
// Dimension of Array
final static int N  = 4 ;
  
static void predictMatrix(int arr[][],
                   int range1a,
                   int range1b,
                   int range0a,
                   int range0b,
                   int K,
                   int b[][])
{
  
    // Count of 1s
    int c = 0;
  
    while (K != 0) {
        K--;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                c = 0;
  
                // Counting all neighbouring 1s
  
                if (i > 0 && arr[i - 1][j] == 1)
                    c++;
                if (j > 0 && arr[i][j - 1] == 1)
                    c++;
                if (i > 0 && j > 0
                    && arr[i - 1][j - 1] == 1)
                    c++;
                if (i < N - 1 && arr[i + 1][j] == 1)
                    c++;
                if (j < N - 1 && arr[i][j + 1] == 1)
                    c++;
                if (i < N - 1 && j < N - 1
                    && arr[i + 1][j + 1] == 1)
                    c++;
                if (i < N - 1 && j > 0
                    && arr[i + 1][j - 1] == 1)
                    c++;
                if (i > 0 && j < N - 1
                    && arr[i - 1][j + 1] == 1)
                    c++;
  
                // Comparing the number of
                // neighbouring 1s with
                // given ranges
                if (arr[i][j] == 1) {
                    if (c >= range1a && c <= range1b)
                        b[i][j] = 1;
                    else
                        b[i][j] = 0;
                }
                if (arr[i][j] == 0) {
                    if (c >= range0a && c <= range0b)
                        b[i][j] = 1;
                    else
                        b[i][j] = 0;
                }
            }
        }
  
        // Copying changes to
        // the main matrix
        for (int k = 0; k < N; k++)
            for (int m = 0; m < N; m++)
                arr[k][m] = b[k][m];
    }
      
}
  
// Driver code
public static void main(String []args)
{
    int arr[][] = { {0, 0, 0, 0},
                      {0, 1, 1, 0},
                      {0, 0, 1, 0},
                      {0, 1, 0, 1 } };
    int range1a = 2, range1b = 2;
    int range0a = 2, range0b = 3;
    int K = 3;
    int b[][] = new int[N][N] ;
  
    // Function call to calculate
    // the resultant matrix
    // after 'K' iterations.
    predictMatrix(arr, range1a, range1b,
                  range0a, range0b, K, b);
  
    // Printing Result
    for (int i = 0; i < N; i++) {
        System.out.println();
        for (int j = 0; j < N; j++)
            System.out.print(b[i][j]+ " ");
    }
      
}
// This Code is contributed by Ryuga
}

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach
  
# Dimension of Array
N = 4
  
def predictMatrix(arr, range1a, range1b, 
                  range0a, range0b, K, b):
  
    # Count of 1s
    c = 0
  
    while (K):
        for i in range(N) :
            for j in range(N):
                c = 0
  
                # Counting all neighbouring 1s
                if (i > 0 and arr[i - 1][j] == 1):
                    c += 1
                if (j > 0 and arr[i][j - 1] == 1):
                    c += 1
                if (i > 0 and j > 0 and 
                    arr[i - 1][j - 1] == 1):
                    c += 1
                if (i < N - 1 and arr[i + 1][j] == 1):
                    c += 1
                if (j < N - 1 and arr[i][j + 1] == 1):
                    c += 1
                if (i < N - 1 and j < N - 1
                    and arr[i + 1][j + 1] == 1):
                    c += 1
                if (i < N - 1 and j > 0
                    and arr[i + 1][j - 1] == 1):
                    c += 1
                if (i > 0 and j < N - 1
                    and arr[i - 1][j + 1] == 1):
                    c += 1
  
                # Comparing the number of neighbouring 
                # 1s with given ranges
                if (arr[i][j] == 1) :
                    if (c >= range1a and c <= range1b):
                        b[i][j] = 1
                    else:
                        b[i][j] = 0
                  
                if (arr[i][j] == 0):
                    if (c >= range0a and c <= range0b):
                        b[i][j] = 1
                    else:
                        b[i][j] = 0
        K -= 1
  
        # Copying changes to the main matrix
        for k in range(N):
            for m in range( N):
                arr[k][m] = b[k][m]
  
# Driver code
if __name__ == "__main__":
      
    arr = [[0, 0, 0, 0],
           [0, 1, 1, 0],
           [0, 0, 1, 0],
           [0, 1, 0, 1]]
    range1a = 2
    range1b = 2
    range0a = 2
    range0b = 3
    K = 3
    b = [[0 for x in range(N)] 
            for y in range(N)]
  
    # Function call to calculate
    # the resultant matrix
    # after 'K' iterations.
    predictMatrix(arr, range1a, range1b,
                  range0a, range0b, K, b)
  
    # Printing Result
    for i in range( N):
        print()
        for j in range(N):
            print(b[i][j], end = " ")
  
# This code is contributed
# by ChitraNayal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach 
using System;
  
class GFG
  
// Dimension of Array 
readonly static int N = 4 ; 
  
static void predictMatrix(int [,]arr, int range1a, 
                          int range1b, int range0a, 
                          int range0b, int K, int [,]b) 
  
    // Count of 1s 
    int c = 0; 
  
    while (K != 0)
    
        K--; 
        for (int i = 0; i < N; i++) 
        
            for (int j = 0; j < N; j++) 
            
                c = 0; 
  
                // Counting all neighbouring 1s 
  
                if (i > 0 && arr[i - 1, j] == 1) 
                    c++; 
                if (j > 0 && arr[i, j - 1] == 1) 
                    c++; 
                if (i > 0 && j > 0
                    && arr[i - 1, j - 1] == 1) 
                    c++; 
                if (i < N - 1 && arr[i + 1, j] == 1) 
                    c++; 
                if (j < N - 1 && arr[i, j + 1] == 1) 
                    c++; 
                if (i < N - 1 && j < N - 1 && 
                    arr[i + 1, j + 1] == 1) 
                    c++; 
                if (i < N - 1 && j > 0 && 
                    arr[i + 1, j - 1] == 1) 
                    c++; 
                if (i > 0 && j < N - 1 && 
                    arr[i - 1, j + 1] == 1) 
                    c++; 
  
                // Comparing the number of 
                // neighbouring 1s with 
                // given ranges 
                if (arr[i,j] == 1) 
                
                    if (c >= range1a && c <= range1b) 
                        b[i, j] = 1; 
                    else
                        b[i, j] = 0; 
                
                if (arr[i,j] == 0)
                
                    if (c >= range0a && c <= range0b) 
                        b[i, j] = 1; 
                    else
                        b[i, j] = 0; 
                
            
        
  
        // Copying changes to the main matrix 
        for (int k = 0; k < N; k++) 
            for (int m = 0; m < N; m++) 
                arr[k, m] = b[k, m]; 
    
  
// Driver code 
public static void Main() 
    int [,]arr = { {0, 0, 0, 0}, 
                   {0, 1, 1, 0}, 
                   {0, 0, 1, 0}, 
                   {0, 1, 0, 1 } }; 
    int range1a = 2, range1b = 2; 
    int range0a = 2, range0b = 3; 
    int K = 3; 
    int [,]b = new int[N, N]; 
  
    // Function call to calculate 
    // the resultant matrix 
    // after 'K' iterations. 
    predictMatrix(arr, range1a, range1b, 
                range0a, range0b, K, b); 
  
    // Printing Result 
    for (int i = 0; i < N; i++)
    
        Console.WriteLine(); 
        for (int j = 0; j < N; j++) 
            Console.Write(b[i, j] + " "); 
    
  
// This code is contributed by 29AjayKumar

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of the approach
  
// Dimension of Array
#define N 4
  
function predictMatrix($arr, $range1a, $range1b,
                       $range0a, $range0b, $K, $b)
{
$N = 4;
    // Count of 1s
    $c = 0;
  
    while ($K--) 
    {
        for ($i = 0; $i < $N; $i++) 
        {
            for ($j = 0; $j < $N; $j++) 
            {
                $c = 0;
  
                // Counting all neighbouring 1s
  
                if ($i > 0 && $arr[$i - 1][$j] == 1)
                    $c++;
                if ($j > 0 && $arr[$i][$j - 1] == 1)
                    $c++;
                if ($i > 0 && $j > 0 && $arr[$i - 1][$j - 1] == 1)
                    $c++;
                if ($i < $N - 1 && $arr[$i + 1][$j] == 1)
                    $c++;
                if ($j < $N - 1 && $arr[$i][$j + 1] == 1)
                    $c++;
                if ($i < $N - 1 && $j < $N - 1 && 
                    $arr[$i + 1][$j + 1] == 1)
                    $c++;
                if ($i < $N - 1 && $j > 0 && $arr[$i + 1][$j - 1] == 1)
                    $c++;
                if ($i > 0 && $j < $N - 1 && $arr[$i - 1][$j + 1] == 1)
                    $c++;
  
                // Comparing the number of
                // neighbouring 1s with
                // given ranges
                if ($arr[$i][$j] == 1) 
                {
                    if ($c >= $range1a && $c <= $range1b)
                        $b[$i][$j] = 1;
                    else
                        $b[$i][$j] = 0;
                }
                if ($arr[$i][$j] == 0) {
                    if ($c >= $range0a && $c <= $range0b)
                        $b[$i][$j] = 1;
                    else
                        $b[$i][$j] = 0;
                }
            }
        }
  
        // Copying changes to
        // the main matrix
        for ($k = 0; $k < $N; $k++)
            for ($m = 0; $m < $N; $m++)
                $arr[$k][$m] = $b[$k][$m];
    }
    return $b;
}
  
// Driver code
$N = 4;
$arr= array(array(0, 0, 0, 0),
        array(0, 1, 1, 0),
        array(0, 0, 1, 0),
        array(0, 1, 0, 1));
$range1a = 2; $range1b = 2;
$range0a = 2; $range0b = 3;
$K = 3; $b = array(array(0));
  
// Function call to calculate
// the resultant matrix
// after 'K' iterations.
$b1 = predictMatrix($arr, $range1a, $range1b,
            $range0a, $range0b, $K, $b);
  
// Printing Result
for ($i = 0; $i < $N; $i++)
{
    echo "\n";
    for ($j = 0; $j < $N; $j++)
        echo $b1[$i][$j] . " ";
}
  
// This code is contributed by Akanksha Rai

chevron_right


Output:

0 1 0 0 
0 1 0 0 
1 1 1 0 
0 0 1 0


My Personal Notes arrow_drop_up

Techie Geek

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.