Travailler sur une liste de listes en Haskell

Je suis un peu débutant à Haskell donc, je me bats un peu avec le type strict des trucs, je me demandais si quelqu'un peut m'aider avec une fonction je suis en train de construire. Fondamentalement, il faut une liste de listes, par exemple:

[[1,2,3], [7,6,8], [0,3,4]]

et les ajoute dans une liste de la traduction de la plus tard de la liste par le nombre de postes, il est long. Ainsi, travailler sur la liste d'exemples, il serait effectivement faire quelque chose comme:

foldl (zipWith +) [] [[1,2,3],[0,7,6,8],[0,0,0,3,4]]

Voici ma fonction actuelle (qui est le type d'erreurs):

    addLists :: [[Integer]] -> [Integer]
    addLists [[]] = []
    addLists [[x]] = [x]
    addLists [x:xs] = zipWith (+) [x] ([0]++ (addLists xs))

Veuillez préciser ce que vous souhaitez que le résultat de addLists [[1,2,3], [7,6,8], [0,3,4]]. Il n'est pas évident de votre question.
Il semble que vous avez édité votre question de le préciser, mais je crains que je ne comprends toujours pas. Quel doit être le résultat de addLists [[1,2,3], [7,6,8], [0,3,4]] ressembler? L'exemple que vous avez donné, foldl (zipWith +) [] [[1,2,3],[0,7,6,8],[0,0,0,3,4]] n'est pas de type vérifier, et je ne peux pas comprendre ce que vous aviez l'intention de faire.
Voulez-vous le résultat à [1, 2+7, 3+6+0, 8+4, 4] = [1,9,9,12,4]?
Oups, signifiait [1,9,9,11,4]?
Désolé, la sortie doit être [1, 2+7, 3+6+0, 8+3, 4]

OriginalL'auteur Nathan Edwards | 2012-10-31

haskell list

3

Je pense que cela ne ce que vous voulez
```
import Data.List (transpose)

addLists :: Num a => [[a]] -> [a]
addLists xs = map sum . transpose $ zipWith (\n x -> replicate n 0 ++ x) [0..] xs
```
Merci, pouvez-vous expliquer exactement comment il fonctionne? Je peux très bien suivre, mais pas assez!
Désolé, je voulais dire de revenir et de développer cette réponse, mais somethign d'autre est venu. Aurez très bientôt, j'espère!
Un peu plus agréable: addLists = map sum . transpose . zipWith (++) (inits (repeat 0)). La partie intéressante est transpose, qui est un Data.List fonction digne d'être familier avec. Puisque c'est une composition, vous pouvez jouer avec chaque partie individuellement pour comprendre comment il fonctionne.
Merci beaucoup. J'ai travaillé sur la façon dont il fonctionne maintenant 🙂

OriginalL'auteur Chris Taylor
6

Noter que ([0]++) est le même que (0:), qui va donner un aspect plus propre et nous sauver d'une nanoseconde ou deux.
(Je plaisante avec l'ordre de la nanoseconde chose - aucun humain ne peut dire quand quelque chose est une nanoseconde plus rapide, mais il est plus agréable de cette façon de toute façon.)

Nous allons d'abord penser à faire les listes dont vous avez besoin. Nous voulons
```
postponeLists [[1,2,3], [7,6,8], [10,20,30,40]] 
             = [[1,2,3], [0,7,6,8], [0,0,10,20,30,40]]
             = [1,2,3] : ones that should have zero in front of them
```
Qui est assez d'informations pour une définition:
```
postponeLists [] = []
postponeLists (l:ls) = l : map (0:) (postponeLists ls)
```
Maintenant, vous avez dit
```
foldl (zipWith +) [] [[1,2,3],[0,7,6,8],[0,0,0,3,4]]
```
mais vous voulez dire que
```
foldl (zipWith (+)) [] [[1,2,3],[0,7,6,8],[0,0,0,3,4]]
```
mais malheureusement, qui vous donne [] parce que zipWith s'arrête dès que l'une des listes d'exécuter à partir d'éléments.
Nous avons besoin de les compresser qui ne s'arrête pas.

Solution 1: trouver le plus long, faire tout ce qui maxlength à l'aide de take maxlength.(++ repeat 0)

Solution 2: écrire une autre zipWith fonction qui ne s'arrête pas.

Je préfère la solution 2. Regardons les définition de zipWith
```
zipWith :: (a->b->c) -> [a]->[b]->[c]
zipWith f (a:as) (b:bs) = f a b : zipWith f as bs
zipWith _ _      _      = [] -- here's the problem - it stops as soon as any list is empty
```
OK, il ne faut pas s'arrêter alors:
```
zipWithMore :: (a -> a -> a) -> [a] -> [a] -> [a]
zipWithMore f (a:as) (b:bs) = f a b : zipWithMore f as bs
zipWithMore f []      bs      = bs -- if there's more in bs, use that
zipWithMore f as      []      = as -- if there's more in as, use that
```
Maintenant, vous pouvez remplacer zipWith (+) avec zipWithMore (+). Je vais laisser le mot de la fin pour vous.

Merci, une grande aide!
(0:) ne vous gagner des nanosecondes sur ([0]++), du moins pas avec ghc -O2. (:) parfois est de plus agréable que de (++) où est applicable, mais vous ne devriez pas laisser l'ordre de la nanoseconde à la spéculation comme celle de la forme de votre code.
Bien sûr que non! J'ai été en indiquant par la blague en disant "sauvez un ordre de la nanoseconde ou deux" qu'il est inutile. (0:) est plus agréable si, et j'ai voulu introduire cette habitude. Qui se soucie de nanosecondes avec un problème comme celui-ci? J'ai fait plus clair, il n'était pas destiné au sérieux.

OriginalL'auteur AndrewC

Vous devez vous connecter pour publier un commentaire.