---
title: Algorithmie évaluation
tags: algorithmie
robots: noindex, nofollow
author: Julien Noyer
---

# 2050, Mac Donald robotise ses fatsfoods Réalisation d'un robot cuisinier


Pour valider ce cursus de formation nous vous proposons de travailer sur une projet fictif de développement d'un robot pour la société Mac Donald. Ce robot sera capable de servire uniquement un menu spécifique et dans toutes les déclinaison possible. Nosu allons définir ensemble les étapes et les temps de préparation et vous aurez à réaliser une étude algorithmique complète que vous dervrez baser sur les notions vue lors de ce cursus

## Définition des contraintes

Pour la réalisation de cette exercice vous devez penser à toutes les étapes pour permettre à notre robot de fonctionner de la __prise de commande__ à la __distribution du menu__ en passant par __le paiement__. Aucune étapes ne doit être oubliées car vous devez concidérer que le __robot est à 100% autonome__. Nous ajoutons également des contraintes qui sont de nature à vous faire réfléchir sur l'enchainement des tâches et leur organisation :

- Le menu est : __Big Mac__
- Les options sont (avec ou sans) :
- __salade__
- __tomate__
- __fromage__
- __sauce__
- __double fromage__
- __double steak__
- Les cuissons sont :
- __saigante__
- __à point__
- __bien cuit__
- Les quantités sont :
- __1__
- __100__
- Le temps d'attente acceptable : __5 minutes pour 1 menu__
- Les moyens de paiement sont :
- __espèce__
- __carte bleue__

# Travail à réaliser _Définition des livrabbles_


Dans le cadre de ce projet nous vous demandons de fournir tous les éléments qui vous ont permit de réaliser le projet : documentation, liens, ressourses,... L'un des aspect qui sera mit en avant est la capacité à expliquer et de justifier une démarche; il vous est fortement reccomandé de créer un fichier en MarkDown retraçant toutes les étapes que vous avez suivi.

En ce qui concerne les éléments obligatoire, vous devrez réaliser :

- Un diagramme PERT
- La définition du chemin ciritique
- Un pseudo-code
- Un calcule de la compléxité

> Il est probale que les quantités différentes induisent des organisations différentes

## Données à traiter

Nous déffinisons les différentes quantités pou chaquer produits constituant le menu

- Un sandwish
- Pain : 3 portions
- Tomate : 40gr
- Avec
- Sans
- Salade : 10gr
- Avec
- Sans
- Fromage : 1 tranche
- Avec
- Sans
- Double : 2 tranches
- Sauce: 10 gr
- Avec
- Sans
- Steack : 2 ou 3 steack
- Simple
- Supplément
- Une portion de frite
- Normal : 114gr
- Grande : 150gr
- Une boisson : Evian, jus d'orange
- Normal : 33cl
- Grande : 50cl

Nous déffinisons temps de traitement des actions de base à réaliser

- Prendre le pain : 10s.
- Prendre les tomate : 10s.
- Prendre la salade : 10s.
- Prendre le fromage : 5s. ou 10s.
- Prendre les steaks : 7s. ou 10s.
- Prendre les frites : 10s. ou 15s.
- Prendre la boisson : 10s. ou 15s.

- Cuisson des steacks :
- saigant : 22s.
- à point : 30s.
- bien cuit : 45s.
- Cuisson des frites : 60s.

## Exemple de Diagramme PERT

L'exemple ci-dessous vous est proposer afin que vous puissiez évaluer celui que vous avez réalisé. En aucun cas il ne vous est imposé dee partir de ce diagramme pour le suite de votre travail.

[](https://i.imgur.com/d7IBy9M.jpg)

### A) Initialisation

#### Tâches

- __A.1)__ Activer le robot (0.0)
- __A.2)__ Afficher le bouton "Start" (0.0)
- __A.3)__ Afficher le bouton "Cancel" (0.0)
- __A.4)__ Cliquer sur "Start" (0.1)
- __B, C)__ Cliquer sur "Cancel" (0.1)
- __a)__ Cliquer sur "Cancel" (0.1)
- __b)__ Supprimer la commande (0.0)
- __c)__ Afficher le bouton "Start" (0.0)
- __d__) Eteindre les cuiseur (0)

