# [Funktional]Quelltexte in Ordung?



## ichbinsnicht (10. Februar 2004)

Hy..

Ich habe ein paar Quelltexte für Gofer geschrieben(funktionale Programmierung) und leider habe ich ein paar Probleme und vielleicht könnt ihr euch ja nebenbei die Sachen mal angucken ob ihr sie für richtig empfindet...

Wir sollen immer in den 3 verschiedenen Versionen den Quellcode bringen... :/ 

Die Grundrechenarten geben einen Fehler von sich, das eine show-Funktion fehlt (?)


```
-- Grundrechenarten
-- Addition
-- funktional mit Guards
plus1 :: (Int,Int) -> Int
plus1(x,y) |otherwise = x+y

-- Imperativ
plus2 :: (Int,Int) -> Int
plus2(x,y) = x+y

-- funktional ohne Guards
plus3 :: (Int,Int) -> Int
plus3(x,y) = x+y



-- Subtraktion
-- funktional mit Guards
minus1 :: (Int,Int) -> Int
minus1(x,y) |otherwise = x-y

-- Imperativ
minus2 :: (Int,Int) -> Int
minus2(x,y) = x-y

-- funktional ohne Guards
minus3 :: (Int,Int) -> Int
minus3(x,y) = x-y


-- Multiplikation
-- funktional mit Guards
mal1 :: (Int,Int) -> Int
mal1(x,y) |otherwise = x*y

-- Imperativ
mal2 :: (Int,Int) -> Int
mal2(x,y) = x*y

-- funktional ohne Guards
mal3 :: (Int,Int) -> Int
mal3(x,y) = x*y


-- Division
-- funktional mit Guards
durch1 :: (Int,Int) -> Int
durch1(x,y) |otherwise = x/y

-- Imperativ
durch2 :: (Int,Int) -> Int
durch2(x,y) = x/y

-- funktional ohne Guards
durch3 :: (Int,Int) -> Int
durch3(x,y) = x/y
```

Sind die folgenden Partialsummen-Codes richtig(?)
das erste soll eine Addition einer Zahl darstellen,
das nächste soll die Summe der ersten n geraden Zahlen darstellen und 
das letzte die summe der quadrate der ersten n zahlen..


```
-- Partialsumme

-- Funktional mit Guards
part_plus1 :: Int -> Int
part_plus1(n) | n<=1 
	 | otherwise = part1(n-1)+n

-- Imperativ
part_plus2 :: Int -> Int
part_plus2(n) = if n>1 then part2(n-1)+n

-- Funktional ohne Guards
part_plus3 :: Int -> Int
part_plus3(n) = n>1 = part3(n-1)+n


-- Funktional mit Guards
part_gerade1 :: Int -> Int
part_gerade1(n) | n<=1 
	 | otherwise = part1(n-1)+n*2

-- Imperativ
part_gerade2 :: Int -> Int
part_gerade2(n) = if n>1 then part2(n-1)+n*2

-- Funktional ohne Guards
part_gerade3 :: Int -> Int
part_gerade3(n) = n>1 = part3(n-1)+n*2



-- Funktional mit Guards
part_quadrat1 :: Int -> Int
part_quadrat1(n) | n<=1 
	 | otherwise = part1(n-1)+n*n

-- Imperativ
part_quadrat2 :: Int -> Int
part_quadrat2(n) = if n>1 then part2(n-1)+n*n

-- Funktional ohne Guards
part_quadrat3 :: Int -> Int
part_quadrat3(n) = n>1 = part3(n-1)+n*n
```


Ist der Quellcode der Potenzfunktion korrekt?


```
-- Potenzfunktion

-- Funktional mit Guards
potenz1 :: Int -> Int
potenz1(n) | n<=1 
	 | otherwise = part1(n-1)*n*n

-- Imperativ
potenz2 :: Int -> Int
potenz2(n) = if n>1 then part2(n-1)*n*n

-- Funktional ohne Guards
potenz3 :: Int -> Int
potenz3(n) = n>1 = part3(n-1)*n*n
```

Kann man das für den größten gemeinsamen Teiler so realisieren?:

```
-- größter gemeinsamer Teiler

-- Funktional mit Guards
ggt1 :: (Int,Int) -> Int
ggt1(m,n) | m>n = ggt1(m-n,n) 
	  | m<n = ggt1(m,n-m)
	 | otherwise = ggt(m,n) = m

-- Imperativ
ggt2 :: (Int,Int) -> Int
ggt2(m, n) = if m>n then ggt2=ggt2(m-n,n)
          else if m<n then ggt2 = ggt2(m,n-m)
	  else ggt2(m,n) = m

-- Funktional ohne Guards
ggt3 :: (Int,Int) -> Int
ggt3(m,n) = m>n = ggt3(m-n,n)
ggt3(m,n) = m<n = ggt3(m,n-m)
ggt3(m,n) = m=n = ggt3(m,n)
```

Nebenbei müssen wir noch eine Aufgabe zu Binomialkoeffizienten machen..
Wisst ihr wie man das anstellt?


```
n!
B(n,k) =  ---------------
                k! * (n-k)!

Weiteres zum Problem:

Falls 0 <= k <= n sonst B(n,k) = 0
Beachte 0! = 1
```

Ich wäre euch wirklich sehr dankbar für Rückantworten

Hope You Help

;(


----------



## RedWing (15. Mai 2004)

**Threadwiederhochhol**

Also ich denk mal das der Post zu spät kommt,
aber für alle die es interessiert und die vielleicht sich mal mit gofer auseinandersetzen wollen, hier das Beispiel für die Binomial Funktion:


```
fak::Int->Int  --Definitionsbereiche festlegen--
binomial::(Int,Int)->Int

fak n = if(n == 0) then 1 else n * fak(n-1) --Fakultätsfunktion n rekursiv --

binomial(n,k) = if(k >= 0 && k <= n) then fak n / ( fak k * fak(n-k)) else 0 --Berechnung von n über k --
```

Aufuf im Interpreter mit : binomial 5 2 

Also hab mich die letzten zwei Tage in gofer etwas eingearbeitet und muss sagen das ich die Programmiersprache sehr intressant finde, da man mit ihr Mathematische Funktionen
sehr elegant berechnen kann, da es eine Funktionale P-Sprache ist.
Wer interesse hat kann hier 
mehr erfahren.

Gruß

RedWing


----------

