Haskell/Soluções: diferenças entre revisões
| [edição não verificada] | [edição não verificada] |
Conteúdo apagado Conteúdo adicionado
Linha 401:
where go [] n = n
go (x:xs) n = go xs (n+1)
</source>
== [[Haskell/Listas II|Listas II]] ==
=== Listas infinitas ===
{{Exercício|1=
Defina a função recursiva <code>repetir :: a -> [a]</code> que cria listas infinitas. O Prelude possui a <code>repeat</code> que realiza a mesma tarefa.}}
<source lang="haskell">
repetir :: a -> [a]
repetir x = x : repetir x
</source>
=== Generalizando ===
{{Exercício|1=
Escreva as seguintes funções e teste-as no GHCi. Não se esqueça das assinaturas de tipo.
# <code>tomarInt</code> retorna os primeiro ''n'' elementos de uma lista. Exemplo: <code>tomarInt 4 [11,21,31,41,51,61] = [11,21,31,41]</code>.
# <code>eliminarInt</code> elemina os ''n'' primeiros elementos de uma lista e retorna o restante. Exemplo: <code>eliminaInt 3 [11,21,31,41,51] = [41,51]</code>.
# <code>somaInt</code> retorna a soma dos elementos de uma lista.
# <code>scanSoma</code> soma os elementos de uma lista e retorna uma lista com valores acumulados. Exemplo: <code>scanSoma [2,3,4,5] = [2,5,9,14]</code>.
# <code>difs</code> retorna a diferença entre elementos adjacentes de uma lista. Exemplo: <code>difs [3,5,6,8] = [2,1,2]</code>.
Dica: possíveis soluções destes exercícios usam funções auxiliares. Outra possibilidade é usar casamento de padrões com listas de pelo menos dois elemtnso usando <code>(x:y:ys)</code>.
As três primeiras funções estão no Prelude e se chamam <code>take</code>, <code>drop</code> e <code>sum</code>.
}}
# <source lang="haskell">
tomarInt :: Int -> [a] -> [a]
tomarInt _ [] = []
tomarInt 0 _ = []
tomarInt n (x:xs) = x : tomarInt (n - 1) xs
</source>
# <source lang="haskell">
eliminarInt :: Int -> [a] -> [a]
eliminarInt _ [] = []
eliminarInt 0 xs = xs
eliminarInt n (x:xs) = eliminar (n - 1) xs
</source>
# <source lang="haskell">
somarInt :: [Int] -> Int
somarInt [] = 0
somarInt (x:xs) = x + somarInt xs
</source>
# <source lang="haskell">
scanSoma :: [Int] -> [Int]
scanSoma [] = []
scanSoma (x:[]) = x : []
scanSoma (x:y:ys) = x : scanSoma ((x + y) : ys)
-- Usando função auxiliar
scanSoma' ls = aux 0 ls
where aux :: Int -> [Int] -> [Int]
aux tot [] = []
aux tot (x:xs) = tot' : aux tot' xs
where tot' = x + tot
</source>
# <source lang="haskell">difs :: [Int] -> [Int]
difs [] = []
difs (x:[]) = []
difs (x:y:ys) = (y - x) : difs (y:ys)
-- Usando função auxiliar
difs' :: [Int] -> [Int]
difs' (x:xs) = aux (x:xs) xs
where aux _ [] = []
aux (a:as) (b:bs) = (b - a) : aux as bs
</source>
| |||