Dupliquer chaque élément dans une liste Haskell

Question

par fonctions Comment puis-je dupliquer chaque élément d'une liste avec deux fois. par exemple. dupliquer [1,3,5] devrait retourner [1,1,3,3,5,5]?

et de remplacer un élément par un autre élément dans une liste. par exemple. remplacer 3 30 [1, 3 ,4 ,5, 3, 4] devrait retourner [1, 30, 4, 5, 30, 4]

Je suis assez nouveau chez Haskell et j'ai besoin de soumettre un devoir aujourd'hui.

Toute aide serait grandement appréciée!

Answer 1

duplicateEach = (>>= replicate 2) 
duplicateEach2 = concatMap (replicate 2) 
duplicateEach3 xs = [ y | x <- xs, y<-[x,x] ] 

import Data.List.Split 

replaceOne f t xs = [ y | x<-xs, let y = if x==f then t else x] 

replaceSublist f t = intercalate t . sepBy f -- f and t is lists 

Answer 2

Plan sur les éléments et les répliquer. Puis concaténer les résultats:

concatMap (replicate 2) [1,3,5] 

Pour la deuxième question, regardez Data.List.Utils

replace [3] [30] [1,3,4,5,3,4] 

Answer 3

Vous pourriez penser à chaque fonction comme une séquence d'étapes:

par des fonctions Comment puis-je dupliquer chaque élément d'une liste avec deux fois.

Pour dupliquer chaque élément d'une liste xs, vous devez appliquer une fonction qui, étant donné un argument x, retourne la liste [x, x], à chaque élément du liste; Puisque cela produit une liste de listes, vous devrez concaténer les résultats. La liste concaténée la liste à chaque élément dupliqué:

k :: a -> [a] 
k x = [x,x] 

g :: (a -> b) -> [a] -> [b] 
g f [] = [] 
g f (x:xs) = f x : g f xs 

duplicate :: [a] -> [a] 
duplicate = concat . (g k) 

Depuis g = map et concat . g = concatMap, la fonction que vous recherchez est:

duplicate :: [a] -> [a] 
duplicate = concatMap (\x -> [x,x]) 
      => concatMap (replicate 2) 

Pour remplacer un élément une par une valeur b, parcourez la liste avec une fonction qui échange b pour un:

f :: Eq a => a -> a -> a -> a 
f o r x = if x == o then r else x 

replaceOn :: Eq a => a -> a -> [a] -> [a] 
replaceOn o r [] = [] 
replaceOn o r (x:xs) = f o r x : h o r xs 

Depuis h = map f, vous avez:

replaceOn :: a -> a -> [a] -> [a] 
replaceOn o r = map (\x -> if x == o then r else x) 

Je ne suis pas un expert Haskell. Cependant, cela m'aide à décomposer les problèmes de Haskell en séquences de "valeurs renvoyées". Ce sont comme des «étapes» dans un langage impératif. Les étapes sont composées à l'aide de combinateurs, de fonctions d'ordre supérieur et d'ordonnancement de fonctions. Vous pouvez penser à séquençage comme: faire f pour obtenir x; à g avec f x pour obtenir x ', etc.

Answer 4

Pour la première:

duplicate_each xs = foldr dup [] xs 
    where dup x y = x : x : y 

au moins pour moi, il est une solution plus claire.