Práctica 1: Archivos requeridos


Descarga aquí

practica1.rkt

Archivo con las funciones a completar.

#lang plai

#| Práctica 1: Introducción a Racket |#

;; Función que toma dos números enteros positivos y eleva uno al otro, para luego sumar las raíces
;; cuadradas de éstos.
;; rps: number number -> number
(define (rps a b)
   (error 'rps "Función no implementada"))

;; Función que encuentra el área de un tirángulo dados sus lados, usando la fórmula de Herón. Se usa
;; la primitiva let para evitar cálculos repetitivos.
;; area-heron: number number number -> number
(define (area-heron a b c)
   (error 'area-heron "Función no implementada"))

;; Predicado que determina si la pareja a b entará en el antro usando condicionales. La respuesta de 
;; el predicado está dada de acuerdo a lo siguiente:
;; "Si el estilo de los asistentes es de ocho o más, el predicado responderá 'si con la excepción de
;;  que si el estilo de alguno de los asistentes es de dos o menos, responderá 'no. En otro caso,
;;  responderá 'quiza."
;; entra?: number number -> symbol
(define (entra? a b)
   (error 'entra? "Función no implementada"))

;; Función recursiva que regresa el número de apariciones del dígito m como digito en el número 
;; entero positivo n.
;; apariciones: number number -> number
(define (apariciones n m)
   (error 'apariciones "Función no implementada"))

;; Función recursiva que calcula el número de pares de una cadena. Decimos que un par en una cadena
;; son dos caracteres idénticos, separados por un tercero. Por ejemplo "AxA" es el par de "A". Los
;; pares, además, pueden anidarse, por ejemplo.
;; cuenta-pares: string -> number
(define (cuenta-pares c)
   (error 'cuenta-pares "Función no implementada"))

;; Función que imprime una piramide con n pisos haciendo uso de alguna función de impresión.
;; piramide: number -> void
(define (piramide n)
   (error 'piramide "Función no implementada"))

;; Función que recibe dos listas y construye una nueva lista con listas de longitud 2 formadas a 
;; partir de los elementos de ambas listas.
;; arma-pares: list list -> (listof list)
(define (arma-pares lst1 lst2)
   (error 'arma-pares "Función no implementada"))

;; Función que recibe una lista con elementos de la forma '(id value) y regresa el valor asociado al
;; id que fue pasado como parámetro.
;; lookup: (listof list) -> any
(define (lookup id lst)
   (error 'lookup "Función no implementada"))

;; Función que compara la longitud de las listas lst1 y lst2. El valor de regreso son alguno de los 
;; siguientes:
;; · 'lista1-mas-grande
;; · 'lista2-mas-grande
;; · 'listas-iguales
;; compara-longitud: list list -> symbol
(define (compara-longitud lst1 lst2)
   (error 'compara-longitud "Función no implementada"))

;; Función que entierra el símbolo nombre, n número de veces. Es decir, se anidan n - 1 listas hasta
;; que se llega a la lista que tiene al símbolo nombre.
;; entierra: symbol number -> list
(define (entierra nombre n)
   (error 'entierra "Función no implementada"))

;; Función que que mezcla dos listas ordenadas obtieniendo una nueva, ordenada de manera ascendente.
;; mezcla: list list -> list
(define (mezcla lst1 lst2)
   (error 'mezcla "Función no implementada"))

;; Función que recibe una lista de números y regresa una nueva lista de cadenas que representan al
;; número binario asociado a estos números.
;; binarios: (listof number) -> (listof string)
(define (binarios lst)
   (error 'binarios "Función no implementada"))

;; Función que recibe una lista y regresa una nueva conteniendo únicamente aquellos que son 
;; triangulares.
;; triangulares: (listof number) -> (listof number)
(define (triangulares lst)
   (error 'triangulares "Función no implementada"))

;; Función que, usando foldr, intercala un símbolo dado entre los elementos de una lista.
;; intercalar: list symbol -> list
(define (intercalar lst s)
   (error 'intercalar "Función no implementada"))

;; Función que, usando foldl, intercala un símbolo dado entre los elementos de una lista.
;; intercalal: list symbol -> list
(define (intercalal lst s)
   (error 'intercalal "Función no implementada"))



test-practica1.rkt

Archivo con las pruebas unitarias de la práctica.

#lang plai

(require "practica1.rkt")

(print-only-errors)

#| Módulo para pruebas unitarias de la práctica 1 |#

;; Pruebas para rps
(test (rps 1 7) 3.64)
(test (rps 2 9) 31.62)
(test (rps 4 0) 1)
(test (rps 5 5) 111.80)
(test (rps 0 2) 1)

;; Pruebas para area-heron
(test (area-heron 3 25 26) 36)
(test (area-heron 3 4 5) 6)
(test (area-heron 3 4 2) 2.9)
(test (area-heron 13 16 23) 100.69)
(test (area-heron 4 6 3) 5.33)

;; Pruebas para entra?
(test (entra? 5 10) 'si)
(test (entra? 3 9) 'si)
(test (entra? 5 2) 'no)
(test (entra? 11 1) 'no)
(test (entra? 5 5) 'quiza)

;; Pruebas para apariciones
(test (apariciones 717 7) 2)
(test (apariciones 2 2) 1)
(test (apariciones 123 8) 0)
(test (apariciones 1729 4) 0)
(test (apariciones 1835 0) 0)

;; Pruebas para cuenta-pares
(test (cuenta-pares "axa") 1)
(test (cuenta-pares "axax") 2)
(test (cuenta-pares "axbx") 1)
(test (cuenta-pares "") 0)
(test (cuenta-pares "axabacadad") 5)

;; No hay pruebas para piramide, revisar su impresión.

;; Pruebas para arma-pares
(test (arma-pares '(foo bar) '(10 20)) '((foo 10) (bar 20)))
(test (arma-pares '(1 7 2 9) '(1 8 3 5)) '((1 1) (7 8) (2 3) (9 5)))
(test (arma-pares '() '()) '())
(test (arma-pares '(#\a #\b #\c #\d) '("a" "b" "c" "d")) '((#\a "a") (#\b "b") (#\c "c") (#\d "d")))
(test 
   (arma-pares '(405 502 613) '("cuatroscientos cinco" "quinientos dos" "seiscientos trece"))
   '((405 "cuatroscientos cinco") (502 "quinientos dos") (613 "seiscientos trece")))

;; Pruebas para lookup
(test (lookup 'foo '((foo 10) (bar 20))) 10)
(test (lookup 'a '((a 1) (b 7) (c 2) (d 9))) 1)
(test (lookup 'c '((a 1) (b 7) (c 2) (d 9))) 2)
(test (lookup "tres" '(("uno" 1) ("dos" 2) ("tres" 3) ("cuatro" 4))) 3)
(test 
   (lookup 
      5 
      (lookup 
         'uno 
         '((uno ((5 "dos"))) 
           (dos ((4 "tres"))) 
           (tres ((3 "cuatro"))) 
           (cuatro ((2 "cinco"))) 
           (cinco ((1 "uno")))))) 
   "dos")

;; Pruebas para compara-longitud
(test (compara-longitud '(4 0) '(5)) 'lista1-mas-grande)
(test (compara-longitud '(1 2 3) '(5 6 7 8 9 10)) 'lista2-mas-grande)
(test (compara-longitud '(0 2) '(6 1 3)) 'lista2-mas-grande)
(test (compara-longitud '() '()) 'listas-iguales)
(test (compara-longitud '(1 7 2 9) '(1 8 3 5)) 'listas-iguales)

;; Pruebas para entierra
(test (entierra 'foo 0) 'foo)
(test (entierra 'foo 1) '(foo))
(test (entierra 'foo 3) '(((foo))))
(test (entierra 'bar 4) '((((bar)))))
(test (entierra 'foo 5) '(((((foo))))))

;; Pruebas para mezcla
(test (mezcla '() '(1 2 7 9)) '(1 2 7 9))
(test (mezcla '(1 3 5 8) '()) '(1 3 5 8))
(test (mezcla '(1 2 3 4 5) '(6 7 8 9 10)) '(1 2 3 4 5 6 7 8 9 10))
(test (mezcla '(6 7 8 9 10) '(1 2 3 4 5)) '(1 2 3 4 5 6 7 8 9 10))
(test (mezcla '(1 2 6 8 10 12) '(2 3 5 9 13)) '(1 2 2 3 5 6 8 9 10 12 13))

;; Pruebas para binarios
(test (binarios '()) '())
(test (binarios '(0 1 2 3 4)) '("0" "01" "010" "011" "0100"))
(test (binarios '(1 7 2 9)) '("01" "0111" "010" "01001"))
(test (binarios '(1 8 3 5)) '("01" "01000" "011" "0101"))
(test (binarios '(4 0 5 5 0 2 6 1 3)) '("0100" "0" "0101" "0101" "0" "010" "0110" "01" "011"))

;; Pruebas para triangulares
(test (triangulares '()) '())
(test (triangulares '(1 2 3 4 5 6)) '(1 3 6))
(test (triangulares '(2 4 5 7 8 9 11 12 13 14)) '())
(test 
   (triangulares '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25))
   '(1 3 6 10 15 21))
(test
   (triangulares (triangulares '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25)))
   '(1 3 6 10 15 21))

;; Pruebas para intercalar
(test (intercalar '() '+) '())
(test (intercalar '("a") '-) '("a"))
(test (intercalar '(1 2 3) '*) '(1 * 2 * 3))
(test (intercalar '(a b c d) '<>) '(a <> b <> c <> d))
(test (intercalar '((4 0 5) (5 0 2) (6 1 3)) '~) '((4 0 5) ~ (5 0 2) ~ (6 1 3)))

;; Pruebas para intercalal
(test (intercalal '() '+) '())
(test (intercalal '("a") '-) '("a"))
(test (intercalal '(1 2 3) '*) '(1 * 2 * 3))
(test (intercalal '(a b c d) '<>) '(a <> b <> c <> d))
(test (intercalal '((4 0 5) (5 0 2) (6 1 3)) '~) '((4 0 5) ~ (5 0 2) ~ (6 1 3)))