distance calculation bug + enhancements

Author: hardik302001

elevator_system/elevator.go

@@ -7,55 +7,55 @@ import (
 
 type Elevator struct {
 	ID               int
-	Capacity         int
 	CurrentFloor     int
-	CurrentDirection Directions
-	CurrentLoad      int
+	CurrentDirection Direction
 	ElevatorPanel    *ElevatorPanel
 	Destinations     []int
-	sync.Mutex
+	sync.Mutex       // helps for locks over go routines
 }
 
 func NewElevator(id int) *Elevator {
-	return &Elevator{ID: id, Capacity: 10, CurrentFloor: 1, CurrentDirection: Still, CurrentLoad: 0, ElevatorPanel: NewElevatorPanel(id)}
+	return &Elevator{
+		ID:               id,
+		CurrentFloor:     1,
+		CurrentDirection: Still,
+		ElevatorPanel:    NewElevatorPanel(id),
+	}
 }
 
 func (e *Elevator) AddDestination(destinationFloor int) {
 	e.Lock()
+	defer e.Unlock()
 	e.ElevatorPanel.AddDestinationFloor(destinationFloor)
 	e.Destinations = append(e.Destinations, destinationFloor)
 	fmt.Printf("Elevator %d received destination floor %d\n", e.ID, destinationFloor)
-	e.Unlock()
 }
 
 func (e *Elevator) RemoveDestination(destinationFloor int) {
 	e.Lock()
+	defer e.Unlock()
 	for i, floor := range e.Destinations {
 		if floor == destinationFloor {
 			e.Destinations = append(e.Destinations[:i], e.Destinations[i+1:]...)
 			e.ElevatorPanel.RemoveDestinationFloor(destinationFloor)
 			break
 		}
 	}
-	e.Unlock()
+	fmt.Printf("Elevator %d removed destination floor %d\n", e.ID, destinationFloor)
 }
 
 func (e *Elevator) UpdateCurrentFloor(newFloor int) {
 	e.Lock()
+	defer e.Unlock()
+	fmt.Printf("Elevator %d moving from floor %d to floor %d\n", e.ID, e.CurrentFloor, newFloor)
 	e.CurrentFloor = newFloor
-	e.Unlock()
-}
-
-func (e *Elevator) UpdateCurrentLoad(newLoad int) {
-	e.Lock()
-	e.CurrentLoad = newLoad
-	e.Unlock()
 }
 
-func (e *Elevator) UpdateCurrentDirection(newDirection Directions) {
+func (e *Elevator) UpdateCurrentDirection(newDirection Direction) {
 	e.Lock()
+	defer e.Unlock()
+	fmt.Printf("Elevator %d changing direction from %s to %s\n", e.ID, e.CurrentDirection, newDirection)
 	e.CurrentDirection = newDirection
-	e.Unlock()
 }
 
 func (e *Elevator) FarthestDestination() int {
@@ -81,3 +81,16 @@ func (e *Elevator) NearestDestination() int {
 
 	return minFloor
 }
+
+func (e *Elevator) PrintState() {
+	e.Lock()
+	defer e.Unlock()
+
+	fmt.Printf(
+		"Elevator %d | Current Floor: %d | Direction: %s | Destinations: %v\n",
+		e.ID,
+		e.CurrentFloor,
+		e.CurrentDirection,
+		e.Destinations,
+	)
+}

elevator_system/elevatorManager.go

@@ -15,21 +15,20 @@ func NewElevatorManager(building *Building) *ElevatorManager {
 
 func (em *ElevatorManager) OperateAllElevators() {
 	for _, elevator := range em.Building.Elevators {
-		go em.OperateElevator(elevator)
+		elevator.PrintState()
+		go em.OperateElevator(elevator) // go thread for each elevator
 	}
 }
 
 func (em *ElevatorManager) OperateElevator(elevator *Elevator) {
-	for {
-		elevator.Lock()
+	for { // infinte loop to keep elevator operating(real world scenario -> event can come any time)
+	
 		if len(elevator.Destinations) == 0 {
 			elevator.CurrentDirection = Still
-			elevator.Unlock()
 			continue
 		}
 
 		sort.Ints(elevator.Destinations)
-		fmt.Printf("Elevator %d is starting from %d and going to %s\n", elevator.ID, elevator.CurrentFloor, elevator.CurrentDirection)
 
 		if elevator.CurrentDirection == Up {
 			em.MoveElevatorUp(elevator)
@@ -38,16 +37,17 @@ func (em *ElevatorManager) OperateElevator(elevator *Elevator) {
 		} else {
 			em.DecideDirection(elevator)
 		}
-		elevator.Unlock()
+
 	}
 }
 
+// move to nearest request
 func (em *ElevatorManager) DecideDirection(elevator *Elevator) {
-	currentFloor := elevator.CurrentFloor
 	if len(elevator.Destinations) == 0 {
 		return
 	}
 
+	currentFloor := elevator.CurrentFloor
 	nearestDestination := elevator.Destinations[0]
 	if nearestDestination > currentFloor {
 		elevator.UpdateCurrentDirection(Up)
@@ -62,10 +62,11 @@ func (em *ElevatorManager) MoveElevatorUp(elevator *Elevator) {
 	for i := 0; i < len(elevator.Destinations); i++ {
 		destination := elevator.Destinations[i]
 		if destination >= elevator.CurrentFloor {
-			fmt.Printf("Elevator %d moving up to floor %d\n", elevator.ID, destination)
 			elevator.UpdateCurrentFloor(destination)
 			elevator.RemoveDestination(destination)
-			i--
+			i-- // because we have removed an element from the slice
+		} else {
+			// skip destinations below current floor
 		}
 	}
 
@@ -80,9 +81,10 @@ func (em *ElevatorManager) MoveElevatorDown(elevator *Elevator) {
 	for i := len(elevator.Destinations) - 1; i >= 0; i-- {
 		destination := elevator.Destinations[i]
 		if destination <= elevator.CurrentFloor {
-			fmt.Printf("Elevator %d moving down to floor %d\n", elevator.ID, destination)
 			elevator.UpdateCurrentFloor(destination)
 			elevator.RemoveDestination(destination)
+		} else {
+			// skip destinations above current floor
 		}
 	}
 
@@ -93,7 +95,8 @@ func (em *ElevatorManager) MoveElevatorDown(elevator *Elevator) {
 	}
 }
 
-func (em *ElevatorManager) AssignElevator(floor int, direction Directions) (bestElevator *Elevator) {
+// manager will assign the best elevator for the hall call request
+func (em *ElevatorManager) AssignElevator(floor int, direction Direction) (bestElevator *Elevator) {
 	bestElevator = em.FindClosestElevator(floor, direction)
 	if bestElevator != nil {
 		bestElevator.AddDestination(floor)
@@ -102,41 +105,66 @@ func (em *ElevatorManager) AssignElevator(floor int, direction Directions) (best
 	return bestElevator
 }
 
-func (em *ElevatorManager) FindClosestElevator(floor int, direction Directions) *Elevator {
+// mamnager will find best elevator for the hall call request
+func (em *ElevatorManager) FindClosestElevator(floor int, direction Direction) *Elevator {
 	var closestElevator *Elevator
 	minDistance := int(1e9)
 
 	for _, elevator := range em.Building.Elevators {
 		elevator.Lock()
 		distance := em.calculateDistance(elevator, floor, direction)
+		elevator.Unlock()
 
 		if distance < minDistance {
 			minDistance = distance
 			closestElevator = elevator
 		}
-
-		elevator.Unlock()
 	}
+
 	return closestElevator
 }
 
-func (em *ElevatorManager) calculateDistance(elevator *Elevator, floor int, direction Directions) int {
+func (em *ElevatorManager) calculateDistance(elevator *Elevator, floor int, direction Direction) int {
 	currentFloor := elevator.CurrentFloor
 	currentDirection := elevator.CurrentDirection
 
-	if currentDirection == Still || (currentDirection == direction && ((direction == Up && floor > currentFloor) || (direction == Down && floor < currentFloor))) {
+	fmt.Println("Calculating distance for Elevator", elevator.ID, "at floor", currentFloor, "going", currentDirection, "to floor", floor, "going", direction)
+
+	// Case 1: Elevator is idle
+	if currentDirection == Still || len(elevator.Destinations) == 0 {
 		return abs(floor - currentFloor)
 	}
 
+	// Case 2: Elevator moving in same direction
+	if currentDirection == direction {
+		if (direction == Up && floor >= currentFloor) || (direction == Down && floor <= currentFloor) {
+			// Request is ahead in same direction → pick up immediately
+			return abs(floor - currentFloor)
+		} else {
+			// Request is behind → calculate distance after finishing current sweep
+			if direction == Up {
+				farthest := elevator.FarthestDestination()
+				return abs(farthest - currentFloor) + abs(farthest - floor)
+			} else { // Down
+				nearest := elevator.NearestDestination()
+				return abs(currentFloor - nearest) + abs(floor - nearest)
+			}
+		}
+	}
+
+	// Case 3: Elevator moving in opposite direction
 	if (currentDirection == Up && direction == Down) || (currentDirection == Down && direction == Up) {
 		if currentDirection == Up {
-			return abs(elevator.FarthestDestination()-currentFloor) + abs(elevator.FarthestDestination()-floor)
-		} else {
-			return abs(elevator.NearestDestination()-currentFloor) + abs(elevator.NearestDestination()-floor)
+			farthest := elevator.FarthestDestination()
+			return abs(farthest - currentFloor) + abs(farthest - floor)
+		} else { // Down
+			nearest := elevator.NearestDestination()
+			return abs(currentFloor - nearest) + abs(floor - nearest)
 		}
 	}
 
-	return 100
+	// Fallback: very far / unlikely elevator
+	return 1000
 }
 
 func abs(x int) int {

elevator_system/go.mod

@@ -2,8 +2,8 @@ module lld_go_elevator_system
 
 go 1.22.5
 
-// elevatorPanel -> inside, ouside
-// elevator care
+// elevatorPanel -> inside, outside
+// elevator core
 // floor
 // building
 // elevator system

elevator_system/hall_panel.go

@@ -2,29 +2,29 @@ package main
 
 import "fmt"
 
-type Directions string
+type Direction string
 
 const (
-	Up    Directions = "Up"
-	Down  Directions = "Down"
-	Still Directions = "Still"
+	Up    Direction = "Up"
+	Down  Direction = "Down"
+	Still Direction = "Still"
 )
 
 type HallPanel struct {
 	PanelID              int
-	DirectionInstruction Directions
+	DirectionInstruction Direction
 	SourceFloor          int
 }
 
 func NewHallPanel(panelID int, sourceFloor int) *HallPanel {
 	return &HallPanel{PanelID: panelID, SourceFloor: sourceFloor, DirectionInstruction: Still}
 }
 
-func (h *HallPanel) SetDirectionInstructions(directionInstruction Directions) {
+func (h *HallPanel) SetDirectionInstructions(directionInstruction Direction) {
 	h.DirectionInstruction = directionInstruction
 }
 
-func (h *HallPanel) RequestElevator(manager *ElevatorManager, direction Directions) (elevator *Elevator) {
+func (h *HallPanel) RequestElevator(manager *ElevatorManager, direction Direction) (elevator *Elevator) {
 	fmt.Printf("Panel %d requesting elevator with direction %s from floor %d\n", h.PanelID, direction, h.SourceFloor)
 	return manager.AssignElevator(h.SourceFloor, direction)
 }

elevator_system/main.go

@@ -11,15 +11,15 @@ func main() {
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		elevator := building.Floors[1].HallPanels[1].RequestElevator(manager, Up)
-		elevator.AddDestination(6)
+		elevator := building.Floors[1].HallPanels[1].RequestElevator(manager, Up) // request elevator from floor 1 to go Up -> hall call
+		elevator.AddDestination(6)                                                // destination floor 6
 	}()
 
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		elevator := building.Floors[8].HallPanels[2].RequestElevator(manager, Down)
-		elevator.AddDestination(7)
+		secondElevator := building.Floors[8].HallPanels[2].RequestElevator(manager, Down)
+		secondElevator.AddDestination(7)
 	}()
 
 	wg.Add(1)
@@ -29,9 +29,9 @@ func main() {
 		thirdElevator.AddDestination(12)
 	}()
 
-	wg.Wait()
+	wg.Wait() // wait unitl all requests are done
 
-	go manager.OperateAllElevators()
+	go manager.OperateAllElevators() // start operating/simulating all elevators
 
-	select {}
+	select {} // it is needed for blocking main for exiting as we have spawned goroutines
 }