#### Pseudo-code

ALGO BigMacBot
  # Import du module de configuration de menu
  IMPORT BigMacConfigurator FROM './BigMacConfigurator.md'

  # Définition des objets
    OBJECT ClientOrder:
      type: STRING
      beverage: STRING
      tomato: BOOLEAN
      salad: BOOLEAN
      sauce: BOOLEAN
      cheese: BOOLEAN
      extraCheese: BOOLEAN
      extraSteak: BOOLEAN
      normalCooking: BOOLEAN
      mediumCooking: BOOLEAN
      hardCooking: BOOLEAN
      price: FLOAT
    END OBJECT

    OBJECT Button:
      value: STRING
      isActive: BOOLEAN
      onClick: FUNCTION()
    END OBJECT

    OBJECT Baking:
      value: STRING
      isActive: BOOLEAN
      duration: NUMBER
      start: FUNCTION()
    END OBJECT
  # 

  # Définition des variables
    botIsActive: BOOLEAN
    startButton: Button
    cancelButton: Button
    newOrder: ClientOrder
    fryer: Baking
    broiler: Baking
    toaster: Baking
  # 

START
  # Définition
    # Variables globales
    botIsActive <- True
    newOrder <- { null, null, True, True, True, True, False, False, True, False, False, 0.0 }

    # Interface graphique
    startButton <- { "Commencer", True }
    cancelButton <- { "Annuler la commande", True }

    # Cuiseurs
    fryer <- { "Friteuse", False, null }
    broiler <- { "Plaque", False, null }
    toaster <- { "Grille pain", False, null }
  # 

  # Méthodes
    FUNCTION startBigMacBot(){
      # Lancer al boucle tant que le bot est en marche
      WHILE botIsActive === True

        # Capter le click sur le bouton start
        startButton.onClick <- startOrder()

        # Capter le click sur le bouton cancel
        cancelButton.onClick <- cancelOrder()

      END WHILE
    }

    FUNCTION startOrder(){
      # Lancer al boucle tant que le bot est en marche
      WHILE botIsActive === True

        # Lancer la commande
        NEW BigMacConfigurator(newOrder)

        # Allumer les cuiseurs
        fryer.isActive <- True
        broiler.isActive <- True
        toaster.isActive <- True

      END WHILE
    }

    FUNCTION cancelOrder(){
      # Lancer al boucle tant que le bot est en marche
      WHILE botIsActive === True

        # Annuler la commande
        DELETE BigMacConfigurator(newOrder)

        # Eteindre les cuiseurs
        fryer.isActive <- False
        broiler.isActive <- False
        toaster.isActive <- False

      END WHILE
    }
  # 

  # Lancer l'algorithme
    startBigMacBot()
  # 

END ALGO

#### Calcule de la complexité de algorithme BigMacBot

__Opérations élémentaires :__

- botIsActive <- True
- newOrder <- { undefined, undefined, True, True, True, True, False, False, 0.0 }
- startButton <- { "Commencer", True }
- __Total__ = 3

__Boucle__

- startButton.onClick <- NEW BigMacConfigurator(newOrder)
- startButton.isActive <- False
- __Total__ = 2

__Résultat__

La complexité total de l'algorithme BigMacBot par commande est :

T(n) = 5

### B) Configuration

#### Tâches

- __B.2)__ Choisir l'option normal ou maxi (10)
- __B.3)__ Choisir les options (10)
- __B.4)__ Choisir la cuisson des steacks (10)
- __B.5)__ Afficher un récapitulatif (10)
- __B.6)__ Valider la commande (0.1)
- __B.7)__ Allumer les cuiseurs (0)

#### Pseudo-code

