www.jammni.de

Gepostet:
07.11.2009 18:22

Sublist

Hey @ all...

Ich habe folgendes Anliegen..

Ich soll ein Haskell Programm schreiben, dass aus einer Liste von Elementen folgendes wieder gibt :

Bsp.

sublist [1,2,3,4] soll [[] [1] [1,2] [1,2,3] [1,2,3,4] ergeben..

nur habe ich gar keine Idee.. wie ich das machen soll.. könnt ihr ihr mir helfen ?
ist wirklich wichtig.

Zum Seitenanfang

Siracusa

Gepostet:
08.11.2009 18:08

Hallo,

die Aufgabe ist nicht schwer, hier mal ein Lösungsansatz: Es gibt erstmal zwei Fälle, die unterschieden werden müssen. Ist die Eingabeliste cs leer, so wird als Ergebnis eine Liste zurückgegeben, die nur eine leere Liste enthält. Ist cs nicht leer, dann gibst du eine Liste zurück, die selbst cs enthält und du berechnest rekursiv das Ergebnis von sublist ds, wobei ds die Liste cs ist, von der das letzte Element entfernt wurde (Dazu gibt es die Funktion init). An das rekursiv berechnete Ergebnis fügst du vorne einfach cs an.

Beim Aufruf sollte dann sowas passieren:

sublist [1,2,3]
= [1,2,3] : (sublist [1,2])
= [1,2,3] : ([1,2] : (sublist [1]))
= [1,2,3] : ([1,2] : ([1] : [ [] ]))
= [ [1,2,3], [1,2], [1], [] ]

Zum Schluss kannst du die Liste mit reverse noch umdrehen.

Viele Grüße,

Siracusa

Zum Seitenanfang

Luks

Gepostet:
08.11.2009 19:00

hab die gleiche aufgabe und bekomms auch nicht hin--...
das sind 2 verschieden ansätze (nur für winhugs zum testen als komentar gemacht)

sublists :: [Int] -> [[Int]]
--sublists []	= [[]]
--sublists [x]	= [[],[x]]
--sublists [x,y]	= [[],[x],[x,y]]
--sublists (x:xs) = [
--		   [],[x],[x|x<-(x:xs), x(_)<=1]
--		  ]

sublists (x:xs) = reverse[(x:xs)]:sublists(init(x:xs))

Zum Seitenanfang

Skater203

Gepostet:
08.11.2009 20:20

Hey danke erstmal..
ich schäme mich fast dafür diese Frage gestellt zu haben.
Nur das mit dem reverse funktioniert nicht ganz , denn

sublists :: [a] -> [[a]]
sublists []= [[]]
sublists (x:xs) = reverse ( (x:xs) : sublists (init (x:xs)) )

ergibt [[1,2,3],[1],[],[1,2],[1,2,3,4]]

wie also anders ?

danke

Zum Seitenanfang

studento

Gepostet:
08.11.2009 23:19

Ich hab die Aufgabe so gelöst:
(rekursiv und listenkomprehnsion)
sublists :: [a] -> [[a]]

sublists' [] = [[]]
sublists' (x:l) = [[]] ++ [x:z | z <- sublists' l]

sublists [] = [[]]
sublists (x:l) = let z = sublists l in
[[]] ++ map (x:) z

Zum Seitenanfang

studento

Gepostet:
08.11.2009 23:22

Zu Skater203 und Luks:
Habt ihr die zweite und letzte Aufgabe schon hingekriegt?

Zum Seitenanfang

Skater203

Gepostet:
08.11.2009 23:56

2. jo.. sieh mal ein thema drunter .. da kriegste n Tip dazu ..
und bei der letzten knobel ich immernoch son bissel .. haste ne idee dazu ?

Zum Seitenanfang

studento

Gepostet:
09.11.2009 00:05

Also bei remDuplicates klappt's irgendwie nicht. Kannst du den ganzen Code noch mal zeigen?
Zur letzten Aufgabe hab ich überhaupt keine Idee.

Zum Seitenanfang

Siracusa

Gepostet:
09.11.2009 01:32

@Skater203: Das Problem ist, reverse wird jetzt auch bei den rekursiven Aufrufen aufgerufen, es soll aber nur einmal ganz zum Schluss aufgerufen werden. Das heißt, eine Hilfsfunktion sublists' schreiben, die die eigentliche Arbeit macht und sublists macht dann nur zum Schluss das reverse: sublists (x:xs) = reverse ( sublists' (x:xs) ).

Viele Grüße,

Siracusa

Zum Seitenanfang

Haskell-Forum