Racket: Heap-uri de împerechere

• Data publicării: 01.03.2025
• Data ultimei modificări: 21.03.2025 (changelog)
• Tema (o arhivă .zip cu toate fișierele .rkt folosite în etapa curentă) se va încărca pe vmchecker

Tema constă în definirea și utilizarea heap-urilor de împerechere și este împărțită în 4 etape:

• una pe care o veți rezolva după laboratorul 2 (cu deadline în ziua laboratorului 3, la ora 23:59)
• una pe care o veți rezolva după laboratorul 3 (cu deadline în ziua laboratorului 4, la ora 23:59)
• una pe care o veți rezolva după laboratorul 4 (cu deadline în ziua laboratorului 5, la ora 23:59)
• una pe care o veți rezolva după laboratorul 5 (cu deadline în ziua laboratorului 6, la ora 23:59)

Așa cum se poate observa, ziua deadline-ului variază în funcție de semigrupa în care sunteți repartizați. Restanțierii care refac tema și nu refac laboratorul beneficiază de ultimul deadline (deci vor avea deadline-uri în zilele de 14.03, 21.03, 28.03, 04.04).

Rezolvările tuturor etapelor pot fi trimise până în ziua laboratorului 6, dar orice exercițiu trimis după deadline (și până în ziua laboratorului 6) se punctează cu jumătate din punctaj. Orice exercițiu trimis după ziua laboratorului 6 nu se mai punctează deloc. Nota finală pe etapă se calculează conform formulei: n = (n1 + n2) / 2 (n1 = nota obținută înainte de deadline; n2 = nota obținută după deadline). Când toate submisiile sunt înainte de deadline, nota pe ultima submisie este și nota finală (întrucât n1 = n2).

În fiecare etapă, veți folosi ce ați învățat în săptămâna anterioară pentru a dezvolta aplicația.

Pentru fiecare etapă veți primi un schelet de cod (dar rezolvarea se bazează în mare măsură pe rezolvările anterioare). Enunțul din această pagină este menit să descrie heap-urile de împerechere (pe care le vom numi PH, conform prescurtării termenului englez “pairing heap”) și să vină cu exemple de rulare a funcțiilor mai complexe din schelet. Dacă preferați, puteți rezolva tema utilizând doar indicațiile din schelet.

În prima etapă vă veți familiariza cu structura și reprezentarea heap-urilor de împerechere (PH) în Racket, și veți implementa un max-heap de împerechere împreună cu operațiile sale uzuale.

Un PH este un heap n-ar eficient și simplu de implementat. În Racket, vom reprezenta un PH vid ca pe o listă vidă, iar un PH nevid ca pe o listă de n elemente, primul element fiind valoarea din rădăcină, iar următoarele n-1 elemente fiind PH-uri - fiii nodului rădăcină. Veți implementa următorii constructori și operatori ai acestui tip:

