Kann mir das Jemand erklären? Danke

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.

Haskell.

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?

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?

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

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

Hey, die Aufgaben lauten:

1. Eine Funktion schreiben die Vektoren addiert

2. Eine Funktion die Skalarprodukt berechnet und

3. Eine Funktion die anhand des Skalarprodukts bestimmen kann, ob der Winkel rechtwinklig ist.

Meine Ansätze:

1.

addVectors:: (Num a) => a -> a -> a

addVectors (a1, a2, a3) (b1, b2, b3) = (a1 + b1) (a2 + b2) (a3 + b3)

2.

scalarProduct:: (Num a) => a -> a -> a 

scalarProduct (a1, a2, a3) (b1, b2, b3) = (a1 * b1) (a2 * b2) (a3 * b3)

3.

Da bin ich mir nicht sicher wie ich es Ausdrücken soll. Am Ende soll halt True rauskommen. Das wahrscheinlich, wenn das Skalarprodukt 0 ergibt.

Servus, wir machen in Info gerade Haskell und da werden die Konzepte der Rekursion und Iteration besprochen.

Ich versteh den Unterschied einfach noch nicht. Könnte mir das einer einfach zusammenfassen?

Rekursion und Iteration rufen sich doch beide selber im Funktionsrumpf auf und dekrementieren bis beim conditional statement ein False erscheint. Ich kann den Unterschied einfach nicht sehen.

Danke schonmal für die Antworten :D

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?

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?

Ich brauche Hilfe bei folgender Aufgabe.

Schreiben Sie eine Funktion, die überprüft ob ein eingegebenes Zeichen eine Ziffer ist.

(a) Durch direktes Angeben eines Booleschen Ausdrucks

(b) Verwenden Sie Pattern-Matching

(c) Verwenden Sie Guards

Hallo,

ich habe das hier stehen:

alternative :: [Integer] -> Integer
alternative = foldr (\x ys-> if (x `mod` 11 == 0) then 13 + ys else x * ys) 7 

Wieso muss ich keine Variable angeben in der Funktionsdefinition? Sowas wie alternative xs = foldr .. .. xs. Ich hätte erwartet, dass er sich beschwert, das nicht genug Argumente an foldr übergeben wurden wenn ich das nicht mache, aber es läuft ohne Probleme. Hat das was mit Eta reduction zu tun?

Schonmal vielen Dank:))

Hallo,

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

Ist das überhaupt möglich?

Hallo,

hier einmal der Code:

fun :: (Int -> Int) -> Bool -> Int -> Int
fun g b n | n <= 0 && b = 1
          | even n = fun (fun g b) False (g (div n 2))
fun g _ n =  g (fun (g . g) True (n-2))
*der .  bei dem g . g ist die Funktions Komposition*

Die Aufhabe anhand dieser Funktion ist es zu entscheiden ob dies Funktionsaufrufe terminieren oder nicht und wenn ja mit welchem Wert.

1. fun (\x->x) True 2
2. fun (\x->x-1) True 4

Die Lösungen sind 1 und 0. Aber wieso bekommt man das raus?

Meine erste Auswertung für 1 als Beispiel für mein Problem damit:

1. ..= fun (fun (\x->x) True) False 1

Wieso kann ich fun (\x->x) True schreiben? Ich hatte erst gedacht, dass durch eta reduction das n=2 einfach ausgelassen wird und der Aufruf eigentlich so aussähe fun (\x->x) True 2, aber wenn ich oben in den Code das n dort einfüge bekomme ich vom Compiler die Fehlermeldung "could not match Int->Int mit Int". Ich verstehe was der meint weil fun :: ...->Int als Ergebnis hat, aber dann macht es ja keinen sinn, dass fun als g verwendet werden darf und besonders, dass fun g b erlaubt ist...

Wieso geht das also?

Schonmal vielen Dank:))