ALGO BigMacConfigurator

  # Import du module de paiement
  IMPORT PayForMenu FROM './PayForMenu.md'

  # Injecter des valeurs dans l'algorithme
    CONSTRUCTOR( ClientOrder )
        THIS newOrder <- ClientOrder
    END CONSTRUCTOR
  # 

  # Définition des objets
    OBJECT Button:
      value: STRING
      isActive: BOOLEAN
      onClick: FUNCTION()
    END OBJECT
  #

  # Définition des variables
    optionPrice: ProductPrice
    chooseBeverageButton: Button
    confirmOrder: Button
    evianButton: Button
    orangeButton: Button
    menuSizeOptions: ARRAY<Button>
    burgerOptions: ARRAY<Button>
    fryer: Baking
    broiler: Baking
    toaster: Baking
  #

START
  # Interface graphique
    chooseBeverageButton <- { "Choisir une boisson", False }
    confirmOrder <- { "Valider la commande", False }
    evianButton <- { "Evian", False }
    orangeButton <- { "Jus d'orange", False }

    menuSizeOptions <- [
      { "Menu normal", False },
      { "Menu maxi", False }
    ]

    burgerOptions <- [
      { "Tomate", True },
      { "Salade", True },
      { "Sauce", True },
      { "Fromage", True },
      { "Supplément fromage", False },
      { "Supplément steak", False },
      { "Cuisson normal", False },
      { "Cuisson à point", False },
      { "Cuisson bien cuit", False }
    ]
  #



  # Fonction pour afficher un bouton
    FUNCTION displayButton(button)
    START
      # Vérifier l'état du bouton
      IF button.isActive === FALSE THEN
        PRINT button
      ELSE
        HIDE button
      END IF

      # Invercer l'état du bouton
      button.isActive <- !button.isActive
    END FUNCTION
  #



  # Fonction pour afficher les options du burger
    FUNCTION displayBurgerOptions()
    START
      # Afficher les boutons pour les option
      FOR i FROM 0 TO burgerOptions.LENGTH [ i <- i + 1 ] 
        # Afficher le bouton
        displayButton(option[i])

        # Capter le clic sur le bouton
        option[i].onClick <- editBurgerOption(option[i].value)
      END FOR

      # Afficher le  pour choisir la boisson
      displayButton(chooseBeverageButton)

      # Capter le clic sur le bouton chooseBeverageButton
      chooseBeverageButton.onClick <- defineBeverage()

    END FUNCTION
  #



  # Fonction pour modifier une option
    FUNCTION editBurgerOption( type: STRING )
    START
      SWITCH type
      "Tomate" : newOrder.tomato <- !newOrder.tomato
      "Salade" : newOrder.salade <- !newOrder.salade
      "Sauce" : newOrder.sauce <- !newOrder.sauce
      "Fromage" : newOrder.cheese <- !newOrder.cheese
      "Supplément fromage" : newOrder.extraCheese <- !newOrder.extraCheese
      "Supplément steak" : newOrder.extraSteak <- !newOrder.extraSteak
      "Cuisson normal" : newOrder.normalCooking <- !newOrder.normalCooking && newOrder.mediumCooking = False && newOrder.hardCooking = False
      "Cuisson à point" : newOrder.mediumCooking <- !newOrder.mediumCooking && newOrder.normalCooking = False && newOrder.hardCooking = False
      "Cuisson bien cuit" : newOrder.hardCooking <- !newOrder.hardCooking && newOrder.mediumCooking = False && newOrder.hardCooking = False
      DEFAULT PRINT("Option inconnue")

    END SWITCH
    END FUNCTION
  #



  # Fonction pour définir la boisson
    FUNCTION defineBeverage()
    START
      # Afficher le choix de boisson
      displayButton(evianButton)
      displayButton(orangeButton)

      # Capter le click pour le choix de la bboisson
      WHILE newOrder.beverage === undefined
        evianButton.onClick <- RETURN newOrder.beverage <- evianButton.value
        orangeButton.onClick <- RETURN newOrder.beverage <- orangeButton.value
      END WHILE

      # Masquer le bouton de la boisson non sélectionnée
      SWITCH newOrder.beverage
        "Evian" : displayButton(orangeButton)
        "Jus d'orange" : displayButton(evianButton)
      END SWITCH

      # Afficher le bouton pour valider la commande
      displayButton(confirmOrder)

      # Capter le click sur le bouton pour valider la commande
      confirmOrder.onClick <- NEW PayForMenu(newOrder)
      
    END FUNCTION
  #



  # Lancer l'algorithme
    WHILE newOrder.type === undefined
      # Afficher les boutons pour le choix de la taille
      FOR i FROM 0 TO menuSizeOptions.LENGTH [ i <- i + 1 ] 
        # Afficher le bouton
        displayButton(option[i])
        option[i].onClick <- RETURN newOrder.type <- option[i].value
      END FOR
    END WHILE

    # Masquer le bouton pour le choix de la taille du menu
    FOR i FROM 0 TO menuSizeOptions.LENGTH [ i <- i + 1 ] 
      displayButton(option[i])
    END FOR

    # Afficher le choix des optionn pour le burger
    displayBurgerOptions()

    # Allumer les cuiseurs
      fryer.isActive <- True
      broiler.isActive <- True
      toaster.isActive <- True
    # 
  # 

