#lang racket
(define (suma x y)
 (+ x y))

; po średniku pisze się komentarze
; to jest język funkcyjny (scheme)
; w funkcjach nie można zmieniać stanu zmiennych
; tutaj rolę pętli pełni rekurencja
;suma(10,20) - C++ (wywołanie funkcji)
(suma 10 20)

; 2 + 2
(+ 2 2)

(define x -1)

; wyrażenie warunkowe
(if (> x 0) ; sprawdzanie (za pomocą NP)
    "X dodatnie" ; jeśli spełnione
    "X niedodatnie") ; jeśli niespełnione
; oba muszą wystąpić

; coś a'la switch.. case
(cond
  ((> x 0) "x dodatnie")
  ((< x 0) "x ujemne")
  (else "x == 0"))

; tworzenie zmiennych lokalnych
; lety można zagnieżdżać
; nie można korzystać np. że (a 10) (b a) [b nie widzi a]
(let ((a 10) (b 20))
  (+ a b))

; tworzenie listy
; typy elementów w liście mogą być różne (można je też zagnieżdżać)
(list 1 2 3 4)

; ZAD 1
"Zad. 1"
(newline)

; Zdefiniować w języku Scheme następujące wyrażenia:

; (45 + 33) * 123.0/4
(* (+ 45 33) (/ 123.0 4))
; 2 * (5 3)/(4 * 2 + 3 * 8)
(/ (* 2 (+ 5 3)) (+ (* 4 2) (* 3 8)))
; (122 + (4 – 3) + 15 * 10)/20.4
(/ (+ 122 (+ (- 4 3) (* 15 10))) 20.4)

; ZAD 2
"Zad. 2"
(newline)
; Zdefiniować funkcję zamieniającą stopnie Fahrenheita na stopnie Celsjusza

(define (ToCelsius temp)
  (* (- temp 32) (/ 5 9)))

(ToCelsius 0)

; ZAD 3
"Zad. 3"
(newline)
; Zdefiniować funkcję obliczającą deltę równania kwadratowego

(define (rownanieKwadratowe w1 w2 w3)
  (- (* w2 w2) (* 4 w1 w3)))

(rownanieKwadratowe 2 4 1)

; ZAD 4
"Zad. 4"
(newline)
; Zdefiniować funkcję obliczającą pierwiastki równania kwadratowego w dziedzinie liczb
; rzeczywistych.
; TODO: NIE DZIALA PRAWIDLOWO

(define (pierwiastki t1 t2 t3)
  (let ((delta (rownanieKwadratowe t1 t2 t2)))
    (cond
      ((> delta 0) (list (/ (- (- t2) (sqrt delta)) (* 2 t1)) (/ (+ (- t2) (sqrt delta)) (* 2 t1))))
      ((< delta 0) "brak rozwiazan")
      (else (/ (- t2) (* 2 t1))))))


(pierwiastki 3 4 1)

;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Ogarnianie list ;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;

