OOD

Minesweeper Game

import java.io.*;
import java.util.*;


public class MS {
    // Minesweeper is a game where mines are hidden in a grid of squares.
// Revealed squares have numbers telling you how many mines touch the square.
// You can use the number clues to solve the game by opening all of the unrevealed squares.
// If you click on a mine you lose the game!

// Your implementation should support:
// 1. Generating a board of ROWS x COLUMNS size
// 2. Randomly placing a set of NUM_MINES mines
// 3. Printing the board state
// 4. Clicking a cell
//   - This should reveal the number of mines that touch the square.
//   - If a mine is clicked, the game is over.
//     All remaining mines should be revealed.
//   - Clicking on an empty cell (a cell with no adjacent mines)ok
//     should reveal all adjacent cells until a cell bordering a mine
//     is reached.

// Revealed squares that have no adjacent mines: 0
// Revealed squares that have adjacent mines: numbers 1 - 8
// Unrevealed cells: '-'
// Revealed mines: 'X'

// Example:

// ROWS = 5
// COLUMNS = 5
// NUM_MINES = 4
// // exampleMineLocations = [[0, 1], [2, 0], [4, 0], [4, 4]]
// // [row, column]

// printBoard()
// Output:
// ['-','-','-','-','-']
// ['-','-','-','-','-']
// ['-','-','-','-','-']
// ['-','-','-','-','-']
// ['-','-','-','-','-']

// click(0, 0)
// printBoard()
// Output:
// ['1','-','-','-','-']
// ['-','-','-','-','-']
// ['-','-','-','-','-']
// ['-','-','-','-','-']
// ['-','-','-','-','-']

// click(0, 4)
// printBoard()
// Output:
// ['1','-','1','0','0']
// ['-','2','1','0','0']
// ['-','1','0','0','0']
// ['-','2','0','1','1']
// ['-','1','0','1','-']

// click(2, 0)
// printBoard()
// Output:
// ['1','X','1','0','0']
// ['-','2','1','0','0']
// ['X','1','0','0','0']
// ['-','2','0','1','1']
// ['X','1','0','1','X']


    /*
     * Click `Run` to execute the snippet below!
     */

    /*
     * To execute Java, please define "static void main" on a class
     * named Solution.
     *
     * If you need more classes, simply define them inline.
     */

        public static void main(String[] args) {

            Minesweeper minesweeper = new Minesweeper(5, 5, 3);
            System.out.println("Initial Board:");
            minesweeper.print();

            // Simulated clicks
            System.out.println("\nClick (0,0):");
            minesweeper.click(0, 0);

            System.out.println("\nClick (1,1):");
            minesweeper.click(1, 1);

            System.out.println("\nClick (2,2):");
            minesweeper.click(2, 2);

            System.out.println("\nClick (4,4):");
            minesweeper.click(4, 4); // might be a mine

            System.out.println("\nClick (3,0):");
            minesweeper.click(3, 0);
        }

        static class Minesweeper {
            String[][] grid;
            String[][] mineGrid;
            int[][] dirs = {
                    {1,0}, {0,1}, {-1,0}, {0,-1},
                    {1,1}, {-1,1}, {1,-1}, {-1,-1}
            };
            Minesweeper(int rows, int cols, int mineCount) {
                this.grid = new String[rows][cols];
                for (String[] r : grid) {
                    Arrays.fill(r, "-");
                }
                this.mineGrid = new String[rows][cols];
                for (String[] r : mineGrid) {
                    Arrays.fill(r, "-");
                }
                this.generateMines(mineCount);
                this.preProcess();
            }

            public void click(int row, int col) {
                if (!inbound(row, col)) {
                    System.out.println("Invalid coordinate");
                    return;
                }
                if (mineGrid[row][col].equals("X")) {
                    System.out.println("Game over");
                    grid = mineGrid;
                } else if (hasAdjacentMine(row, col)) {
                    grid[row][col] = mineGrid[row][col];
                } else {
                    dfs(row, col);
                }
                print();
            }

            void dfs(int row, int col) {
                grid[row][col] = mineGrid[row][col];
                for (int[] dir : dirs) {
                    int newRow = row + dir[0];
                    int newCol = col + dir[1];
                    if (inbound(newRow, newCol)
                            && !mineGrid[newRow][newCol].equals("X")
                            && grid[newRow][newCol].equals("-")
                            && !hasAdjacentMine(newRow, newCol)) {
                        dfs(newRow, newCol);
                    }
                }
            }

            private boolean hasAdjacentMine(int row, int col) {
                for (int[] dir : dirs) {
                    int newRow = row + dir[0];
                    int newCol = col + dir[1];
                    if (inbound(newRow, newCol) && mineGrid[newRow][newCol].equals("X")) {
                        return true;
                    }
                }
                return false;
            }

            public void print() {
                System.out.println("Grid:");
                for (String[] row : grid) {
                    for (String c : row) System.out.print(c + ',');
                    System.out.println();
                }

//                System.out.println("Mine Grid:");
//                for (String[] row : mineGrid) {
//                    for (String c : row) System.out.print(c + ',');
//                    System.out.println();
//                }
            }

