CareerCup

Elevator
        private int weightApplied
        private int passengerNumber;
        private String elevatorID;
        private int floorNumber
        private int capacity
        private boolean started
        private String direction
        private String state
        private boolean goingUp
        private boolean doorsOpen
        private PriorityQueue pq//PQ that gives priority to different floors based on floorNumber, non-preemptive priority scheduling

        void go_up(int floorNumber);
        void go_down(int floorNumber);
        boolean isStarted(boolean start);
        boolean setStarted(boolean start);
        void load_passengers();
        void unload_passengers();
        etc...
        getters and setters for all instance variables...
    Passenger extends Elevator
        private int destinationFloor;

        int current_destination(int destinationFloor)

There's probably something else I'm missing but I think I have some idea...

*repose with format corrected*

public class Elevator {
	
	public static final int MAX_FLOORS = 50;
	
	// upward floor queue
	private PriorityQueue<Integer> floors_up = new PriorityQueue<Integer>(MAX_FLOORS);
	
	// downward floor queue
	private PriorityQueue<Integer> floors_down = new PriorityQueue<Integer>(MAX_FLOORS, new Comparator<Integer>(){
		public int compare(Integer arg0, Integer arg1) {
			return arg1.compareTo(arg0);
		}
	});
	
	// effective floor queue
	private PriorityQueue<Integer> floors = floors_up;
	
	// current floor
	private int current = 0;

	public void userCallAt(int where) {
		setTarget(where);
	}
	
	public void setTarget(int target) {
		
		// ignore if target is current
		if (target == current) {
			return;
		}
		
		// add target to right queue
		if (floors == floors_up) {
			if (target < current) {
				floors_down.offer(target);
			} else {
				floors_up.offer(target);
			}
		} else {
			if (target > current) {
				floors_up.offer(target);
			} else {
				floors_down.offer(target);
			}
		}
		
		// swap queue to turn around the elevator
		if (floors.isEmpty()) {
			floors = (floors == floors_up ? floors_down : floors_up);
		}
	}
	
	public int getTarget() {
		
		if (!floors.isEmpty()) {
			return floors.peek();
		}
		
		if (floors_up.isEmpty() && floors_down.isEmpty()) {
			return current;
		}
		
		floors = (floors == floors_up ? floors_down : floors_up);
		return floors.peek();
	}
	
	public int getCurrent() {
		return current;
	}
	
	public void step(int target) {
		if (target > current) {
			current++;
		} else {
			current--;
		}
	}
	
	public void stop() {
		floors.poll();
	}
	
	public void move() {
		
		while (getCurrent() != getTarget()) {
			do {
				step(getTarget());
			} while (getCurrent() != getTarget());
			stop();
		}
		
	}
	
}

I think we dont need so much variables and methods ... as per my approach

we need
enum Motion
{
Going_Up, Going_Down, Stoped
}

Class Lift
{
int current Floor;
int priorityQueue nextFloorToStop;
int LiftId;
}

Class LiftController
{
array of lifts;
queue Allrequests;

public void CallLift(int floorIndex)
{

}

public void int NearestLift(int floorIndex)
{

}

public void bool IsMovingInSameDirection(int liftId, int FloorIndex)
{

}
}

If No lift is available to take request then add that request in AllRequest queue else add it in lift's queue.
When when lift comes to stop (after completing its all floor stops) then it will notify controller class to
check if there is any request pending in "allRequest Queue".

