Racket Práctica 3.1

EJERCICIO 1)

; Representamos las coordenadas de puntos en el plano y las distancias entre ellos mediante números.

; distancia-origen: Number Number -> Number
; Recibe la abscisa y ordenada de un punto en el plano y calcula su distancia al origen de coordenadas.
(check-expect (distancia-origen 3 4) 5)
(check-expect (distancia-origen 0 0) 0)
(check-expect (distancia-origen -6 -8) 10)
(check-within (distancia-origen -1 1) 1.41 0.01)
(define (distancia-origen x y) (sqrt(+ (sqr x) (sqr y) ) ) )


EJERCICIO 2)

; Representamos las coordenadas de puntos en el plano y las distancias entre ellos mediante números.

; distancia-puntos: Number Number Number Number -> Number
; Recibe x1, y1, x2, y2 , abscisas y ordenadas de dos punto en el plano. Luego, calcula la distancia entre los puntos.
(check-expect (distancia-puntos 1 1 4 5) 5)
(check-expect (distancia-puntos -3 -4 3 4) 10)
(check-within (distancia-puntos 1 1 0 0) 1.41 0.01)
(define (distancia-puntos x1 y1 x2 y2) (sqrt(+ (sqr (- x1 x2)) (sqr (- y1 y2) ) ) ) )

EJERCICIO 3)

; Representamos las medidas de largo y volumen como números.

; vol-cubo Number -> Number
; Recibe un número positivo que representa el largo de la arista de un cubo y calcula el volumen del mismo.
(check-expect (vol-cubo 1) 1)
(check-expect (vol-cubo 10) 1000)
(check-expect (vol-cubo 5) 125)
(define (vol-cubo l) (expt l 3) )

EJERCICIO 4)

; Representamos las medidas de largo y volumen como números.

; area-cubo Number -> Number
; Recibe un número positivo que representa el largo de la arista de un cubo y calcula el area del mismo.
(check-expect (area-cubo 1) 6)
(check-expect (area-cubo 10) 600)
(check-expect (area-cubo 5) 150)
(define (area-cubo l) (* 6 (sqr l) ) )

EJERCICIO 5)

; Representamos el área de las imágenes como números.

; area-imagen Image -> Number
; Recibe una imagen y calcula su área.
(check-expect (area-imagen (rectangle 20 10 "solid" "red")) 200)
(check-expect (area-imagen (circle 10 "solid" "red")) 400)
(check-expect (area-imagen (rectangle 1 1 "solid" "red")) 1)
(define (area-imagen n) (* (image-height n) (image-width n) ) )

EJERCICIO 6)

; Representamos las cadenas como strings y las posiciones en la cadena como números.

; string-insert: String Number -> String
; Recibe una cadena y un entero no negativo i. Inserta un guión ("-") en la posición i-ésima de la cadena.
(check-expect (string-insert "Hola" 0) "-Hola")
(check-expect (string-insert "Cadena" 5) "Caden-a")
(check-expect (string-insert "Ejemplo" 2) "Ej-emplo")
(define (string-insert cadena i) (string-append (substring cadena 0 i) "-" (substring cadena i (string-length cadena) ) ) )

EJERCICIO 7)

; Representamos las cadenas como strings.

; string-last: String -> String
; Recibe una cadena y devuelve el último caracter de la misma.
(check-expect (string-last "Hola") "a")
(check-expect (string-last "String") "g")
(check-expect (string-last "E") "E")
(define (string-last cadena) (substring cadena (- (string-length cadena) 1) (string-length cadena) ) )


EJERCICIO 8)

; Representamos las cadenas como strings.

; string-remove-last: String -> String
; Recibe una cadena y un entero no negativo i. Inserta un guión ("-") en la posición i-ésima de la cadena.
(check-expect (string-remove-last "Hola") "Hol")
(check-expect (string-remove-last "Cadena") "Caden")
(check-expect (string-remove-last "E") "")
(define (string-remove-last cadena) (substring cadena 0 (- (string-length cadena) 1) ) )

EJERCICIO 10)

; Representamos los puntos del plano mediante estructuras posn.

; distancia-manhattan: posn -> Number
; Recibe un punto en el plano y calcula su distancia de Manhattan al origen de coordenadas.
(check-expect (distancia-manhattan (make-posn 10 15)) 25)
(check-expect (distancia-manhattan (make-posn -5 0)) 5)
(check-expect (distancia-manhattan (make-posn -8 5)) 13)
(define (distancia-manhattan n) (+ (abs (posn-x n)) (abs (posn-y n)) ) )

EJERCICIO 11)

; Representamos las horas mediante estructuras tiempo.

;tiempo es (make-tiempo Number Number Number)
;Interpretación: Una estructura tiempo representa una hora con tres números enteros: el primero representa la cantidad de horas; el segundo, los minutos; y el tercero, los segundos.
(define-struct tiempo [Horas Minutos Segundos])


; tiempo->segundos: tiempo -> Number
; Recibe una hora y calcula la cantidad de segundos que pasaron desde la medianoche en esa hora.
(check-expect (tiempo->segundos (make-tiempo 0 0 0)) 0)
(check-expect (tiempo->segundos (make-tiempo 10 0 0)) 36000)
(check-expect (tiempo->segundos (make-tiempo 10 30 50)) 37850)
(define (tiempo->segundos n) (+ (* 3600 (tiempo-Horas n)) (* 60 (tiempo-Minutos n)) (tiempo-Segundos n) ) )

EJERCICIO 12)

Sub-EJERCICIO 2:
;Estado es un número
;Interpretación del Estado: Representa la distancia en píxeles del círculo al borde superior de la escena.

