1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:

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

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:

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

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

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

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

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

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

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

Weiteres zum Problem:

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