lisp.txt

#lang planet neil/sicp

(define (czy-podzielnee? a b)
  (= (remainder b a) 0))

(define (czy-p n)
  (and #t (cond ((= n 1) #f)
         (else (czy-p-iter n 2 0)))))

(define (czy-p-iter n x c)
  (cond ((and (= n x) (<= c 0)) #t)
        ((czy-podzielnee? n x) (czy-p-iter n (+ x 1) (+ c 1)))
        ((and (< x n) (<= c 0)) (czy-p-iter n (+ x 1) c))
        (else #f)))

(czy-p 1)
(czy-p 2)
(czy-p 3)
(czy-p 4)
(czy-p 5)
(czy-p 6)
(czy-p 7)

(define (square x) (* x x))
(define (sum-of-squares x y) (+ (square x) (square y)))

(define (fun x y z) (if (and (> x z) (> y z)) (sum-of-squares x y)
                        (if(and(> x y) (> z y)) (sum-of-squares x z)
                           (sum-of-squares y z))))

(define (average x y)
  (/ (+ x y) 2))

(define (good-enough? guess x)
  (< (abs (- (square guess) x)) 0.001))


(define (improve guess x)
  (average guess (/ x guess)))

(define (sqrt-iter guess x)
  (if (good-enough? guess x)
      guess
      (sqrt-iter (improve guess x) x)))

(define (sqrt x) (sqrt-iter 1.0 x))



(define (for x y)
  (if (< x y) (pom x y)
      
      ))

(define (pom x y)
   (display (sqrt x))
   (newline)
   (for (+ x 1) y)
 )

(for 2 5)

; Ackerman - funkcja
(define (A x y)
  (cond ((= y 0) 0)
        ((= x 0) (* 2 y))
        ((= y 1) 2)
        (else (A (- x 1) (A x (- y 1))))))
(A 1 10)
(A 2 4)
(A 3 3)

; fibonacci
(define (fib n)
  (cond ((= n 0) 0)
        ((= n 1) 1)
        (else (+ (fib (- n 1)) (fib (- n 2))))))

(fib 1)
(fib 4)
(fib 10)

; NWD
(define (NWD a b)
  (if (= b 0)
      a
      (NWD b (remainder a b))))

(NWD 40 60)
(NWD 6 4)

; czy liczba pierwsza - prime
(define (czy-podzielne? a b)
  (= (remainder b a) 0))

(define (znajdz-dzielenik n x)
  (cond ((> (square x) n) n)
        ((czy-podzielne? x n) x)
        (else (znajdz-dzielenik n (+ x 1)))))

(define (najmniejszy-dzielnik n)
  (znajdz-dzielenik n 2))

(define (czy-liczba-pierwsza? n)
  (= n (najmniejszy-dzielnik n)))

(display "czy pierwsza")
(newline)
(czy-liczba-pierwsza? 1)
(czy-liczba-pierwsza? 3)
(czy-liczba-pierwsza? 4)
(czy-liczba-pierwsza? 5)
(czy-liczba-pierwsza? 6)
(czy-liczba-pierwsza? 7)

; potega zad 7
(define (expt b n)
  (expt-iter b n 1))

(define (expt-iter b counter product)
  (if (= counter 0)
      product
      (expt-iter b (- counter 1) (muliply-by-add product b))))

(define (muliply-by-add a b)
  (muliply-by-add-iter a (- b 1)))

(define (muliply-by-add-iter a b)
  (if (<= b 0)
      a
      (+ a (muliply-by-add-iter a (- b 1)))))  

(display "mozenie dodawaniem")
(muliply-by-add 1 1)
(muliply-by-add 1 2)
(muliply-by-add 2 2)
(muliply-by-add 3 2)
(newline)
(muliply-by-add 2 3)
(muliply-by-add 2 5)
(muliply-by-add 2 10)
(muliply-by-add 10 2)

(newline)
(expt 2 5)
(expt 5 2)