Haskell – die meistgelesenen Beiträge

Kann mir das Jemand erklären? Danke

Haskell.

Hallo,

könnt ihr mir eine Seite oder auch (noch besser) ein Informatik-Forum empfehlen? Am besten für Studenten, da ich es studiere. Habe momentan große Probleme in der Programmiersprache Haskell (aktuell z.b. bzgl. Matrix).

Wäre nett wenn ihr einen Ort für Leute wie mich wüsstet.

Danke. LG

Guten Abend,

unszwar geht es darum, daß wir versucht haben auf Mac eine Haskell-Datei namens hallowelt.hs zu öffnen. Die Datei haben wir mit einem Texteditor geschrieben und möchten sie nun ihm Compiler GHCi 8.6.3 öffnen. Auf Windows klappt alles tadellos. Man klickt mit Rechtsklick auf "Öffnen mit GHCi 8.6.3." und die Datei öffnet sich im Compiler.

Auf Mac klappt es leider nicht. Da steht dann "Öffnen mit anderen Programm" und wenn wir dann den Rechner durchsuchen finden wir GHCi 8.6.3 nicht, obwohl GHCi auf dem Mac installiert ist und nachweislich funktioniert.

Haben auch probiert direkt über GHCi das Modul zu laden, aber es zeigt immer eine Fehlermeldung an, daß diese Datei nicht gefunden wurde, obwohl sie unter Downloads gespeichert wurde. Woran könnte das liegen?

PS: Wer sich wundert. In dem geschwärzten steht nur der Klarname der Person, welcher der Mac gehört. Bin mir nicht sicher, ob sie das so cool finden würde, daß der hier im Internet auftaucht, deswegen geschwärzt.

Wo liegt der Fehler?

Danke und liebe Grüße

Wir haben folgende Funktionen:

prod :: [Int] -> Int

prod [] = 1 -- prod.1

prod (x:xs) = x * prod xs -- prod.2

foldl :: (b -> a -> b) -> b -> [a] -> b

foldl f acc [] = acc -- foldl.1

foldl f acc (x:xs) = foldl f (f acc x) xs -- foldl.2

Aufgabe:

Man soll mit struktureller Induktion beweisen, dass folgende Aussage gilt:

foldl (*) 1 xs = prod xs

Ich habe momentan:

foldl (*) 1 xs = prod xs

I.A. (xs = []):

foldl (*) 1 [] = prod []

foldl f acc [] = acc prod [] = 1 -- foldl.1 & plod.1

foldl f 1 [] = 1

1 = 1

I.V.: Wir nehmen an, dass die Aussage gilt für ein beliebiges xs

I.S. (xs -> x:xs):

foldl (*) 1 (x:xs) = prod (x:xs) -- foldl.2 & prod.2

foldl (*) ((*) 1 x) xs = x * prod xs

Problem: Ich weiß nun nicht wie ich mit dem Induktionsschritt fortfahren soll.

Hi,

was ist der Unterschied zwischen mod und rem in Haskell?

Bei der Eingabe ins GHCI erhält man das gleiche Resultat.

(-4 `mod` 5) == (-4 `rem` 5) 

TRUE

Allerdings ist hier FALSE:

(4 `mod` (-5)) == (4 `rem` (-5)) 

Habe im Internet recherchiert und das hier gefunden.

https://stackoverflow.com/questions/5891140/difference-between-mod-and-rem-in-haskell

"Yes, those functions act differently. As defined in the official documentation:

quot

 is integer division truncated toward zero

rem

 is integer remainder, satisfying:

(x `quot` y)*y + (x `rem` y) == x

div

 is integer division truncated toward negative infinity

mod

 is integer modulus, satisfying:

(x `div` y)*y + (x `mod` y) == x