public class Elevator {

public static final int MAX_FLOORS = 50;

// upward floor queue
private PriorityQueue<Integer> floors_up = new PriorityQueue<Integer>(MAX_FLOORS);

// downward floor queue
private PriorityQueue<Integer> floors_down = new PriorityQueue<Integer>(MAX_FLOORS, new Comparator<Integer>(){
public int compare(Integer arg0, Integer arg1) {
return arg1.compareTo(arg0);
}
});

// effective floor queue
private PriorityQueue<Integer> floors = floors_up;

// current floor
private int current = 0;

public void userCallAt(int where) {
setTarget(where);
}

public void setTarget(int target) {

// ignore if target is current
if (target == current) {
return;
}

// add target to right queue
if (floors == floors_up) {
if (target < current) {
floors_down.offer(target);
} else {
floors_up.offer(target);
}
} else {
if (target > current) {
floors_up.offer(target);
} else {
floors_down.offer(target);
}
}

// swap queue to turn around the elevator
if (floors.isEmpty()) {
floors = (floors == floors_up ? floors_down : floors_up);
}
}

public int getTarget() {

if (!floors.isEmpty()) {
return floors.peek();
}

if (floors_up.isEmpty() && floors_down.isEmpty()) {
return current;
}

floors = (floors == floors_up ? floors_down : floors_up);
return floors.peek();
}

public int getCurrent() {
return current;
}

public void step(int target) {
if (target > current) {
current++;
} else {
current--;
}
}

public void stop() {
floors.poll();
}

public void move() {

while (getCurrent() != getTarget()) {
do {
step(getTarget());
} while (getCurrent() != getTarget());
stop();
}

}

}

*code for demo idea*

Direction {
	UP, DOWN
}

Elevator {
	Elevator id;
	Direction currentDirection;
	int currentLevel;
        List<MovementPlan> pendingPlans;
	MovementPlan currentPlan;

	// Definite stop in route. Create a new plan if required.
        public void addStoppage(int level) {
		boolean isPossibleInCurrentPlan = currentPlan.addStop(level, currentDirection);
		if (isPossibleInCurrentPlan) {
			return;
		}

		// try to see if it can fit in other plans
		for (MovementPlan plan : pendingPlans) {
			isPossibleInPending = plan.addStop(level, currentDirection);
			if(isPossibleInPending) return;
		}

		// Make a new plan. Current plan didn't work means request is of opposite direction
		Direction oppositeDirection = direction.equals(UP)?DOWN:UP;
		Integer firstStop = currentPlan.getLast(); // last stop there is first stop here
		Set<Integer> stops = {firstStop, level};
		MovementPlan newPlan = new MovementPlan(stops, oppositeDirection);
		plans.add(newPlan);
	}

	public boolean isIdle() { // if currentPlan==null && pendingPlans.isEmpty() }

	// Should keep executing asynchronously
        public void move() {
                while(true) {	
			moveTo(currentPlan.getNext());
			refreshCurrentLevel();

			// assuming movement completed
			currentPlan.reachedNextStop();

			if (currentPlan.isCompleted()) {
				if (pendingPlans.isEmpty()) {
					// wait for new plan
				} else {
					currentPlan = pendingPlans.get(0);
				}
			}
		}
	}
}

MovementPlan {
	Direction direction;
	Set<Integer> assignedStoppages;

	public ElevationPlan(Set<Integer assignedStops, Direction direction) {
		// keep assigned stops in sorted order.
		// ascending if direction is UP, else descending if direction is DOWN
	}        

	public Integer getNext() {
		assignedStoppages.get(0);
	}

	public Integer getLast() {
		assignedStoppages.get(assignedStoppages.size() -1);
	}

	// Adds if new stop falls in the way. Else returns false
	public boolean addStop(int newStop, Direction direction) {
		// is elevator moving in same direction 
		boolean isAlignedWithPlan = ((direction.equals(UP) && newStop > getNext()) 
				|| (direction.equals(DOWN)&& newStop < getNext()))


		if ((!isCompleted()) && this.direction.equals(direction) && isAlignedWithPlan)
               		assignedStoppages.add(newStop);
		else 
			return false;
	}

	public Integer reachedNextStop() {
		Integer next = getNext();
		assignedStoppages.remove(next);
	}

	public boolean isCompleted() {
		return assignedStoppages.isEmpty();
	}
}	

ExternalController {
	List<Elevator> elevators;
	initialize(Set<Elevator> elevators) {
		// initialize
	}

	public void addPickRequest(int stopAtLevel, Direction direction) {
		// get all current movement plans from all elevators
		// Check if already assigned to one of the elevators
		// else pick up next idle elevator and call addStoppage there
		// else if no elevator is idle
			// pick one elevator and call addStoppage there. will internally create new movement plan if necessary
	}	
}