• empty-ph: creează un PH vid
• (val->ph val): creează un PH care este un singur nod cu valoarea val
• (ph-empty? ph): verifică dacă un PH este vid
• (ph-root ph): întoarce valoarea din rădăcină, sau false dacă nu există o asemenea valoare întrucât argumentul este un PH vid
• (ph-subtrees ph): întoarce lista fiilor rădăcinii (o listă de PH-uri), sau false dacă argumentul este un PH vid
• (merge ph1 ph2): reunește PH-urile ph1 și ph2 - în cazul unui max-PH, aceasta înseamnă că PH-ul cu rădăcina mai mică devine cel mai din stânga fiu al celui cu rădăcina mai mare, ca în figura de mai jos:
  • Un posibil apel Racket corespunzător imaginii este:

    (merge '(8 (2) (5) (7 (3)))
           '(12 (6) (11 (8) (10 (4) (1) (2)))))

    • Cum 12 > 8, primul arbore devine cel mai din stânga fiu al celui de-al doilea, producând rezultatul '(12 (8 (2) (5) (7 (3))) (6) (11 (8) (10 (4) (1) (2))))
• (ph-insert val ph): inserează valoarea val în PH-ul ph - inserția este de fapt un merge între ph și un PH care conține doar valoarea val, ca în figura de mai jos:
• (list->ph lst): inserează toate valorile din lista lst, de la dreapta la stânga, într-un PH vid
  • ex:

    (list->ph '(2 5 8 7 3))

    • se inserează 3 în vid ⇒ '(3)
    • se inserează 7 în rezultat ⇒ '(7 (3))
    • se inserează 8 în rezultat ⇒ '(8 (7 (3)))
    • se inserează 5 în rezultat ⇒ '(8 (5) (7 (3)))
    • se inserează 2 în rezultat ⇒ '(8 (2) (5) (7 (3)))
• (two-pass-merge-LR phs): reunește toate PH-urile din lista phs, conform unui protocol în 2 pași, ca în figura de mai jos:
  • ex:

    (two-pass-merge-LR '((8 (2))   
                         (12)
                         (14 (11 (8)))   
                         (5 (4))   
                         (11 (10 (9)))))

    • se reunesc PH-urile două câte două, de la stânga la dreapta ⇒
      '(12 (8 (2)))
'(14 (5 (4)) (11 (8)))
'(11 (10 (9))) (ultima valoare rămâne ca atare, întrucât nu are cu cine să se unească)
    • se reunesc rezultatele, de la stânga la dreapta ⇒
      '(14 (12 (8 (2))) (5 (4)) (11 (8))) ⇒
      '(14 (11 (10 (9))) (12 (8 (2))) (5 (4)) (11 (8)))
• (two-pass-merge-RL phs): la fel, însă ambii pași se realizează de la dreapta la stânga
  • ex:

    (two-pass-merge-RL '((8 (2))   
                         (12)   
                         (14 (11 (8)))   
                         (5 (4))   
                         (11 (10 (9)))))

    • se reunesc PH-urile două câte două, de la dreapta la stânga ⇒
      '(8 (2)) (prima valoare rămâne ca atare, întrucât nu are cu cine să se unească)
      '(14 (12) (11 (8)))
'(11 (5 (4)) (10 (9)))
    • se reunesc rezultatele, de la dreapta la stânga ⇒
      '(14 (11 (5 (4)) (10 (9))) (12) (11 (8))) ⇒
      '(14 (8 (2)) (11 (5 (4)) (10 (9))) (12) (11 (8)))
• (tournament-merge phs): reprezintă un alt protocol de reuniune a PH-urilor din lista phs - se realizează primul pas de la two-pass-merge-LR asupra listei phs, apoi din nou asupra listei rezultate anterior, și tot așa până rămâne un singur PH
  • ex:

    (tournament-merge '((8 (2))   
                        (12)   
                        (14 (11 (8)))   
                        (5 (4))   
                        (11 (10 (9)))))

    • se reunesc PH-urile două câte două, de la stânga la dreapta ⇒
      '(12 (8 (2)))
'(14 (5 (4)) (11 (8)))
'(11 (10 (9))) (ca la two-pass-merge-LR)
    • se reunesc rezultatele două câte două, de la stânga la dreapta ⇒
      '(14 (12 (8 (2))) (5 (4)) (11 (8)))
'(11 (10 (9)))
    • se reunesc rezultatele două câte două, de la stânga la dreapta ⇒
      '(14 (11 (10 (9))) (12 (8 (2))) (5 (4)) (11 (8)))
• (ph-del-root ph): întoarce PH-ul obținut în urma ștergerii rădăcinii lui ph - fiii nodului șters sunt reuniți prin two-pass-merge-LR (vezi figura anterioară)

În rezolvare, veți exersa lucrul cu:

• liste și operatorii acestora (întrucât fiecare PH este reprezentat ca listă)
• funcții recursive pe stivă, respectiv pe coadă (observați tipul de recursivitate al fiecărei funcții implementate, și atenție la cazurile în care vi se solicită un anumit tip de implementare - chiar dacă obțineți punctaj pe checker, punctajul va fi anulat în cazul în care funcțiile nu sunt implementate conform cerințelor)
• operatori condiționali, operatori logici și valori boolene

• Unele exerciții vă cer să folosiți un anumit tip de recursivitate. Fiecare restricție încălcată atrage după sine o depunctare de 10p. Când funcția testată de checker apelează funcții ajutătoare, atunci restricțiile se răsfrâng asupra funcțiilor ajutătoare.
• Folosiți interfața (constructorii și operatorii) tipului PH, nu funcții echivalente pentru liste care fac codul mai puțin lizibil și greu de modificat în cazul în care modalitatea de implementare a PH-urilor se schimbă. Deși încălcarea acestei reguli nu se depunctează, este un aspect important pe care îl vom dezvolta în capitolul despre abstractizare.