END ALGO

#### Calcule de la complexité de algorithme BigMacConfigurator

__Opérations élémentaires__

- newOrder <- ClientOrder
- chooseBeverageButton <- { "Choisir une boisson", False }
- confirmOrder <- { "Valider la commande", False }
- evianButton <- { "Evian", False }
- orangeButton <- { "Jus d'orange", False }
- menuSizeOptions <- [...]
- { "Menu normal", False }
- { "Menu maxi", False }
- burgerOptions <- [...]
- { "Tomate", True }
- { "Salade", True }
- { "Sauce", True }
- { "Fromage", True }
- { "Supplément fromage", False }
- { "Supplément steak", False }
- { "Cuisson à point", False },
- { "Cuisson bien cuit", False }
- __Total__ = 17

__FUNCTION displayBurgerOptions()__

- FOR i FROM 0
- 0 TO burgerOptions.LENGTH (8)
- i + 1
- displayButton(option[i])
- displayButton(chooseBeverageButton)
- option[i].onClick <- editBurgerOption(option[i].value)
- chooseBeverageButton.onClick <- defineBeverage()
- __Total__ = 48 + 1

__FUNCTION editBurgerOption()__

- SWITCH type
- "Tomate" : newOrder.tomato <- !newOrder.tomato
- "Salade" : newOrder.salade <- !newOrder.salade
- "Sauce" : newOrder.sauce <- !newOrder.sauce
- "Fromage" : newOrder.cheese <- !newOrder.cheese
- "Supplément fromage" : newOrder.extraCheese <- !newOrder.extraCheese
- "Supplément steak" : newOrder.extraSteak <- !newOrder.extraSteak
- "Cuisson normal" : newOrder.normalCooking <- !newOrder.normalCooking && newOrder.mediumCooking = False && newOrder.hardCooking = False
- "Cuisson à point" : newOrder.mediumCooking <- !newOrder.mediumCooking && newOrder.normalCooking = False && newOrder.hardCooking = False
- "Cuisson bien cuit" : newOrder.hardCooking <- !newOrder.hardCooking && newOrder.mediumCooking = False && newOrder.hardCooking = False
- __Total__ = 16

__FUNCTION defineBeverage()__

- displayButton(evianButton)
- displayButton(orangeButton)
- evianButton.onClick <- RETURN newOrder.beverage <- evianButton.value
- orangeButton.onClick <- RETURN newOrder.beverage <- orangeButton.value
- SWITCH newOrder.beverage
- displayButton(confirmOrder)
- confirmOrder.onClick <- NEW PayForMenu(newOrder)
- __Total__ = 9

__Lancer l'algorithme__

