Programación Funcional con Scheme parte II

;;----------------------------------------------------------------------;;
;; Ejercicio 1
;; Contrato: define una estructura que represente un
;; punto en el plano. Crear una función que calcule
;; la distancia entre dos puntos dados recibiendo
;; como parámetros la estructura de cada uno.
;;----------------------------------------------------------------------;;

(define-struct punto (x y))

(define distancia_entre_2_ptos (lambda (punto1 punto2)
(let (
(cuadrado (lambda (x)
(* x x)
);lambda
); cuadrado

(punto1 (make-punto 1 1))
(punto2 (make-punto 3 3))
)
(sqrt ( + (cuadrado (- (punto-x punto2) (punto-x punto1)))
(cuadrado (- (punto-y punto2) (punto-y punto1)))))
);let
);lambda
);define

(define p1 (make-punto 1 1))
(define p2 (make-punto 3 3))

(distancia_entre_2_ptos p1 p2)


;;----------------------------------------------------------------------------;;
;; Ejercicio 2
;; Contrato: definie una estructura que represente un
;; punto en el espacio. Crear una función que calcule
;; el centro de gravedad de una lista de puntos en el
;; espacio representados por la estructura definida
;; previamente.
;;----------------------------------------------------------------------------;;

(define-struct punto3d (x y z))

(define centro_de_gravedad (lambda (lista_puntos)
(letrec (
(centro (lambda (n puntos)
(if (null? puntos)
'(0 0 0)
(list
(+ (/ (punto3d-x (car puntos)) n) (car (centro n (cdr puntos))))
(+ (/ (punto3d-y (car puntos)) n) (cadr (centro n (cdr puntos))))
(+ (/ (punto3d-z (car puntos)) n) (caddr (centro n (cdr puntos))))
);list
);if
);lambda
);centro
)
(centro (length lista_puntos) lista_puntos)
);letrec
);lambda
);define

(define p1 (make-punto3d 2 4 2))
(define p2 (make-punto3d 3 9 4))
(define p3 (make-punto3d 2 1 2))
(define p4 (make-punto3d 1 1 2))

(centro_de_gravedad (list p1 p2 p3 p4))


;;---------------------------------------------------------------------------;;
;;Ejercicio 3
;; Contrato: define una estructura que represente un
;; automóvil con las sgtes. características:
;; - consumo promedio en km /Lts
;; - velocidad promedio km /Hora
;; usar la estructura para calcular el consumo de
;; combustible y el tiempo que tardo en recorrer dos
;; puntos representados por estructuras del ejercicio 1
;;---------------------------------------------------------------------------;;

(define-struct automovil(consumo velocidad))
(define-struct punto(x y))

(define distancia_entre_2_ptos (lambda (punto1 punto2)
(sqrt ( +
(expt (- (punto-x punto2) (punto-x punto1)) 2)
(expt (- (punto-y punto2) (punto-y punto1)) 2)
)
)
)
)

(define tiempo_y_consumo (lambda (punto1 punto2)
(list
(/ (distancia_entre_2_ptos punto1 punto2) (automovil-consumo auto))
(/ (distancia_entre_2_ptos punto1 punto2) (automovil-velocidad auto))
)
)
)

(define p1 (make-punto 1 1))
(define p2 (make-punto 3 3))
(define auto (make-automovil 1 123))

(tiempo_y_consumo p1 p2)


;;----------------------------------------------------------------------;;
;; Ejercicio 4
;; Contrato: calcule la distancia máxima entre dos
;; puntos de una lista, usando el predicado MAP y
;; estructuras.
;;----------------------------------------------------------------------;;

(define-struct punto(x y))

(define distancia_2p (lambda (p1 p2)
(round (sqrt (+ (expt (- (punto-x p2) (punto-x p1)) 2) (expt (- (punto-y p2) (punto-y p1)) 2))))
);lambda
);define

(define maximo (lambda (lista)
(if (null? lista)
'()
(if (null? (cdr lista))
(car lista)
(if (> (car lista) (maximo (cdr lista)))
(car lista)
(maximo (cdr lista))
);if
);if
);if
);lambda
);maximo


(define max_distancia_p_lista (lambda (punto lista_distancias)
(maximo
(map
(lambda (pp) (distancia_2p punto pp))
lista_distancias
);map
);maximo
);lambda
);define


(define punto1 (make-punto 2 4))
(define punto2 (make-punto 3 9))
(define punto3 (make-punto 2 1))
(define punto4 (make-punto 1 1))

(max_distancia_p_lista punto1 (list punto2 punto3 punto4))


;;-------------------------------------------------------------------------;;
;; Ejercicio 5
;; Contrato: cuenta la cantidad de palabras
;; y de caracteres de un archivo.
;;-------------------------------------------------------------------------;;

(define (cant_palabras_archivo archivo)
(letrec (
(contar_palabras(lambda (archivillo cant_palabras)
(let (
(palabra (read archivillo))
);let
(if (eof-object? palabra)
cant_palabras
(contar_palabras archivillo (+ cant_palabras 1))
);if
);let
);lambda
);contar_palabras
)
(contar_palabras archivo 0)
);letrec
);define

(define archivo1 (open-input-file "archivo.txt"))
(display "La cantidad de palabras es: ")
(cant_palabras_archivo archivo1)
(close-input-port archivo1)


(define (cant_caracteres_archivo archivo)
(letrec (
(contar_caracteres(lambda (archi cant_caracteres)
(let (
(caracter (read-char archi))
);let
(if (eof-object? caracter)
cant_caracteres
(contar_caracteres archi (+ cant_caracteres 1))
);if
);let
);lambda
);contar_caracteres
)
(contar_caracteres archivo 0)
);letrec
);define

(define archivo2 (open-input-file "archivo.txt"))
(display "La cantidad de caractéres es: ")
(cant_caracteres_archivo archivo2)
(close-input-port archivo2)


;;-----------------------------------------------------;;
;; Ejercicio 6
;; Contrato: muestra por pantalla
;; un archivo de texto.
;;-----------------------------------------------------;;

(define (mostrar_archivo archivo)
(letrec (
(leer_archivo (lambda(archi contenido)
(let* (
(palabra (read archi))
(contenido_aux (cons contenido (cons palabra '())))
(contenido contenido_aux)
)
(if (eof-object? palabra)
contenido
(leer_archivo archi contenido)
);if
);let*
);lambda
);leer_archivo
);letrec
(leer_archivo archivo "")
);letrec
);define


(define archivo (open-input-file "archivo.txt"))
(mostrar_archivo archivo)
(close-input-port archivo)


;;------------------------------------------------------------------------;;
;; Ejercicio 7
;; Contrato: lee una operación aritmética simple
;; (+, -) y la convierta en sintáxis de Scheme.
;;------------------------------------------------------------------------;;

(let (
(convierte_operacion (lambda (ecuacion)
(let (
(parametro1 (car ecuacion))
(operador (car (cdr ecuacion)))
(parametro2 (car (cdr (cdr ecuacion))))
)
(cons operador (cons parametro1 (cons parametro2 '())))
);let
);lambda
);convierte_operacion
)
(convierte_operacion (list 34 + 2))
);let

;; Nota: como el enunciado dice "una operación
;; aritmética simple", solo contemplo el ingreso
;; de un único operador y de dos operandos.