În această etapă veți abstractiza operatorii tipului PH astfel încât aceștia să poată manipula min-PH-uri, max-PH-uri, și în general PH-uri bazate pe orice relație de ordine între valorile stocate în noduri.

• Cum criteriul de ordonare este folosit doar în funcția merge, veți defini o funcție mai generală merge-f care compară rădăcinile a două PH-uri după un criteriu primit ca parametru. Din această funcție veți deriva tipuri particulare de merge:
  • merge-max - pentru max-PH-uri
  • merge-min - pentru min-PH-uri
  • alte variante de merge cerute explicit în schelet sau pe post de funcții ajutătoare pentru alte funcții
• Cum funcția merge este apelată direct sau indirect de alți operatori ai tipului PH, și aceștia vor trebui abstractizați - adică modificați să primească tipul de merge ca parametru.

În etapele următoare veți folosi heap-uri de împerechere pentru a prelucra filme. De aceea, în partea a doua a acestei etape definim structura movie, care stochează informații despre un film în 5 câmpuri intitulate name, rating, genre, duration, others. Fișierul tutorial.rkt vă oferă exemple de definire și manipulare a structurilor.

Aveți apoi de implementat o serie de funcții dedicate filmelor:

• (lst->movie lst) - constructor al structurii movie care primește ca parametru o listă cu 5 valori, nu 5 valori separate
• (mark-as-seen m) - adaugă informația 'seen la începutul câmpului (listei) others a filmului m
• (mark-as-seen-from-list movies seen) - în lista de filme movies, marchează ca văzute filmele din lista de nume seen
  • ex:

    (mark-as-seen-from-list
     (list (make-movie 'a 9.3 'drama '(2 12) '())
           (make-movie 'b 8.2 'comedy '(1 56) '(feel-good))
           (make-movie 'c 8.8 'drama '(1 44) '(old))
           (make-movie 'd 8.0 'thriller '(2 25) '())
           (make-movie 'e 8.1 'action '(2 19) '(sequel)))
     '(a c))

    • se adaugă informația 'seen în câmpul others al filmelor 'a și 'c ⇒
      '((movie 'a 9.3 'drama '(2 12) '(seen))
(movie 'b 8.2 'comedy '(1 56) '(feel-good))
(movie 'c 8.8 'drama '(1 44) '(seen old))
(movie 'd 8.0 'thriller '(2 25) '())
(movie 'e 8.1 'action '(2 19) '(sequel)))
• (extract-seen movies) - extrage numele filmelor văzute din lista de filme movies
  • ex:

    (extract-seen
     (list (make-movie 'a 9.3 'drama '(2 12) '(seen))
           (make-movie 'b 8.2 'comedy '(1 56) '(feel-good))
           (make-movie 'c 8.8 'drama '(1 44) '(legal seen old))
           (make-movie 'd 8.0 'thriller '(2 25) '())
           (make-movie 'e 8.1 'action '(2 19) '(sequel))))

    • ⇒ '(a c) (întrucât se cere o listă de nume, nu o listă de filme)
    • observați că informația 'seen poate apărea pe orice poziție în câmpul others
• (rating-stats movies) - calculează o pereche cu rating-ul mediu al filmelor văzute, respectiv al celor nevăzute (prin convenție, dacă nu există filme de un anumit fel, rating-ul mediu al acestora este 0)
  • ex:

    (rating-stats
     (list (make-movie 'a 9.3 'drama '(2 12) '(seen))
           (make-movie 'b 8.2 'comedy '(1 56) '(feel-good))
           (make-movie 'c 8.8 'drama '(1 44) '(legal seen old))
           (make-movie 'd 8.0 'thriller '(2 25) '())
           (make-movie 'e 8.1 'action '(2 19) '(sequel))))

    • ⇒ '(9.05 . 8.1) (observați că rezultatul este o pereche cu punct, nu o listă)
