Práctica 7, ejercicio 2

Me faltan todavía palabraMasLarga y palabras, lo lamento si alguien entró ilusionado porque estaba buscando esos 😳
Cuando los tenga los pongo, pero pensé que a alguien le podría servir ir viendo estos si está medio trabado.

Si alguien quiere colaborar y ya los tiene, bienvenido sea!

Archivo hs para bajar: acá

Código:

sacarTodos :: [Char] -> [Char] -> [Char]
sacarTodos x (y:ys)
	| length x > length (y:ys) = (y:ys)
	| length x == length (y:ys) = (sacarDelPrincipio x (y:ys))
	| (esPrefijo x (y:ys)) = (sacarTodos x (sacarPrefijo x (y:ys)))
	| (not (esPrefijo x (y:ys)))= (y:(sacarTodos x ys))

sacarBlancosRepetidos :: [Char] -> [Char]
sacarBlancosRepetidos [] 		= []
sacarBlancosRepetidos (x:xs)
	| x==' ' 			= if (head xs)==' ' then (sacarBlancosRepetidos xs) else (x:(sacarBlancosRepetidos xs))
	| otherwise			= (x:(sacarBlancosRepetidos xs))

contarPalabras :: [Char] -> Integer
contarPalabras [] 	= 0
contarPalabras (x:[]) 	= 1
contarPalabras (x:xs)
	| x==' '	= 1 + (contarPalabras xs)
	| otherwise = (contarPalabras xs)

aplanar :: [[Char]] -> [Char]
aplanar ((x:xs):[]) 	= (x:xs)
aplanar ((x:xs):(y:ys)) = (x:xs)++(aplanar (y:ys))

aplanarConBlancos :: [[Char]] -> [Char]
aplanarConBlancos ((x:xs):[]) 		= (x:xs)
aplanarConBlancos ((x:xs):(y:ys))	= (x:xs)++[' ']++(aplanarConBlancos (y:ys))

aplanarConNBlancos :: [[Char]] -> Integer -> [Char]
aplanarConNBlancos ((x:xs):[]) n	= (x:xs)
aplanarConNBlancos ((x:xs):(y:ys)) n	= (x:xs) ++ (nBlancos n) ++(aplanarConNBlancos (y:ys) n)

nat2bin :: Integer -> [Integer]
nat2bin 0 = [0]
nat2bin 1 = [1]
nat2bin n = (nat2bin (div n 2)) ++ [mod n 2]

bin2nat :: [Integer] -> Integer
bin2nat [] = 0
bin2nat (x:xs) = x * (2^(length xs)) + (bin2nat xs)

nat2hex :: Integer -> [Char]
nat2hex 1 	= ['1']
nat2hex 2 	= ['2']
nat2hex 3 	= ['3']
nat2hex 4 	= ['4']
nat2hex 5 	= ['5']
nat2hex 6 	= ['6']
nat2hex 7 	= ['7']
nat2hex 8 	= ['8']
nat2hex 9 	= ['9']
nat2hex 10 	= ['A']
nat2hex 11 	= ['B']
nat2hex 12 	= ['C']
nat2hex 13 	= ['D']
nat2hex 14 	= ['E']
nat2hex 15 	= ['F']
nat2hex n = (nat2hex (div n 16)) ++ (nat2hex (mod n 16))

---- FUNCIONES AUXILIARES ----
sacarDelPrincipio :: [Char] -> [Char] -> [Char]
sacarDelPrincipio x y
	| (esPrefijo x y) = (sacarPrefijo x y)
	| (not (esPrefijo x y)) = y

esPrefijo :: [Char] -> [Char] -> Bool
esPrefijo [] y = True
esPrefijo (x:xs) [] = False
esPrefijo (x:xs) (y:ys)
	| x==y = (esPrefijo xs ys)
	| otherwise = False

sacarPrefijo :: [Char] -> [Char] -> [Char]
sacarPrefijo [] y = y
sacarPrefijo (x:xs) (y:ys) = sacarPrefijo xs ys

nBlancos :: Integer -> [Char]
nBlancos 0 = []
nBlancos n = [' ']++ (nBlancos (n-1))

ult :: [a] -> a
ult (x:[]) = x
ult (x:xs) = ult xs

palabraMasLarga y palabras fue de los que más me costo

lo que hice fue hacer primero palabras, despues hacer un auxiliar para que dice cual es la palabra más larga y por último unir estos dos para laPalabraMasLarga

palabraMasLarga :: [Char] -> [Char]
palabraMasLarga x = elMasLargo (palabras x)

elMasLargo :: [[Char]] -> [Char]
elMasLargo (x:[]) = x
elMasLargo (x:(y:ys))
	| length x >= length y 	= elMasLargo (x:ys)
	| otherwise			= elMasLargo (y:ys)

palabras :: [Char] -> [[Char]]
palabras x
	| not(hayPalabra x) 	= []
	| head x == ' '		= palabras (tail x)
	| otherwise			= p : (palabras (sacarPrefijo p x))
		where p = primerPalabra x

hayPalabra :: [Char] -> Bool
hayPalabra [] = False
hayPalabra (x:xs)
	| x == ' ' 	= hayPalabra xs
	| otherwise = True

primerPalabra :: [Char] -> [Char]
primerPalabra (x:[]) = [x]
primerPalabra (x:xs)
	| x == ' ' =  []
	| otherwise = x:(primerPalabra xs)

sacarPrefijo :: [Char] -> [Char] -> [Char]
sacarPrefijo [] x = x
sacarPrefijo (y:ys) (x:xs) = (sacarPrefijo ys xs)

me quedo bastante largo, supongo que se puede hacer mejor, pero creo q este sirve.
Saludos!

jjaja y yo que pensé que era el único haciendo haskell a la madrugada del domingo 😄

estaban complicados esos dos ejercicios!