(require(lib"mzlib/compat"))
(require(lib"racket/trace"))
(require(lib"racket/list"))

;práctica con santiago
(define x 3)
(define y 4)
(define
  (fun x) ;nombre de funcion y parámetros
  (* x 2) ;resultado de la función
  )

(define (fun-if x)
   (if (< x 4)
       "verdadero"
       "falso" ))
(define (factorial n)
  (if (= n 0)
      1
      (* n (factorial (- n 1) ))))

;EJERCICIO 2

;A) hyp que calcule la hipotenusa teniendo los lados a y b de un triángulo rectángulo.
(define (hyp a b)(
                  sqrt (+ (expt a 2) (expt b 2))))

;B) segundo que obtenga el segundo elemento de una lista (utilice car y cdr).
(define (segundo lista)
  (car (cdr lista)))
;(segundo '(a d c d))

;C) div_segura que devuelva 0 si el divisor es 0 (utilice if).
(define (div_segura dividendo divisor)
  ( if (equal? divisor 0)
       "El divisor no puede ser cero"
       (/ dividendo divisor)))
;(div_segura 9 4)
;(div_segura 9 0)

;D) pruebe en la mitad superior de la pantalla los segmentos de código que contiene el libro de texto de la cátedra.
;don sebesta

;E) Pregunte por su nombre y le conteste Hola nombre!.

; ask : string -> prints output, waits for text input, returns it
(define (ask question)
 ;(let ([ip (open-input-string "x\ny\n")])
   (display question)
  (display (string-append "hola " (read-line ))))
;(ask "cual es tu nombre?")

;F) Pregunte por un número y en caso de ingresar otro cosa, siga preguntando, caso contrario que escriba FIN
(define (ask-number)
  (display "Ingrese un número:")
  (if (number? (read))
  (ask-number)
  "FIN"))
;(ask-number)

;EJERCICIO 3
;A) un número y determine si es positivo, negativo o nulo informando
;con estas palabras el resultado. Incluya la lectura de datos.


(define (ingrese-numero)
  (display "Ingrese un número")
  (read))

(define (determinar-numero numero)
  (if (number? numero)
      (if(zero? numero)
         "Es cero"
         (if(positive? numero)
            "Es positivo"
            "Es negativo"))
      (determinar-numero (ingrese-numero))))
;(trace determinar-numero)
;(determinar-numero(ingrese-numero))

;B) dos números y realice la suma de los números comprendidos entre ellos.
(define (sumatoria-rango min max)
  (if( or (= min max) (= max (+ min 1)))
     0
     (+ (+ min 1) (sumatoria-rango (+ min 1) max))))
;(trace sumatoria-rango)
;(sumatoria-rango 0 10)

;C) un entero n y produzca una lista con los números desde 1 a n en orden ascendente.
(define (ascendente base n)
  (if(= (+ base 1) n)
     n
     (list (+ base 1) (ascendente (+ base 1) n)) ))
;(ascendente 0 10)

(define (lista-n n)
  (map (lambda (number)
         (+ 1 number))
       (build-list n values)))

;(lista-n 12)

;D) un entero n y produzca una lista con los números desde 1 a n en orden ascendente.
(define (lista-n-descendente n)
  (reverse (lista-n n)))
;(lista-n-descendente 12)
#|(let ([x (read)]
      [y (read)])
  (displayln x)
  (display y))|#

;F) una lista y cuente la cantidad de átomos.
(define (cuenta-atomos lista)
  (if(= (length lista) 0 )
     0
     (if (atom? (car lista))
       (+ 1 (cuenta-atomos (cdr lista)))
       0)))

;(cuenta-atomos '(1 2 3 5 2 '(3) 2))

;G) un átomo y una lista e informe con verdadero o falso si el átomo está incluido en la lista,
;llame a esta función mem?
(define (esta-list atomo lista )
  (if (member atomo lista)
      "Verdadero"
      "Falso"))
;(esta-list 7 '(1 2 3 4))

;H) dos listas simples y devuelva la unión de las dos listas. Utilice la función mem? para evitar
;átomos repetidos.

(define (union-lista lista-1 lista-2)
  (cond
   [(eq? empty lista-1) lista-2]
   [(member (car lista-1) lista-2) (union-lista (cdr lista-1) lista-2)]
   [else (cons (car lista-1) (union-lista (cdr lista-1) lista-2))]))

;(trace union-lista)
(union-lista '(1 2 3 6) '(1 2 3 6 4 5 7 8 9 10))

;i) un átomo y una lista y devuelva una lista donde todas las ocurrencias del átomo fueron
;quitadas (sin importar el nivel de profundidad de ocurrencia del átomo en la lista).

;EJERCICIO 4
(define (prueba atom lis)
(cond
((null? lis) ())
((eq? atom (car lis)) (cons (car lis) (prueba atom (cdr lis))))
(else (prueba atom (cdr lis)))
)
)
; Dado un atomo y una lista simple, retorna una lista que contiene tantos atomos como se hallan encontrado igual a 'atom'.
;(prueba 'a '(d a '(b a) a a))

(require(lib"compat.ss"))
(define (que_hace lis)
(cond
((empty? lis) 0)
((atom? (car lis))
(cond
((eq? (car lis) null) (que_hace (cdr lis)))
(else (add1 (que_hace (cdr lis))))
)
)
(else (+ (que_hace (car lis)) (que_hace (cdr lis))))
)
)
;(trace que_hace)
;(que_hace '(1 2 3 4 5  (a b c) 6 ()))

;(define (es-2-3-4-5 n) (and (< n 6) (> n 1)))
;(filter es-2-3-4-5 '(1 2 3 4 5))

;EJERCICIO 5
(define (misterio ls)
(if (null? (cddr ls)) (cons (car ls) ())
(cons (car ls) (misterio (cdr ls)))))

;(trace misterio)
;(misterio '(1 2 3))
;EJERCICIO 6
;Escriba una función suma_todo que encuentre la suma de los números de una lista que puede
;contener sublistas anidadas de números. Pruebe con los siguientes ejemplos:
(define (suma-todo lista)
  (if(eq? empty lista)
     0
     (+ (car lista) (suma-todo (cdr(flatten lista))))))
;(suma-todo '(1 2 (3 4)))

(define (sumar-todo lista)
  ( cond
     ((eq? empty lista) 0)
     ((atom?(car lista))(+ (car lista) (sumar-todo (cdr lista))))
     (else (sumar-todo (car lista)))))

;(sumar-todo '(1 2 (3 4 (1 10))))

(define (aux-ascendente i n)
 (if(eq? n i)
      (list i)
      (cons i (aux-ascendente (+ i 1) n))))

(define (lista-n-ascendente n)
  (aux-ascendente 1 n))

(trace lista-n-ascendente)
(lista-n-ascendente 10)
; Cuenta pares
(define (cuenta-pares list)
  (cond
    ((eq? empty list) 0)
    ((odd? (car list))(cuenta-pares (cdr list)))
    (even? (car list) (+ 1 (cuenta-pares (cdr list))))))

;(cuenta-pares '(1 2 3 4 1 10))

(define (aplanar lista)
  (cond
    [(eq? empty lista) '()]
    [(atom?(car lista))(cons (car lista)(aplanar (cdr lista)))]
    [else ( append(aplanar(car lista)) (aplanar(cdr lista)))]))

(aplanar '(1 2 (3 4 (7 8))(5 6)))