Machine Coding Round

# Step 1: Requirements (5 min)
? Functional requirements kya hain?
? Non-functional requirements (scale, latency)?
? Edge cases kya ho sakte hain?

# Step 2: Design (10 min)
? Classes aur relationships banao
? Design patterns identify karo
? Interface design karo pehle

# Step 3: Coding (25 min)
? Clean, modular code likho
? Design patterns apply karo
? Error handling mat bhoolo

# Step 4: Testing (5 min)
? Basic test cases socho
? Edge cases handle karo
? Demo karo interviewer ko

# Golden Rules:
? Interface-first design karo
? Single Responsibility follow karo
? Error handling mat bhoolo
? Production-quality code likho
? Time management karo — don't overthink

# Requirements:
1. Multiple floors, multiple vehicle types (bike, car, truck)
2. Parking spots type-wise allocated
3. Entry/exit points
4. Ticket generation with timestamp
5. Payment calculation

# Design:
from abc import ABC, abstractmethod
from enum import Enum
from datetime import datetime

class VehicleType(Enum):
 BIKE = 1
 CAR = 2
 TRUCK = 3

class Vehicle:
 def __init__(self, license_plate, vehicle_type):
 self.license_plate = license_plate
 self.vehicle_type = vehicle_type

class ParkingSpot:
 def __init__(self, spot_id, vehicle_type):
 self.spot_id = spot_id
 self.vehicle_type = vehicle_type
 self.is_occupied = False
 self.vehicle = None
 
 def park(self, vehicle):
 if self.is_occupied:
 return False
 self.vehicle = vehicle
 self.is_occupied = True
 return True
 
 def remove(self):
 self.vehicle = None
 self.is_occupied = False

class ParkingFloor:
 def __init__(self, floor_id):
 self.floor_id = floor_id
 self.spots = []
 
 def add_spot(self, spot):
 self.spots.append(spot)
 
 def find_spot(self, vehicle_type):
 for spot in self.spots:
 if (spot.vehicle_type == vehicle_type and 
 not spot.is_occupied):
 return spot
 return None

class ParkingLot:
 _instance = None
 
 @staticmethod
 def get_instance():
 if ParkingLot._instance is None:
 ParkingLot._instance = ParkingLot()
 return ParkingLot._instance
 
 def __init__(self):
 self.floors = []
 
 def add_floor(self, floor):
 self.floors.append(floor)
 
 def park_vehicle(self, vehicle):
 for floor in self.floors:
 spot = floor.find_spot(vehicle.vehicle_type)
 if spot:
 spot.park(vehicle)
 return Ticket(vehicle, spot, datetime.now())
 return None # Full parking lot

class Ticket:
 def __init__(self, vehicle, spot, entry_time):
 self.vehicle = vehicle
 self.spot = spot
 self.entry_time = entry_time

# 1. Factory Pattern
? Objects create karna without specifying class
? VehicleFactory.create("car") — Car object

# 2. Strategy Pattern
? Behavior dynamically change karna
? PaymentStrategy: CreditCard, UPI, Cash

# 3. Observer Pattern
? Event notification
? ParkingLot full — Notify all apps

# 4. Singleton Pattern
? Single instance
? ParkingLot, Database connection

# 5. State Pattern
? Object state ke hisaab se behavior change
? Elevator states: Idle, Moving, DoorOpen

# 6. Decorator Pattern
? Additional behavior add karna
? Vehicle — Vehicle with Insurance — Vehicle with GPS

# Code Quality Tips:
? Meaningful variable names
? Method length < 20 lines
? DRY (Don't Repeat Yourself)
? Error handling (try/except)
? Type hints (Python 3.5+)

# Before Coding:
1. Clarify requirements — 2 min waste better than 20 min wrong
2. Draw high-level design — interviewer se discuss karo
3. Identify core classes — interface-first approach
4. Talk through your thought process

# During Coding:
1. Start with interface/class definition
2. One feature at time — incremental development
3. Handle errors gracefully
4. Test as you go — don't wait till end

# After Coding:
1. Walk through the code
2. Discuss scalability
3. Mention improvements
4. Handle edge cases verbally

# Common Problems:
- Parking Lot: Singleton, Strategy, Factory
- Elevator: State, Observer
- Chat System: Observer, Strategy
- Vending Machine: State, Strategy
- BookMyShow: Singleton, Strategy, Observer