snake and ladder solution

2048-game/README.md

@@ -0,0 +1,18 @@
+## Getting Started
+
+Welcome to the VS Code Java world. Here is a guideline to help you get started to write Java code in Visual Studio Code.
+
+## Folder Structure
+
+The workspace contains two folders by default, where:
+
+- `src`: the folder to maintain sources
+- `lib`: the folder to maintain dependencies
+
+Meanwhile, the compiled output files will be generated in the `bin` folder by default.
+
+> If you want to customize the folder structure, open `.vscode/settings.json` and update the related settings there.
+
+## Dependency Management
+
+The `JAVA PROJECTS` view allows you to manage your dependencies. More details can be found [here](https://github.com/microsoft/vscode-java-dependency#manage-dependencies).

2048-game/src/Board.java

@@ -0,0 +1,53 @@
+// import java.util.ArrayList;
+// import java.util.Arrays;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class Board {
+    int size;
+    int basevalue;
+    int numberOfValues;
+    Tile[][] tiles;
+    int[] boardValues;
+
+    Board(int size,int base,int count){
+        this.size = size;
+        this.basevalue = base;
+        this.numberOfValues = count;
+        initializeValues(base,count);
+        initializeBoard(size);
+    }
+
+    private void initializeValues(int base,int numberOfValues){
+        boardValues = new int[numberOfValues];
+        for(int i=0;i<numberOfValues;i++){
+            boardValues[i] = (int) Math.pow((double)base, (double)(i+1));
+        }
+    }
+    private void initializeBoard(int size){
+        tiles = new Tile[size][size];
+        for(int i=0;i<size;i++){
+            for(int j=0;j < size;j++){
+                tiles[i][j] = new Tile();
+                tiles[i][j].value = 0;
+            }
+        }
+
+        for(int i=0;i<2;i++){
+            int row = ThreadLocalRandom.current().nextInt(0,size);
+            int column = ThreadLocalRandom.current().nextInt(0,size);
+
+            if(tiles[row][column].value == 2){
+                i--;
+            }
+            else tiles[row][column].value = 2;
+        }
+    }
+
+    // public void insertTile(){
+    //     int row = ThreadLocalRandom.current().nextInt(0,size);
+    //     int column = ThreadLocalRandom.current().nextInt(0,size);
+    //     int number = ThreadLocalRandom.current().nextInt(0,6);
+
+    //     tiles[row][column].value = tileValueList.get(number);
+    // }
+}

2048-game/src/Displayboard.java

@@ -0,0 +1,16 @@
+public class Displayboard {
+    Board board;
+
+    Displayboard(Board board){
+        this.board = board;
+    }
+
+    public void showOutput(){
+        for(int i=0;i<board.size;i++){
+            for(int j=0;j<board.size;j++){
+                System.out.print(board.tiles[i][j].value + " ");
+            }
+            System.out.println('\n');
+        }
+    }
+}

2048-game/src/Game.java

@@ -0,0 +1,194 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Scanner;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class Game {
+    Board board;
+    int direction;
+    int size ;
+    Displayboard displayboard;
+    boolean flag = false;
+    int filledTiles = 0;
+    ArrayList<Integer> tileValueList;
+
+    Scanner scanner = new Scanner(System.in);
+
+    Game(Board board){
+        this.board = board;
+        size = board.size;
+        tileValueList = new ArrayList<Integer>(Arrays.asList(2,4));
+        displayboard = new Displayboard(board);
+    }
+
+    public void startGame(Board board){
+        displayboard.showOutput();
+        while (filledTiles < size*size && flag == false) {
+            direction = scanner.nextInt();
+            if(direction == 3){
+                slideBottom();
+            }
+            else if(direction == 2){
+                slideUp();
+            }
+            else if(direction == 1){
+                slideRight();
+            }
+            else {
+                slideLeft();
+            }
+            insertTile();
+            displayboard.showOutput();
+            checkGame();
+        }
+        if(flag == true){
+            System.out.println("Congratulations");
+        }
+        else System.out.println("Game over"); 
+    }
+
+    private void insertTile(){
+        int add = 0;
+        while(add < 1){
+            int row = ThreadLocalRandom.current().nextInt(0,size);
+            int column = ThreadLocalRandom.current().nextInt(0,size);
+            int number = ThreadLocalRandom.current().nextInt(0,tileValueList.size());
+
+            if(board.tiles[row][column].value == 0){
+                board.tiles[row][column].value = tileValueList.get(number);
+                add++;
+            }
+        }
+    }
+
+    private void checkGame(){
+        filledTiles = 0;
+        for(int i=0;i<size;i++){
+            for(int j=0;j<size;j++){
+                if(board.tiles[i][j].value == 2048){
+                    flag = true;
+                    break;
+                }
+                if(board.tiles[i][j].value == 0){
+                    break;
+                }
+                else filledTiles += 1;
+            }
+        }
+    }
+    private void slideBottom(){
+        for(int j=0;j<size;j++){
+            int end = size-1;
+            for(int i=size-1;i>=0;i--){
+                int k = i;
+                if(board.tiles[i][j].value > 0){
+                    while(k < end){
+                        if(board.tiles[k+1][j].value > 0){
+                            if(board.tiles[k+1][j].value != board.tiles[k][j].value){
+                                end = k;
+                                break;
+                            }
+                            else {
+                                board.tiles[k+1][j].value += board.tiles[k][j].value;
+                                board.tiles[k][j].value = 0;
+                                end = k+1;
+                            }
+                        }
+                        else {
+                            board.tiles[k+1][j].value = board.tiles[k][j].value;
+                            board.tiles[k][j].value = 0;
+                        }
+                        k++;
+                    }
+                }
+            }
+        }
+    }
+
+    private void slideUp(){
+        for(int j=0;j<size;j++){
+            int end = 0;
+            for(int i=0;i<size;i++){
+                int k = i;
+                if(board.tiles[i][j].value > 0){
+                    while(k > end){
+                        if(board.tiles[k-1][j].value > 0){
+                            if(board.tiles[k-1][j].value != board.tiles[k][j].value){
+                                end = k;
+                                break;
+                            }
+                            else {
+                                board.tiles[k-1][j].value += board.tiles[k][j].value;
+                                board.tiles[k][j].value = 0;
+                                end = k-1;
+                            }
+                        }
+                        else {
+                            board.tiles[k-1][j].value = board.tiles[k][j].value;
+                            board.tiles[k][j].value = 0;
+                        }
+                        k--;
+                    }
+                }
+            }
+        }
+    }
+
+    private void slideRight(){
+        for(int i=0;i<size;i++){
+            int end = size-1;
+            for(int j=size-1;j>=0;j--){
+                int k = j;
+                if(board.tiles[i][j].value > 0){
+                    while(k < end){
+                        if(board.tiles[i][k+1].value > 0){
+                            if(board.tiles[i][k+1].value != board.tiles[i][k].value){
+                                end = k;
+                                break;
+                            }
+                            else {
+                                board.tiles[i][k+1].value += board.tiles[i][k].value;
+                                board.tiles[i][k].value = 0;
+                                end = k+1;
+                            }
+                        }
+                        else {
+                            board.tiles[i][k+1].value = board.tiles[i][k].value;
+                            board.tiles[i][k].value = 0;
+                        }
+                        k++;
+                    }
+                }
+            }
+        }
+    }
+
+    private void slideLeft(){
+        for(int i=0;i<size;i++){
+            int end = 0;
+            for(int j=0;j< size;j++){
+                int k = j;
+                if(board.tiles[i][j].value > 0){
+                    while(k > end){
+                        if(board.tiles[i][k-1].value > 0){
+                            if(board.tiles[i][k-1].value != board.tiles[i][k].value){
+                                end = k;
+                                break;
+                            }
+                            else {
+                                board.tiles[i][k-1].value += board.tiles[i][k].value;
+                                board.tiles[i][k].value = 0;
+                                end = k-1;
+                            }
+                        }
+                        else {
+                            board.tiles[i][k-1].value = board.tiles[i][k].value;
+                            board.tiles[i][k].value = 0;
+                        }
+                        k--;
+                    }
+                }
+            }
+        }
+    }
+}