• (extract-name-rating movies) - transformă o listă de filme într-o listă de perechi între numele și rating-ul filmului, renunțând la celelalte informații
  • ex:

    (extract-name-rating
     (list (make-movie 'a 9.3 'drama '(2 12) '(seen))
           (make-movie 'b 8.2 'comedy '(1 56) '(feel-good))
           (make-movie 'c 8.8 'drama '(1 44) '(legal seen old))
           (make-movie 'd 8.0 'thriller '(2 25) '())
           (make-movie 'e 8.1 'action '(2 19) '(sequel))))

    • ⇒ '((a . 9.3) (b . 8.2) (c . 8.8) (d . 8.0) (e . 8.1))
• (make-rating-ph movies) - construiește un max-PH care conține perechi nume-rating corespunzătoare filmelor din lista movies, ordonate după rating
  • ordinea de inserare a valorilor în PH este de la dreapta listei către stânga
  • ex:

    (make-rating-ph
     (list (make-movie 'a 9.3 'drama '(2 12) '(seen))
           (make-movie 'b 8.2 'comedy '(1 56) '(feel-good))
           (make-movie 'c 8.8 'drama '(1 44) '(legal seen old))
           (make-movie 'd 8.0 'thriller '(2 25) '())
           (make-movie 'e 8.1 'action '(2 19) '(sequel))))

    • se inserează 'e ⇒
      '((e . 8.1))
    • se inserează 'd, care devine fiul lui 'e, pentru că are rating mai mic ⇒
      '((e . 8.1) ((d . 8.0)))
    • se inserează 'c, care devine părintele lui 'e, pentru că are rating mai mare ⇒
      '((c . 8.8) ((e . 8.1) ((d . 8.0))))
    • se inserează 'b, care devine fiul lui 'c, pentru că are rating mai mic ⇒
      '((c . 8.8) ((b . 8.2)) ((e . 8.1) ((d . 8.0))))
    • se inserează 'a, care devine părintele lui 'c, pentru că are rating mai mare ⇒
      '((a . 9.3) ((c . 8.8) ((b . 8.2)) ((e . 8.1) ((d . 8.0)))))
• (before? a b L) - întoarce true dacă și numai dacă a = b sau a apare înaintea lui b în lista L
  • nu este necesar ca a și b să apară în lista L
    • dacă apare doar a, rezultatul este true
    • dacă apare doar b sau nu apare niciuna (și nici nu sunt egale), rezultatul este false