(define lst '(1 2 3))
; apostrof zapobiega interpretowaniu tego co jest w nawiasach jako funkcji, tylko jako elementy listy
(null? lst) ; sprawdza czy pusta (#f - false)
(cons 1 lst) ; wstawiona lista jako pierwszy element ( '(1 1 2 3 ) (listy mozna traktować jako pary
; pierwszy element to "głowa" a drugi to "ogon"
(list 1 lst) ; '(1 (1 2 3))
(car lst) ; pobranie "głowy" listy
(cdr lst) ; pobranie "ogona" listy

; w językach funkcyjnych nie ma pętli więck korzystamy z rekurencji


; Żeby zbudować listę wynikową trzeba użyć cons (podobnie w 10)
; W 11 trzeba scalić dwie listy [rekurencja]
; 12, 13 i 14 są podobne (jak sprawdzić na którym miejscu znajdujemy się na liście) np. zmniejszać n aż zejdzie do zera

; ZAD 5
"Zad. 5"
(newline)

(define (ocena pkt)
  (cond
  ((> pkt 90) "Ocena 5")
  ((> pkt 80) "Ocena 4.5")
  ((> pkt 70) "Ocena 4.0")
  ((> pkt 60) "Ocena 3.5")
  ((> pkt 50) "Ocena 3.0")
  (else "Ocena 2.0")))

(ocena 49)

; ZAD 6
"Zad. 6"
(newline)

; Zdefiniować funkcję sum obliczającą sumę wszystkich elementów w liście.

(define (sumaLista lilista)
      (if (null? lilista)
      0
      (+ (car lilista) (sumaLista (cdr lilista)))))

(sumaLista (list 1 2 3 4))

; ZAD 7
"Zad. 7"
(newline)

; Zdefiniować funkcje dlugosc obliczającą długość listy

(define (dlugosc lst)
  (if (null? lst)
      0
      (+ 1 (dlugosc (cdr lst))))) ; żeby pozbywać się elementów przy rekurencji, aby policzyć kolejne elementy, pobieramy ogon

(dlugosc (list 1 2 3 4 5 6 12 13)) ; dziala :D
(dlugosc lst)

; ZAD 8
"Zad. 8"
(newline)

; Zdefiniować funkcję ostatni zwracającą ostatni element listy

(define (ostatniElement lapista)
  (if (= (dlugosc lapista) 1)
      (car lapista)
      (ostatniElement (cdr lapista))))

(ostatniElement (list 1 2 9 33 324 123486 389))

; ZAD 9
"Zad. 9"
(newline)

; Zdefiniować funkcję mapa tworzącą listę elementów z listy źródłowej dla której zadano funkcję
; przekazywaną jako parametr np. dla wywołania (mapa sqrt '(1 4 16)) wynikiem ma być (1 2 4).

(define (mapa funkcja kolejnaLista)
   (if(null? kolejnaLista)
      null
      (cons (funkcja (car kolejnaLista)) (mapa funkcja (cdr kolejnaLista)))))

(mapa sqrt'(1 4 16))

; ZAD 10
"Zad. 10"
(newline)

; Zdefiniować funkcję przechowaj przyjmującą listę i predykat, elementy, które
; spełniają ten predykat powinny być przekopiowane do listy wynikowej np.(przechowajspelniajacepredykat '(1 2 3 4) odd?)
; powinno zwrócić listę (1 3).\
; TODO: NIE DZIALA

(define (przechowaj nextList predykat)
  (define listaWynikowa'())
  (if (null? nextList)
     listaWynikowa
     (if (predykat (car nextList))
        (cons (car nextList) (przechowaj (cdr nextList) predykat))
     (przechowaj (cdr nextList) predykat))))

 (przechowaj '(1 2 3 4 5 6 7 8 11 17 19 22) odd?)

; ZAD 11
"Zad. 11"
(newline)

; Zdefiniować funkcje dolacz łączącą dwie listy w jedną listę wynikową np. (dolacz '(1 2 3 4) '(5 6))
; powinno zwrócić listę (1 2 3 4 5 6).

;(define (dolacz lista1 lista2)
;  (if (null? lista2)
;      lista1
;      (dolacz lista1 (cons lista1 (cdr lista2)))))

(define (dolacz lst1 lst2)
  (if(null? lst1)
     lst2    (cons (car lst1) (dolacz (cdr lst1) lst2))))
(dolacz '(1 2 3) '(4 5 6))

(dolacz (list 1 2 3 4) (list 5 6))

; Zad 12
; Zdefiniować funkcję jedynki tworzącą listę zawierającą n jedynek – n przekazywane jako argument funkcji np. (jedynki 4) powinno zwrócić listę (1 1 1 1).
"Zad. 12"
(newline)

(define (jedynka n)
  (define duzoJedynek'())
  (if (= n 0)
     duzoJedynek
     (cons 1 (jedynka (- n 1)) )
  ))

(jedynka 11)

; Zad 13
; Zdefiniować funkcję n-ty-element znajdującą n-ty element listy.
"Zad. 13"
(newline)

(define (ntyelement n elementy)
  (if (= n 1)
     (car elementy)
     (ntyelement (- n 1) (cdr elementy)) ))

(define duzoCyckow'(1 2 3 4 5 6 7 8 9 10))

(ntyelement 5 duzoCyckow)

; Zad 14
; Zdefiniować funkcję wstawnty wstawiającą do listy element na pozycji ntej.
"Zad. 14"
(newline)

(define (wstawnty n elementy elemelele)
  (if (= n 1)
     (cons elemelele elementy)
     (cons (car elementy) (wstawnty (- n 1) (cdr elementy) elemelele))))

(wstawnty 5 duzoCyckow "ochnascie")