Day 25 - Java

Problem Statement

You are given a 2D grid of candies represented as a List<List<String>>, where each string denotes the type and color of the candy. The grid follows these rules:

1. A candy is represented by a color:

   • Colors: r (red), g (green), b (blue), y (yellow)

2. When 3 or more adjacent candies of the same color (in a row or column) are found, they "crush" and become empty (""). After crushing, candies above fall down to fill the empty spots, and new candies (random colors) appear at the top.

Your task is to simulate one step of the candy crush game: find and crush all valid groups, shift candies down, and print the updated grid.

Input Format

• A single integer n (2 ≤ n ≤ 10) representing the number of rows.
• A single integer m (2 ≤ m ≤ 10) representing the number of columns.
• Followed by n lines, each containing m space-separated strings representing the initial grid of candies.

Output Format

• Print the updated grid after one round of crushing and shifting. Each row of the grid should be printed on a new line.

Sample Input 0

4
4
r g g g
r b y b
r b b b
y y y b

Sample Output 0
. . . .
. . . .
. . . .
. b y .

Explanation 0

Row-wise crushing:

• In row 1, we crushed the group of g g g.
• In row 3, we crushed the group of b b b.
• In row 4, we crushed the group of y y y.

Shift down:

• After crushing, the remaining candies fall down to fill the empty spots.

Resulting grid:

• The final grid has . at the top and the remaining candies (b and y) shifted to the bottom.

Sample Input 1

5
5
r g g g r
r b b y g
r b b b g
y y y b r
g b g y g

Sample Output 1
. . . . r
. . . . g
. . . y g
. b b b r
g b g y g

Explanation 1

Row-wise crushing:
In row 1, we crushed the group of g g g.
In row 3, we crushed the group of b b b.
In row 4, we crushed the group of y y y.
Shift down:
After crushing, the remaining candies fall down to fill the empty spots.
Resulting grid:
The final grid has . at the top, and the remaining candies (b, y, r, g) are shifted to the bottom.

Code: 
import java.util.*;

public class CandyCrush2D {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        scanner.nextLine();

        String[][] grid = new String[n][m];
        for (int i = 0; i < n; i++) {
            grid[i] = scanner.nextLine().split(" ");
        }

        // Crush candies
        boolean[][] toCrush = new boolean[n][m];

        // Check rows
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m - 2; j++) {
                if (!grid[i][j].isEmpty() && grid[i][j].equals(grid[i][j + 1]) 
                        && grid[i][j].equals(grid[i][j + 2])) {
                    toCrush[i][j] = toCrush[i][j + 1] = toCrush[i][j + 2] = true;
                }
            }
        }

        // Check columns
        for (int j = 0; j < m; j++) {
            for (int i = 0; i < n - 2; i++) {
                if (!grid[i][j].isEmpty() && grid[i][j].equals(grid[i + 1][j]) 
                        && grid[i][j].equals(grid[i + 2][j])) {
                    toCrush[i][j] = toCrush[i + 1][j] = toCrush[i + 2][j] = true;
                }
            }
        }

        // Crush and drop
        for (int j = 0; j < m; j++) {
            int writePointer = n - 1; // Start from the bottom of the column
            for (int i = n - 1; i >= 0; i--) {
                if (!toCrush[i][j]) {
                    grid[writePointer--][j] = grid[i][j];
                }
            }
            while (writePointer >= 0) {
                grid[writePointer--][j] = "."; // Empty spots
            }
        }

        // Print result
        for (String[] row : grid) {
            System.out.println(String.join(" ", row));
        }
    }
}

Features

• Row and Column Detection: Checks for horizontal and vertical matches.
• Dynamic Grid: Works for grids of different sizes (n x m).
• Crush and Shift: Marks candies to be crushed and shifts remaining candies down.

Insights

• The program begins by reading the grid dimensions n (rows) and m (columns) from input.
• The grid is then populated using a 2D array, where each element represents a candy color.
• A boolean 2D array toCrush is used to track which candies need to be crushed.
• The program checks for horizontal groups of 3 consecutive candies of the same color (row-wise).
• It marks candies for crushing in the toCrush array if they form a group of 3 or more.
• A similar check is performed for vertical groups of 3 consecutive candies (column-wise).
• After identifying candies to crush, the program shifts non-crushed candies downward in each column.
• For each column, the program writes non-crushed candies starting from the bottom.
• Empty spaces are filled with "." to represent the crushed candies after the shift.
• The final grid is printed, showing the updated candy arrangement with crushed spots replaced by ".".

Debugging is like clearing a row of candies in Candy Crush—sometimes you just need to match the right pieces to make everything fall into place. Keep coding, and let those errors disappear like crushed candies! 

 Enjoy the game of colors along with coding!!! 🟡🟢🔴🧑‍💻🟠👩‍💻🟣🟤🔵