{- Tarea a entregar antes del 16 de setiembre de 2023 a las 23 hs -}
{- Funciones lineales -}

{- INTEGRANTES GRUPO 1
María De Los Ángeles Vila Bravo
Manuel Ernesto Cicarello Martino
-}

incluir Predefinido

{- Ejercicio 1: escribir dos funciones cantPos y cantNeg que dada una secuencia de enteros devuelven la cantidad de positivos (o cero) y de negativos que hay en la secuencia respectivamente. 
Escribir una funcion posNeg que dada una secuencia devuelve un par donde el primer elemento es la cantidad de enteros no negativos (positivos o cero) de la secuencia y el segundo la cantidad de negativos. Ejemplo:
posNeg ([1,2,7,0,-1,-3, 0])
(5,2)

-}

{-PROBLEMA ALGORÍTMICO:
Parte I) Función CantPos:
Dominio: Una secuencia de Enteros(Z*)
Codominio: El conjunto de los números Naturales (N), ya que se trata de una CANTIDAD (cantidad de números positivos o ceros)

 Datos de ENTRADA: Una secuencia de Enteros.
 Datos de SALIDA: Un número natural, que sea la cantidad de elementos positivos de la secuencia

ParteII) Función CantNeg:
Dominio: Una secuencia de Enteros(Z*)
Codominio: El conjunto de los números Naturales (N), ya que se trata de una CANTIDAD (cantidad de números positivos o ceros)

 Datos de ENTRADA: Una secuencia de Enteros.
 Datos de SALIDA: Un número natural, que sea la cantidad de elementos negativos de la secuencia

SubProblema: Definir la FUNCIÓN posNeg:
Dominio: Una secuencia de enteros (Z*)
Codominio: (N X N), ya que se trata de un par ORDENADO de naturales que representan CANTIDADES.

 Datos de ENTRADA: Una secuencia de Enteros.
 Datos de SALIDA: Un par ordenado, formado por la cantidad de elementos positivos y negativos de la secuencia

-}
   
cantPos :: Z* -> N
cantPos(secuencia) = 0 si secuencia == [] 					
					o 1 + cantPos(resto(secuencia)) si primero(secuencia) >= 0
                    o cantPos(resto(secuencia))
                    
{-EJEMPLO CONCRETO: cantPos ([-1,0,-2,5,8])
Pregunta 1) La secuencia es vacia? R: NO
Pregunta 2) ¿El primer elemento de la secuencia es >=0? R: NO
Pregunta 3) Llamamos recursivamente a la funcion: 

cantPos([0,-2,5,8])
 
Pregunta 1) La secuencia es vacia? R: NO
Pregunta 2) ¿El primer elemento de la secuencia es >=0? R: SI. Llamamos recursivamente a la funcion:

1 + cantPos([-2,5,8])

Pregunta 1) La secuencia es vacia? R: NO
Pregunta 2) ¿El primer elemento de la secuencia es >=0? R: NO
Pregunta 3) Llamamos recursivamente a la funcion: 
 
cantPos([5,8])
 
Pregunta 1) La secuencia es vacia? R: NO
Pregunta 2) ¿El primer elemento de la secuencia es >=0? R: SI. Llamamos recursivamente a la funcion:

cantPos([8])

Pregunta 1) La secuencia es vacia? R: NO
Pregunta 2) ¿El primer elemento de la secuencia es >=0? R: SI
Llamamos recursivamente a la funcion:

cantPos([])

Pregunta 1) La secuencia es vacia? R: SI. Devolvemos 0

RESUMEN
cantPos([-1,0,-2,5,8])	
cantPos([0,-2,5,8])	
1 + cantPos([-2,5,8])
1 + cantPos([5,8])
1 + 1 + cantPos([8])
1 + 1 + 1 + cantPos([])
1 + 1 + 1 + 0

Efectivamente hay una cantidad de 3 números con la condición >= 0, en la secuencia dada
-}

cantNeg :: Z* -> N
cantNeg(secuencia) = 0 si secuencia == [] 
					o 1 + cantNeg(resto(secuencia)) si primero(secuencia) < 0
                    o cantNeg(resto(secuencia))
 {- Funciona igual que la función cantPos, pero "contando" cantidad de números negativos presentes -}
 
