Programmieren in Haskell-.-

Hey Leute wir haben grade im Informatik-Unterricht Haskell und ich verzweifel die ganze Zeit sonst bin ich immer nahc langer Zeit aufs Ergebniss gekommen, aber jetzt hab ich keine Ahnung-.-

Als erstes ein paar Beispiele, welche ich hatte um zu zeigen um was es geht.

inssort: fügt ein Element in eine sortierte Liste ein. Dabei sollen doppelte Elemente erlaubt sein.


-- inssort

inssort n [] = [n]
inssort n (x:xs)
|n > x = [x] ++ (inssort n xs)
|otherwise = [n] ++ [x] ++ xs

del: löscht alle Vorkommen eines bestimmten Elements in einer Liste

-- del

del a [] = []
del a (x:xs)
|a == x = del a xs
|otherwise = [x] ++ (del a xs)

summe: liefert die Summe aller Listenelemente

--summe

summe [] = 0
summe (x:xs) = x + summe xs

So darum geht es! Jetzt zu den Aufgaben an denen ich komplett verzweifelt bin.

Schreiben Sie eine Funktion nehme_n, die die ersten n Elemente einer Liste zurückliefert. Wenn n größer als die Länge der Liste ist, soll die gesmate Liste zurückgeliefert werden.
Ich habe mit folgendes Gedacht, aber leider fehlt da noch was:

--nehme_n

nehme_n a [] = 0
nehme_n a (x:xs)
|a > (x:xs) = [x] ++ xs

Jetzt die 2te Aufgabe die ich noch weniger verstehe-..-

Eine Funktion nehme_solange, liefert alle Elemente einer Liste zurück, bis eine boolsche Bedingung nicht mehr erfüllt ist.

nehme_solange (<10) [1,2,3,12,4] = [1,3,5]

PS: Alle Funktionen müssen Rekursiv sein

Ich hoffe ihr könnte mir helfen, ich würd mich auch über tips freuen.

Danke im vorraus

gh0st

nehme_n a (x:xs)

erkläre mir mal pls was genau mit (x:xs) gemeint is dann versuche ich mich mal dran :P hab kp wie man auf x oder xs kommen soll bzw wie sich das ergibt??

x ist der Kopf einer Liste, also die erste Zahl einer Liste
xs ist der ganze Rest der in einer Liste vorhanden ist

(x:xs) ist die Schreibweise dafür, dass die Liste einen Anfang hat und einen Rest.

(x:xs) muss in jeder Definition vorhanden sein, weil sie angibt das es sich überhaupt um eine Funktion handelt in der man Listen benutzt

Auch so ein armes Opfer der funktionalen Sprachen?
ich frische in den nächsten Tagen meine MoscowML kenntnisse auf, da Haskell auf Ml basiert, wirds keine großen Unterschiede geben.

Deine erste Aufgabe ist ja nur ne FOR-Schleife, kannste durch Iter erzeugen:

fun iter (n:int) (s:int) (f:int->int) : int = if n < 1 then s else iter (n-1) (f s) f

@Steiger_mp

ja das Problem ist ist steh total unter Zeitdruck wenn ich das Freitag nicht abgebe hab ich eine 6-.-
Ich hab jetzt die Übungen auch im Internet gefunden, nur leider ohne Lösung, aber vllt hilft euch das etwas weiter.

http://www.pns-berlin.de/listen1.html

Aufgabe 5 und 6 fehlen mir

Sachma... Pass lieber ein wenig in deinem Informatikunterricht auf...
Was du hier fragst sind wirklich grundlegende Fragen.
Arbeite das auf jedenfall nach!
Ich bin nicht hier um deine Hausaufgaben zu machen und werde dir auch keine Nachhilfe in funktionaler Programmierung geben.
Trotzdem zeig ich dir die Lösungen zu den Aufgaben damit du vielleicht was draus lernst...
Meine Lösungen sind in ML. Hoffe du bekommst den Code in Haskell gegossen.

Aufgabe 5:
fun nehme_n n nil = nil
| nehme_n n (x::xs) = if n < 1 then nil else x::(nehme_n (n-1) xs)
val a = nehme_n 5 [1,2,3,4,5,6,7]
val a : int list = [1, 2, 3, 4, 5]

Erklärung:
Hoffe du hattest schon regelbasierte Prozeduren...
Die Prozedur bekommt einen Wert n und eine Liste mitgeliefert.
Dann schaust du ob die Liste leer ist.
Falls ja bist du schnell fertig, weil du dann die leere Liste lieferst.
Sonst schaust du ob n<1 ist.
Falls ja hängst du nil an die Liste und bist fertig.
Falls nicht nimmst du das erste Element aus der Liste und gehst mit dem Rest der Liste in Rekursion.
Solange bis n<1 eintritt oder die Liste leer ist.
FERTIG!

Aufgabe 6:
fun nehme_solange f nil = nil
| nehme_solange f (x::xs) = if f x then x::(nehme_solange f xs) else nehme_solange f xs
val a = nehme_solange (fn i => i < 4) [1,2,3,4,5,6,7]
val a : int list = [1, 2, 3]

Erklärung:
Die Prozedur bekommt eine Abstraktion und eine Liste mitgeliefert.
Wenn die Liste leer ist lieferst du die leere Liste.
Sonst schaust du ob x angewandt auf die Abstraktion true ergibt.
Falls ja nimmst du das Element und gehst mit dem Rest der Liste in Rekursion.
Falls nicht gehst du auch mit dem Rest der Liste in Rekursion. Jedoch ohne das aktuelle Element zu beachten. Es hat schließlich die Bedingung nicht erfüllt.
Du bist solange in Rekursion bis du alle Elemente der Liste abgearbeitet hast und hängst nil ans ende der Liste.
FERTIG!

So... Und ab jetzt bitte keine Kindergartenaufgaben mehr!
Ich hoffe ich konnte dir helfen ;-)

ich hätte take etwas anders formuliert:
fun take n xs = if n <= 0 then nil else hd xs::(take(n-1), tl xs)

gruß steiger

Meine regelbasierte Prozedur macht genau das gleiche bis auf den nil Fall:

Zitat:

---

fun take n xs = if n <= 0 then nil else (hd xs)::(take (n-1) (tl xs))
val a = take 5 nil
Uncaught exception
Empty

---

Deswegen wäre es gut, wenn du den nil Fall mit in betracht ziehst.

PS: Schade dass es kein Feedback vom Threadersteller gab zu meinem doch sehr ausführlichen Post gab.
Hatte mir eingeltich viel Mühe gegeben.