Această etapă își propune să sublinieze importanța abstractizării. Va trebui să vă definiți propriul TDA (tip de date abstract) și să oferiți o interfață completă (un set de constructori și operatori) prin care utilizatorul poate manipula valorile tipului, independent de implementarea din spate. Apoi, este esențial ca voi înșivă să folosiți TDA-ul doar prin intermediul interfeței (în etapa 4 veți înțelege și mai bine de ce este esențial).

Veți începe rezolvarea etapei prin a implementa TDA-ul queue în fișierul queue.rkt.

Acest tip reprezintă o coadă (first-in-first-out) ca pe o structură:

(define-struct queue (left right size-l size-r))

• left, right
  • sunt stive (last-in-first-out, implementate ca liste Racket)
  • fiecare adăugare în coadă va fi o adăugare în stiva right
  • ex adăugare:
    adaug 1 ⇒ right = '(1),
    adaug 2 ⇒ right = '(2 1)
  • fiecare scoatere din coadă va fi o scoatere din stiva left (când left este vidă, va trebui mai întâi să mutăm toate elementele din right în left, apoi să scoatem din left)
  • mutarea este rezultatul unor operații pop (din right) + push (în left) repetate
  • ex mutare:
    mut în left = '() din right = '(2 1) ⇒
    left = '(2), right = '(1) (primul pop din right îl extrage pe 2 și îi face push în left) ⇒
    left = '(1 2), right = '() (apoi pop din right îl extrage pe 1 și îi face push în left)
  • ex scoatere:
    scot din coada cu left = '(), right = '(2 1) ⇒
    left = '(1 2), right = '() (după mutarea elementelor) ⇒
    left = '(2), right = '() (după scoaterea primului element)
  • observați că primul element adăugat este primul element scos (first-in-first-out)
• size-l, size-r
  • sunt numere naturale, reprezentând numărul de elemente din cele 2 stive

Sarcina voastră este să implementați interfața TDA-ului queue:

  empty-queue  :              -> queue  (constructor nular pentru o coadă goală)
  queue-empty? :        queue -> Bool   (operator care verifică dacă o coadă este goală)
  enqueue      : Elem x queue -> queue  (operatorul de adăugare în coadă)
  dequeue      :        queue -> queue  (operatorul de scoatere din coadă)
  top          :        queue -> Elem   (operatorul de vizualizare a elementului din vârful cozii)

Această reprezentare pentru coadă asigură cost amortizat O(1) pentru operațiile de enqueue și dequeue. Vom folosi această reprezentare pentru câmpul queue al structurii counter, întrucât este mai eficientă decât reprezentarea cu liste Racket din etapele 1 și 2.

După ce ați finalizat implementarea TDA-ului, continuați dezvoltarea simulatorului în fișierul supermarket.rkt.

În primul rând, va trebui să adaptați o serie de funcții de la etapa 2 astfel încât ele să țină cont de noua reprezentare (în care câmpul queue din structura counter este de tip coadă (queue) - TDA-ul implementat de voi; este o coincidență că numele câmpului coincide cu numele tipului, în niciun caz nu era necesar acest lucru).

În plus față de etapa anterioară, în această etapă simulatorul trebuie să modeleze trecerea timpului. Până acum, simulatorul trata așezările la cozi, întârzierile și deschiderile de noi case ca și cum s-ar produce în ordine, dar la un același moment de timp. Acest lucru nu corespunde realității - între diversele evenimente este firesc să treacă timp, timp în care clienții avansează la case și, la un moment dat, părăsesc supermarketul.

Exceptând adaptările menționate, funcțiile principale pe care va trebui să le implementați sunt:

(pass-time-through-counter minutes)

• este o funcție curry (aplicată doar pe un număr de minute, va aștepta un al doilea argument de tip counter)
• odată ce și-a primit (pe rând) argumentele, pass-time-through-counter actualizează tt-ul și et-ul casei în tt-ul și et-ul pe care casa ar trebui să le aibă după trecerea numărului dat de minute
• queue-ul casei nu se modifică, pentru că intenția este de a nu folosi niciodată această funcție pentru a avansa cu un număr de minute mai mare decât timpul până la ieșirea primului client din coadă

Exemplu:

((pass-time-through-counter 5) 
 (counter 1 
          12 
          7 
          (make-queue '() '((ada . 7)) 0 1)))

⇒ (counter 1 7 2 (queue '() '((ada . 7)) 0 1))

(serve requests fast-counters slow-counters)

• serve actualizează casele din fast-counters și slow-counters pe măsură ce situația lor evoluează, pe baza listei requests în care elementele sunt:
  • cereri (așezări la coadă, întârzieri, ajustări ale numărului de case)
    sau
  • timpi care trec între cereri

Exemplu:

(serve '((ana 14) (mia 2) 5 (ion 7) (delay 1 2) 7)
       (list (empty-counter 1))
       (list (empty-counter 2) (empty-counter 3)))

pentru ITEMS = 5:

• observăm că avem o casă fast (o vom numi C1) și 2 case slow (le vom numi C2 și C3)
• primele 2 cereri distribuie cei 2 clienți astfel:
  • ana la C2 ⇒ C2 = (counter 2 14 14 (queue '() '((ana . 14)) 0 1))
  • mia la C1 ⇒ C1 = (counter 1 2 2 (queue '() '((mia . 2)) 0 1))
• apoi trec 5 minute, după care situația trebuie să fie:
  • mia a ieșit de la C1, care a rămas goală ⇒ C1 = (counter 1 0 0 (queue '() '() 0 0))
  • la C2 au trecut 5 minute ⇒ C2 = (counter 2 9 9 (queue '() '((ana . 14)) 0 1))
  • C3 a rămas cum era: goală și neîntârziată ⇒ C3 = (counter 3 0 0 (queue '() '() 0 0))
  • au părăsit supermarketul, în ordine: '((1 . mia)) (mia de la C1)
• ion se așază la C3 ⇒ C3 = (counter 3 7 7 (queue '() '((ion . 7)) 0 1))
• C1 este întârziată cu 2 minute ⇒ C1 = (counter 1 2 2 (queue '() '() 0 0))
• apoi trec 7 minute, după care situația trebuie să fie:
  • întârzierea de la C1 s-a consumat ⇒ C1 = (counter 1 0 0 (queue '() '() 0 0))
  • la C2 au trecut 7 minute ⇒ C2 = (counter 2 2 2 (queue '() '((ana . 14)) 0 1))
  • ion a ieșit de la C3, care a rămas goală ⇒ C3 = (counter 3 0 0 (queue '() '() 0 0))
  • au părăsit supermarketul, în ordine:: '((1 . mia) (3 . ion))