• (make-genre-ph movies genres) - construiește un PH care conține filme din lista movies, ordonate după preferințele exprimate în lista de genuri genres - genul unui nod copil nu poate să apară înaintea genului nodului părinte în lista genres
  • ca de obicei, inserarea se face de la dreapta la stânga
  • ex:

    (make-genre-ph
     (list (make-movie 'a 9.3 'drama '(2 12) '(seen))
           (make-movie 'b 8.2 'comedy '(1 56) '(feel-good))
           (make-movie 'c 8.8 'drama '(1 44) '(legal seen old))
           (make-movie 'd 8.0 'thriller '(2 25) '())
           (make-movie 'e 8.1 'action '(2 19) '(sequel)))
     '(drama comedy action))

    • se inserează 'e
    • se inserează 'd, care devine fiul lui 'e, întrucât 'action apare în lista de preferințe iar 'thriller nu
    • se inserează 'c, care devine părintele lui 'e, întrucât 'drama precede pe 'action
    • se inserează 'b, care devine fiul lui 'c, întrucât 'drama precede pe 'comedy
    • se inserează 'a, care devine fiul lui 'c, întrucât inserția este un merge între rezultatul anterior și noua valoare, iar la valori egale (ambele filme au genul 'drama) funcția before? întoarce true, preferând primul root (același principiu pe care îl folosea și funcția merge)
    • ⇒

      (list (movie 'c 8.8 'drama '(1 44) '(legal seen old))
            (list (movie 'a 9.3 'drama '(2 12) '(seen)))
            (list (movie 'b 8.2 'comedy '(1 56) '(feel-good)))
            (list (movie 'e 8.1 'action '(2 19) '(sequel))
                  (list (movie 'd 8.0 'thriller '(2 25) '()))))

Exercițiile valorifică faptul că, în programarea funcțională, funcțiile sunt valori de ordinul întâi. Scopul etapei este consolidarea cunoștințelor legate de:

• funcționale (anumite sarcini impun lucrul cu funcționale în locul utilizării recursivității explicite)
• funcții anonime (deși aveți libertate cu privire la utilizarea lor, vă recomandăm să dați funcții anonime ca parametri pentru funcționale atunci când funcțiile respective nu mai sunt necesare altundeva)
• funcții curry și uncurry (veți folosi mecanismul de curry-ing pentru a deriva “cu ușurință” diverse tipuri de merge dintr-o funcție mai generală)

Baremul depunctărilor posibile în etapa 2 este:

• -5p*n: unde n = numărul de funcții dintre merge-max, merge-min, merge-max-rating care nu sunt definite point-free prin aplicația parțială a lui merge-f
• -10p*n: unde n = numărul de funcții dintre lst->movie, mark-as-seen-from-list, extract-seen, rating-stats, extract-name-rating, before? rezolvate fără a folosi funcționale (conform cerinței) în locul recursivității explicite

În această etapă veți implementa două aplicații ale heap-urilor de împerechere:

• extragerea primelor k elemente dintr-o listă, conform unui anumit criteriu de sortare
• interclasarea valorilor conținute în mai multe PH-uri

Mai precis, veți implementa particularizări ale celor două aplicații dedicate filmelor, așa cum au fost acestea definite în etapa 2. Observați că la începutul fișierului etapa3.rkt apare linia (require “etapa2.rkt”), ceea ce înseamnă că va fi necesar să aduceți rezolvarea etapei 2 în același folder în care rezolvați etapa 3, pentru a beneficia de funcțiile implementate anterior.

Scopul etapei este lucrul cu expresii de legare statică a variabilelor:

• let sau let* - pentru evitarea calculelor duplicate
• named let - pentru implementarea ad-hoc a proceselor recursive, fără a apela la funcții ajutătoare

Aveți de implementat următoarele funcții:

• best-k - o funcție care primește un criteriu de comparație op, o listă de filme movies și un număr k, într-o ordine și grupare definite de voi (de aceea nu am specificat antetul funcției), și determină primele k filme din movies conform criteriului op
  • rezultatul trebuie obținut folosind un PH construit pe baza listei movies și a criteriului op
  • odată inițializat acest PH, lista finală rezultă din k extrageri succesive ale rădăcinii sale
  • funcția best-k nu este punctată de checker, însă pe baza ei trebuie obținute funcțiile best-k-rating și best-k-duration, care sunt punctate
• best-k-rating - determină cele mai bune k filme dintr-o listă, din punct de vedere al rating-ului
  • ex:

    (best-k-rating
     (list (make-movie 'a 9.3 'drama '(2 12) '(seen))
           (make-movie 'b 8.2 'comedy '(1 56) '(feel-good))
           (make-movie 'c 8.8 'drama '(1 44) '(legal seen old))
           (make-movie 'd 8.0 'thriller '(2 25) '())
           (make-movie 'e 8.1 'action '(2 19) '(sequel)))
     4)

    • ⇒

      (list
       (movie 'a 9.3 'drama '(2 12) '(seen))
       (movie 'c 8.8 'drama '(1 44) '(legal seen old))
       (movie 'b 8.2 'comedy '(1 56) '(feel-good))
       (movie 'e 8.1 'action '(2 19) '(sequel)))

• best-k-duration - determină cele mai scurte k filme dintr-o listă
  • ex:

    (best-k-duration
     (list (make-movie 'a 9.3 'drama '(2 12) '(seen))
           (make-movie 'b 8.2 'comedy '(1 56) '(feel-good))
           (make-movie 'c 8.8 'drama '(1 44) '(legal seen old))
           (make-movie 'd 8.0 'thriller '(2 25) '())
           (make-movie 'e 8.1 'action '(2 19) '(sequel)))
     3)

    • ⇒

      (list
       (movie 'c 8.8 'drama '(1 44) '(legal seen old))
       (movie 'b 8.2 'comedy '(1 56) '(feel-good))
       (movie 'a 9.3 'drama '(2 12) '(seen)))

• (update-pairs p pairs) - șterge rădăcina PH-ului primei perechi care satisface predicatul p
  • fiecare pereche din pairs conține un nume de film și un max-PH de rating-uri acordate filmului de diverși utilizatori
  • dacă nu sunt stocate rating-uri pentru filmul din perechea vizată (PH-ul asociat este vid), atunci se întoarce lista pairs nemodificată
  • dacă nicio pereche nu satisface predicatul p, se întoarce lista pairs nemodificată
  • ex:

    (update-pairs
     (λ (p) #t)
     '((a 10 (9) (10 (8) (9 (7) (9 (8)))))
       (b 10 (9) (6) (8) (9) (8) (7 (7)))
       (c 10 (8) (10 (8) (7) (9) (8) (6)))))

    • toate perechile satisfac predicatul, așadar se va șterge rădăcina PH-ului primei perechi
    • întrucât perechile au pe a doua poziție un PH, adică o listă, ele nu se afișează ca perechi cu punct, ci ca liste care au pe prima poziție numele filmului, iar restul listei corespunde PH-ului
    • ⇒

      '((a 10 (9) (8) (9 (7) (9 (8))))      ; aici a fost ștearsă rădăcina 10
        (b 10 (9) (6) (8) (9) (8) (7 (7)))
        (c 10 (8) (10 (8) (7) (9) (8) (6))))

• (best-k-ratings-overall pairs k) - determină cele mai bune k recenzii (în pereche cu filmul căruia i-au fost acordate), pe baza unei liste pairs de tipul celei de mai sus (perechi (nume-film . PH-cu-rating-uri-film))
  • rezultatul este o listă de perechi (nume-film . rating) și se obține prin interclasarea PH-urilor corespunzătoare fiecărui film, astfel:
    • se inițializează un nou PH cu perechi (nume-film . rating) corespunzătoare rădăcinilor fiecărui PH din pairs - îl vom numi PH-ul de rădăcini
    • invariant: rădăcina PH-ului de rădăcini corespunde celei mai bune recenzii per total
    • la fiecare iterație, se extrage această rădăcină și se aduce în PH-ul de rădăcini următorul cel mai bun rating corespunzător filmului care tocmai a fost extras (pentru a menține invariantul)
  • ex:

    (best-k-ratings-overall 
     '((a 10 (9) (10 (8) (9 (7) (9 (8)))))
       (b 10 (9) (6) (8) (9) (8) (7 (7)))
       (c 10 (8) (10 (8) (7) (9) (8) (6))))
     7)

    • se inițializează PH-ul de rădăcini cu perechile '(a . 10), '(b . 10), '(c . 10) ⇒
      una dintre ele devine rădăcină, de exemplu '(c . 10)
    • în urma extragerii lui '(c . 10), se aduce un alt '(c . 10) în locul acestuia (întrucât mai există un rating 10 pentru filmul c) ⇒
      avem aceleași valori în PH-ul de rădăcini, iar noua rădăcină este, de exemplu, '(a . 10)
    • se extrage '(a . 10), în locul său fiind adus un nou '(a . 10), iar noua rădăcină este '(c . 10)
    • se extrage '(c . 10), în locul său fiind adus un '(c . 9), iar noua rădăcină este '(a . 10)
    • se extrage '(a . 10), în locul său fiind adus un '(a . 9), iar noua rădăcină este '(b . 10)
    • se extrage '(b . 10), în locul său fiind adus un '(b . 9), iar noua rădăcină este '(a . 9)
    • se extrage '(a . 9), în locul său fiind adus un nou '(a . 9), iar noua rădăcină este '(b . 9)
    • extragerea lui '(b . 9) este a șaptea extragere ⇒
      '((c . 10) (a . 10) (c . 10) (a . 10) (b . 10) (a . 9) (b . 9))
    • Observație: checker-ul acceptă și alte rezultate corecte (aceleași rating-uri dar în pereche cu alte filme, cât timp perechile respective corespund unor recenzii din input)

