Mit Haskell map-Funktion berechnet die Summe einer Liste

Haskell

addm::[Int]->Int
addm (x:xs) = sum(x:xs)

War ich in der Lage zu erreichen, um eine Summe einer Liste mit sum Funktion aber ist es möglich die Summe einer Liste mit map Funktion? Auch was die Verwendung der map-Funktion?

Sie vereinfachen können Sie addm nur addm = sum.
Hinweis: Ihre addm-Funktion ist nicht definiert für die leere Liste, es sei denn, Sie etwas tun, wie Waldheinz schlägt.

InformationsquelleAutor Sudantha | 2011-05-30

20

Können Sie nicht wirklich nutzen map zusammenfassend eine Liste, weil die Karte behandelt jedes element in der Liste, die unabhängig von den anderen. Sie können map beispielsweise erhöht jeder Wert in einer Liste, wie in
```
map (+1) [1,2,3,4] -- gives [2,3,4,5]
```
Einen anderen Weg, um Ihre addm wäre, die Nutzung foldl:
```
addm' = foldl (+) 0
```
InformationsquelleAutor Waldheinz
6

Hier ist es, das vermeintlich Unmögliche definition von sum im Hinblick auf map:
```
sum' xs  =  let { ys = 0 : map (\(a,b) -> a + b) (zip xs ys) } in last ys
```
dieser zeigt tatsächlich, wie scanl umgesetzt werden können, in Bezug auf map (und zip und last), die oben genannten gleichwertig zu foldl (+) 0 xs === last $ scanl (+) 0 xs:
```
scanl' f z xs  =  let { ys = z : map (uncurry f) (zip ys xs) } in ys
```
Ich erwarte, dass man berechnen kann, viele Dinge mit map, die Vermittlung von Informationen aller Art fließen durch zip.

