Design snake and ladder,ATM, BookMyShow, CricBuzz, FlightManagement, LibraryManagement,MeetingRoom, ParkingLot, Splitwise

DeckOfCards/Card.java

@@ -0,0 +1,17 @@
+package DeckOfCards;
+
+
+public class Card {
+    private Suit suit;
+    private Rank rank;
+
+    public Card(Suit suit, Rank rank) {
+        this.suit = suit;
+        this.rank = rank;
+    }
+
+    @Override
+    public String toString() {
+        return rank + " of " + suit;
+    }
+}

DeckOfCards/Deck.java

@@ -0,0 +1,75 @@
+package DeckOfCards;
+
+import java.util.*;
+
+public class Deck {
+    private Stack<Card> cards;
+
+    public Deck(int numberOfDecks) {
+        cards = new Stack<>();
+        createDeck(numberOfDecks);
+    }
+
+    private void createDeck(int numberOfDecks) {
+        for (int i = 0; i < numberOfDecks; i++) {
+            for (Suit suit : Suit.values()) {
+                for (Rank rank : Rank.values()) {
+                    cards.push(new Card(suit, rank));
+                }
+            }
+        }
+    }
+
+    public void shuffleDeck(int numberOfShuffles) {
+        Random random = new Random();
+        Card[] tempArray = cards.toArray(new Card[0]);
+
+        for (int m = 0; m < numberOfShuffles; m++) { // Shuffle M times
+            for (int i = tempArray.length - 1; i > 0; i--) {
+                int j = random.nextInt(i + 1);
+                Card temp = tempArray[i];
+                tempArray[i] = tempArray[j];
+                tempArray[j] = temp;
+            }
+        }
+
+        // Rebuild the stack
+        cards.clear();
+        for (Card card : tempArray) {
+            cards.push(card);
+        }
+    }
+
+    // Distribute cards to players
+    public Map<Integer, List<Card>> dealCards(int numberOfPlayers, int cardsPerPlayer) {
+        int totalAvailable = cards.size();
+        int required = numberOfPlayers * cardsPerPlayer;
+
+        // Edge case check
+        if (required > totalAvailable) {
+            throw new IllegalArgumentException("Not enough cards! Required: " + required + ", Available: " + totalAvailable);
+        }
+
+        Map<Integer, List<Card>> playerHands = new HashMap<>();
+        for (int player = 1; player <= numberOfPlayers; player++) {
+            List<Card> hand = new ArrayList<>();
+            for (int c = 0; c < cardsPerPlayer; c++) {
+                hand.add(cards.pop());
+            }
+            playerHands.put(player, hand);
+        }
+        return playerHands;
+    }
+
+
+    public Card drawCard() {
+        if (cards.isEmpty()) {
+            throw new IllegalStateException("No cards left in the deck!");
+        }
+        return cards.pop(); // Draw from top
+    }
+
+    public int remainingCards() {
+        return cards.size();
+    }
+}

DeckOfCards/Main.java

@@ -0,0 +1,33 @@
+package DeckOfCards;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+
+public class Main {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        System.out.print("Enter number of decks (N): ");
+        int N = sc.nextInt();
+
+        System.out.print("Enter number of shuffles (M): ");
+        int M = sc.nextInt();
+
+        Deck deck = new Deck(N);
+        deck.shuffleDeck(M);
+
+        Map<Integer, List<Card>> dealCards = deck.dealCards(11, 11);
+
+        for (Map.Entry<Integer, List<Card>> entry : dealCards.entrySet()) {
+            Integer playerId = entry.getKey();
+            List<Card> cards = entry.getValue();
+
+            System.out.println("Player " + playerId + ": " + cards);
+        }
+
+
+        System.out.println("Remaining cards: " + deck.remainingCards());
+    }
+}

DeckOfCards/Rank.java

@@ -0,0 +1,6 @@
+package DeckOfCards;
+
+enum Rank {
+    TWO, THREE, FOUR, FIVE, SIX, SEVEN,
+    EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE
+}

DeckOfCards/Suit.java

