#lang racket
#|
  Enunț:
  (chunk L n)

  Scrieți o funcție care grupează elementele unei liste L în subliste de lungime n,
  păstrând ordinea.

  Input:
    - o listă L
    - un număr natural n.

  Output:
    - o listă de liste, unde ultima listă poate avea o lungime mai mică decât n.

  Exemplu:
  (chunk '(a b c d e) 2) -> '((a b) (c d) (e))
|#
(define (chunk L n)
  'your-code-here)

#|
  Enunț:
  (split2 L)

  Găsiți toate modurile distincte de a împărți o listă numerică L în două liste
  A și B astfel încât L = append(A, B) și sum(A) < sum(B).

  Input:
    - o listă numerică L.

  Output:
    - o listă de liste de forma (A B), în ordine crescătoare a lungimii listei A.

  Exemplu:
  (split2 '(1 -2 3)) -> '((() (1 -2 3)) ((1 -2) (3)))
|#
(define (split2 L)
  'your-code-here)

#|
  Enunț:
  (between-occurences L x)

  Extrageți subsecvența din L cuprinsă între prima și ultima apariție a lui x (inclusiv).

  Input:
    - o listă L
    - o valoare x.

  Output:
    - subsecvența x1 ... xn, unde x1 este prima apariție a lui x în L și xn ultima.
    - se returnează '() dacă x nu apare în L.

  Exemple:
  (between-occurences '(0 1 0 2 1 5) 1) -> '(1 0 2 1)
  (between-occurences '(1 2 3) 4) -> '()
  (between-occurences '(1 2 3) 2) -> '(2)
|#
(define (between-occurences L x)
  'your-code-here)

#|
  Enunț:
  (pairs L s)

  Găsiți toate perechile (a . b) din L, cu a < b care însumate dau valoarea s.

  Input:
    - o listă numerică L, care nu conține duplicate
    - o sumă s.

  Output:
    - o listă de perechi (a . b) cu a < b și a + b = s,
      sortate după indexul lui a în L.

  Exemplu:
  (pairs '(10 5 1 3 9 6 2 4 7 8) 7) -> '((1 . 6) (3 . 4) (2 . 5))
|#
(define (pairs L s)
  'your-code-here)

#|
  Enunț:
  (stream-group s)

  Scrieți o funcție care grupează maximal elementele consecutive egale dintr-un flux,
  producând un flux de liste.

  Input:
    - un flux s.

  Output:
    - un flux s' de liste, unde fiecare listă este un grup maximal de elemente
      consecutive egale. Grupurile respectă ordinea originală a elementelor.

  Exemplu:
  (stream-group (stream 1 2 2 3)) -> (stream '(1) '(2 2) '(3))
|#
(define (stream-group s)
  'your-code-here)

#|
  Enunț:
  (stream-encode s)

  Scrieți o funcție care comprimă un flux de liste cu elemente egale codificând
  grupurile de dimensiune > 2 ca perechi de forma (valoare . număr-de-apariții).
  Grupurile (listele) de lungime 1 sau 2 rămân neschimbate.

  Input:
    - un flux s de grupuri (ca outputul unui stream-group).

  Output:
    - un flux s' în care:
      - grupurile de maxim 2 valori rămân neschimbate
      - grupurile de dimensiune > 2 devin perechi (valoare . număr-de-apariții).

  Exemplu:
  (stream-encode (stream '(1) '(2 2 2))) -> (stream '(1) '(2 . 3))
|#
(define (stream-encode s)
  'your-code-here)