PROCEDURES IN SCHEME: Procedure dediğimiz şey fonksiyon gibidir.(procedure-name argument-1 .... argument-n)
PAIRS: cons fonksiyonu girilen argumanları pair yapar.
>(cons 1 2)
(1 . 2)
>(cons (cons 1 2) 3)
((1 . 2) . 3)
LISTS:
Listler pairlardan oluşur.
>(cons 1 (cons 2 null))
'(1 2)
>(define my-list (cons 1 (cons 2 (cons 3 null))))
>my-list
'( 1 2 3)
Genel olarak şu şekilde yazabiliriz.
list (el-1 el-2 el-3 .....el-n)
(cons el-1 (cons el-2 (cons el-3 (cons el-4 null))))
Scheme de listelere istediğimiz şeyleri yazabiliriz.
>(define lst (list 1 2 3 'a 'b 'c "hello"))
lst
'( 1 2 3 a b c "hello")
Örnek: Bir fonksiyon yazalım bizden bir sayı alsın ve 0 dan o sayıya kadar olan sıralamayı bize liste olarak yazdırsın.
>(define (compile-list-helper x lst)
(cond[(zero? x) (append (list 0) lst)]
[else (compile-list-helper (- x 1) (append (list x) lst))]))
>(define (compile-list num)
(compile-list-helper num empty)) ; basta elimizdeki listenin empty oldugunu gosteriyor. Bu fonksiyonun calısması için bir helper fonksyon yazalım ve onu bu fonksyonun uzerine yazalım.
Bir de listeler için car cdr gibi özellikler var. car listenin ilk elemanı , cdr ise listenin ilk elemanını çıkardığımızda kalan halidir.car ile first , cdr ile rest fonksiyonu aynıdır.
>(define lst (list 1 2 3 'a 'b 'c "hello"))
>(first lst) => 1
>(car lst) => 1
>(rest lst) => '(2 3 a b c "hello")
>(cdr lst) => '(2 3 a b c "hello")
Bir de caddr cdddr gibi bunların kompleks hali var.Bunları sondan okumaya başlıyoruz.Mesela cadr ise önce listenin cdr sini alıcaz sonra cdr listesinin car ını alıcaz.Yani daha açık haliyle önce ilk elemanı çıkarıp kalan listeyi elde edicez ve cdr yi elde etmiş olcaz.Sonra kalan listenin ilk elemanını alıcaz.Bu şekilde cdr nin car ını alıcaz yani cadr.
>(define lst (list 1 2 3 'a 'b 'c "hello"))
>(cadr lst) => 2
>(caddr lst) => 3
>(cdddr lst) =>'(a b c "hello")
>(equal? (list 1 2 3) lst) =>list ile lst yi karşılaştırır.True ya da false döndürür.
#f
Örnek: Bir procedure yazalım.Bir liste ve bir sayı alsın.Mesela 0 girdiysem listenin ilk elemanını, 1 girdiysem 2. elemanını, 3 girdiysek 2. elemanını göstersin.
>(define (my-list-ref lst n)
(cond[(zero? n) (car lst)]
[else (my-list-ref (cdr lst) (- n 1))]))
(my-list-ref (list 'a 'b 'c 'd) 1)
'b
(my-list-ref (list 'a 'b 'c 'd) 3)
'd
Örnek: Verilen bir listedeki seçtiğimiz bir elemanın kaç tane olduğunu bulan kod yazalım.Mesela
(member-count '(1 1 2 2 3 4 4 5 5 5) 5) => 3 outputunu vermeli.
>(define (member-count-helper counter lst member)
(cond[(null? lst) counter]
[(eq? (car lst) member) (member-count-helper (+ counter 1) (cdr lst) member) ]
[else (member-count-helper counter (cdr lst) member)]))
(define (member-count list member1)
(member-count-helper 0 list member1))
ya da
>(define (member-count list member)
(if (null? list)
0
(if (= (car list) member)
(+ 1 (member-count (cdr list) member))
(member-count (cdr list) member)
)
))
USING LET TO DEFINE LOCAL VARIABLES:
Mesela elimizde f fonksiyonu olsun ve şu şekilde tanımlanmış olsun.
f(x,y) = x(1+xy)^2 + y(1-y) + (1+xy)(1-y)
a= (1 + xy)
b= (1 - y)
O zaman f(x,y) = xa^2 + yb + ab olur.
>(define (f x y)
(define a (+ 1 (* x y)))
(define b (- 1 y))
(+ (* x (* a a)) (* y b) (* a b)))
>(define (f x y)
(let ((a (+ 1 (* x y)))
(b (- 1 y)))
(+ (* x (* a a)) (* y b) (* a b))))
>(define (f x y)
((lambda ( a b)
(+ (* x (* a a)) (* y b) (* a b)))
(+ 1 (* x y))
(- 1 y)))
Let in genel şeklini yazacak olursak:
(let ((var-a (def-a))
(var-b (def-b))
..........
(var-n (def-n)) (body))
Lamda ile Türev: D = f(x+dx) -f(x) şeklindedir.
dx
>(define (cube x) (* x (* x x)))
>(define (deriv f dx)
(lambda (x)
(/ (- (f (+ x dx)) (f x)) dx)))
((deriv cube 0.001) 5)
75.01500100002545 sonucunu alırız.
Lambda genel şekilde yazılırsa:
(lambda (<parameters>) (body))
LAMBDA
Procedure ları lambda kullanarak yazabiliriz.
>(define (plus4 x) (+ x 4))
>(define plus4 (lambda (x) (+ x 4)))
Örnek: İkili bir liste girdiğimizde 2.elemanı büyük olan pairin ilk elemanını gösteren kod yazalım:
Mesela '((2 3)(3 7) (7 98) (1 34) (9 45)) bu listede en büyük ikinci eleman 98 dir.Onun başındaki eleman olan 7 yi output olarak vermeli.
>(define (find-largest list largest element)
(cond[(null? list) element]
[(> (cadar list) largest) (find-largest (cdr list) (cadar list) (caar list))]
[else (find-largest (cdr list) largest element)]))
(find-largest '((2 3)(3 7) (7 98) (1 34) (9 45)) 0 0)
7
Örnek : Listedeki elemanı silen kod yazınız:Mesela '((2 3)(3 7) (19 98) (1 34) (9 45)) '(3 7)
'((2 3) (19 98) (1 34) (9 45)) olsun.
>(define (f list n)
(cond ((null? list) '())
((equal? (car list) n) (cdr list))
(else (cons (car list) (f (cdr list) n)))))
(f '((2 3)(3 7) (19 98) (1 34) (9 45)) '(3 7))
'((2 3) (19 98) (1 34) (9 45))
Örnek : Listeyi istediğimiz şekilde sıralayan kod yazalım: Mesela:'((-5 3) (9 17) (8 32) (3 6)) descending
dediğimizde '((9 17) (8 32) (3 6) (-5 3)) olsun.
>(define (ascending a b)
(if (< a b)
#t
#f))
(define (descending a b)
(if (> a b)
#t
#f))
(define (remove-list list element)
(cond[(null? list) '()]
[(= (car element) (caar list)) (cdr list)]
[else (cons (car list)(remove-list (cdr list) element))]))
(define (find-order list element sort-type)
(cond[(null? list) element]
[(sort-type (caar list) (car element)) (find-order (cdr list) (car list) sort-type)]
[else (find-order (cdr list) element sort-type)]))
(define (sort-list list sort-type)
(if (null? list) list
(cons (find-order list (car list) sort-type) (sort-list (remove-list list (find-order list (car list) sort-type)) sort-type))))
(sort-list '((-5 3) (9 17) (8 32) (3 6)) descending)
'((9 17) (8 32) (3 6) (-5 3))
MAP:
>(map + '(1 2 3) '(4 5 6))
'(5 7 9)
>(map (lambda (x) (* x x)) '(1 2 3))
'(1 4 9)
SORTING:
>(sort '(8 6 7 2 -1 4 3) <)
'(-1 2 3 4 6 7 8)
LOCAL VARIABLE:
>(let ((i 2) (j 3))
(* i j))
6
>(let ((i 1))
(let ((j (+ i 1)))
(+ i j)))
3
>(let* ((i 1) (j (+ i 2)))
(* i j))
3
>(reverse '(1 2 3 4 5))
'(5 4 3 2 1)
karekok
(define (sqrt x)
(the y (and (>= y 0) (= (square y) x))))
Hiç yorum yok:
Yorum Gönder