#lang racket
#|
  Enunț:
  (suffixes L)

  Scrieți o funcție care primește o listă L și returnează toate sufixele
  nevide ale acestei liste.

  Input:
    - o listă L.
  
  Output:
    - o listă care conține toate sufixele nevide ale listei L, în ordine descrescătoare
      a lungimii acestora (primul element este chiar lista originală).
  
  Exemplu:
  (suffixes '(1 2 3)) -> '((1 2 3) (2 3) (3))
|#
(define (suffixes L)
  'your-code-here)

#|
  Enunț:
  (interleave L1 L2)

  Scrieți o funcție care primește 2 liste și intercalează elementele acestor liste,
  începând cu prima listă, cât timp ambele liste mai au elemente.

  Input:
    - 2 liste L1 și L2, de lungimi posibil diferite.
  
  Output:
    - O listă cu elementele intercalate după regulile de mai sus, care trebuie
      să conțină același număr de elemente din L1 și din L2.
  
  Exemple:
  (interleave '(1 2 3) '(a b c d e)) -> '(1 a 2 b 3 c)
  (interleave '(1 2 3 4) '(a b c)) -> '(1 a 2 b 3 c)
|#
(define (interleave L1 L2)
  'your-code-here)

#|
  Enunț:
  (trim L to-remove)

  Scrieți o funcție care primește 2 liste (L și to-remove) și întoarce o
  listă de rezultate, astfel:
    - primul element este lista L', rezultată prin eliminarea din lista L a valorilor
      care apar în to-remove
    - următoarele elemente sunt perechi cu punct între un element din to-remove
      și numărul de apariții ale acestui element în lista L.
      Ordinea perechilor corespunde ordinii elementelor listei to-remove.

  Input:
    - o listă L 
    - o listă to-remove care nu conține duplicate.

  Output:
    - o listă cu L' și cu perechile descrise anterior.

  Exemplu:
  (trim '(a n a - a r e - - m e r e ? !) '(! -)) ->
  '((a n a a r e m e r e ?) (! . 1) (- . 3))
|#
(define (trim L to-remove)
  'your-code-here)

#|
  Enunț:
  (words L separator)

  Scrieți o funcție care primește o listă L și un element separator și întoarce
  lista tuturor subsecvențelor (contigue) separate prin una sau mai multe apariții
  ale valorii separator.

  Input:
    - O listă L
    - O valoare separator.

  Output:
    - O listă de liste (subsecvențe nevide) conform regulilor de mai sus.
      Ordinea subsecvențelor corespunde ordinii în lista L.

  Exemplu:
  (words '(a n a - a r e - - m u l t e - - m e r e) '-) -> '((a n a) (a r e) (m u l t e) (m e r e))
|#
(define (words L separator)
  'your-code-here)

#|
  Enunț:
  (subsequence-stream L)

  Scrieți o funcție care primește o listă L și returnează un flux de liste, astfel:
    - primul element din flux este o listă cu toate subsecvențele de lungime 1 din L
    - al doilea element este o listă cu toate subsecvențele de lungime 2 din L
    ...
    - ultimul element este o listă care conține lista L.

  Input:
    - o listă nevidă L.

  Output:
    - un flux conținând liste cu subsecvențele de aceeași lungime, ca mai sus.
      Ordinea subsecvențelor de aceeași lungime corespunde ordinii în L.

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

#|
  Enunț:
  (convert-stream s)

  Scrieți o funcție care primește un flux de liste și desface listele,
  întorcând un flux de elemente.

  Input:
    - un flux (finit sau infinit) ale cărui elemente sunt liste.
  
  Output:
    - un flux cu elementele din listele fluxului original, în aceeași ordine. 

  Exemplu:
  (convert-stream (stream '(1 2 3) '(4 5 6)) -> (stream 1 2 3 4 5 6)
|#
(define (convert-stream s)
  'your-code-here)