#lang racket
(require (lib "trace.ss"))

; ------------------Recursivitate pe stivă------------------
(define (fact-stack n)
  (if (zero? n)
      1
      (* n (fact-stack (- n 1)))))

;(trace fact-stack)
;(fact-stack 4)

; ------------------Recursivitate pe coadă------------------
(define (fact-tail n)
  (fact-tail-helper n 1))

(define (fact-tail-helper n acc)
  (if (zero? n)
      acc
      (fact-tail-helper (- n 1) (* n acc))))

;(trace fact-tail-helper)
;(fact-tail 10)

; ------------------Recursivitate arborescentă------------------
(define (fibo-stack n)
  (if (< n 2)
      n
      (+ (fibo-stack (- n 1)) (fibo-stack (- n 2)))))

;(trace fibo-stack)
;(fibo-stack 5)
;(fibo-stack 40) ;;  deja incepe sa dureze mult


; Ex: Fibonacci cu recursivitate pe coadă
(define (fibo-tail n)
  (fibo-tail-helper n 0 1))

(define (fibo-tail-helper n a b)
  (if (zero? n)
      a
      (fibo-tail-helper (- n 1) b (+ a b))))
;(trace fibo-tail-helper)
;(fibo-tail 5)
;(fibo-tail 100000)


; Ex: Fibonacci cu tupling
; În loc să îmbogățim argumentele (calcul la avans)
; îmbogățim rezultatul (calcul la revenire)
; Ideea: rezultatul unui singur apel recursiv are
; suficientă informație pentru a calcula (fibo n)
; (f n)       = (F_n . F_n+1)
; (f (- n 1)) = (F_n-1 . F_n)
(define (fibo-tupling n)
  (if (zero? n)
      (cons 0 1)
      (match (fibo-tupling (- n 1))
        [(cons f-n-1 f-n)
         (cons f-n (+ f-n-1 f-n))])))
 
;(trace fibo-tupling)
;(fibo-tupling 5)

; ---------------------Transformare stivă -> coadă---------------------
(define (my-take L n)
  (if (or (null? L) (zero? n))
      '()
      (cons (car L)
            (my-take (cdr L) (- n 1)))))

; Ex: my-take-it care folosește recursivitate pe coadă
; Definiți funcția helper folosind define în define.
(define (my-take-it L n)
  (define (my-take-it-helper L n acc)
    (if (or (null? L) (zero? n))
        (reverse acc)
        ;acc
        (my-take-it-helper (cdr L)
                           (- n 1)
                           (cons (car L) acc))))
                           ;(append acc (list (car L))))))
  (my-take-it-helper L n '()))

(my-take-it (range 2 10) 3)

; ------------------Recunoaștere tip de recursivitate------------------
(define (g L result)
  (cond ((null? L)        result)
        ((list? (car L))  (g (cdr L) (append (g (car L) '()) result))) ; evaluare aplicativă
        (else             (g (cdr L) (cons (car L) result)))))

;(trace g)
;(g '(1 (2 3) (4 (5 6))) '())