posNeg :: Z* -> N X N
posNeg(secuencia) = (cantPos(secuencia), cantNeg(secuencia))
 {- Invocamos a las funciones cantPos y cantNeg -}

 {- Ejercicio 2: Definir el conjunto de secuencias de enteros no vacías, SecZnoV. Usando la funcion dada restoZ escribir una funcion minSec que dada una secuencia no vacia de enteros devuelva el minimo.  Idem para el maximo (maxSec). Ejemplos:
minSec([1,3,0,4])
0
maxSec([1,3,0,4])
4
maxSec([])
Error: {Interprete columna: 8}
 Valor [] no pertenece al conjunto SecZnoV
porque no se cumple: [[] /= []].  
-}                     
restoZ :: Z* -> Z*
restoZ (xs) = resto(xs)   

 {-Definido como Conjunto) -} 
conj SecZnoV = {x en Z* | x /= [] }

 {-Definido como Funcion) -} 
secZnoV :: Z* -> Bool
secZnoV(secuencia) = False si secuencia == [] o True

{-Funcion auxiliar para que se entienda mejor minSec y maxSec -} 
sacarPrimero :: Z* -> Z*
sacarPrimero(secuencia) = resto(secuencia)

{-Devuelve 0 si es la secuencia [] / no se como capturar el error -} 

{- COMENTARIO Acepta la secuencia vacía devolviendo 0. Esto es porque no se usó SecZnoV como dominio de la función y restoZ(secuencia) == [] como se pedia -}

minSec :: Z* -> Z
minSec(secuencia) = 0 si secuencia == []
    o primero(secuencia) si restoZ(secuencia) == []
	o minSec(primero(secuencia):sacarPrimero(restoZ(secuencia))) si primero(secuencia) <= primero(restoZ(secuencia))
    o minSec(restoZ(secuencia))
    
 {-PROBLEMA ALGORÍTMICO:
 Datos de ENTRADA: Una secuencia de Enteros no vacía.
 Datos de SALIDA: Un número entero, que sea el MÍNIMO del Conjunto-}
 


 {- Ejemplo Concreto:
 
minSec([-1,12,3,-7,0,9])
    
Pregunta 1) ¿La secuencia es vacía? R: No.
Pregunta 2) ¿El resto de la secuencia es vacía? R: No. El resto es [12,3,-7,0,9]
Pregunta 3) ¿El primero de [-1,12,3,-7,0,9] es menor o igual que el primero de [12,3,-7,0,9]? R: Si. 
Entonces llamamos recursivamente: 
minSec([-1,3,-7,0,9])

Pregunta 1) ¿La secuencia es vacía? R: No.
Pregunta 2) ¿El resto de la secuencia es vacía? R: No. El resto es 
[3,-7,0,9]
Pregunta 3) ¿El primero de [-1,3,-7,0,9] es menor o igual que el primero de [3,-7,0,9]? R: Si. 

Entonces llamamos recursivamente: 
minSec([-1,-7,0,9])

Pregunta 1) ¿La secuencia es vacía? R: No.
Pregunta 2) ¿El resto de la secuencia es vacía? R: No. El resto es 
[-7,0,9]
Pregunta 3) ¿El primero de [-1,-7,0,9] es menor o igual que el primero de [-7,0,9]? R: NO
Entonces llamamos recursivamente: 
minSec(resto([-1,-7,0,9])), ES DECIR:

minSec([-7,0,9])

Pregunta 1) ¿La secuencia es vacía? R: No.
Pregunta 2) ¿El resto de la secuencia es vacía? R: No. El resto es 
[0,9]
Pregunta 3) ¿El primero de [-7,0,9] es menor o igual que el primero de [0,9]? R: Si

Entonces llamamos recursivamente: 
minSec([-7,9])
 
Pregunta 1) ¿La secuencia es vacía? R: No.
Pregunta 2) ¿El resto de la secuencia es vacía? R: No. El resto es 
[9]
Pregunta 3) ¿El primero de [-7,9] es menor o igual que el primero de [9]? R: Si

