Pattern Matching und List-Comprehension in der Liste von Tupeln

type a = [(Int,Int,Int,Int)]

fun:: a -> Int
func [a,b,c,d] = ?

Habe ich eine Liste von Tupeln, wie das, was ich erforderlich ist, gelten list comprehensions oder pattern matching .. z.B. unter Summe oder filter nur teilen 2 Nummern ... ich will einfach nur einen start-wie auf Werte zugreifen und oder eine Liste Verständnis dieser Liste von Tupeln

  • Können Sie uns ein Beispiel geben von dem, was Sie versuchen zu erreichen?
  • Einfaches Beispiel sich aus der Summe der a
InformationsquelleAutor Sudantha | 2011-06-06
  1. 8

    Zusammenfassend as, verwenden Sie so etwas wie dieses:

    type A = [(Int, Int, Int, Int)]

func :: A -> Int
func tuples = sum [a | (a, b, c, d) <- tuples]

    Beachten Sie auch, dass ein Typ-alias muss beginnen mit einem GROSSBUCHSTABEN. Kleinbuchstaben werden verwendet für Typ Variablen.

    • vielen Dank, wie dies zu tun ? --> [x|x<-xs|x 'mod'2] .. ist es möglich ?
    • Um eine Bedingung hinzuzufügen, trennen Sie es von der "generator" x <- xs mit einem Komma, z.B. [x | x <- xs, x `mod` 2 == 0]
    • danke, was ich nicht habe ist, wie es auf der A ? wie die oben genannten ur Antwort 🙂
    • Meinst du die Summe nur die noch as? sum [a | (a, b, c, d) <- tuples, a `mod` 2 == 0].
    • sorry, verwechselt , die Daten zurück geben .. vielen Dank u gelöst, ein bisschen prob 🙂
    • hey ich will nur func tuples = [a | a <- tuples,a mod` 2 == 0]", um diese zur Rückgabe aller mod2 ppl aus der Liste der Tupel aber immer eine Fehlermeldung keine Ahnung Instance of Integral (Int,Int,Int,Int) required for definition of func
    • ich habe gerade drucken wollen, benötigen Sie gleicht von der Liste der Tupel.
    • Tupel passen a gegen das gesamte Tupel. Wenn Sie möchten, dass nur das erste element, das Sie verwenden müssen (a,b,c,d) oder (a,_,_,_).

    InformationsquelleAutor hammar
  2. 3

    hammar Antwort Liste Verstehens, die grundlegenden Schemas für rekursive Funktionen mittels pattern-matching ist:

    f [] = ..
f ((a,b,c,d):xs) = ..

    So müssen Sie einen Basis-Fall für eine Liste, die keine 4-Tupel, und einen rekursiven Fall, wenn die Liste besteht aus einem 4-Tupel (a,b,c,d) gefolgt von einer (eventuell leeren, möglicherweise nicht-leere) Liste von 4-Tupeln xs. Das Muster auf der zweiten Zeile ist ein verschachtelte Muster: es den ersten Eintrag in der Liste entspricht, gegen ein Muster wie (x:xs), d.h. element x gefolgt vom rest der Liste xs; und dann passt es x gegen die 4-Tupel-Struktur.

    Unten gebe ich einige grundlegende Beispiele. Beachten Sie, dass Sie können auch schreiben dies mit standard-higher-order Funktionen, wie filter und map, und ich bin deliberaty nicht zu erwähnen, Dinge wie @-Muster und strenge. Ich empfehle nicht, es zu tun, wie diese, aber es ist nur um Ihnen eine Idee geben!

    Wenn Sie möchten, um die Summe der ersten Teil der Tupel, man könnte es so machen:

    sum4 :: [(Int,Int,Int,Int)] -> Int
sum4 [] = 0
sum4 ((a,b,c,d):xs) = a + sum4 xs

    Wenn Sie möchten, heraus zu filtern, die Tupel, wo alle a,b,c und d sind auch:

    filter4allEven :: [(Int,Int,Int,Int)] -> [(Int,Int,Int,Int)]
filter4allEven [] = []
filter4allEven ((a,b,c,d):xs) 
    | all even [a,b,c,d] = (a,b,c,d) : filter4AllEven xs
    | otherwise = filter4AllEven xs

    (Wenn die Verwendung von all verwirrt Sie, Lesen Sie even a && even b && even c && even d)

    Und schließlich, hier ist eine Funktion zurückgibt, die alle auch Tupel-Komponenten (Tupel können sich nicht selbst!) in der gleichen Reihenfolge aufgeführt wie in der argument-Liste:

    evenTupleComponents :: [(Int,Int,Int,Int)] -> [Int]
evenTupleComponents [] = []
evenTupleComponents ((a,b,c,d):xs) = [x | x <- [a,b,c,d], even x] ++ evenTupleComponents

    Sobald Sie das tun ein paar übungen wie diese, werden Sie sehen, warum die Verwendung von standard-Funktionen ist eine gute Idee, da Sie alle ähnlichen mustern Folgen, wie die Anwendung einer Funktion auf jedes Tupel einzeln, mit oder ohne ein Tupel, wenn es hat eine gewisse Eigenschaft oder, mehr allgemein, geben Sie einen Basis-Wert für die leere Liste und eine Kombination von Funktion für den rekursiven Fall. Beispielsweise würde ich schreiben evenTupleComponents als evenTupleComponents = filter even . concatMap (\(a,b,c,d) -> [a,b,c,d]), aber das ist eine andere Geschichte 🙂

    InformationsquelleAutor yatima2975
Schreibe einen Kommentar