p1 lpp

#lang r6rs
(import (rnrs)
        (schemeunit ))
;;Ejercicio 1 : binario-a-decimal

;;a)

(define (binario-a-decimal b3 b2 b1 b0)
       (+ (* b3(expt 2 3))
          (* b2(expt 2 2))
          (* b1(expt 2 1))
          (* b0(expt 2 0))
       )

)
(display "Probando binario-a-decimal\n")
(check-equal? (binario-a-decimal 1 1 1 1) 15)
(check-equal? (binario-a-decimal 0 1 1 0) 6)
(check-equal? (binario-a-decimal 0 0 1 0) 2)

;;b) binario-a-hexadecimal

(define (binario-a-hexadecimal b3 b2 b1 b0)
  (if (> (binario-a-decimal b3 b2 b1 b0) 9)
      (integer->char (+ (binario-a-decimal b3 b2 b1 b0) (- (char->integer #\A) 10)))
      (integer->char (+ (binario-a-decimal b3 b2 b1 b0)(char->integer #\0))))

)
(display "Probando binario-a-hexadecimal\n")
(check-equal? (binario-a-hexadecimal 1 1 1 1) #\F)
(check-equal? (binario-a-hexadecimal 0 1 1 0) #\6)
(check-equal? (binario-a-hexadecimal 1 0 1 0) #\A)

;;Ejercicio 2 : (menor-de-tres n1 n2 n3)
;;a)

(define (menor-de-tres n1 n2 n3)
  (if (< n1 n2)
      (if (< n1 n3) n1 n3)
      (if (< n2 n3) n2 n3))

  )
(display "Probando menor-de-tres\n")
(check-equal? (menor-de-tres 1 2 3) 1)
(check-equal? (menor-de-tres 4 2 7) 2)
(check-equal? (menor-de-tres 8 3 1) 1)

;;b) (menor-de-tres-v2 n1 n2 n3)

(define (menor x y)
  (if (< x y) x y)
  )

(define (menor-de-tres-v2 n1 n2 n3)
  (menor (menor n1 n2 ) (menor n2 n3))

  )
(display "Probando menor-de-tres-v2\n")
(check-equal? (menor-de-tres-v2 1 2 3) 1)
(check-equal? (menor-de-tres-v2 4 2 7) 2)
(check-equal? (menor-de-tres-v2 8 3 1) 1)

;;Ejercicio 3

;
; (define (f x y)
;     (+ x y))
;
; (define (g x)
;     (* 2 x))
;
; (f (g (+ 2 1)) (+ 1 1))
;
; Normal :
; (f (g (+ 2 1)) (+ 1 1))r4
; (+ (* 2 (+ 2 1)) (+ 1 1))r4
; (+(* 2 3) 2)r3
; (+ 6 2)r3
; 8
;
; Aplicativo:
; (f (g (+ 2 1)) (+ 1 1))r3
; (f (g 3) 2) r4
; (f (* 2 3) 2) r3
; (f 6 2)r4
; (+ 6 2)r3
; 8
;



;;Ejercicio 4 (tirada-ganadora t1 t2)

(define (tirada-ganadora t1 t2)
  (cond ( (< (abs(- 7 (+ (car t1) (cdr t1)))) (abs(- 7 (+ (car t2) (cdr t2))))) 1)
        ( (> (abs(- 7 (+ (car t1) (cdr t1)))) (abs(- 7 (+ (car t2) (cdr t2))))) 2)
        ( (= (abs(- 7 (+ (car t1) (cdr t1)))) (abs(- 7 (+ (car t2) (cdr t2))))) 0)
   )
)

(display "Probando tirada-ganadora\n")

(check-equal?  (tirada-ganadora (cons 3 3) (cons 1 6))  2)
(check-equal?  (tirada-ganadora (cons 1 5) (cons 2 2))  1)
(check-equal?  (tirada-ganadora (cons 6 2) (cons 3 3))  0)

;;Ejercicio 5: juego de guerra de barcos

(define(kmh-a-ms v)
(/ (* 1000 v) 3600)
)

(display "Probando kmh-a-ms\n")

(check-equal?  (kmh-a-ms 90) 25)

(define (calcula-alcance v)
  (* (kmh-a-ms v) (/ 5000 (expt (kmh-a-ms v) 2)) )
)
(define (calcula-distancia x1 y1 x2 y2)
  (sqrt (+ (expt (- x2 x1) 2) (expt (- y2 y1) 2)))
)

(define (dentro-alcance? x1 y1 x2 y2 v)
  (if (< (- (calcula-alcance v) (calcula-distancia x1 y1 x2 y2)) 0) #f #t)
)

(display "Probando dentro-alcance? \n")

(check-equal?  (dentro-alcance?  0 0 500 500 30) #f)
(check-equal?  (dentro-alcance?  100 200 500 500 20) #t)


;;Ejercicio 6:tipo-triangulo


(define epsilon 0.0001)

(define (iguales-reales? x y)
  (< (abs (- x y)) epsilon))

(define (tipo-triangulo a b c)
(cond
  ((equal? (and (iguales-reales? (calcula-distancia (car a) (cdr a) (car b) (cdr b)) (calcula-distancia (car b) (cdr b) (car c) (cdr c) ) ) (iguales-reales? (calcula-distancia (car a) (cdr a) (car c) (cdr c)) (calcula-distancia (car b) (cdr b) (car c) (cdr c) ) ) )
            #t) "equilatero")
  ((or(or
          (equal? (and (iguales-reales? (calcula-distancia (car a) (cdr a) (car b) (cdr b)) (calcula-distancia (car b) (cdr b) (car c) (cdr c) ) ) (equal?(iguales-reales? (calcula-distancia (car a) (cdr a) (car c) (cdr c)) (calcula-distancia (car b) (cdr b) (car c) (cdr c) ) ) #f))
            #t)

          (equal? (and (iguales-reales? (calcula-distancia (car a) (cdr a) (car c) (cdr c)) (calcula-distancia (car b) (cdr b) (car c) (cdr c) ) ) (equal?(iguales-reales? (calcula-distancia (car a) (cdr a) (car b) (cdr b)) (calcula-distancia (car b) (cdr b) (car c) (cdr c) ) ) #f))
            #t)

          )


      (equal? (and (iguales-reales? (calcula-distancia (car a) (cdr a) (car c) (cdr c)) (calcula-distancia (car a) (cdr a) (car b) (cdr b) ) ) (equal?(iguales-reales? (calcula-distancia (car a) (cdr a) (car b) (cdr b)) (calcula-distancia (car b) (cdr b) (car c) (cdr c) ) ) #f))
            #t)
      )
   "isosceles")

  (else "escaleno")
 )
)


(display "Probando tipo-triangulo \n")

(check-equal?  (tipo-triangulo (cons 1 1) (cons  1 6) (cons 6 1))"isosceles")
(check-equal?  (tipo-triangulo (cons -2 3) (cons  2 6) (cons 5 3)) "escaleno")
(check-equal?  (tipo-triangulo (cons -3 0) (cons  3 0) (cons 0 5.1961)) "equilatero")


;;Ejercicio 7 : calculadora


(define (multiplicar lista)
  (* (car lista) (cadr  lista))
  )

(display "Probando multiplicar \n")

(define (dividir lista)
  (/ (car lista) (cadr lista))
  )

(define (sumar lista)
  (+ (car lista) (cadr lista))
  )

(define (restar lista)
  (- (car lista) (cadr lista))
  )

(check-equal?  (multiplicar  (list 2 3)) 6)

(define (calculadora lista)
  (cond ((equal? (car lista) #\+) (sumar (cdr lista)))
      ((equal? (car lista) #\-) (restar (cdr lista)))
      ((equal? (car lista) #\*) (multiplicar (cdr lista)))
      ((equal? (car lista) #\/) (dividir (cdr lista)))
  )


)

(check-equal?  (calculadora  (list #\/ 4 4)) 1)