mp3

#lang racket

(define (gcd x y)
  (cond ((= y 0) x)
        (else (gcd y (modulo x y)))))
#|   pary
(define (make-rat n d)
  (let ([g (gcd n d)])
    (cons (/ n g) (/ d g))))

(define (rat-num x) (car x))

(define (rat-den x) (cdr x))

(define (rat? x)
  (and(pair? x)
      (not (= (rat-den x) 0))
      (= x (gcd (rat-num x) (rat-den x)))))
|#
(define (make-rat n d)
  (let ([g (gcd n d)])
    (list (/ n g) (/ d g))))

(define (rat-num x) (car x))

(define (rat-den x) (car (cdr x)))

(define (rat? x)
  (and(pair? x)
      (not (= (rat-den x) 0))
      (= 1 (gcd (rat-num x) (rat-den x)))
      (null? (cdr (cdr x)))))

(define (print-rat x)
  (newline)
  (display (rat-num x))
  (display "/")
  (display (rat-den x)))

(define (add-rat x y)
  (make-rat (+ (* (rat-num x) (rat-den y))
               (* (rat-num y) (rat-den x)))
            (* (rat-den x) (rat-den y))))
(define (sub-rat x y)
  (make-rat (- (* (rat-num x) (rat-den y))
               (* (rat-num y) (rat-den x)))
            (* (rat-den x) (rat-den y))))
(define (mul-rat x y)
    (make-rat (* (rat-num x) (rat-num y))
              (* (rat-den x) (rat-den y))))
(define (div-rat x y)
    (make-rat (* (rat-num x) (rat-den y))
              (* (rat-den x) (rat-num y))))
;; zad 2
( define ( display-point p )
( display "(")
( display ( point-x p ) )
( display ", ")
( display ( point-y p ) )
( display ")") )
( define ( display-vect v )
( display "[")
( display-point ( vect-begin v ) )
( display ", ")
( display-point ( vect-end v ) )
( display "]") )

(define (make-point x y)
  (cons x y))
(define (point? p)
  (pair? p))
(define (point-x p)
  (car p))
(define (point-y p)
  (cdr p))
(define (make-vect p1 p2)
  (cons p1 p2))
(define (vect-begin v)
  (car v))
(define (vect-end v)
  (cdr v))
(define (vect? v)
  (and (pair? v)
       (point? (vect-begin v))
       (point? (vect-end v))))
(define (vect-length v)
  (let ((x (- (point-x (vect-begin v)) (point-x (vect-end v))))
        (y (- (point-y (vect-begin v)) (point-y (vect-end v)))))
    (sqrt (+ (* x x) (* y y)))))
(define (vect-scale v k)
  (let ((b (vect-begin v))
        (e (vect-end v)))
    (make-vect b (make-point
            (+ (point-x b) (* k (- (point-x e) (point-x b))))
            (+ (point-y b) (* k (- (point-y e) (point-y b))))))))
(define (point-translate p t)
  (make-point (+ (point-x p) (point-x t))
              (+ (point-y p) (point-y t))))
(define (vect-translate v p)
  (make-vect (point-translate (vect-begin v ) p)
             (point-translate (vect-end v) p)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;zad 3
(define (make-vect3 p a l)
  (cons p (cons a l)))
(define (vect-length3 v)
  (cdr (cdr v)))
(define (vect-scale3 v k)
  (make-vect3 (car v) (car (cdr v)) (* k (cdr (cdr v)))))
(define (vect-translate3 v p)
  (make-vect3 (point-translate (car v p)) (car (cdr v)) (cdr (cdr v))))
(define (vect-end3 v)
  (make-point (+ (point-x (car v)) (* (sin (car (cdr v))) (vect-length3 v)))
              (+ (point-y (car v)) (* (cos (car (cdr v))) (vect-length3 v)))))
( define ( display-vect3 v )
( display "[")
( display-point ( vect-begin v ) )
( display ", ")
( display-point ( vect-end3 v ) )
( display "]") )

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;zad 4

(define (append xs ys)
  (if (null? xs)
      ys
      (cons (car xs) (append (cdr xs) ys))))

(define (reverse-iter l)
  (define (iter ok todo)
    (if (null? todo)
        ok
        (iter (cons (car todo) ok) (cdr todo))))
  (iter null l))

(define (reverse l)
  (if (null? l)
      null
      (append (reverse (cdr l)) (list (car l)))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;zad 5
(define (insert xs n)
  (cond [(null? xs) (list n)]
        [(< n (car xs)) (cons n xs)]
        [else (cons (car xs) (insert (cdr xs) n))]))

(define (insert-iter xs n)
  (define (iter front back)
    (cond [(null? back) (iter front (list n))]
          [(< n (car back)) (iter front (cons n back))]
          [else (iter (cons (car back) front) (cdr back))]))
  (iter null xs))

(define (insert-sort xs)
  (define (iter ok todo)
    (if (null? todo)
        ok
        (iter (insert ok (car todo)) (cdr todo))))
  (iter (list (car xs)) (cdr xs)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;zad 6
(define (insert-at l x at)
  (if (= at 0)
      (cons x l)
      (if (null? l)
          (cons x null)
          (cons (car l) (insert-at (cdr l) x (- at 1))))))
(define (length xs)
  (if (null? xs)
      0
      (+ 1 (length (cdr xs)))))

#|
(define (permi xs)
  (if (null? xs)
      null
      (
|#