Discussion :

[Youyayouyou]

Bonjour,

Je travaille sur un projet Java sur le fonctionnement d'un ascenseur, et j'aurai besoin d'aide s'il vous plaît:

Le but de ce projet est d'optimiser le temps de charge et de décharge des personnes. Sachant qu'on a 50 personnes distribuées aléatoirement sur 4 étages et se rendent aléatoirement aux étages, la capacité maximale de l'ascenseur = 5 et le nombre maximal dans une fil d'attente dans chaque étage = 7. L'ascenseur est initialement à l'étage 1, et une fois avoir déchargé toutes les personnes, il se revient à l'étage 1.

Je résume les temps de fonctionnement :

• Un ascenseur à l'arrêt met 18s à se rendre à l’étage immédiatement au-dessus ou au-dessous.
• Un ascenseur à l'arrêt met 12s à changer étage, sans s’y arrêter.
• Un ascenseur en mouvement met 6s pour changer d'étage sans s’y arrêter.
• Un ascenseur en mouvement met 12s pour changer d'étage et s'y arrêter.

Je résume les temps de charge et de décharge :

• Ouvrir ou fermer les portes prend 3 secondes.
• Le chargement d'une personne prend 9 secondes.
• Le chargement de chaque personne supplémentaire prend 6 secondes.
• Le déchargement d'une personne prend 9 secondes.
• Le déchargement de chaque personne supplémentaire prend 6 secondes.

Comment faire pour avoir à la fois :

• l'ascenseur s'arrête bien au niveau 1 et pas à un autre étage.
• l'ascenseur est vide.
• plus personne n'attend dans les étages.
• le temps de fonctionnement est minimal.

Voici le code principal:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
package org.elevator;
 
import org.elevator.event.Event;
import org.elevator.model.Person;
import org.elevator.model.WaitingList;
import org.elevator.student.DumbElevator;
import org.elevator.system.ShadowElevator;
 
import java.time.LocalTime;
import java.util.*;
 
public class Building {
 
    public static final int ELEVATOR_CAPACITY = 5;
    public static final int MAX_FLOOR = 4;
    public static final LocalTime START_TIME = LocalTime.of(6, 0, 0); // 6h 0mn 0s
    public static final int MAX_PEOPLE_ARRIVING = 50;
    public static final int MAX_NUMBER_OF_PEOPLE_IN_LINE = 7;
 
    public static final float PROBABILITY_TO_SEE_A_NEW_PERSON_IN_LINE = 0.025f;
    public static Random random = new Random(10L);
 
