www.jammni.de

Gepostet:
28.11.2013 13:06

kleinstmögliche differenz ausgeben

hey leute und zwar geht es darum, bei der Eingabe von drei Integeren die kleinstmögliche Differenz aus zweien dieser drei Integere auszurechnen:

differenceAB :: Int -> Int -> Int
differenceAB a b
| a > b = abs(a-b)

differenceBC :: Int -> Int -> Int
differenceBC b c
| b > c = abs(b-c)

differenceAC :: Int -> Int -> Int
differenceAC a c
| a > c = abs(a-c)

smallestDifference3 :: Int -> Int -> Int -> Int
smallestDifference3 a b c
| (differenceAB < differenceBC) && (differenceBC < differenceAC) = differenceAB
| otherwise = differenceAB

da kriege ich aber:

Couldn't match expected type `Int'
with actual type `Int -> Int -> Int'
In the expression: differenceAB
In an equation for `smallestDifference3':
smallestDifference3 a b c
| (differenceAB < differenceBC) && (differenceBC < differenceAC)
= differenceAB
| otherwise = differenceAB
Failed, modules loaded: none.

weiß jmd wieso?

Zum Seitenanfang

Landei

Gepostet:
14.12.2013 19:58

Vor die | muss mindestens ein Leerzeichen, aber ich denke, das ist das Forum hier (versuche mal Code-Tags).

Der Fehler ist einfach, dass du in smallestDifference deine Unterfunktionen wie Variablen benutzt, aber differenceAB ist ja kein Int, sondern eine Funktion Int -> Int -> Int. Du willst an der Stelle aber das Endergebnis, also musst du auch die Argumente mitgeben: (differenceAB a b)

Diese Unterfunktionen sind aber auch nicht richtig: Du behandelst z.B. bei differenceAB den Fall a > b, aber was passiert bei a <= b? Da gibt es dann einen Match-Error

Ich denke, folgende Variante ist nicht nur kurz, sondern auch leicht verständlich:


smallestDifference3 :: Int -> Int -> Int -> Int
smallestDifference3 a b c = minimum [abs (a-b), abs (b-c), abs (c-a)]

Wenn du minimum nicht verwenden darfst oder noch keine Listen hattest, würde ich das vorschlagen:


smallestDifference3 :: Int -> Int -> Int -> Int
smallestDifference3 a b c = 
  let ab = abs (a - b)
      ac = abs (a - c)
      bc = abs (b - c)
  in min ab (min ac bc)

Ich hoffe das hilft dir weiter

Zum Seitenanfang

absolutbeginner

Gepostet:
15.12.2013 20:17

ich versuche gerade sowas ähnliches, allerdings sind meine Int in einer Liste und ich will jeweils die größte differenz von direkten Nachbarn ermitteln



diff:: [Int] -> [Int]
diff(x:y:w:xs) = x-y : y-w : foo xs
diff xs = xs

das ist mein ansatz, der zumindest schon mal die differenzen errechnet, klappt allerdings nur bei gerader Elementanzahl.. Hab den Eindruck das ich völlig auf dem falschen weg bin

Zum Seitenanfang

Landei

Gepostet:
17.12.2013 12:41

Um eine Operation op auf benachbarte Listenelemente anzuwenden, bietet sich das Schema "zipWith op xs (tail xs)" an. Und zur Ermittlung des Maximums gibt es auch eine fertige Funktion:


diff xs = maximum $ zipWith absDiff xs (tail xs) where
  absDiff x y = abs (x - y)

-- oder kurz
diff xs = maximum $ zipWith ((abs.).(-)) xs (tail xs)

Zum Seitenanfang

Haskell-Forum