#lang racket

(define (factorial n)
  (if (zero? n)
      1
      (* n (factorial (- n 1)))))
;(factorial 5)
;(map factorial (range 0 11))

(define (factorial-adv n)
  (apply * (range 2 (+ n 1))))

; ------------------Expresii------------------
; expresie = (f e1 e2 .. en)
;(+ 6 (- (* 5 2) 3) 1)


; ------------------Define------------------
; (define identificator expresie)
(define PI 3.14159265)
(define r 5)
(define area (* PI r r))
;area


; ------------------Funcții------------------
; funcții anonime: (lambda listă-parametri corp)
; λx.x - în Calcul Lambda
;(lambda (x) x)
;( (lambda (x) x) 11)

;λx.λy.(x y) - în Calcul Lambda
;(λ (x)
;  (λ (y)
;    (x y)))
;(((λ (x)
;    (λ (y)
;      (x y))) add1) 4)

;(λx.x λx.y) - în Calcul Lambda

(define arithmetic-m
  (λ (x y)
    (/ (+ x y) 2)))
;(arithmetic-m 6 12)

; (define (f x y ... ) corp)
(define (arithmetic-mean x y)
  (/ (+ x y) 2))

(define (sum-of-squares x y)
  (+ (sqr x) (sqr y)))
;(sum-of-squares (+ 1 2) (* 3 5))


; ------------------Perechi------------------
; constructor: cons
; selectori: car, cdr
;(cons (cons 1 2) 'a)
;(cons + 3)
;(car (cons (cons 1 2) 5))
;(cdr '(4 . b))


; ------------------Liste------------------
; constructori: null, cons, list
; selectori: car, cdr
; alte operații: null?, length, append
;(car (list 1 'a +))
;(cdr '(2 3 4 5))
;(null? '())
;(length (list))
;(append (cons 1 '(2)) '(a b))


; ------------------Operatori condiționali------------------
; (if conditie rez-then rez-else)
;(if (null? '(1))
;    (/ 1 0)
;    (- 7 1))

; (cond (cond1 rez1) (cond2 rez2) ... )
(define L '(1 2 3))
(define val
  (cond
    ((null? L)             0)
    ((null? (cdr L)) (/ 1 0))
    (else             'other)))
;val


; ------------------Recursivitate------------------
; Traducere din axiome:
; sum([])  = 0           ; suma elementelor din lista vidă este 0
; sum(x:l) = x + sum(l)  ; suma elementelor din lista cons(x,l) este x + suma elementelor din l
(define (sum L)
  (if (null? L)
      0
      (+ (car L) (sum (cdr L)))))
;(sum '(1 2 3))


; Exemplu: my-take
; L = '(1 2 3 4 5 6 7)       
; n = 4                      
; r = '(1 2 3 4)

; 1) După ce variabile fac recursivitatea?
;   (ce variabile își schimbă valoarea de la un apel la altul?)
; L1 = '(2 3 4 5 6 7)
; n1 = 3
; r1 = '(2 3 4)

; 2) Scrie condiția de oprire pentru fiecare asemenea variabilă
;   (constructori nulari și externi).
; axiome:
; my-take([], n) = []
; my-take(L, 0) = []

; 3) Scrie ce se întâmplă când problema nu este încă elementară
;   (constructori interni, care generează obligatoriu
;   cel puțin un apel recursiv).
; axiome:
; my-take((x:l), n) = x : my-take(l, n-1)

(define (my-take L n)
  (if (or (null? L) (= n 0))
      '()
      (cons (car L) (my-take (cdr L) (- n 1)))))

;(my-take (range 2 10) 20)
;(my-take (range 2 10) 3)

(and 2 #f #t)
(or 2 (/ 1 0) #t)