#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)
  
;(trace 
;(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)
 
;(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)

;(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))) '())