-- -------------------------------------------------------------------------------
-- PROGRAMACION FUNCIONAL  -  SOLUCIONES CONTROL 1  (25.4.06)
-- -------------------------------------------------------------------------------

module Control_1 where

-- -------------------------------------------------------------------------------

-- 1. Dar implementaciones sencillas para f y g, con f recursiva, y reducir la 
--    siguiente expresión:	
--
--                         f ( f (if g ('w',5) then 0 else 1))

--    Por ejemplo, para:

g :: (Char, Int) -> Bool  -- pues g tiene como argumento el par ('w',5) y 
                          -- su salida queda en la pregunta del if
g (a,n) = ord a < n

f :: Int -> Int           -- pues f recoge un entero del if, y su salida 
                          -- queda como argumento de ella misma
f 0 = 0
f n = n - f (n-1)

-- la expresión se reduce a:
--
--   f ( f (if g ('w',5) then 0 else 1))
--   ----- regla de g --------------> f ( f (if ord 'w' < 5 then 0 else 1))
--   ----- reglas de ord (ascii) ---> f ( f (if False then 0 else 1))
--   ----- reglas de if ------------> f ( f 1)
--   ----- segunda regla de f ------> f ( 1 - f 0)
--   ----- primera regla de f ------> f ( 1 - 0) = f 1 = 1


-- --------------------------------------------------------------------------------

-- 2. Implementar una función Haskell que suma las cifras de un entero. 
--    Generalizarla para una lista de enteros.	

sumCifras :: Integer -> Integer
sumCifras 0 = 0
sumCifras n = (mod n 10) + sumCifras (div n 10)

sumCG :: [Integer] -> [Integer]
sumCG [] = []
sumCG (h:t) = (sumCifras h) : sumCG t



-- ---------------------------------------------------------------------------------

-- 3. Implementar en Haskel la función polimórfica menorL, que obtiene de una lista 
--    de enteros, el menor elemento y una lista con los restantes (en cualquier orden). 
--    Por ejemplo, con la lista [4,2,4,1,2,1,3,5] obtiene 1 y la lista [4,2,4,1,2,3,5] 
--    (los elementos podrían estar en otro orden). No deben implementarse ambas tareas 
--    por separado. Usando menorL, implementar una función polimórfica para ordenar 
--    una lista (ordenación por selección).


menorL :: (Ord a) => [a] -> (a,[a])
menorL [x] = (x,[])
menorL (h:t) = let
                (y,r) = menorL t
              in
                if h<y
                   then (h,t)
                   else (y,h:r)
    
                                  
ordSelec :: (Ord a) => [a] -> [a]

ordSelec [] = []
ordSelec l  = let
               (m,s) = menorL l
              in
               m : (ordSelec s)