    public static void main(String[] args) {
 
        NavigableMap<LocalTime, Event> events = new TreeMap<>();
 
        LocalTime time = START_TIME;
        Event startEvent = new Event(Event.ELEVATOR_STARTS);
        events.put(time, startEvent);
 
        WaitingList peopleWaitingPerFloor = new WaitingList();
        Elevator elevator = new DumbElevator(ELEVATOR_CAPACITY);
 
        int totalNumberOfPeople = peopleWaitingPerFloor.countPeople();
        elevator.peopleWaiting(peopleWaitingPerFloor.getLists());
        ShadowElevator shadowElevator = new ShadowElevator(ELEVATOR_CAPACITY, peopleWaitingPerFloor);
 
        printInitInfos(peopleWaitingPerFloor, totalNumberOfPeople);
 
        while (totalNumberOfPeople < MAX_PEOPLE_ARRIVING || !shadowElevator.isStopped()) {
 
            if (!events.containsKey(time)) {
                if (totalNumberOfPeople < MAX_PEOPLE_ARRIVING) {
                    totalNumberOfPeople += addNewPersonToWaitingLists(time, peopleWaitingPerFloor, elevator);
                    if (totalNumberOfPeople == MAX_PEOPLE_ARRIVING) {
                        shadowElevator.lastPersonArrived();
                        elevator.lastPersonArrived();
                    }
                }
                time = time.plusSeconds(3);
                continue;
            }
 
            Event nextEvent = events.get(time);
            events.remove(time);
 
            if (nextEvent.getName().equals(Event.ELEVATOR_STARTS)) {
 
                Event event = Event.fromElevatorStart(time, elevator, shadowElevator);
                LocalTime arrivalTime = event.getTimeOfArrivalFrom(time);
                events.put(arrivalTime, event);
 
            } else if (nextEvent.getName().equals(Event.ARRIVES_AT_FLOOR)) {
 
                Event event = Event.fromArrivesAtFloor(time, elevator, shadowElevator);
                LocalTime arrivalTime = event.getTimeOfArrivalFrom(time);
                events.put(arrivalTime, event);
 
            } else if (nextEvent.getName().equals(Event.DOOR_OPENING)) {
 
                Event event = Event.fromDoorOpening(time, elevator, shadowElevator);
                LocalTime arrivalTime = event.getTimeOfArrivalFrom(time);
                events.put(arrivalTime, event);
 
            } else if (nextEvent.getName().equals(Event.DOOR_CLOSING)) {
 
                Event event = Event.fromDoorClosing(time, shadowElevator);
                LocalTime arrivalTime = time.plus(event.getDuration());
                events.put(arrivalTime, event);
 
            } else if (nextEvent.getName().equals(Event.LOADING_FIRST_PERSON)) {
 
                Event event = Event.fromLoadingFirstPerson(time, shadowElevator, elevator, nextEvent);
                LocalTime arrivalTime = event.getTimeOfArrivalFrom(time);
                events.put(arrivalTime, event);
 
            } else if (nextEvent.getName().equals(Event.LOADING_NEXT_PERSON)) {
 
                Event event = Event.fromLoadingNextPerson(time, shadowElevator, elevator, nextEvent);
                LocalTime arrivalTime = event.getTimeOfArrivalFrom(time);
                events.put(arrivalTime, event);
 
            } else if (nextEvent.getName().equals(Event.UNLOADING_FIRST_PERSON)) {
 
                Event event = Event.fromUnloadingFirstPerson(time, elevator, shadowElevator, nextEvent);
 
                LocalTime arrivalTime = event.getTimeOfArrivalFrom(time);
                events.put(arrivalTime, event);
 
            } else if (nextEvent.getName().equals(Event.UNLOADING_NEXT_PERSON)) {
 
                Event event = Event.fromUnloadingNextPerson(time, elevator, shadowElevator, nextEvent);
 
                LocalTime arrivalTime = event.getTimeOfArrivalFrom(time);
                events.put(arrivalTime, event);
 
            } else if (nextEvent.getName().equals(Event.STAND_BY_AT_FLOOR)) {
 
                Event event = Event.fromStandByAtFloor(time, elevator, shadowElevator);
 
                LocalTime arrivalTime = event.getTimeOfArrivalFrom(time);
                events.put(arrivalTime, event);
 
            } else if (nextEvent.getName().equals(Event.STOPPING_AT_FLOOR)) {
 
                shadowElevator.stopping();
            }
 
            if (totalNumberOfPeople < MAX_PEOPLE_ARRIVING) {
                totalNumberOfPeople += addNewPersonToWaitingLists(time, peopleWaitingPerFloor, elevator);
                if (totalNumberOfPeople == MAX_PEOPLE_ARRIVING) {
                    shadowElevator.lastPersonArrived();
                    elevator.lastPersonArrived();
                }
            }
            time = time.plusSeconds(3);
        }
        peopleWaitingPerFloor.print();
        shadowElevator.printPeople();
        System.out.printf("[%s] Times up\n", time);
    }
 
    private static void printInitInfos(WaitingList peopleWaitingPerFloor, int totalNumberOfPeople) {
        double averageNumberOfPeoplePerMinute = 1d - Math.pow(1d - PROBABILITY_TO_SEE_A_NEW_PERSON_IN_LINE, 20d);
        System.out.printf("Average number of people in line per minute = %4.2f\n", averageNumberOfPeoplePerMinute);
        System.out.printf("Number of people waiting = %d\n", totalNumberOfPeople);
        peopleWaitingPerFloor.print();
    }
 
    private static int addNewPersonToWaitingLists(LocalTime time, WaitingList peopleWaitingPerFloor, Elevator elevator) {
        Optional<Map.Entry<Integer, Person>> newPersonWaiting = peopleWaitingPerFloor.addNewPeopleToLists();
        if (newPersonWaiting.isPresent()) {
            int floor = newPersonWaiting.orElseThrow().getKey();
            Person person = newPersonWaiting.orElseThrow().getValue();
            elevator.newPersonWaitingAtFloor(floor, person);
            System.out.printf("\n[%s] %s calls the elevator from floor %d to go to floor %d\n", time, person.getName(), floor, person.getDestinationFloor());
            System.out.printf("Waiting list is now:\n");
            peopleWaitingPerFloor.print();
            return 1;
        } else {
            return 0;
        }
    }
}