edit: das oben ist nur ein zipWith in Verkleidung natürlich (und zipWith ist eine Art map2):
```
sum' xs  =  let { ys = 0 : zipWith (+) ys xs } in last ys
```
Dies scheint darauf hinzuweisen, dass scanl ist vielseitiger als foldl.
- Ok, es ist möglich, aber ich glaube nicht, dass die Sprache Haskell. Aber +1 weil technisch gesehen hast du Recht. 🙂
- Ich denke, Sie schummeln hier, Wird. Im Grunde lese ich die Frage, wie die Frage, ob Sie mit der Functor [] Beispiel zur Berechnung der Länge einer Liste; und Ihre Antwort ist, dass Sie verwenden können, eine Applicative [] Instanz zu tun (im Grunde ZipList). Ich weiß, ich bin "bereichern" die Frage (so zu sagen) durch das Lesen Functor hinein, aber durch das argument, Sie bereichern es mehr, als ich bin, seit Applicative ist mächtiger als Functor.
- der Sinn dieser Antwort ist, dass die Listen sind nicht Sätze, die ich Schätze; Ihre Struktur (Elemente' - Positionen; erste/Letzte element) ist gut sichtbar; map ist nicht nur fmap. IOW instance Functor [] spricht von Listen als sets, da nur fmap verfügbar ist &nichts anderes. mit sets gibt es nur die Mitgliedschaft, nicht in der Lage, so gibt es keine Ordnung. wir können sehr gut definieren Applicative für Listen-als-sets auch, mit dem kartesischen Produkt die einzig mögliche Umsetzung - gerade weil es kein Konzept der position. Aber mit ihm, innere Produkt wird eine weitere Möglichkeit (d.h. zip, d.h. ZipList).
- Listen sind indizierte Familien, es scheint, oder Sequenzen. Wenn Sie dies akzeptieren, können Sie nicht Objekt, um die Verwendung von zip. Wenn Sie Objekt, das bedeutet, dass Sie die Behandlung von Listen als nicht-sequenziert, ungeordnete Sammlungen.
- eine andere Sache ist, die OP ist nicht zu sagen, dass map ist die einzige Funktion, die erlaubt ist. Also ja, diese Antwort nutzt map, zip und last im Endeffekt die Umsetzung sum = foldl (+) 0, aber immer noch, es nutzt map in eine nicht-triviale Art und Weise, dies zu erreichen.
InformationsquelleAutor Will Ness
5

Es ist nicht möglich map zu reduzieren, eine Liste seiner Summe. Diese rekursive Muster ist ein fold.
```
sum :: [Int] -> Int
sum = foldr (+) 0
```
Beachten Sie übrigens, dass Sie definieren können map als fold als auch:
```
map :: (a -> b) -> ([a] -> [b])
map f = fold (\x xs -> f x : xs) []
```
Dies ist, weil foldr ist die kanonische rekursive Funktion, die auf Listen.

Referenzen: Ein tutorial über die Universalität und die Ausdruckskraft der Falten, Graham Hutton, J. Funktionale Programmierung 9 (4): 355-372, Juli 1999.

InformationsquelleAutor Don Stewart
4

Nachdem einige Einsichten, die ich hinzufügen, die eine andere Antwort: Sie können nicht die Summe einer Liste mit map ist, aber Sie können die Summe mit seinem monadischen version mapM. Alles, was Sie tun müssen, ist die Verwendung eines Writer Monade (siehe LYAHFGG) über die Sum monoid (siehe LYAHFGG).

Schrieb ich eine spezielle version, das ist wahrscheinlich einfacher zu verstehen:
```
data Adder a = Adder a Int

instance Monad Adder where
  return x = Adder x 0
  (Adder x s) >>= f = let Adder x' s' = f x
                      in Adder x' (s + s') 

toAdder x = Adder x x

sum' xs = let Adder _ s = mapM toAdder xs in s  

main = print $ sum' [1..100]
--5050
```
Adder ist nur ein wrapper um einige geben, die hält auch ein "running sum." Wir können Adder eine Monade, und hier spielt es einige Arbeit: Wenn die operation >>= (ein.k.ein. "binden") ausgeführt wird, gibt es das neue Ergebnis und der Wert der Laufenden Summe, das Ergebnis plus die Originale Summe. Die toAdder - Funktion nimmt ein Int und erzeugt eine Adder hält, dass dieses argument sowohl gewickelt als Wert und als laufende Summe (eigentlich interessiert uns nicht der Wert, sondern nur in der Summe Teil). Dann in sum' mapM tun kann ist seine Magie: Während es funktioniert ähnlich wie map für die eingebetteten Werten in der Monade, der es ausführt, "monadischen" Funktionen wie toAdder, und Ketten diese Anrufe (es verwendet sequence um dies zu tun). An diesem Punkt erhalten wir durch die "Hintertür", die unsere Monade, die Interaktion zwischen der Listen-Elemente, die die standard - map fehlt.

InformationsquelleAutor Landei
2

Map "Karten" jedes element der Liste, um ein element in Ihrer Ausgabe:
```
let f(x) = x*x
map f [1,2,3]
```
Dieser gibt eine Liste der Quadrate.

Summe aller Elemente in einer Liste verwenden Sie Falten:
```
foldl (+) 0 [1,2,3]
```
+ ist die Funktion, die Sie anwenden möchten, und 0 ist der erste Wert (0-Summe, 1 für Produkt etc)

InformationsquelleAutor Frank Schmitt
1

Wie die anderen Antworten zeigen, ist der "normale" Weg ist die Verwendung eines fold Funktionen. Allerdings ist es möglich, etwas zu schreiben, ziemlich ähnlich zu einer while - Schleife in imperativen Sprachen:
```
sum' [] = 0
sum' xs = head $ until single loop xs where 
   single [_] = True
   single _ = False
   loop (x1 : x2 : xs) = (x1 + x2) : xs 
```
Er fügt hinzu, die ersten beiden Elemente der Liste zusammen, bis es endet mit einem element der Liste und gibt diesen Wert (mit head).

InformationsquelleAutor Landei
1

Erkenne ich diese Frage bereits beantwortet wurde, aber ich wollte noch hinzufügen das gedacht...
```
listLen2 :: [a] -> Int
listLen2 = sum . map (const 1)
```
Ich glaube, es gibt die Konstante 1 für jedes Element in der Liste, und gibt die Summe zurück!
Vielleicht nicht der beste Programmierstil, aber es war ein Beispiel mein professor hat zu uns Studenten, dass scheint zu beziehen sich auf diese Frage gut.

InformationsquelleAutor user3481138
0

map kann niemals das primäre tool für die Summierung der Elemente eines Containers, in viel die gleiche Weise, dass ein Schraubendreher, kann niemals das primäre tool für einen Film. Aber Sie können einen Schraubendreher verwenden, um fix einen Film-Projektor. Wenn Sie wirklich wollen, können Sie schreiben
```
import Data.Monoid
import Data.Foldable

mySum :: (Foldable f, Functor f, Num a)
      => f a -> a
mySum = getSum . fold . fmap Sum
```
Natürlich, das ist dumm. Sie können einen mehr Allgemeinen, und möglicherweise effizienter, version:
```
mySum' :: (Foldable f, Num a) => f a -> a
mySum' = getSum . foldMap Sum
```
Oder besser, benutzen Sie einfach sum, weil Sie die eigentlich gemacht für den job.

InformationsquelleAutor dfeuer

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.