- FOR i FROM 0
- 0 TO menuSizeOptions.LENGTH (9)
- i + 1
- displayButton(option[i])
- option[i].onClick <- RETURN newOrder.type <- option[i].value
- FOR i FROM 0
- 0 TO menuSizeOptions.LENGTH (9)
- i + 1
- displayButton(option[i])
- fryer.isActive <- True
- broiler.isActive <- True
- toaster.isActive <- True
- __Total__ = (5 x 9) + (4 x 9) + 3

__Résultat__

La complexité total de l'algorithme BigMacConfigurator par commande est :

T(n) = 175n

### C) Paiement

#### Tâches

- __C.1)__ Afficher le prix total (0.1)
- __C.2)__ Payer la commande (10)
- __C.3)__ Valider le paiement (0.1)
- __C.4)__ Rendre la monnaie éventuelle (10)

#### Pseudo-code

ALGO PayForMenu
  # Import du générateur de menu 
  IMPORT BigMacGenerator FROM './BigMacGenerator.md'

  # Injecter une valeur dans l'algorithme
  CONSTRUCTOR( ClientOrder )
    THIS newOrder <- ClientOrder
  END CONSTRUCTOR

  # Définition des objets
    OBJECT Button:
      value: STRING
      isActive: BOOLEAN
      onClick: FUNCTION()
    END OBJECT
  # 

  # Définition des variables
    paiementOption: ARRAY<Button>
    coinSlot: Button
    coinSender: Button
    cardSlot: Button
  #

START
  # Interface graphique
    paiementOption <- [
      { "Payer en espèce", False },
      { "Payer par carte", False }
    ]
  # 

  # Objets physiques
    coinSlot <- { "Monnayeur", False }
    coinSender <- { "Rendu monnaie", False }
    cardSlot <- { "Centrale CB", False }
  #

  # Fonction pour afficher un bouton
    FUNCTION displayButton(button)
    START
      # Vérifier l'état du bouton
      IF button.isActive === FALSE THEN
        PRINT button
      ELSE
        HIDE button
      END IF

      # Invercer l'état du bouton
      button.isActive <- !button.isActive
    END FUNCTION
  #



  # Fonction de calcule de prix
    FUNCTION definePrice()
    START
      # Définir le prix du menu
      IF newOrder.type === "Normal"
        newOrder.price <- newOrder.price + 8.5
      ELSE IF newOrder.type === "Extra"
        newOrder.price <- newOrder.price + 12.5
      END IF

      # Vérifier le supplément fromage
      IF newOrder.extraCheese === True
        newOrder.price <- newOrder.price + 0.8
      END IF

      # Vérifier le supplément steak
      IF newOrder.extraSteak === True
        newOrder.price <- newOrder.price + 1.2
      END IF

      # Afficher le prix
      PRINT("Le prix de votre commande est de " + newOrder.price + "euros" )

      # Afficher les bouton pour payer la commande
      FOR i FROM 0 TO paiementOption.LENGTH [ i <- i + 1 ] 
        # Afficher le bouton
        displayButton(option[i])

        # Capter le clic sur la bouton pour payer la commande
        option[i].onClick <- payOrder(option[i].value)
      END FOR
      
    END FUNCTION
  #




  # Fonction pour payer la commande
    FUNCTION payOrder( type: STRING )
    START
      IF type === "Payer en espèce" THEN
        # Activer le monnayeur
        coinSlot.isActive <- True

        # Attendre le paiement de la commande
        WHILE coinSlot.isActive === True
          # Stopper la boucle quand la commande est payée
          IF totalCurrency === newOrder.price THEN
            # Stoper le paiement
            coinSlot.isActive <- False

            # Commencer la préparation
            NEW BigMacGenerator(newOrder)

            # Vérifier la monnaie
            sendMonneyBack()
          END IF

        END WHILE
        
      ELSE IF type === "Payer par carte" THEN
        # Activer la centrale CB
        cardSlot.isActive <- True

        # Attendre le paiement de la commande
        WHILE cardSlot.isActive === True
          # Stopper la boucle quand la commande est payée
          IF totalCurrency === newOrder.price THEN
            # Stoper le paiement
            coinSlot.isActive <- False

            # Commencer la préparation du menu
            NEW BigMacGenerator(newOrder)
          END IF

        END WHILE

      END IF

    END FUNCTION
  #



  # Fonction vérifier le montant de la monnaie
    FUNCTION sendMonneyBack()
    START
      # Vérifier le montant de la monnaie
      IF totalCurrency > newOrder.price THEN
        # Activer le retour de la monnaie
        coinSender.isActive <- True

        # Rendre la monnaie
        coinSender.SEND( newOrder.price - totalCurrency )

        # Désactiver le retour de la monnaie
        coinSender.isActive <- False
      END IF
      
    END FUNCTION
  #



  # Lancer l'algorithme
    definePrice()
  #

