#lang racket

(define abc 5) ; numele a este legat la valoarea 3

(define sum2 (lambda       (a b)    (+ a b)))
;       nume  constr fn   L args   valoarea întoarsă

(define (sum3 a b c) (+ a b c))


; suma elementelor dintr-o listă
(define sumList
  (lambda (L)
    (if (null? L) ; pentru o listă vidă rezultatul este zero
        0
        (+ ; altfel, adun
         (car L) ; primul element
         (sumList (cdr L)) ; suma restului elementelor
         )
        )))

; exemplu
(sumList '(1 2 3 4 5))


; mod index întoarce o listă identică cu L, doar că la poziția index are valoare value (în loc de ce era în L)
(define modIndex
  (lambda (L index value)
    (if (null? L) ; pentru o listă vidă, întorc o listă vidă
        '()
        (if (zero? index) ; dacă am ajuns la poziția de "modificat"
            (cons value (cdr L)) ; pun valoarea dată, restul listei rămâne la fel
            (cons (car L) ; altfel, elementul curent rămâne același din lista inițială
                  (modIndex (cdr L) ; iar restul listei îl "modific" corespunzător
                            (- index 1)
                            value))
            ))))

; exemplu
(modIndex '(1 2 3 4 5) 2 15)

; exemplu definire de funcții "scurtă"
(define (modIndex2 L index value)
  'corp)


; întoarce o listă cu elementele din L incrementate
(define incList
  (lambda (L)
    (if (null? L)
        '()
        (cons
         (add1 (car L)) ; obțin incrementul elementului
         (incList (cdr L))) ; incrementez și restul listei
        )))

; exemplu
(incList '(1 2 3 4 5))


; exemplu definire de funcții "scurtă"
(define (incList2 L)
  (if (null? L)
      '()
      (cons
       (add1 (car L))
       (incList2 (cdr L)))
      ))

; legarea unui alt nume pentru aceeași funcție
(define incL incList)
(incL '(1 2 3 4 5))


; întoarce o listă cu elementele pare dintr-o listă dată      
(define (evens L)
  (if (null? L)
      '()
      (if (even? (car L))
          (cons (car L)
                (evens (cdr L)))
          (evens (cdr L))
          )))

(evens '(1 2 3 4 5 6 7))

; soluție alternativă, în care introduc if-ul în expresia de concatenare
(define (evens2 L)
  (if (null? L)
      '()
      (append
       (if (even? (car L))
           (list (car L))
           '()
           )
       (evens2 (cdr L))
       )))

(evens2 '(1 2 3 4 5 6 7))