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:))

Hallo,

einmal der Code:

module Task29 where


import System.IO



main :: IO ()
main = do
  hSetBuffering stdout NoBuffering  -- needed depending on your operating system and settings
  putStrLn "Bitte gebe die erste Zahl ein:"
  x1 <- readLn
  putStrLn "Zweite"
  x2 <- readLn
  let sum =  x1 + x2
  print ("Die Summe ist:" ++ show(sum))
  result <- while (x1,1) (\x -> x/=0) (\(x,count) -> do     putStrLn "Bitte gebe die erste Zahl an"
                                                            x1 <- readLn
                                                            putStrLn "Zweite"
                                                            x2 <- readLn
                                                            let sum = x1 + x2
                                                            print ("Die Summe ist:" ++ show(sum))
                                                            return (x1,(count+1)))
  print ("Anzahl additionen:" ++ show(snd(result)))															
  
  
while :: a -> (a -> Bool) -> (a -> IO a) -> IO a
while a p body = loop a
                 where loop x = if p x then do x'<- body x
                                               loop x'
                                       else return x 

Und einmal die beschwerde:

das Gleich kommt bei let sum = x1 + x2, bei show und bei der 1 im Tupel (x1,1), und bei /=0.

Ich verstehe nicht was der mir damit sagen will und wie ich das lösen kann.

Schonmal danke:))

Hallo,

sagen wir ich habe:

fucntion = do let x = 2
           if... let x = 0 else let x=1 
           return x

Ist das erlaubt? Oder muss ich nach if und else jeweils do oder return stehen haben?

Dank schonmal:))

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?

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,

ich würde gerne einen Kreis von der Mitte nach Rechts und dann von Rechts nach Links durchlaufen lassen. Dann von Links wieder zur Mitte.

Wie genau kann ich das machen?

Hier einmal der Code:

module Main where


import CodeWorld
import Prelude hiding (($))


main :: IO()
main = animationOf scene


scene :: Double -> Picture 
scene t =  kreis t


kreis :: Double -> Picture
kreis t = translated 0 0 (colored red (solidCircle 2))

Wenn ich den Kreis jetzt für eine gewisse Zeit t nach rechts laufen lassen will würde ich if ... then .. nutzen. Wenn ich dann aber möchte, dass er nach der gewissen Zeit von seinem jetzigen Standpunkt aus zurück nach Links soll und ich würde else if .. then ... nutzen dann geht er aber wieder vom Startpunkt aus. Wie schaffe ich es, dass er von Rechts dann wieder nach Links ,,läuft"?

Vielen dank schonmal :))

???

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

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.

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

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.

Hi, ich bin Pogrammierer und kann sehr viele Sprachen: C#, Node js, python, Javascript usw. Nur möchte ich gerne wissen, wie beliebt die beliebige Sprache ist.

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

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

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?

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?

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

Kann mir das Jemand erklären? Danke

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