2048-game/src/Main.java

@@ -0,0 +1,8 @@
+// import java.util.Scanner;
+public class Main {
+    public static void main(String[] args) throws Exception {
+        Board board = new Board(4,2, 10);
+        Game game = new Game(board);
+        game.startGame(board);
+    }
+}

2048-game/src/Tile.java

@@ -0,0 +1,4 @@
+
+public class Tile {
+    int value;
+}

snake-ladder-practice/README.md

@@ -0,0 +1,18 @@
+## Getting Started
+
+Welcome to the VS Code Java world. Here is a guideline to help you get started to write Java code in Visual Studio Code.
+
+## Folder Structure
+
+The workspace contains two folders by default, where:
+
+- `src`: the folder to maintain sources
+- `lib`: the folder to maintain dependencies
+
+Meanwhile, the compiled output files will be generated in the `bin` folder by default.
+
+> If you want to customize the folder structure, open `.vscode/settings.json` and update the related settings there.
+
+## Dependency Management
+
+The `JAVA PROJECTS` view allows you to manage your dependencies. More details can be found [here](https://github.com/microsoft/vscode-java-dependency#manage-dependencies).

snake-ladder-practice/src/Board.java

@@ -0,0 +1,70 @@
+// import java.util.ArrayList;
+import java.util.Scanner;
+
+public class Board {
+    Cell[][] cells;
+
+    // int n = cells.length;
+    // int m = cells[0].length;
+    Scanner scn =  new Scanner(System.in);
+
+    Board(int boardSize){
+        initializeBoard(boardSize);
+        addSnakes();
+        addLadders();
+    }
+
+    private void initializeBoard(int size){
+        cells = new Cell[size][size];
+        for(int i=0;i<size;i++){
+            for(int j=0;j<size;j++){
+                cells[i][j] = new Cell();
+            }
+        }
+    }
+
+    private void addSnakes(){
+        int snakesCount = scn.nextInt();
+        while(snakesCount > 0){
+            int head = scn.nextInt();
+            int tail = scn.nextInt();
+            if(head <= tail || head == 100 || getCell(head).jump != null){
+                System.err.print("not possible ! Enter again");
+            }
+            else {
+                Jump snakeJump = new Jump();
+                snakeJump.start = head;
+                snakeJump.end = tail;
+                Cell headCell = getCell(head);
+                headCell.jump = snakeJump;
+                snakesCount--;
+            }
+        }
+    }
+
+    private void addLadders(){
+        int laddersCount = scn.nextInt();
+        while(laddersCount > 0){
+            int start = scn.nextInt();
+            int end = scn.nextInt();
+            if(start >= end || getCell(start).jump != null){
+                System.err.print("not possible ! Enter again");
+            }
+            else {
+                Jump ladderJump = new Jump();
+                ladderJump.start = start;
+                ladderJump.end = end;
+                Cell headCell = getCell(start);
+                headCell.jump = ladderJump;
+                laddersCount--;
+            }
+        }
+    }
+
+    Cell getCell(int position){
+        int row = (position-1)/cells.length;
+        int column  = (position-1)%cells.length;
+        return cells[row][column];
+    }
+
+}

snake-ladder-practice/src/Cell.java

@@ -0,0 +1,3 @@
+public class Cell {
+    Jump jump;
+}