Haskell: Liste mit Tupel < Haskell < Programmiersprachen < Praxis < Informatik < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 15:03 So 12.10.2008 | | Autor: | haski |
| Aufgabe | Gegeben: eine Liste von Tupel der Form [(a,b)]
Ich möchte das zweite Element des Tupels für alle Tupel in der Liste prüfen, ob es einen bestimmten Eintrag hat. Sobald es in der Liste ein Tupel gibt, dass einem bestimmten Eintrag besitzt soll True ausgegeben werden, wenn nicht, dann False |
Ich habe folgende dazu ausgedacht:
type Model = [(Int, LFlag)]
data LFlag = Nd | D deriving (Eq, Show)
checkModel :: Model -> Maybe Bool
checkModel ((i, flag) : _) | snd (i, flag) == D = Just True
checkModel (tup : tupl) = checkModel(tup) || checkModel(tupl)
es prüft nur das erste Element (Tupel) in der Liste nach dem flag "D", aber was ist wenn es nicht im ersten Tupel auftaucht?
Ich hoffe jemand kann mir helfen.
Viele Grüße und danke im Voraus
Haski
Ich habe diese Frage in keinem Forum auf anderen Internetseiten gestellt.
|
|
| |
|
Hallo,
also mein Haskell-Interpreter frisst das nicht. Also erstmal einige fragen:
Warum ist der Ergebnistyp ein Maybe ... ?
Warum benutzt du snd, wo du durch dein Pattern Matching eh schon das zweite Element benannt hast?
Weißt du, dass beide Patterns dasselbe testen und deshalb nur das erste zum Zuge kommt?
Wo ist denn deine Rekursionsbasis, sprich: Wo wird denn die leere Liste verarbeitet? Was wäre denn das Ergebnis bei einer leeren Liste?
Kannst du deine Funktion wirklich rekursiv sowohl auf ein Paar als auch auf eine Liste von Paaren anwenden? Meckert da dein Interpreter nicht?
Mach dir mal ein paar Gedanken dazu. Ich denke, wenn du alle Fragen beantwortet hast, bist du dem Ziel ziemlich nah. Du kannst ja immer noch nachfragen.
Gruß
Martin
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 19:35 So 12.10.2008 | | Autor: | haski |
Laut Martin frisst der Interpreter schonmal das was ich geschrieben habe.
Die Lösung ist aber unbefriedigend, da es nur für eine Liste mit zwei Tupel-Elementen funktioniert.
Um die Frage von Martin zu beantworten wegen dem "Maybe": ich wollte bei einer leeren Liste "Nothing" zurückgeben.
Jetzt meine Teillösung:
type Model = [(Int, LFlag)]
data LFlag = Nd | D deriving (Eq, Show)
checkModel :: Model ->Maybe Bool
checkModel [] = Nothing
checkModel [(i, flag)] = if (i, flag) == (i, D) then Just True
else Just False
checkModel [x, y] = case (checkModel [x]) of
Just True -> Just True
Just False -> checkModel [y]
Vielleicht kann mir jemand sagen wie ich für alle Elemente in der Liste prüfen kann. Die Liste besteht aus endlich vielen Tupel, deren zweites Element gematcht werden soll, wohlgemerkt.
Viele Grüße
HASKI
|
|
|
| |
|
Hallo,
> Laut Martin frisst der Interpreter schonmal das was ich geschrieben habe.
Nein, das habe ich nie behauptet.
> Um die Frage von Martin zu beantworten wegen dem "Maybe": ich wollte bei einer leeren Liste "Nothing" zurückgeben.
Ich weiß nicht, ob man hier tatsächlich zu Maybe greifen muss. Wenn die Liste leer ist, dann enthält sie auch kein Paar, dessen zweiter Eintrag mit irgendetwas übereinstimmt. Also kannst du da einfach False zurückgeben und alles ist einheitlich geregelt ohne auf Monaden zurückgreifen zu müssen.
Wenn du dennoch Maybe haben willst, dann brauchst du eine Hilfsfunktion, die anspringt, wenn die Liste nicht leer ist. Dort machst du ein einfaches Pattern Matching:
1. Fall: einelementige Liste
2. Fall: beliebige Liste mit Kopf und Rumpf, wobei auf Rumpf rekursiv weitergearbeitet wird.
Wenn du auf das Maybe verzichtest, dann sind es zwei Zeilen, sonst vielleicht vier.
Gruß
Martin
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 20:37 So 12.10.2008 | | Autor: | haski |
Wenn ich eine leere Liste habe, dann brauche ich auch nicht nach dem Flag "D" zu matchen, von daher ist "Maybe" eigentlich überflüssig
type Model = [(Int, LFlag)]
data LFlag = Nd | D deriving (Eq, Show)
checkModel :: Model -> Bool
--checkModel [] = Nothing
checkModel [(i, flag)] = if (i, flag) == (i, D) then True
else False
checkModel ((i, flag) : y) = case (checkModel [(i, flag)] ) of
True -> True
False -> checkModel y
ich danke Maritn an dieser Stelle, wegen seinen Tipps.
Viele Grüße
Haski
|
|
|
| |
|
Hallo,
ok, das mit dem Maybe war mir auch irgendwie ein Dorn im Auge. Jetzt, wo es geklappt hat, will ich auch meine Lösung präsentieren:
checkModel ((_, b) : tupl) = b==D || checkModel tupl
checkModel [] = False
Aber wie man es macht, ist letzten Ende egal.
Gruß
Martin
|
|
|
|
