Zapoctove ukoly

[adam.korinek]

Tady je odkaz na zapoctove ukoly, az to budu mit hodim to sem vyresene

Zapoctove ukoly

[adam.korinek]

Tady jsou hotove zapoctove ukoly...
Delal jsem to cele sam, takze je mozne ze to neni uplne super a optimal ale snaha byla

kód:


;euklid
(define euclid (lambda (a b)
    (cond ((= a 0) b)
          ((= b 0) a)
          (else (euclid b (remainder a b))))))
;Why use accum (define/let) b is accum!!!
(euclid 24 9)
(euclid 17 25)
(euclid 270 192)
(define euclid1 (lambda (a b)
    (let eu ((a a)
            (b b))
      (cond ((= a 0) b)
          ((= b 0) a)
          (else (eu b (remainder a b)))))))
(euclid1 24 9)
(euclid1 17 25)
(euclid1 270 192)
;Counter
(define count (lambda (list)
                (foldr (lambda (value prevValue)
                        (if (empty? prevValue)
                            (cons (cons value 1) `())
                            (foldr (lambda (par prevListPart)
                                      (let ((upgade (cons (car par) (+ (cdr par) 1))))
                                      (if (eq? (car par) value)
                                          (if (eq? (car par) (caar prevListPart))
                                              (cons upgade (rest prevListPart))
                                              (cons upgade (remove (car (last-pair prevListPart)) prevListPart)))
                                              (if (eq? (car par) (caar prevListPart))
                                                  (cons par (rest prevListPart))
                                                  (cons par prevListPart)))))
                                    (cons (cons value 1) `()) prevValue)))
                      `() list)
                ))
(count `(1 3 3 1 3 3 1 1 5 1 1 3 5))
(count `(d b a c b b a))
;Histogram
(define histogram (lambda (list)
                    (let ((lst (foldr append `() list)))
;                      (count lst) ; Or you can use, comment rest
                      (foldr (lambda (value prevValue)
                        (if (empty? prevValue)
                            (cons (cons value 1) `())
                            (foldr (lambda (par prevListPart)
                                      (let ((upgade (cons (car par) (+ (cdr par) 1))))
                                      (if (eq? (car par) value)
                                          (if (eq? (car par) (caar prevListPart))
                                              (cons upgade (rest prevListPart))
                                              (cons upgade (remove (car (last-pair prevListPart)) prevListPart)))
                                              (if (eq? (car par) (caar prevListPart))
                                                  (cons par (rest prevListPart))
                                                  (cons par prevListPart)))))
                                    (cons (cons value 1) `()) prevValue)))
                      `() lst)
                      )))
(histogram `((0 100 80) (255 0 255) (0 100 255) (0 0 0)))
;map-index-pred
(define map-index-pred (lambda (pred proc list)
                        (let ((size  (length list)))
                          (let recurse ((index 0))
                            (if (< index size)
                                (cons (if (pred index)
                                          (proc (list-ref list index))
                                          (list-ref list index)) (recurse (+ index 1)))
                                `())
                            ))))
(map-index-pred odd? sqr `())
(map-index-pred odd? sqr `(2 3 4 5))
(map-index-pred (lambda(i) (< i 2)) - `(1 2 3 4 5))
;divided-by-three
(define divided-by-three? (lambda (list)
                          (eq? (let ((size (length list)))
                                  (let recurse ((index 0)
                                                (accum `a))
                                    (if (< index size)
                                        (let ((value (list-ref list index)))
                                          (recurse (+ index 1)
                                                  (cond
                                                    [(eq? accum `a)
                                                      (cond
                                                        [(eq? value 0) `a]
                                                        [(eq? value 1) `c]
                                                        [(eq? value 2) `b])]
                                                    [(eq? accum `b)                                     
                                                      (cond
                                                        [(eq? value 0) `b]
                                                        [(eq? value 1) `a]
                                                        [(eq? value 2) `c])]
                                                    [(eq? accum `c)
                                                      (cond
                                                        [(eq? value 0) `c]
                                                        [(eq? value 1) `b]
                                                        [(eq? value 2) `a])]))
                                          ) accum)
                                    )) `a)
                            ))
(divided-by-three? `(2 0 2 1 1))
(divided-by-three? `(0 1 2 2 2 2 1))


[adam.korinek]

Super kratka verze 4.2 a 4.3 ukolu

kód:


(require racket/list)
(define mycount (lambda (seznam)
                (let ((unikatniSeznam (remove-duplicates seznam)))
                  (foldr (lambda (prvek predchoziSeznam)
                          (cons (cons prvek (count (lambda (x) (eq? x prvek)) seznam)) predchoziSeznam))
                        `() unikatniSeznam))))
(define histogram (lambda (seznam)
                    (let ((spojeny-seznam (foldr append '() seznam)))
                      (mycount spojeny-seznam))))
(mycount '(3 1 3 2 1 2 3 3 3))
(mycount '(d b a c b b a))
(histogram '((0 100 80) (255 0 255) (0 100 255) (0 0 0)))


[Sponsored content]