Education: 2021 Grad, IIIT College
Position: SDE1 at Fintech
Location: Bengaluru, IN

Applied Position: SDE2 at Flexport
Location: Bengaluru, IN
Date: April, 2024

===================================
Board Class
===================================


package Board;

import Game.Disc;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class GridBoard {

    HashMap<Integer, List<Disc>> board;
    Integer NumberOfMatches;

    public GridBoard(Integer N) {
        NumberOfMatches = N;
        board = new HashMap<>();
    }

    public boolean put(Integer column, Disc disc) {
        // Check for empty column
        if (!board.containsKey(column)) {
            board.put(column, new ArrayList<>());
        }

        // Put the disc in given column
        board.get(column).add(disc);

        if (isWinningMoveLastNColumn(column, disc)) {
            System.out.println("Game finished with Column match!");
            return true;
        } else if(isWinningMoveLastNRow(column, disc)) {
            System.out.println("Game finished with Row match!");
        } else {
            System.out.println("Next Player turn!!!");
        }
        return false;
    }

    private boolean isWinningMove(Integer column, Disc disc) {
        List<Disc> discs = board.get(column);

        int discsSize = discs.size();

        if (discsSize < 3 || !(discs.get(discsSize-1)==discs.get(discsSize-2) && discs.get(discsSize-2)==discs.get(discsSize-3)))
            return false;

        return true;
    }

    private boolean isWinningMoveLastNColumn(Integer column, Disc disc) {
        List<Disc> discs = board.get(column);

        int discsSize = discs.size();

        if (discsSize < NumberOfMatches)
            return false;

        // 5 elements, N = 3
        // 0, 1, 2, 3, 4 => Check for 2, 3, 4
        for (int i = discsSize-2; i >= discsSize - NumberOfMatches; --i) {
            if (discs.get(discsSize-1) != discs.get(i))
                return false;
        }
        return true;
    }

    private boolean isWinningMoveLastNRow(Integer column, Disc disc) {
        List<Disc> discs = board.get(column);

        int currRow = discs.size();
        int totalMatches = 1;
        int leftColumn = column-1;

        while (board.containsKey(leftColumn)) {
            List<Disc> leftColumnDisc = board.get(leftColumn);

            if (leftColumnDisc.size() < currRow || leftColumnDisc.get(currRow-1) != disc)
                break;

            ++totalMatches;
            if (totalMatches >= NumberOfMatches)
                break;

            leftColumn--;
        }

        int rightColumn = column+1;
        while (board.containsKey(rightColumn)) {
            List<Disc> rightColumnDisc = board.get(rightColumn);

            if (rightColumnDisc.size() < currRow || rightColumnDisc.get(currRow-1) != disc)
                break;

            ++totalMatches;
            if (totalMatches >= NumberOfMatches)
                break;

            rightColumn++;
        }

        return (totalMatches >= NumberOfMatches);
    }

}


===================================
Disc ENUM
===================================


package Game;

public enum Disc {
    R,
    G,
    B,
    W,
    Y;
}



===================================
Main Class
===================================

import Board.GridBoard;
import Game.Disc;

public class Main {

    /*
                      R
                B     R  B
             R     B  R  R  B
      -  -  -  -  -  -  -  -  -
...  -3 -2 -1  0  1  2  3  4  5  ...
     */
    public static void main(String[] args) {
        System.out.println("Connection Board Game!");

        GridBoard gridBoard = new GridBoard(4);

        // Starting game
        gridBoard.put(-2, Disc.Y);
        gridBoard.put(-3, Disc.R);
        gridBoard.put(-1, Disc.R);
        gridBoard.put(0, Disc.R);
        gridBoard.put(0, Disc.Y);
        gridBoard.put(-1, Disc.Y);
        gridBoard.put(-2, Disc.Y);
        gridBoard.put(-3, Disc.B);
        gridBoard.put(2, Disc.R);
        gridBoard.put(1, Disc.R);

        // TC: O(N) , where N is number of matches
    }
}