Entonces llamamos recursivamente: 
minSec([-7])


Pregunta 1) ¿La secuencia es vacía? R: No
Pregunta 2) ¿El resto de la secuencia es vacía? R: Si

Entonces, devolvemos  
primero(secuencia) es decir -7

Por tanto, el minSec([-1,12,3,-7,0,9]) es -7 -}

    
maxSec :: Z* -> Z
maxSec(secuencia) =  0 si secuencia == []
    o primero(secuencia) si resto(secuencia) == []
	o maxSec(primero(secuencia):sacarPrimero(resto(secuencia))) si primero(secuencia) >= primero(resto(secuencia))
    o maxSec(resto(secuencia))
    
 {-PROBLEMA ALGORÍTMICO:
 Datos de ENTRADA: Una secuencia de Enteros no vacía.
 Datos de SALIDA: Un número entero, que sea el MÁXIMO del Conjunto-}
 
  {- Funciona igual que la función minSec, pero buscando el maximo -}

{- Ejercicio 3: dado un elemento entero y una secuencia de enteros escribir una funcion pertenece que devuelve True si el elemento esta en la lista y False si no. Ejemplos:
pertenece (0, [1,3,0,4])
True
pertenece (-5, [1,3,0,4])
False
-}  
pertenece :: Z X Z* -> Bool
pertenece(x,secuencia) = False si secuencia == [] 
						o True si x == primero(secuencia)
                        o pertenece(x,resto(secuencia))
                        
 {-PROBLEMA ALGORÍTMICO:
 Datos de ENTRADA: Un numero entero y una secuencia de Enteros.
 Datos de SALIDA: Un valor booleano indicando si pertenece (True) o no pertenece (False) a la secuencia
 
pertenece (0, [1,3,0,4])
pertenece (0, [3,0,4])
pertenece (0, [0,4])
True

pertenece (-5, [1,3,0,4])
pertenece (-5, [3,0,4]) 
pertenece (-5, [0,4]) 
pertenece (-5, [4])
pertenece (-5, [])
False
 
 -}
 
                        
{- Ejercicio 4: dadas dos secuencias de enteros escribir una funcion inter que devuelve una secuencia con los elementos comunes a ambas. 
Ejemplo:
inter ([1,3,0,4], [-5,3,0,-1,2])
[3,0] 
-}            

{- PROBLEMA ALGORÍTMICO:
 Datos de ENTRADA: Dos secuencias de Enteros.
 Datos de SALIDA:Una secuencia de enteros
 -} 
                
inter :: Z* X Z* -> Z*
inter (a,b) = [] si a == []
				o [] si b == []
                o (primero(a) : inter(resto(a),b)) si pertenece(primero(a),b) == True
                o inter((resto(a),b))
                
{- COMENTARIO Funciona bien, pero no es conmutativa:
>inter([1,2,2],[1,2])
[1,2,2]
>inter([1,2],[1,2,2])
[1,2]                
-} 
                
{- Ejercicio 5: Definir una funcion mcd que dados dos naturales a y b distintos de 0 implemente el algoritmo de Euclides para hallar el maximo comun divisor de a y b. Componiendo la funcion divisores del Predefinido y algunas de las funciones anteriores,  definir una funcion mcdDef que dados dos naturales distintos de 0, devuelva el maximo comun 
divisor de ellos. -}    

{- PROBLEMA ALGORÍTMICO:
 Datos de ENTRADA: Dos numeros Naturales DISTINTOS de cero.
 Datos de SALIDA: Un numero natural
 -} 
 
mcd :: Nno0 X Nno0 -> N
mcd (a,b) = b si (mod(a,b) == 0 )
			o mcd(b,mod(a,b))
                        
mcdDef :: Nno0 X Nno0 -> N
mcdDef (a,b) = maxSec(inter(divisores(a),divisores(b)))

{- 
mcd(10,4)
Como mod(10,4) /= 0  mod(10,4)= 2
Llamamos recursivamente:
mcd(4,2)
Como mod(4,2) = 0, entonces
mcd(4,2) = 2

mcdDef(10,4) =  maxSec(inter(divisores(10),divisores(4)) -}