Haskell itérer sur une liste

Je sais que vous supposez à penser différemment en Haskell, mais quelqu'un peut me donner une réponse rapide sur la façon de parcourir une liste ou une liste imbriquée et imprimer un caractère sur la base de la valeur de l'élément de la liste.

list1 = [[1 0 0][0 1 0][0 0 1]]

Par itération dans cette liste imbriquée, il doit imprimer x 0 et y 1

yxx
xyx
xxy

Grâce

Plus généralement, en cas de déplacement à partir d'un langage impératif pour un langage fonctionnel, vous devriez probablement arrêter de penser "itérer sur une liste" et de penser davantage en termes de fonctions comme map et filter.

OriginalL'auteur nobody | 2011-09-27

Tout d'abord, je pense que tu veux dire:

list1 :: [[Int]]
list1 = [[1,0,0],[0,1,0],[0,0,1]]

Que pour ce que vous voulez:

valueOf :: Int -> Char
valueOf 0 = 'x'
valueOf 1 = 'y'
valueOf _ = 'z'

listValues :: [[Int]] -> [String]
listValues = map (map valueOf)

printValues :: [[Int]] -> IO ()
printValues = putStrLn . unlines . listValues

Puis dans ghci:

*Main> printValues list1 
yxx
xyx
xxy

OriginalL'auteur ivanm

Essayez ceci:

fun :: [[Int]] -> [String]
fun = (map . map) (\x -> if x == 0 then 'x' else 'y')

Si vous avez vraiment besoin de l'impression de résultat:

printSomeFancyList :: [[Int]] -> IO ()
printSomeFancyList = putStrLn . unlines . fun

OriginalL'auteur franza

définir f par quelque chose comme

f x = if x == 0 then 'x' else 'y'

puis

map (map f) [[1,0,0],[0,1,0],[0,0,1]]

est ce que vous voulez ou si vous le souhaitez amateur:

map' = map.map
map' f [[1,0,0],[0,1,0],[0,0,1]]

OriginalL'auteur Carsten

1
```
iterateList = foldl1 (>>).concat.intersperse [putStrLn ""].(map.map) (\c ->  putStr $ if (c==0) then "X" else "Y")
```
Vous aurez besoin d'importer des Données.Liste (intercaler,foldl1)
Vous pouvez remplacer concat.intersperse avec intercalate et devrait remplacer l' foldl1 (>>) avec foldr (>>) (return ()) de sorte qu'il ne tombe pas en panne. sequence_ est encore plus beau.
En outre, vous pouvez utiliser mapM_ pour l'amener à mapM_.((>> putStrLn "").).mapM_ $ \c -> .... 🙂

OriginalL'auteur Satvik
1

Les solutions à l'aide de map sont privilégiées Haskell style. Mais pendant que vous êtes en train d'apprendre, vous pouvez trouver de récursion explicite plus facile à suivre. Comme:
```
charSub :: Int -> Char
charSub 0 = 'x'
charSub 1 = 'y'
charSub x = error "Non-binary value!"

listSub :: [Int] -> String
listSub [] = []
listSub (x:xs) = (charSub x) : (listSub xs)

nestedSub :: [[Int]] -> String
nestedSub [] = []
nestedSub (y:ys) = (listSub y) ++ "\n" ++ (nestedSub ys) 
```
map fait à peu près la même chose, il applique une fonction à chaque élément d'une liste. Mais il peut être plus facile de voir ce qui se passe ici.

OriginalL'auteur Zopa
0

Si vous êtes intéressé par l'arbitraire des listes imbriquées, alors vous pouvez écrire quelque chose comme ceci (un arbitraire de la liste imbriquée est essentiellement un arbre):
```
data Nested a = Leaf a | Nest [Nested a] deriving Show

traverse :: Nested Integer -> Nested Char
traverse (Leaf x) = Leaf (valueOf x)
traverse (Nest xs) = Nest (map traverse xs)

valueOf :: Integer -> Char
valueOf 0 = 'x'
valueOf 1 = 'y'
valueOf _ = 'z'
```
Avec que vous pouvez faire:
```
Main> let nl = Nest [Leaf 1, Leaf 0, Nest [Leaf 0, Leaf 0, Leaf 1, Nest [Leaf 1, Leaf 1, Leaf 0]], Nest [Leaf 1, Leaf 1]]
Main> traverse nl
Nest [Leaf 'y',Leaf 'x',Nest [Leaf 'x',Leaf 'x',Leaf 'y',Nest [Leaf 'y',Leaf 'y',Leaf 'x']],Nest [Leaf 'y',Leaf 'y']]
```
La fonction traverse prend un arbitraire de la liste imbriquée de Integers et renvoie un correspondant de la liste imbriquée de Chars selon les valueOf règle

Vous pourriez avoir un certain plaisir à essayer de définir une véritable arbitrairement liste imbriquée: c'est à dire la somme des types [a], [[a]], [[[a]]], [[[[a]]]], ... Interdit par exemple. [[0,1],2,[[3],4]], l'arbre permet.
vous avez raison

OriginalL'auteur MarcoS

-1

Les solutions

cambiar = putStr.unlines.(map (map f)) where f x = if x == 0 then 'x' else 'y'

cambiar [[1,0,0],[1,1,0],[1,1,1]] ==> yxx yyx yyy

OriginalL'auteur jmejia

Vous devez vous connecter pour publier un commentaire.