Baremul depunctărilor posibile în etapa 3 este:

• -5p*n: unde n = numărul de funcții dintre best-k-rating, best-k-duration care nu sunt definite ca aplicații ale lui best-k
• -20p*n: unde n = numărul de funcții dintre best-k, update-pairs, best-k-ratings-overall rezolvate fără a folosi named let conform enunțului
• -0p: Vă încurajăm să folosiți let și let* pentru a evita calculele duplicate, chiar dacă nu există depunctări referitoare la acest aspect.

Când interesează percepția “tipică” a utilizatorilor asupra unui film, mediana rating-urilor poate fi mai relevantă decât media, cu precădere când lista de rating-uri conține valori extreme, care pot distorsiona semnificativ media. Întrucât rating-urile pentru un film sosesc în flux continuu, pe măsură ce filmul înregistrează noi vizionări, și valoarea medianei trebuie actualizată frecvent. În loc să recalculăm această valoare de fiecare dată când filmul primește o nouă recenzie, ea poate fi menținută în mod dinamic, cu ajutorul a două heap-uri de împerechere:

• un max-PH care reține jumătatea cu cele mai mici rating-uri
• un min-PH care reține jumătatea cu cele mai mari rating-uri
• cele două PH-uri trebuie să rămână echilibrate: în cel mai nebalansat caz, max-PH va conține o valoare mai mult decât min-PH
• fiecare nouă recenzie implică inserarea noului rating în PH-ul aferent (cel cu rating-uri mai mari sau mai mici, după caz) și reechilibrarea celor două PH-uri
  • pentru a implementa cu ușurință acest proces, la un anumit moment t unui film îi va corespunde un cvartet (nume-film delta max-ph min-ph), unde delta reprezintă diferența dintre dimensiunea lui max-ph și dimensiunea lui min-ph (0 sau 1)