END ALGO

#### Calcule de la complexité de algorithme PayForMenu

__Opérations élémentaires__

- newOrder <- ClientOrder
- paiementOption <- [...]
- { "Payer en espèce", False }
- { "Payer par carte", False }
- coinSlot <- { "Monnayeur", False }
- coinSender <- { "Rendu monnaie", False }
- cardSlot <- { "Centrale CB", False }
- __Total__ = 8

__FUNCTION definePrice()__

- IF newOrder.type === "Normal"
- newOrder.price <- newOrder.price + 8.5
- ELSE IF newOrder.type === "Extra"
- newOrder.price <- newOrder.price + 12.5
- IF newOrder.extraCheese === True
- newOrder.price <- newOrder.price + 0.8
- IF newOrder.extraSteak === True
- newOrder.price <- newOrder.price + 1.2
- FOR i FROM 0
- 0 TO paiementOption.LENGTH (3)
- i + 1
- displayButton(option[i])
- option[i].onClick <- payOrder(option[i].value)
- __Total__ = 8 + (5 x 3)

__FUNCTION payOrder()__

- IF type === "Payer en espèce"
- coinSlot.isActive <- True
- WHILE coinSlot.isActive === True
- IF totalCurrency === newOrder.price
- coinSlot.isActive <- False
- ELSE IF type === "Payer par carte"
- cardSlot.isActive <- True
- WHILE cardSlot.isActive === True
- IF totalCurrency === newOrder.price
- coinSlot.isActive <- False
- __Total__ = 10

__FUNCTION sendMonneyBack()__

- IF totalCurrency > newOrder.price
- coinSender.isActive <- True
- newOrder.price - totalCurrency
- coinSender.isActive <- False
- __Total__ = 4

__Résultat__

La complexité total de l'algorithme PayForMenu par commande est :

T(n) = 45

### D) Préparation

#### Tâches

- __D.1)__ Récapituler les options (0.1)
- __D.2)__ Préparer la boisson (10)
- __D.3)__ Prendre les frites (10)
- __D.4)__ Faire cuire les frites (60)
- __D.5)__ Prendre les steacks (10)
- __D.6)__ Cuire les steack (45)
- __D.7)__ Prendre et toaster le pain (10)
- __D.8)__ Arréter la cuisson du steack (0.1)
- __D.9)__ Arréter la cuisson des frites (0.1)
- __D.10)__ Assembler les éléments (50)
- __D.11)__ Livrer le menu (0.1)
- __D.12)__ Réinitialiser la commande (0.0)
- __D.13)__ Supprimer la commande (0.0)
- __D.14)__ Eteindre les cuiseur (0)
- __D.15)__ Afficher le bouton "Start" (0.0)

#### Pseudo-code

ALGO BigMacGenerator

  # Injecter une valeur dans l'algorithme
  CONSTRUCTOR( ClientOrder )
    THIS newOrder <- ClientOrder
  END CONSTRUCTOR

  # Définition des objets
    OBJECT Ingredient:
      value: STRING
      weight: NUMBER
    END OBJECT

    OBJECT Stock:
      bread: Ingredient
      tomato: Ingredient
      salad: Ingredient
      cheese: Ingredient
      sauce: Ingredient
      steak: Ingredient
    END OBJECT

    OBJECT Baking:
      value: STRING
      isActive: BOOLEAN
      duration: NUMBER
      start: FUNCTION()
    END OBJECT
  # 

  # Définition des variables
    botStock: Stock
    ingredientCollection: ARRAY<Ingredient>
    fryer: Baking
    broiler: Baking
    toaster: Baking
  # 

