#lang racket
#|
  Enunț:
  (pair-to-index L)

  Scrieți o funcție care primește o listă L și returnează o listă de perechi
  cu punct între fiecare element din lista L și indexul său în listă.

  Input:
    - o listă L.

  Output:
    - o listă de perechi (element . index), în ordine crescătoare a indecșilor.
      Indexarea începe de la 0.
      
  Exemplu:
  (pair-to-index '(a b c d)) -> '((a . 0) (b . 1) (c . 2) (d . 3))
|#
(define (pair-to-index L)
  'your-code-here)

#|
  Enunț:
  (split-cipher L)

  Scrieți o funcție care rearanjează elementele unei liste L în funcție de
  paritatea indicilor.

  Input:
    - o listă L.
  
  Output:
    - o listă care conține întâi toate elementele de pe poziții pare din L,
      apoi toate elementele de pe poziții impare din L.
      Indexarea începe de la 0.
      La aceeași paritate, ordinea elementelor corespunde ordinii în L.
  
  Exemplu:
  (split-cipher '(1 a 2 b 3 c 4)) -> '(1 2 3 4 a b c)
|#
(define (split-cipher L)
  'your-code-here)

#|
  Enunț:
  (scytale-cipher L n)

  Implementați o funcție care realizează o permutare de tip "scytale",
  grupând elementele după restul împărțirii indexului la n.

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

  Output:
    - o listă care conține:
      - întâi toate elementele din L de la (poziție mod n) = 0
      - apoi toate elementele din L de la (poziție mod n) = 1
      - ... până la (poziție mod n) = n-1.
      La același rest mod n, ordinea elementelor corespunde ordinii în L.

  Exemplu:
  (scytale-cipher '(1 a x 2 b y 3 c z 4 d) 3) -> '(1 2 3 4 a b c d x y z)
|#
(define (scytale-cipher L n)
  'your-code-here)

#|
  Enunț:
  (most-frequent L)

  Găsiți cea mai frecventă valoare dintr-o listă nevidă.

  Input:
    - o listă nevidă L.

  Output:
    - valoarea care apare de cele mai multe ori (se garantează soluție unică).

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

#|
  Enunț:
  (key-stream alphabet text)

  Enunț:
  Generați un flux infinit de indecși corespunzători elementelor dintr-un text
  raportat la un alfabet.

  Input:
    - o listă alphabet (fără duplicate).
    - o listă text, care conține doar valori din alphabet.

  Output:
    - flux infinit de numere reprezentând indecșii elementelor din text în alphabet.
    După ce se termină valorile din text, fluxul se reia de la text[0].

  Exemplu:
  (stream->list (stream-take (key-stream '(a b c d e) '(b e)) 4)) -> '(1 4 1 4)
  Explicație:
  În lista alphabet, 'b are index 1 și 'e are index 4.
|#
(define (key-stream alphabet text)
  'your-code-here)

#|
  Enunț:
  (make-infinite-stream s)

  Scrieți o funcție care transformă un flux numeric finit într-un flux infinit,
  alternând repetarea și incrementarea elementelor din fluxul inițial.

  Input:
    - un flux finit s, numeric.

  Output:
    - fluxul infinit s' care conține:
      - întâi toate valorile din s, păstrând ordinea
      - apoi toate valorile din s incrementate, păstrând ordinea
      - apoi iar valorile originale, iar cele incrementate, etc.

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