Kann mir einer erklären, was diese Zeilen bedeuten? (integer modulus, integer remainder?

Wenn man eine Funktion erstellen soll, bei der die Funktion zwei Werte nimmt und prüft, ob ein Wert durch den anderen teilbar ist, wie schreibt man das in Haskell als Code?

nehmen wir an:

isDivisible -> Integer -> Integer -> Bool

Wie schaut dann der Rest aus? So?

isDivisible x % y == 0 = true else false

y % x == 0 = true else false?? Das klingt so bescheuert aber ich weiß sonst nicht wie es aussehen sollte! Kann mir da wer weiterhelfen?

Zusätzlich müsste ich dann auch eine Funktion schreiben, die so aussieht:

isPrime -> Integer -> Bool

welches eine Zahl nimmt und ausgibt ob diese eine Primzahl ist oder nicht, dafür soll ich die vorherige Funktion benutzen, jedoch komm ich da eben nicht weiter. Und bei der hier bin ich mir auch nicht sicher, wie würde da der Code aussehen?

Moinsen,

Wir fangen im Studium grade mit Haskell an, ist auch gut und scön, wir benutzen den Glasgow Haskell Compiler, aber man kann so weit ich das verstanden habe nur schon vorhandene .hs Dateien per Konsolenbefehl Compilieren und ausführen. Kennt ihr n anständigen Editor mit dem ich die .hs dateien erstellen kann?

Aufgabe:

Betrachten wir die folgenden Funktionsdefinitionen :

data Tree a = Leaf a | Node a (Tree a) (Tree a)

sumLeaves :: Tree a -> Integer

sumLeaves (Leaf x) = 1

sumLeaves (Node _ lt rt) = sumLeaves lt + sumLeaves rt

sumNodes :: Tree a -> Integer

sumNodes (Leaf x) = 0

sumNodes (Node _ lt rt) = 1 + sumNodes lt + sumNodes rt

Beweisen Sie mittels struktureller Induktion, dass für alle endlichen Bäume t :: Tree a gilt:

sumLeaves t = sumNodes t + 1

will bisschen mit haskell rumarbeiten und wenn ich ein stück code starten will kommt nur ein fenster auf wo drauf steht "ausführen - Ausführende Programme hier eingeben". mache das zum ersten mal mit notepad sorry

Man sieht immer übertrieben viele Memes etc. das Programmierer besonders viel mit Stackoverflow etc. arbeiten und der meiste Code zusammengegoolt wird. Ich arbeite auch mit einigen Programmiersprachen auf Freizeitbasis und mich fuckt das unglaublich ab, alle 2 Minuten irgendwas zu googeln weil etwas nicht funktioniert oder ich nicht weiß wie es geht, weil es auch viel Zeit frisst die richtige Lösung zu finden. Deswegen frage ich mich ob die wirklich professionellen Programmierer echt so viel solche Sachen benutzen oder ob das mehr bei den Amateurprogrammieren so der Fall ist?

Hallo,

wie kann ich mir vom Compiler die Schritte zum Auswerten der Funktion anschauen?

Ist das überhaupt möglich?

Ich versuche, Bubblesort in Haskell zu implementieren:

bsort:: (Ord a) => [a] -> [a]
bsort [] = []
bsort [x] = [x]
bsort (x:y:xs)
    | x <= y = x: bsort(y:xs)
    | x >= y = y: bsort(x:xs)

Nachdem die Funktion ausgeführt wurde, wird der gesamte Vorgang nicht noch einmal wiederholt, so dass die Liste nicht vollständig sortiert ist. Wie kann ich der Funktion sagen, dass sie sich wiederholen soll, bis die Liste vollständig sortiert ist?

Wenn ich zum Beispiel eintippe: bsort [1,5,2,4] erhalte ich [1,2,4,5]

aber wenn ich eintippe: bsort [9,6,1,5,2,4] erhalte ich [6,1,5,2,4,9], wie sage ich, dass der Prozess mit [6,1,5,2,4,9] wiederholt werden soll?