START
  # Variables globales
    botStock <- {
      bread <- { "Pain", 300 }
      tomato <- { "Tomate", 4000 }
      salad <- { "Salade", 1000 }
      sauce <- { "Sauce", 1000 }
      cheese <- { "Fromage", 200 }
      steak <- { "Steak", 300 }
    }
  # 


  # Function pour sélectionner les ingrédients
    FUNCTION selectIngredient()
    START
      # Allumer les systèmes de cuisson
      fryer.isActive <- True
      boiler.isActive <- True
      toaster.isActive <- True

      # Activer la fonction tant qu'il reste du pain en stock
      WHILE botStock.bread.weight >= 3
        # Prendre le pain du stock
        
        # Prendre les tomates
        IF botStock.tomato.weight >= 40 && newOrder.tomato THEN
          
        ELSE THEN 
          PRINT("Stock de tomate épuisé")
        END IF

        # Prendre la salade
        IF botStock.salad.weight >= 10 && newOrder.salad THEN
          
        ELSE THEN 
          PRINT("Stock de salade épuisé")
        END IF

        # Prendre les steaks
        IF newOrder.type === "Menu normal" && botStock.steak.weight >= 2 THEN
        
        ELSE IF IF newOrder.type === "Menu maxi" && botStock.steak.weight >= 3 THEN

        ELSE THEN 
          PRINT("Stock de steak épuisé")
        END IF
        
      END WHILE

    END FUNCTION
  # 


  # Function pour cuire les ingrédients
    FUNCTION cookIngredient( ingredient: Ingredient, quantity: FLOAT, tool: Baking, duration: NUMBER  )
    START
      # Cuire les ingredients
      tool.start <- COOK(ingredient, quantity)

      # Attendre la fin de la cuisson
      WAIT(duration)
    END FUNCTION
  # 


  # Function pour assembler les ingrédents
    FUNCTION gatherIngredient()
    START
      # Prendre le pain
      WAIT( 10 )
      
      # Prendre les tomates
        IF botStock.tomato.weight >= 40 && newOrder.tomato THEN
          WAIT( 10 )
        END IF
      # 

      # Prendre le fromage
        IF botStock.cheese.weight >= 1 && newOrder.cheese && newOrder.extraCheese === False THEN
          WAIT( 10 )

        ELSE IF botStock.cheese.weight >= 2 && newOrder.cheese && newOrder.extraCheese === True THEN
          WAIT( 10 )
        END IF
      # 

      # Prendre les steaks
      IF newOrder.type === "Menu normal" THEN WAIT( 7 )
      ELSE WAIT( 10 )

      # Prendre les trites
      WAIT( 10 )

      # Prendre la boisson
      WAIT( 10 )

      # Livrer la commande
      PRINT("Votre menu est prêt !")
      RETURN BurgerBox

      # Etteindre les systèmes de cuisson
      fryer.isActive <- False
      boiler.isActive <- False
      toaster.isActive <- False

    END FUNCTION
  #

  # Function pour commencer la préparation
    FUNCTION startCooking()
    START
      # Vérifier la quantité de pain avant de commencer la commande
        IF botStock.bread.weight >= 3 THEN

          # Cuire les steaks
            IF botStock.steak.weight >= 2 && newOrder.extraSteak === False THEN
              # Lancer la cuisson
              cookIngredient( botStock.steak, 2, broiler, newOrder.baking )
              
              # Réduire le stock
              botStock.steak.weight <- botStock.steak.weight - 2

            ELSE IF botStock.steak.weight >= 3 && newOrder.extraSteak === True THEN
              # Lancer la cuisson
              cookIngredient( botStock.steak, 3, broiler, newOrder.baking )
              
              # Réduire le stock
              botStock.steak.weight <- botStock.steak.weight - 3

            ELSE THEN 
              PRINT("Stock de steak épuisé")
            END IF
          # 

          # Cuire les frites
            IF newOrder.type === "Menu normal" && botStock.fries.weight >= 114 THEN
              # Lancer la cuisson
              cookIngredient( botStock.fries, 114, fryer, 60 )
              
              # Réduire le stock
              botStock.fries.weight <- botStock.fries.weight - 114

            ELSE IF IF newOrder.type === "Menu maxi" && botStock.fries.weight >= 150 THEN
              # Lancer la cuisson
              cookIngredient( botStock.fries, 150, fryer, 60 )
              
              # Réduire le stock
              botStock.fries.weight <- botStock.fries.weight - 150

            ELSE THEN 
              PRINT("Stock de steak épuisé")
            END IF
          #

          # Toaster le pain
            cookIngredient(botStock.bread, 3, toaster, 20)
          # 

          # Assembler le menu
            # Attendre 30 secondes
            WAIT( 30 )

            # Assembler le menu
            gatherIngredient()
          # 

        ELSE THEN 
          PRINT("Stock de pain épuisé")
        END IF
      # 

    END FUNCTION
  #
  

  # Lancer l'algorithme
    selectIngredient()
  # 

