ATTENTE AU RESTAURANT

1. Le problème :

Il faut simuler le foctionnement d'un restaurant pendant un service de 4 heures, avec une file d'attente et des tables. Le nombre de clients par groupe est choisi au hasard, de 1 à 6 personnes. Il faut donc modéliser ce restaurant pour pouvoir avoir des informations sur son fonctionnement (nombres de clients en attente, assis).

2. Comment je l'ai abordé :

J'ai tout d'abord pris une feuille et modélisé le fonctionnement de ce restaurant conformément aux règles de celui-ci. J'ai décidé de modéliser ce restaurant avec trois structures de données : les dictionnaires, les files et les listes. Ma deuxième partie de projet consistait donc à la conception de mon programme python. J'ai choisis d'utiliser la Programmation Orientée Objet pour créer plusieurs classes correspondant à mes besoins. J'ai choisis de différencier la création des groupes de clients ainsi que leurs attributs sous forme de dictionnaire, de la création des tables sous forme de liste, de la création de la file d'attente sous forme de... file. Je pense être allé un peu loin dans la partie codage, en effet mon code n'est pas vraiment fonctionnel car très complexe. Je pense avoir pu faire plus simple, mais l'important pour moi est que je comprenne cette modélisation, même si je n'arrive pas à la traduire en code. Il me faudrait un peu plus de recul.

3. Mon code :

from dico import *
from liste import *
from random import randint

# création d'une classe groupe avec le type abstrait LISTE
class Groupe:

    def __init__(self):
        self.tab_groupe = Liste(240)

    def remplir_tab(self):
        for i in range(240):
            nombre = randint(1,6)
            groupe = creer_dico_vide()
            groupe = ajouter(groupe,'indice',0)
            groupe = ajouter(groupe,'nombre',nombre)
            groupe = ajouter(groupe,'durée_manger',randint(60,120))
            groupe = ajouter(groupe,'temps_instal',0)
            self.tab_groupe[i] = groupe
        return self.tab_groupe

from liste import *
from groupe import *
from random import randint

# création d'une classe tables avec le type abstrait LISTE
class Tables:

    def __init__ (self):
        self.tables = Liste(50)

    def __str__ (self):
        return self.tables.__str__()

    def table_libre(self):
        for i in range(50):
            if self.tables[i] == True:
                return i

    def nbr_table_libre (self):
        nbr_table_libre = 0
        for i in range(50):
            if self.tables[i] == True:
                nbr_table_libre += 1
        return nbr_table_libre

    def remplir_table (self,groupe):
        nbr_groupe = groupe[2][1]
        if nbr_groupe%2 == 1:
            i1 = self.table_libre()
            self.tables[i] = [False,True]
            nbr_groupe -= 1
            groupe[1][1] = i1
        else :
            i2 = self.table_libre()
            self.tables[i] = [False,False]
            nbr_groupe -= 2
        for i in range (nbr_groupe//2):
            i3 = self.table_libre()
            self.tables[i] = [False,False]

        return groupe

    def vider_table (self,groupe):
        self.tables[groupe[1][1]] = [True,True]
        return groupe


##SIMULATION D'UN SERVICE DANS LE MODÈLE DE RESTAURANT DONNÉ
#importation des modules nécéssaires
from file import *
from random import randint
from tables import *
from groupe import *

#création d'une classe avec le type abstrait FILE

class Restaurant:

    def __init__ (self):
        self.file_attente = FileDyna() #représentation de la file d'attente sous forme de type abstrait FILE
        self.clients_servis = 0 # compteur du nombre de clients servis
        self.tables = Tables()
        self.groupe = Groupe()

    def __str__ (self):
        return self.file_attente.__str__() + self.tables.__str__()

    def arrivee_clients (self):
        groupe = self.groupe.remplir_tab()[2][1]
        self.file_attente.enfiler(groupe)
        return groupe

    def installation(self):
        assert not self.file_attente.est_vide() , "La file d'attente est vide"
        groupe = self.file_attente.defiler()
        nbr_tables_requises = groupe//2 + groupe%2
        if self.tables.nbr_table_libre() >= nbr_tables_requises:
            self.tables.remplir_table(groupe)
            self.clients_servis += groupe[2][1]
            groupe[4][1]
            return 'clients installés'

    def depart_clients (self,temps):
        if self.groupe.tab_groupe[3][1] + self.groupe.tab_groupe[4][1] == temps:
            self.tables.vider_table()
            return 'clients partis'
        return 'les clients mangent'


##tests

restaurant = Restaurant()
print(restaurant)
for temps in range (120):
    groupe = restaurant.arrivee_clients(temps)
    for i in range (2):
        print(restaurant)
        print(restaurant.installation())
        print(restaurant)

			

4. Conclusion :

Grâce à ce projet j'ai pu donc modéliser le fonctionnement d'un restaurant et j'ai appris à allier plusieurs types de structures de données interagisseantes les une avec les autres. Ce projet était intéréssant également dans le sens où il est complet : on ne code pas seulement; on modélise sur papier, on cherche un problème à ésoudre ou quelque chose à améliorer. Cela donne un vrai sens concret d'utilisation dans la vie quotidienne de ces structures de données.