@@ -0,0 +1,17 @@
+package DeckOfCards;
+
+public enum Suit {
+    SPADE(0),
+    HEART(1),
+    CLUB(2),
+    DIAMOND(3);
+    private final int value;
+
+    private Suit(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}

atm/ATM.java

@@ -0,0 +1,79 @@
+package atm;
+
+
+
+public class ATM {
+
+    private static ATM atmObject = new ATM(); //Singleton: eager initialization
+
+    ATMState currentATMState;
+
+    private int atmBalance;
+    int noOfTwoThousandNotes;
+    int noOfFiveHundredNotes;
+    int noOfOneHundredNotes;
+
+
+    private ATM() {
+    }
+
+    public void setCurrentATMState(ATMState currentATMState) {
+        this.currentATMState = currentATMState;
+    }
+
+    public ATMState getCurrentATMState() {
+        return currentATMState;
+    }
+
+    public static ATM getATMObject() {
+        atmObject.setCurrentATMState(new IdleState());
+        return atmObject;
+    }
+
+    public int getAtmBalance() {
+        return atmBalance;
+    }
+
+    public void setAtmBalance(int atmBalance, int noOfTwoThousandNotes, int noOfFiveHundredNotes, int noOfOneHundredNotes) {
+        this.atmBalance = atmBalance;
+        this.noOfTwoThousandNotes = noOfTwoThousandNotes;
+        this.noOfFiveHundredNotes = noOfFiveHundredNotes;
+        this.noOfOneHundredNotes = noOfOneHundredNotes;
+    }
+
+    public int getNoOfTwoThousandNotes() {
+        return noOfTwoThousandNotes;
+    }
+
+    public int getNoOfFiveHundredNotes() {
+        return noOfFiveHundredNotes;
+    }
+
+    public int getNoOfOneHundredNotes() {
+        return noOfOneHundredNotes;
+    }
+
+    public void deductATMBalance(int amount) {
+        atmBalance = atmBalance - amount;
+    }
+
+    public void deductTwoThousandNotes(int number) {
+        noOfTwoThousandNotes = noOfTwoThousandNotes - number;
+    }
+
+    public void deductFiveHundredNotes(int number) {
+        noOfFiveHundredNotes = noOfFiveHundredNotes - number;
+    }
+
+    public void deductOneHundredNotes(int number) {
+        noOfOneHundredNotes = noOfOneHundredNotes - number;
+    }
+
+    public void printCurrentATMStatus(){
+        System.out.println("Balance: " + atmBalance);
+        System.out.println("2kNotes: " + noOfTwoThousandNotes);
+        System.out.println("500Notes: " + noOfFiveHundredNotes);
+        System.out.println("100Notes: " + noOfOneHundredNotes);
+
+    }
+}

atm/ATMRoom.java

@@ -0,0 +1,55 @@
+package atm;
+
+public class ATMRoom {
+    ATM atm;
+    User user;
+
+    public static void main(String args[]) {
+
+        ATMRoom atmRoom = new ATMRoom();
+        atmRoom.initialize();
+
+        atmRoom.atm.printCurrentATMStatus();
+        atmRoom.atm.getCurrentATMState().insertCard(atmRoom.atm, atmRoom.user.card);
+        atmRoom.atm.getCurrentATMState().authenticatePin(atmRoom.atm, atmRoom.user.card, 112211);
+        atmRoom.atm.getCurrentATMState().selectOperation(atmRoom.atm, atmRoom.user.card, TransactionType.CASH_WITHDRAWAL);
+        atmRoom.atm.getCurrentATMState().cashWithdrawal(atmRoom.atm, atmRoom.user.card, 2700);
+        atmRoom.atm.printCurrentATMStatus();
+
+
+    }
+
+    private void initialize() {
+
+        //create ATM
+        atm = ATM.getATMObject();
+        atm.setAtmBalance(3500, 1,2,5);
+
+        //create User
+        this.user = createUser();
+    }
+
+    private User createUser(){
+
+        User user = new User();
+        user.setCard(createCard());
+        return user;
+    }
+
+    private Card createCard(){
+
+        Card card = new Card();
+        card.setBankAccount(createBankAccount());
+        return card;
+    }
+
+    private UserBankAccount createBankAccount() {
+
+        UserBankAccount bankAccount = new UserBankAccount();
+        bankAccount.balance = 3000;
+
+        return bankAccount;
+
+    }
+
+}

atm/ATMState.java

@@ -0,0 +1,32 @@
+package atm;
+
+public abstract class ATMState {
+
+    public void insertCard(ATM atm, Card card) {
+        System.out.println("OOPS!! Something went wrong");
+    }
+
+    public void authenticatePin(ATM atm, Card card, int pin){
+        System.out.println("OOPS!! Something went wrong");
+    }
+
+    public void selectOperation(ATM atm, Card card, TransactionType txnType){
+        System.out.println("OOPS!! Something went wrong");
+    }
+
+    public void cashWithdrawal(ATM atm, Card card, int withdrawAmount){
+        System.out.println("OOPS!! Something went wrong");
+    }
+
+    public void displayBalance(ATM atm, Card card){
+        System.out.println("OOPS!! Something went wrong");
+    }
+
+    public void returnCard(){
+        System.out.println("OOPS!! Something went wrong");
+    }
+
+    public void exit(ATM atm){
+        System.out.println("OOPS!! Something went wrong");
+    }
+}

atm/Card.java

@@ -0,0 +1,31 @@
+package atm;
+
+public class Card {
+
+    private int cardNumber;
+    private int cvv;
+    private int expiryDate;
+    private int holderName;
+    static int PIN_NUMBER = 112211;
+    private UserBankAccount bankAccount;
+
+    public boolean isCorrectPINEntered(int pin) {
+
+        if (pin == PIN_NUMBER) {
+            return true;
+        }
+        return false;
+    }
+
+    public int getBankBalance(){
+        return bankAccount.balance;
+    }
+
+    public void deductBankBalance(int amount){
+        bankAccount.withdrawalBalance(amount);
+    }
+
+    public void setBankAccount(UserBankAccount bankAccount) {
+        this.bankAccount = bankAccount;
+    }
+}

atm/CashWithdrawProcessor.java

@@ -0,0 +1,19 @@
+package atm;
+
+public abstract class CashWithdrawProcessor {
+
+    CashWithdrawProcessor nextCashWithdrawalProcessor;
+
+    CashWithdrawProcessor(CashWithdrawProcessor cashWithdrawalProcessor) {
+
+        this.nextCashWithdrawalProcessor = cashWithdrawalProcessor;
+
+    }
+
+    public void withdraw(ATM atm, int remainingAmount) {
+
+        if (nextCashWithdrawalProcessor != null) {
+            nextCashWithdrawalProcessor.withdraw(atm, remainingAmount);
+        }
+    }
+}