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

module Control_1 where


-- 1. En el fragmento de programa que sigue, dar posibles tipos polimórficos 
--    de f y g, y completar sus reglas. Para la regla de g, sólo se exige que 
--    haga uso de sus parámetros x e y.    
--    Según lo hecho, ¿qué vale f 'a' 3 ?.  ¿Y f 5 2 ?	[1.5]

-- 	g :: ... -- completar
-- 	g x 0 = []
-- 	g x n = ... -- completar,usando x y n
--
-- 	f :: ... -- completar
-- 	f x 0 = ... -- completar 
-- 	f x n = (g x n):(f x (n-1))


g :: a -> Integer -> [a]		
g x 0 = []
g x n = x : g x (n-1) 	

f :: a -> Integer -> [[a]] 		
f x 0 = []		
f x n = (g x n):(f x (n-1))

	
-- 2. Implementar una función Haskell que calcula las veces que un determinado 
--    dígito está en un entero. Por ejemplo, 3 está 4 veces en 432633 y 0 veces 
--    en 455, 0 está 2 veces en 10021, etc. 

digitos :: Integer -> Integer -> Integer
digitos _ 0 = 0
digitos c n = if (mod n 10) == c
              then 1 + digitos c (div n 10)
              else digitos c (div n 10)

-- Nota: el caso concreto 'digitos 0 0' devuelve 0 (y debería ser 1).
--       Podríamos hacer otra función que trate éste caso aparte,
--       que sería la principal y llamaría a la enterior en 
--       cualquier otro caso:

dig :: Integer -> Integer -> Integer
dig c n = if c == 0 && n == 0  
             then 1 
             else digitos c n
            
-- observemos que dig no puede ser recursiva
            
-- 3. Implementar en Haskel una función para pasar un entero a una base 
--    cualquiera (incluso mayor que 10). La salida será en forma de string. Por 
--    ejemplo, si pasamos 5 a base 2 saldría el string "101", si pasamos 684 
--    a base 16 saldría el string "2AC", etc.


aB :: Integer -> Integer -> String
aB n b = aStr (aBase n b)

aBase :: Integer -> Integer -> [Integer]
aBase n b = if n<b
            then [n]
            else (aBase (div n b) b) ++ [mod n b]
            
aStr :: [Integer] -> String
aStr (n:t) = (valor n lista) : aStr t
             where lista = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
aStr []    = []
          
valor :: Integer -> String -> Char
valor 0 (h:t) = h
valor n (_:t) = valor (n-1) t