Post Transition In C hackerrank solution

      
  #include <stdio.h>           
  // Function to calculate the next state of a cell based on its neighbors
  char getNextState(char grid[][102], int i, int j) {
      int sum = 0;
      sum += grid[i - 1][j - 1] - '0';
      sum += grid[i - 1][j] - '0';
      sum += grid[i - 1][j + 1] - '0';
      sum += grid[i][j - 1] - '0';
      sum += grid[i][j + 1] - '0';
      sum += grid[i + 1][j - 1] - '0';
      sum += grid[i + 1][j] - '0';
      sum += grid[i + 1][j + 1] - '0';
  
      return (sum % 2 == 0) ? '1' : '0';
  }
  
  // Function to simulate the transition for a given number of generations
  void simulateTransition(char grid[][102], int R, int C, int generations) {
      char tempGrid[R][C];
  
      // Perform the transition for the specified number of generations
      for (int gen = 0; gen < generations; gen++) {
          // Update the grid by calculating the next state of each cell
          for (int i = 1; i <= R; i++) {
              for (int j = 1; j <= C; j++) {
                  tempGrid[i][j] = getNextState(grid, i, j);
              }
          }
  
          // Copy the temporary grid back to the original grid
          for (int i = 1; i <= R; i++) {
              for (int j = 1; j <= C; j++) {
                  grid[i][j] = tempGrid[i][j];
              }
          }
      }
  }
  
  int main() {
      int R, C, K;
      scanf("%d %d %d", &R, &C, &K);
  
      char grid[R + 2][102];
  
      // Read the initial grid state
      for (int i = 1; i <= R; i++) {
          scanf("%s", grid[i] + 1);
      }
  
      simulateTransition(grid, R, C, K);
  
      // Print the final grid state
      for (int i = 1; i <= R; i++) {
          printf("%s\n", grid[i] + 1);
      }
  
      return 0;
  }
  

Explanation:

Let's go through the code step by step:

We include the necessary header files, for input/output operations.

The getNextState() function takes the grid, row index, and column index of a cell and calculates its next state based on the sum of its neighboring cells. It returns the next state of the cell ('1' or '0').

The simulateTransition() function takes the grid, the number of rows (R), the number of columns (C), and the number of generations (K). It simulates the transition for the given number of generations.

In the main() function, we read the number of rows (R), number of columns (C), and number of generations (K) from the user.

We declare a grid with dimensions R + 2 x 102 to handle the boundary cells. We add two extra rows and columns to the grid to accommodate the boundary cells without the need for additional boundary checks.

We use a loop to read the initial grid state from the user, storing it in the grid array.

We call the simulateTransition() function, passing the grid, number of rows, number of columns, and number of generations.

Finally, we iterate over the grid and print the final state of each row.

The code works by iteratively calculating the next state of each cell based on the sum of its neighboring cells and updating the grid accordingly. It performs this transition for the specified number of generations and prints the final state of the grid.