#lang racket
#|
  Enunț:
  (all-equal? L)
  
  Scrieți o funcție care indică dacă toate elementele unei liste sunt egale între ele.

  Input:
    - o listă L.

  Output:
    - #t, dacă toate elementele din L sunt egale între ele.
    - #f, altfel.

  Exemple:
  (all-equal? '()) -> #t
  (all-equal? '(1 1)) -> #t
  (all-equal? '(1 2)) -> #f
|#
(define (all-equal? L)
  'your-code-here)


#|
  Enunț:
  (interchange A B pos)

  Scrieți o funcție care primește 2 liste de aceeași lungime A și B și un
  index valid pos și interschimbă elementele de la indexul pos între listele A și B.

  Input:
    - 2 liste A și B (de aceeași lungime)
    - un index pos. Indexarea se face de la 0.

  Output:
    - O listă care conține cele 2 liste rezultate.

  Exemplu:
  (interchange '(1 2 3 4) '(5 6 7 8) 2) -> '((1 2 7 4) (5 6 3 8))
|#
(define (interchange A B pos)
  'your-code-here)

#|
  Enunț:
  (get-hole square)

  Scrieți o funcție care primește un pătrat numeric - listă de liste reprezentând
  o matrice pătratică, și returnează coordonatele elementului 0 (”hole”).
  Indexarea începe de la 0. Se garantează că elementul 0 este unic.

  Input:
    - O listă de liste de aceeași lungime, reprezentând o matrice pătratică
  
  Output:
    - Coordonatele elementului 0 ca pereche cu punct: linia și coloana elementului 0.
  
  Exemplu:
  (get-hole '((1 2 3) (4 5 6) (7 0 9))) -> '(2 . 1)
|#
(define (get-hole square)
  'your-code-here)

#|
  Enunț:
  (magic-square? square)
  
  Scrieți o funcție care determină dacă un pătrat numeric este un pătrat magic.
  O matrice pătratică este un pătrat magic dacă toate liniile și toate
  coloanele au aceeași sumă.

  Input:
    - O matrice pătratică, reprezentată ca listă de liste.
  
  Output:
    - #t, dacă pătratul este magic, #f altfel.
  
  Exemple:
  (magic-square? '((8 1 6) (3 5 7) (4 9 2))) -> #t (toate liniile și coloanele au suma 15)
  (magic-square? '((1 2) (3 4))) -> #f
|#
(define (magic-square? square)
  'your-code-here)

#|
  Enunț:
  (magic-stream square moves)
  
  Să se scrie o funcție care primește un pătrat glisant și o listă de mutări posibile
  și returnează un flux de liste:
    - prima listă conține pătratul original
    - a doua listă conține pătratele obținute prin efectuarea tuturor mutărilor valide
      asupra pătratului original
      - ordinea noilor pătrate corespunde ordinii mutărilor din lista moves
    - a treia listă conține pătratele obținute prin efectuarea mutărilor valide
      asupra pătratelor din lista precedentă
      - ordinea noilor pătrate:
        - întâi mutările valide aplicate (în ordine) asupra primului pătrat anterior
        - apoi mutările valide aplicate (în ordine) asupra celui de-al doilea pătrat anterior
        - ...
    - ș.a.m.d.
  
  Input:
    - Un pătrat glisant - pătrat numeric ce conține un ”hole” (o unică valoare nulă).
    - O listă de mutări - o mutare este o funcție care primește un pătrat și returnează:
      - un nou pătrat, dacă mutarea este validă
      - #f, altfel.
      Mutări uzuale sunt up, down, left, right (mută un element peste ”hole”).
  
  Output:
    - Fluxul infinit de liste descris mai sus.
      O listă (element al fluxului) conține doar efectul mutărilor valide, nu și
      valori #f.
      Lista poate conține duplicate (pătrate identice obținute
      prin secvențe distincte de mutări).

  Exemplu:
  (magic-stream '((1 2 3) (4 0 6) (7 8 9)) (list up left)) ->
  (stream
    (list '((1 2 3) (4 0 6) (7 8 9))) -> patratul original
    (list '((1 2 3) (4 8 6) (7 0 9)) -> patratul cu mutarea up
          '((1 2 3) (4 6 0) (7 8 9)) -> patratul cu mutarea left
      )
    ...
  )
|#
(define (magic-stream square moves)
  'your-code-here)

#|
  Enunț:
  (steps-to-destination final? s)

  Scrieți o funcție care primește un predicat și un flux al tuturor stărilor
  unei probleme (ca la exercițiul anterior) și returnează numărul minim de pași realizați
  până la obținerea unei soluții.

  Input:
    - un predicat final? - (final? state) returnează #t dacă state este soluție.
    - un flux s care codifică spațiul stărilor unei probleme
      - primul element este o listă care conține starea inițială
      - al doilea este o listă cu toate stările la un pas de starea inițială
      ...
  
  Output:
    - numărul minim de pași după care se poate ajunge într-o stare finală (soluție)
  
  Exemplu:
  (steps-to-destination (curry = 1) (stream '(0) '(1 0 -1) '(2 1 0 -1 -2) ...)) ->
  1
|#
(define (steps-to-destination final? s)
  'your-code-here)