Voici le code de la classe dumbElevator (qui est la seule classe qui doit être modifiée),(les codes des autres packages ne sont pas mis):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
package org.elevator.student;
 
import org.elevator.Elevator;
import org.elevator.model.Person;
 
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
 
public class DumbElevator implements Elevator {
 
 
	Random random = new Random(314L); 
    private int elevatorCapacity;
	private int peopleInElevator = 0;
	private int peopleWaitingAtFloors = 0;
	private int currentFloor;
	private int nextFloor;
	private boolean lastPersonArrived = false;
	private List<List<Person>> peopleByFloor;
 
    public DumbElevator(int elevatorCapacity) {
        this.elevatorCapacity = elevatorCapacity;
    }
 
 
    @Override
    public void startsAtFloor(LocalTime time, int initialFloor) {
    this.currentFloor = initialFloor;
    }
 
 
    @Override
    public void peopleWaiting(List<List<Person>> peopleByFloor) {
    this.peopleByFloor = peopleByFloor;
  //   for(int i=1; i<=4; i++) {
 //	      Iterator<Person> itr = (peopleByFloor.get(i)).iterator();
//	      while(itr.hasNext()) 
    this.peopleWaitingAtFloors = peopleByFloor.stream().mapToInt(List::size).sum();
    }
 
 
    @Override
    public int chooseNextFloor() { 
 
   int direction = 0;
   this.nextFloor = random.nextInt(4) + 1; 
 
   if(this.nextFloor > this.currentFloor) 
     direction = 1 ;
    else 
     direction = -1;
    if(!lastPersonArrived && this.peopleInElevator != 0 && this.peopleWaitingAtFloors != 0) 
       while(this.currentFloor != this.nextFloor) 
          this.currentFloor = this.currentFloor + direction;  
    else
    	return 1;
   return nextFloor;
 
    } 
 
 
 
    @Override
    public void arriveAtFloor(int floor) {
        this.currentFloor = floor;
    }
 
 
 
    @Override
    public void loadPerson(Person person) {
//       List<Person> people = peopleByFloor.get(currentFloor);
 
     //this means that the person can not be loaded into the elevator as he/she is not in the waiting queue of the current floor
 
//        if(people.contains(person)){
//        this.peopleInElevator++;
         this.peopleWaitingAtFloors--;
 
 
 
    }
 
 
    @Override
    public void unloadPerson(Person person) {
    //	  Iterator<List<Person>> itr = peopleByFloor.iterator();
 
    	//    while(itr.hasNext()) 
    	    	this.peopleInElevator--;
    }
 
    @Override
    public void newPersonWaitingAtFloor(int floor, Person person) {
    /*
     	for(int i=1; i<=4; i++) {
    	      Iterator<Person> itr = (peopleByFloor.get(i)).iterator();
    	      while(itr.hasNext()) 
                  this.peopleWaitingAtFloors++;
    	}
    */
        this.peopleWaitingAtFloors++;
    }
 
    @Override
    public void lastPersonArrived() {
    	this.lastPersonArrived = true;
    }
}

Le code que j'ai écit m'a certes permis de s'arrêter au niveau 1 et est vide, mais il reste tout de même 2 personnes qui attendent dans les étages et le temps de fonctionnement n'est pas minimal.
Est-ce que quelqu'un pourrait m'aider s'il vous plaît?

[thelvin]

Pureï.

J'ai quand même pas mal l'impression que la solution se fait avec du brute-force. Avec des données de cette taille ça devrait être tranquille.

Mais s'il y a de meilleures solutions que la force brute, c'est un exercice de recherche opérationnelle bien avant d'être un exercice de Java.

Cela dit les données sont pas très claires : normalement un ascenseur ne peut pas deviner qui va où avant qu'ils soient montés pour appuyer sur un bouton disant où ils vont, et un ascenseur ne peut pas contrôler qui choisit de monter ou descendre quand il s'arrête à un étage. Et s'il y a 4 étage et maximum 7 personnes par étage, ça fait 28 personnes. Passablement moins que les 50 supposées au début.