            private void preProcess() {
                for (int x = 0; x < mineGrid.length; x++) {
                    for (int y = 0; y < mineGrid[0].length; y++) {
                        if (mineGrid[x][y] != "-") continue;
                        // get number of neighbor mines
                        int val = 0;
                        for (int[] d : dirs) {
                            int nX = d[0] + x;
                            int nY = d[1] + y;
                            if (inbound(nX, nY) && mineGrid[nX][nY].equals("X")) val++;
                        }
                        mineGrid[x][y] = String.valueOf(val);
                    }
                }
            }

            private void generateMines(int count) {
                Random rand = new Random();
                int i = 0;
                while (i < count) {
                    int x = rand.nextInt(this.grid.length);
                    int y = rand.nextInt(this.grid[0].length);
                    if (inbound(x, y) && !mineGrid[x][y].equals("X")) {
                        mineGrid[x][y] = "X";
                        i++;
                    }
                }
            }

            private boolean inbound(int x, int y) {
                return x >= 0 && x < grid.length && y >= 0 && y < grid[0].length;
            }
        }
}

Elevator

Design an elevator control system for a building with M elevators and N floors. The system should handle:

• Requests from outside (up/down buttons on each floor)

• Requests from inside (floor buttons inside each elevator)

• Elevator movement, state management, and load handling

import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;

public class ElevatorSystem {

    class Elevator {
        int id;
        int currentFloor;
        Direction direction;
        ElevatorState state;
        TreeSet<Integer> requests = new TreeSet<>();

        Elevator(int id) {
            this.id = id;
            this.currentFloor = 0;
            this.direction = Direction.IDLE;
            this.state = ElevatorState.IDLE;
        }

        void moveOneFloor() {
            synchronized (this) {
                if (requests.isEmpty()) {
                    direction = Direction.IDLE;
                    state = ElevatorState.IDLE;
                    return;
                }

                int targetFloor = direction == Direction.UP ? requests.first() : requests.last();

                if (currentFloor == targetFloor) {
                    System.out.println("Elevator " + id + " stopping at floor " + currentFloor);
                    requests.remove(currentFloor);
                    state = ElevatorState.STOPPED;
                    updateDirection(); // may go idle
                } else {
                    state = ElevatorState.MOVING;
                    if (currentFloor < targetFloor) {
                        currentFloor++;
                        direction = Direction.UP;
                    } else if (currentFloor > targetFloor) {
                        currentFloor--;
                        direction = Direction.DOWN;
                    }
                    System.out.println("Elevator " + id + " moved to floor " + currentFloor);
                }
            }
        }

        void addRequest(int floor) {
            synchronized (this) {
                requests.add(floor);
                updateDirection();
            }
        }

        private void updateDirection() {
            if (requests.isEmpty()) {
                state = ElevatorState.IDLE;
                direction = Direction.IDLE;
            } else if (currentFloor < requests.first()) {
                state = ElevatorState.MOVING;
                direction = Direction.UP;
            } else if (currentFloor > requests.last()) {
                state = ElevatorState.MOVING;
                direction = Direction.DOWN;
            } else {
                // Between floors or already at target
                state = ElevatorState.MOVING;
                direction = (direction == Direction.UP) ? Direction.UP : Direction.DOWN;
            }
        }
    }

    enum Direction {
        UP, DOWN, IDLE
    }

    enum ElevatorState {
        MOVING, STOPPED, IDLE
    }

    List<Elevator> elevators;

    public ElevatorSystem(int numberOfElevators) {
        this.elevators = new ArrayList<>();
        for (int i = 0; i < numberOfElevators; i++) {
            elevators.add(new Elevator(i));
        }
    }

    public synchronized Elevator assignElevator(int requestFloor, Direction direction) {
        Elevator best = null;
        int minDistance = Integer.MAX_VALUE;
        for (Elevator e : elevators) {
            if (e.direction == direction || e.state == ElevatorState.IDLE) {
                int distance = Math.abs(requestFloor - e.currentFloor);
                if (distance < minDistance) {
                    best = e;
                    minDistance = distance;
                }
            }
        }
        return best;
    }

    public synchronized void requestPickup(int floor, Direction direction) {
        Elevator best = assignElevator(floor, direction);
        if (best != null) {
            best.addRequest(floor);
            System.out.println("Assigned elevator " + best.id + " to floor " + floor + " (" + direction + ")");
        }
    }

    public void step() {
        for (Elevator e : elevators) {
            e.moveOneFloor();
        }
    }

    public void status() {
        for (Elevator e : elevators) {
            System.out.println("Elevator " + e.id +
                    " at floor " + e.currentFloor +
                    " going " + e.direction +
                    " state: " + e.state +
                    " queue: " + e.requests);
        }
    }

    public static void main(String[] args) {
        ElevatorSystem system = new ElevatorSystem(2);

        system.requestPickup(3, Direction.UP);
        system.requestPickup(0, Direction.UP);
        system.elevators.get(0).addRequest(5); // simulate inside elevator button press

        for (int i = 0; i < 10; i++) {
            System.out.println("\nStep " + i);
            system.step();
            system.status();
        }
    }
}