;La constante ANCHO se usa para determinar el ancho del fondo a utilizar.
(define ANCHO 400)
;La constante ALTO se usa para determinar el alto del fondo a utilizar.
(define ALTO 200)
;La constante RADIO se usa para definir el radio del círculo.
(define RADIO 20)
;La constante DELTA define cuánta distancia en píxeles recorerá el círculo en cada movimiento.
(define DELTA 20)


;pantalla: Estado -> Image
;Ubica el círculo n píxeles debajo del margen superior del FONDO, centrado horizontalmente en la escena.
(define (pantalla n) (place-image (circle RADIO "solid" "magenta") (/ ANCHO 2) n (empty-scene ANCHO ALTO)) )


;mover: Estado Key -> Estado
;Modifica el estado asociado al big bang, siguiendo las reglas:
; En caso de apretar la flecha arriba, el estado aumente DELTA unidades, siempre que el círculo no escape de la pantalla.
; En caso de apretar la flecha abajo, el estado disminuya DELTA unidades, siempre que el círculo no escape de la pantalla.
; En caso de apretar la barra espaciadora, el estado vuelva a la situación inicial
; Ignore cualquier otra tecla y mantenga el estado como se encuentra.
(define (mover n tecla) (cond
                          [(key=? tecla "up")    (if (>= n (* 2 RADIO)) (- n DELTA) n)]
                          [(key=? tecla "down")  (if (<= n (- ALTO (* 2 RADIO))) (+ n DELTA) n)]
                          [(key=? tecla " ") (/ ALTO 2)]
                          [else n]))

;mouse-handler; Estado Number Number String -> Estado
;Modifica el estado para que el círculo se posicione en la altura correspondiente a un click izquierdo en la escena.
(define (mouse-handler n x y event) (cond [(string=? event "button-down") y]
                                          [else n]))

(big-bang (/ ALTO 2)
          [to-draw pantalla]
          [on-key mover]
          [on-mouse mouse-handler]
)

Sub.EJERCICIO 4:

;Estado es un Número
;Interpretación: Representa la distancia en píxeles a la que se encontrará la imagen del borde izquierdo de una escena.

;La constante AUTO establece la imagen que se irá moviendo en la escena.
(define AUTO .)

;La constante LARGO_AUTO determina el largo de la imagen AUTO.
(define LARGO_AUTO (image-width AUTO))
;La constante DIST_MIN determina la distancia mínima en píxeles a la que podrá estar el auto a los extremos de la escena.
(define DIST_MIN (+ (/ LARGO_AUTO 2) 5) )
;La constante DELTA establece cuántos píxeles aumentará el estado en cada tick del reloj.
(define DELTA 3)
;La constante LARGO establece el largo en píxeles de la escena.
(define LARGO 450)
;La constante ALTO establece el alto en píxeles de la escena.
(define ALTO 100)
;La constante ESCENA define el fondo sobre el que se moverá la imagen AUTO.
(define ESCENA (empty-scene LARGO ALTO))


;pantalla: Estado -> Image
;Toma un estado n y dibuja la imagen AUTO a n píxeles a la derecha del borde izquierdo de una escena, centrado verticalmente.
(check-expect (pantalla 0) (place-image AUTO 0 (/ ALTO 2) ESCENA) )
(check-expect (pantalla 15) (place-image AUTO 15 (/ ALTO 2) ESCENA) )
(check-expect (pantalla 43) (place-image AUTO 43 (/ ALTO 2) ESCENA) )
(define (pantalla n) (place-image AUTO n (/ ALTO 2) ESCENA) )


;incrementar: Estado -> Estado
;Toma un estado y lo incrementa en DELTA, desplazando el auto DELTA píxeles a la derecha
;en caso que el mismo se mantenga en la escena luego del incremento.
(check-expect (incrementar 0) (+ 0 DELTA) )
(check-expect (incrementar 20) (+ 20 DELTA) )
(check-expect (incrementar LARGO) LARGO )
(define (incrementar n) (if(<= n (- LARGO DIST_MIN) ) (+ n DELTA) n ) )

;teclado: Estado Key -> Estado
;Modifica el estado en función de la tecla que se apriete, siguiendo estas reglas:
; Flecha derecha: Incrementa el estado en 20, en caso que el auto se mantenga en la escena luego del aumento.
; Flecha izquierda: Decrementa el estado en 20, en caso que el auto se mantenga en la escena luego de la disminución.
; Barra espaciadora: Devuelve el estado al valor inicial.
; En caso que se presione cualquier otra tecla, ésta será ignorada y el estado se mantendrá igual.
(check-expect (teclado 0 "right") 20 )
(check-expect (teclado 0 "left") 0 )
(check-expect (teclado 0 " ") DIST_MIN )
(check-expect (teclado 0 "r") 0)
(define (teclado n tecla) (cond [(key=? tecla " ") DIST_MIN]
                                [(and (key=? tecla "right") (< n (- LARGO DIST_MIN)) ) (+ n 20) ]
                                [(and (key=? tecla "left") (> n (+ 20 DIST_MIN)) ) (- n 20)]
                                [else n] ) )

;clickear: Estado MouseEvent -> Estado
; Revisa si un evento de mouse es un click izquierdo. En caso que lo sea, modifica el estado para que corresponda a la posición
; en x del click. En caso contrario, el estado se mantiene.
(check-expect (clickear 0 20 20 "button-down") 20 )
(check-expect (clickear 0 40 35 "move") 0 )
(define (clickear n x y evento) (cond [(string=? evento "button-down") x]
                                          [else n]))


;programa-principal Estado -> Estado
;Lanza la función big bang desde la distancia inicial.
(define (programa DIST_MIN)
(big-bang DIST_MIN
    [to-draw pantalla]
        [on-tick incrementar]
        [on-key teclado]
        [on-mouse clickear]
))