• mediana va fi:
  • media rădăcinilor celor 2 PH-uri, pentru număr par de recenzii
  • rădăcina lui max-PH, pentru număr impar de recenzii

În etapa 4 veți implementa acest algoritm pentru calculul dinamic al medianei, pe baza unui flux de recenzii modelat ca flux Racket.

Noutatea etapei constă în lucrul cu fluxuri:

• Recenziile care intră în sistem sunt modelate ca flux
• Stadiile de evoluție ale medianelor sunt modelate ca flux
• Fiecare nouă recenzie corespunde unui moment de timp t, iar pentru fiecare moment de timp t vom depune un “stadiu” în fluxul rezultat - informația despre cât erau medianele filmelor la momentul t

Este important sa discerneți între situațiile în care operați cu liste și cele în care operați cu fluxuri:

• Intrările și ieșirile algoritmului sunt fluxuri - reflectă o evoluție temporală potențial infinită
• Fiecare element din fluxul rezultat este o listă - este necesară o listă pentru că interesează “starea” tuturor filmelor la un anumit moment t

Aveți de implementat următoarele funcții:

• (add-rating quad rating) - primește un cvartet tip (nume-film delta max-ph min-ph) și un rating, și întoarce cvartetul actualizat prin inserarea rating-ului în PH-ul aferent și reechilibrarea PH-urilor
  • ex:

    (add-rating '(a 0 (4) (7)) 5)

    • întrucât 5 > 4 (rating > root(max-ph)), 4 este inserat în min-ph ⇒
      '(a -1 (4) (5 (7)))
    • întrucât delta < 0, root(min-ph) este mutat în max-ph ⇒
      '(a 1 (5 (4)) (7))
• (reviews->quads reviews) - transformă un flux de recenzii (recenzie = pereche (nume-film . rating)) într-un flux de stadii (stadiu = listă de cvartete: câte un cvartet pentru fiecare film care a primit recenzii până în acest moment)
  • ex:

    (reviews->quads (stream '(a . 4) '(b . 1) '(a . 2)))

    • la început nu avem informații despre niciun film
    • la momentul t = 1, avem de adăugat rating-ul 4 pentru filmul 'a ⇒
      se creează un cvartet pentru filmul 'a, în care doar max-PH-ul conține valoarea 4 ⇒
      '((a 1 (4) ())) este primul stadiu de evoluție (o listă care conține un singur cvartet)
    • la momentul t = 2, avem de adăugat rating-ul 1 pentru filmul 'b ⇒
      se creează un cvartet pentru filmul 'b, în care doar max-PH-ul conține valoarea 1 ⇒
      '((b 1 (1) ()) (a 1 (4) ())) este al doilea stadiu de evoluție (o listă cu două cvartete)
    • la momentul t = 3, avem de adăugat rating-ul 2 pentru filmul 'a ⇒
      se actualizează cvartetul pentru filmul 'a prin adăugarea rating-ului 2 ⇒
      '((b 1 (1) ()) (a 0 (2) (4))) este al treilea stadiu de evoluție
    • rezultatul apelului este un flux care conține cele 3 liste de mai sus (cele 3 stadii)
• (quads->medians quads) - transformă un flux de stadii reprezentate folosind cvartete într-un flux de stadii reprezentate folosind mediane
  • ex:

    (quads->medians (reviews->quads (stream '(a . 4) '(b . 1) '(a . 2))))

    • lista de cvartete '((a 1 (4) ())) devine lista de perechi '((a . 4))
      (pentru filmul 'a, mediana coincide cu singurul rating primit)
    • lista de cvartete '((b 1 (1) ()) (a 1 (4) ())) devine lista de perechi '((b . 1) (a . 4))
    • lista de cvartete '((b 1 (1) ()) (a 0 (2) (4))) devine lista de perechi '((b . 1) (a . 3))
      (pentru 'a, mediana este media celor 2 rating-uri, conform formulei pentru număr par de rating-uri)
    • rezultatul apelului este un flux care conține cele 3 liste de perechi de mai sus

Baremul depunctărilor posibile în etapa 4 este:

• -20p: dacă faceți conversii din liste în fluxuri sau din fluxuri în liste, în loc să operați direct cu interfața pentru fluxuri (când creați/manipulați fluxuri) și cu interfața pentru liste (când creați/manipulați liste)
• -20p: dacă funcția quads->medians folosește recursivitate explicită sau nu folosește o funcțională pe fluxuri

• Scheletul fiecărei etape va conține unul sau mai multe fișiere .rkt în care trebuie să lucrați, plus fișierul checker.rkt pe care îl veți folosi doar pentru testare (rulând codul fără să îl modificați).
• Fiecare etapă (o arhivă .zip cu fișierele în care ați lucrat, plus eventualele fișiere care sunt solicitate de acestea cu “require”) se va încărca pe vmchecker. Testele de vmchecker sunt aceleași cu cele din checker.rkt.
• În fiecare etapă veți avea de implementat o serie de funcții, în sprijinul cărora vă puteți defini oricând funcții ajutătoare (dacă nu se interzice asta în mod explicit). Atunci când există restricții asupra implementării funcției din cerință, aceleași restricții trebuie respectate și de eventualele funcții ajutătoare definite de voi.
• Dacă doriți să rezolvați exerciții din etapa curentă care depind de exerciții din etapele anterioare pe care nu le-ați rezolvat, puteți semnala acest lucru responsabilului de temă, care vă va pune la dispoziție o rezolvare pentru acele exerciții astfel încât să puteți continua tema. Odată ce alegeți această variantă, renunțați la dreptul de a mai trimite cu întârziere etapa pentru care ați solicitat parțial sau integral rezolvarea. Puteți solicita rezolvări doar pentru exercițiile din etapele anterioare, nu și pentru cele din etapa curentă. Dacă implementați un exercițiu din etapa curentă pe baza unui alt exercițiu din etapa curentă pe care nu l-ați rezolvat, se va lua în calcul punctajul dat de checker, chiar dacă implementarea ar funcționa în caz că exercițiul nerezolvat ar funcționa.
• Tema este o temă de programare funcțională - pentru care folosim Racket. Racket este un limbaj multiparadigmă, care conține și elemente “ne-funcționale” (de exemplu proceduri cu efecte laterale), pe care nu este permis să le folosiți în rezolvare.
• Pentru fiecare etapă, checker-ul vă oferă un punctaj între 0 și 120 de puncte. Nota 100 corespunde punctajului maxim pe etapă, iar orice surplus se transformă într-un bonus proporțional.
• Veți prezenta tema asistentului, care poate modifica punctajul dat de checker dacă observă nereguli precum răspunsuri hardcodate, proceduri cu efecte laterale, implementări neconforme cu restricțiile din enunț.
• Temele implementează o politică de zero toleranță pentru copiere. Cât timp respectați politica de colaborare și utilizare a internetului descrisă în regulamentul materiei, nu aveți motive de îngrijorare. Contăm pe voi să nu recurgeți la mijloace nepermise, și vă stăm la dispoziție pentru orice neclaritate.

• etapa 1
• etapa 2
• etapa 3
• etapa 4

• 21.03 (ora 12:16) - Am publicat etapa 4.
• 15.03 (ora 08:45) - Am publicat etapa 3.
• 07.03 (ora 15:15) - Am publicat etapa 2.
• 01.03 (ora 01:45) - Am publicat etapa 1.

• The Pairing Heap: A New Form of Self-Adjusting Heap