Kolorwanie:
Status:
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417
;1. obliczającą długość listy------------------------------------------------------------------------

(define (dlugosc list)
( cond 
( (null? list) 0)
( else ( + 1 ( dlugosc (cdr list))))))

(display (dlugosc '(10 20 2 2 2 2 2 2)));

;2. obliczającą sumę elementów na liście ------------------------------------------------------------

(define (suma list)
( cond
( (null? list) 0 )
( else ( + (car list) ( suma (cdr list))))))

(newline)
(display (suma '(10 20 2 2 2 2 2 2)));
(newline)
;3. obliczającą iloczyn elementów na liście ---------------------------------------------------------
(define (iloczyn list)
( cond
( (null? list) 1 )
( else ( * (car list) ( iloczyn (cdr list))))))


(display (iloczyn '(10 20 2 2 2 2 2 2)));
(newline)
;4. obliczającą iloczyn skalarny dwóch list --------------------------------------------------------------------
(define (skalar l1 l2)
( cond
( (null? l1) 0)
( (null? l2) 0)
( else ( + ( * (car l1)(car l2)) (skalar (cdr l1) (cdr l2))))))

(display (skalar '(10 20) '(2 10)));


;5 obliczającą liczbę elementów na liście spełniających predykat----------------------------------------------
;(count_if '(3 5 2) odd?) => 2

(newline)

( define (count_if l1 pred)
( cond
( (null? l1) 0)
( (pred(car l1)) (+ 1 ( count_if (cdr l1) pred)))
( else ( count_if (cdr l1) pred))))

(display (count_if '(10 2 2 2 3 3 4 ) even?));
(newline)

;6. obliczającą liczbę elementów ookreślonej wartości w liście(count_elem '(1 1 2 3 1) 1) => 3--------------------

(define (count_elem list wartosc)
( cond
( (null? list) 0)
( (=(car list) wartosc) ( + 1 (count_elem (cdr list) wartosc)))
( else ( count_elem (cdr list) wartosc))))

(display (count_elem '(10 2 2 10 10 3 3) 3 ));
;7.przyjmującą listę i predykat, elementy, które spełniają ten predykat powinny być ---------------------------
;przekopiowane do listy wynikowej
;(copy_if '(1 2 3 4 5) odd?) => (1 3 5)
;
(newline)

(define ( copy_if list pred)
( cond 
( (null? list) '())
( (pred(car list)) ( cons (car list) (copy_if (cdr list) pred)))
( else ( copy_if (cdr list) pred))))

(display (copy_if '(10 2 2 3 14 15) odd?));

;8.tworzącą listę, której elementy są kolejnymi sumami elementów dwóch list----------------------------------
;(suma-list '(1 2 3) '(1 2 3)) => (2 4 6)
(newline)

(define ( suma-list l1 l2)
( cond 
( (null? l1) l2)
( (null? l2) l1)
( else (cons (+ (car l1) (car l2)) (suma-list (cdr l1) (cdr l2))))))

(display (suma-list '(10 20 30 40) '(1 2 3 4)))

;9.--tworzącą listę zawierającą n określonych parametrem liczb---------------------------------------------------
;(wypelnij 10 3) => (10 10 10)
(newline)

(define (wypelnij liczba n)
(cond 
( (= n 0) '())
( else ( cons liczba ( wypelnij liczba (- n 1))))))

(display (wypelnij 10 3))

(newline)
;10.znajdującą maksymalny element na liście(maksymalna '(4 2 10 1))=> 10-----------------------------------
(define (maksymalna list)
(define (pomocnicza n list)
( cond 
( (null? list) n)
( (> (car list) n) ( pomocnicza (car list) (cdr list)))
( else ( pomocnicza (- n 1) (cdr list)))))
(pomocnicza 1 list))

(display (maksymalna '(10 2 3 45 10 22 40)))

(newline)
;11.-znajdującą i zwracającą pierwszy element spełniający predykat-----------------------------------------
;( => 3

(define (pierwszy list pred)
( cond 
( (null? list) 0)
( (pred(car list)) (car list))
( else ( pierwszy (cdr list) pred))))

(display (pierwszy '(10 2 3 41 15 2) odd?))

;12.-tworzącą listę zawierającą elementy z listy docelowej zmodyfikowane przekazywaną jako-------------------
;drugi parametr funkcją
;(mapa '(4 16 36) sqrt) => (2 4 6)

(newline)

(define (mapa list fun)
( cond  
( (null? list) '())
( else  (cons (fun(car list)) (mapa (cdr list) fun)))))

(display (mapa '(10 9 25 100) sqrt))
(newline)

;13 ciag geometryczna
(define (geometr a n q)
(define (pomoc a n)
( cond
( (= n 0) '())
( else ( cons a (pomoc (* a q) (- n 1))))))
(pomoc 1 n))

(display (geometr 5 5 5))

;14. arytmetyczny
(newline)
(define (arytm a n q)
(define (pomoc a n)
( cond
( (= n 0) '())
( else ( cons a (pomoc (+ a q) (- n 1))))))
(pomoc 1 n))

(display (arytm 5 5 5))

;15 szescian 
(newline)
(define (szescian list)
( cond 
( (null? list) '())
( else (cons(* (car list) (car list) (car list)) (szescian (cdr list))))))

(display (szescian'(10 20 30 40 50)));

;16 pole kwadratu
(newline)
(define (kwadrat a b)
( * a b))
(display (kwadrat 2 3))
;16b pole kwadratu - lista
(define (kwadratb l)
( cond 
( (null? l) '())
( else (cons (* (car l) (car l)) (kwadratb(cdr l))))))
(newline)
(display (kwadratb '(10 20 30 40 50 60)))
;17 srednia arytmetyczna
(newline)
(define (sarytm list)
(define (pomoc acc list)
( cond
( (null? list) acc)
( else (pomoc (+ acc (car list)) (cdr list)))))
(define (dlugosc acc list)
( if(null? list) acc ( dlugosc (+ acc 1) (cdr list))))
(/(pomoc 0 list) (dlugosc 0 list)))

(display (sarytm '(10 20 40 50 22)));
---------------------------------------------------KODY Z LABEK --------------------------------------------------------------------------------------------------------------------
; LAB 7.1
(newline)
 
(define jasiek
 (* 2(/ (- 5 3) (+ (* 4 2) (* 3 8)))))
 (newline)
 (display jasiek)
; LAB 7.2
(define (stopnie x)
( /(- x 32) 1.8))
 
(display (stopnie 5))
 
 
 
 
(newline)
(newline)
; LAB 7.4
(define (delta a b c)
 (- (* b b) (* 4(* a c))));b^2 - 4ac
 
(display ( delta 4 3 1))
 
 
(newline)
 
(newline)
; LAB 7.3
(define (fib x)
( cond
( (= x 0) 0)
( (= x 1 ) 1 )
( else ( + (fib (- x 1)) (fib (- x 2))))))
 
 
; LAB 7.6 nie chcialo mi sie konczyc, leci tak samo w COND
(define ( ocena x)
( cond
( (> x 90) 5.0)
( (and (> x 80) (<= x 90)) 4.5)
( (and (> x 70) (<= x 80)) 4.0)
( else 2.0)))
 
(display (ocena 78))
 
;------ delta---------------------
(define (delta a b c)
 (- (* b b) (* 4(* a c))));b^2 - 4ac
(newline)
;------- suma--------------------- pamietac + a nie cons, ;poruszanie sie po liscie (car list) i cdr list - rekurencja
(define (sum  list)
( if( null? list) 0
 (+ (car list) ( sum( cdr list)))))
 
(display (sum '(10 23 20)))
(newline)
;--------dlugosc-------------- pamietac + a nie cons,
;-cons to do tworzenia nowej listy;) a + do zliczenia czegos
; w liscie np dlugosc - rekurencja
(define (dl list)
( if(null? list) 0
(+ 1 (dl ( cdr list)))))
 
(display ( dl '(1 2 3 3 3 3 3)))
(newline)
 
;-------ostatni------------ zastosowanie rekurencji
;pamietac ze ostatni element jest pusty
(define (ostatni list)
( if(null? (cdr list)) (car list)
( ostatni (cdr list))))
 
(display (ostatni '( 2 )))
;-------ostatni ------ zagniezdzona
 
;----- dodawanie ilus tam jedynek ;) 10 + rekurencja
; rekurencja - zmniejszanie licznika
(define (jedynki n)
( if(= n 0) '()
(cons 1 (jedynki(- n 1)))))
(newline)
 
(display ( jedynki 10))
(newline)
;LAB 9.2
;---- jedynki -- zagniezdzona - zachowuje sie tak jak tablica i wskaznik , chodzenie po tablicy
(define (jedynkii n)
(define (pomocnicza i)
(if(= n i) '()
( cons 1 (pomocnicza(+ i 1 )))))
(pomocnicza 0))
(display (jedynkii 5))
(newline)
;------ tworzenie nowej listy dla ktorej mamy sqrt;)
;- pamietac arg. pom przed list, uzywamy cons - rekurencja
(define (mapa pom list )
( if(null? list) '()
(cons(pom(car list)) (mapa pom(cdr list)))))
(newline)
(display (mapa sqrt'(10 20 30 40 50) ))
(newline)
 
;---- LAB9
;LAB9.1 - a tak se zrobilem a co
(define (stworz-dodaj n)
(let (
(x 3)
)( + x n)
))
(display (stworz-dodaj 3))
;LAB 9.1 - lambda
 
(define (stw-dod y)
( lambda (c) (+ c y))) ; ok - nie wiem jak wyswietlic
(newline)
;(display (( stw-dod 3) 5)
 
;LAB 9.3
(define (dolacz l1 l2) ; nazw_funk = dolacz + 2 para. = nasze 2 listy ;)
(if(null? l1) l2 ; jesli pusta l1 to l2 tylko :)
( cons (car l1) (dolacz (cdr l1)l2)))); jesli nie to do 1 elementu listy 1 dolaczamy rekurencyjnie reszte z listy 1 i cala liste l2 ;)
(display( dolacz '( 1 2 3) '(22 33 44)));
(newline)
;zagniezdzona
 
;LAB 9.4
(define (n-TY n list)
(define (pom i list)
 (if(= i n);if(null? list) '()
 (car list)
 (pom(+ i 1)(cdr list))))
(pom 1 list))
 
(display (n-TY 2 '(1 2 3 19 3)));
;( define (n-ty n el list)
;( if(null? list) '()
;( if(= n el) (car el list)
;(n-ty (- n 1) (cdr list)
 
(newline)
;(define (n-ty-element n list)
 ; if(= n 5) (car (list)) (n-ty-element (- n 1) cdr list;))
 
;  (display (n-ty-element 5 '(10 230 5 32 5)));
 
 
;LAB9.5 - good
 
(define (wstaw-nty co gdzie list)
(define (pom i list)
(if(= gdzie i) (cons co list) ; cons (n) (list) - 2 parametry - n do list
( cons (car list) (pom (+ i 1) (cdr list)))))
(pom 1 list))
(display (wstaw-nty 99 6 '( 1 2 3 4 4 4 10 24)));
 
 
(newline)
(newline)
 
;LAB 9.6
 
 
;(define (przechowuj pred list  )
;((if( pred(car list)) (car list)
;( przechowuj pred ( cdr list) ))))
 
;(display ( przechowuj odd? '(10 15 20 25 30 45 50) ))
 
 
(newline)
(newline)
; LAB10 - ogoonowe -rekurencja
 
; jeszcze zobaczyc
(newline)
 
(define (potr a n)
  (define (pomoc wynik n)
    (if (= n 0) wynik (pomoc (* wynik a) (- n 1))))
    (pomoc 1 n))
   
(display (potr 8 2))
 
(newline)
(define (dlugosc list)
(define (pomocnicza wynik list)
( if (null? list) wynik
( pomocnicza (+ wynik 1) (cdr list))))
(pomocnicza 0 list))
 
(display (dlugosc '(1 2 3 34 32 12 42)))
 
 
(newline)
(define (suma list)
(define (pomocnicza wynik list)
( if (null? list) wynik
( pomocnicza (+ wynik (car list)) (cdr list))))
(pomocnicza 0 list))
 
(display (suma '(1 2 3 34 32 12 42)))
 
(newline)
 
(define (max list)
(define (pomocnicza wynik list)
( if (null? list) wynik
( pomocnicza (
  if(> (car list) wynik) (car list) wynik)
(cdr list))))
(pomocnicza (car list) list))
 
(display (max '(1 2 3 34 32 12 42)))
 
(newline)
 
(define (fib n)
  (define (pomocnicza n)
  (cond
  ((= n 0) 0)
  ((= n 1) 1)
  ((> n 1) (+ (pomocnicza (- n 1)) (pomocnicza (- n 2))))))
  (pomocnicza n))
 
  (display (fib 10))

Copyrights 2014-2018 © Wklejaj.pl Wszelkie prawa zastrzeżone.