END ALGO

#### Calcule de la complexité de algorithme BigMacGenerator

__Opérations élémentaires__

- newOrder <- ClientOrder
- botStock <- {...}
- bread <- { "Pain", 300 }
- tomato <- { "Tomate", 4000 }
- salad <- { "Salade", 1000 }
- sauce <- { "Sauce", 1000 }
- cheese <- { "Fromage", 200 }
- steak <- { "Steak", 300 }
- __Total__ = 8

__FUNCTION selectIngredient()__

- fryer.isActive <- True
- boiler.isActive <- True
- toaster.isActive <- True
- WHILE botStock.bread.weight >= 3
- IF botStock.tomato.weight >= 40 && newOrder.tomato THEN
- IF botStock.salad.weight >= 10 && newOrder.salad THEN
- IF newOrder.type === "Menu normal" && botStock.steak.weight >= 2 THEN
- ELSE IF IF newOrder.type === "Menu maxi" && botStock.steak.weight >= 3 THEN
- __Total__ = 12

__FUNCTION gatherIngredient()__

- IF botStock.tomato.weight >= 40 && newOrder.tomato
- IF botStock.cheese.weight >= 1 && newOrder.cheese && newOrder.extraCheese === False
- ELSE IF botStock.cheese.weight >= 2 && newOrder.cheese && newOrder.extraCheese === True
- IF newOrder.type === "Menu normal"
- fryer.isActive <- False
- boiler.isActive <- False
- toaster.isActive <- False
- __Total__ = 12

__FUNCTION startCooking()__

- IF botStock.bread.weight >= 3
- IF botStock.steak.weight >= 2 && newOrder.extraSteak === False
- cookIngredient( botStock.steak, 2, broiler, newOrder.baking )
- botStock.steak.weight <- botStock.steak.weight - 2
- ELSE IF botStock.steak.weight >= 3 && newOrder.extraSteak === True
- cookIngredient( botStock.steak, 3, broiler, newOrder.baking )
- botStock.steak.weight <- botStock.steak.weight - 3
- IF newOrder.type === "Menu normal" && botStock.fries.weight >= 114
- cookIngredient( botStock.fries, 114, fryer, 60 )
- botStock.fries.weight <- botStock.fries.weight - 114
- ELSE IF IF newOrder.type === "Menu maxi" && botStock.fries.weight >= 150
- cookIngredient( botStock.fries, 150, fryer, 60 )
- botStock.fries.weight <- botStock.fries.weight - 150
- __Total__ = 21

__Résultat__

La complexité total de l'algorithme BigMacGenerator par commande est :

T(n) = 53n