Skip to content
Related Articles

Related Articles

Problem of 8 Neighbours of an element in a 2-D Matrix
  • Last Updated : 14 Dec, 2018

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++




// 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;
}

Java




// 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
}

Python 3




# 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

C#




// 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

PHP




<?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
Output:
0 1 0 0 
0 1 0 0 
1 1 1 0 
0 0 1 0

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :