Rekursive Listenfunktionen

lastElement [1,2,3,4] =
=
=
=
lastElement [2,3,4]
lastElement [3,4]
lastElement [4]
4
RekursiveListenfunktionen
• WiebekommenwirdieListeohnedasletzteElement?
– DieElementewerdensolangeineinerneuenListegesammelt,bisdie
ein-elementige Listeerreichtist.
– DiesewirddanndurcheineleereListeersetztundsomitdasletzte
Elemententfernt.
RekursiveListenfunktionen
• WiebekommenwirdieListeohnedasletzteElement?
– DieElementewerdensolangeineinerneuenListegesammelt,bisdie
ein-elementige Listeerreichtist.
– DiesewirddanndurcheineleereListeersetztundsomitdasletzte
Elemententfernt.
withoutLast ::
withoutLast
withoutLast
->
=
=
RekursiveListenfunktionen
• WiebekommenwirdieListeohnedasletzteElement?
– DieElementewerdensolangeineinerneuenListegesammelt,bisdie
ein-elementige Listeerreichtist.
– DiesewirddanndurcheineleereListeersetztundsomitdasletzte
Elemententfernt.
withoutLast :: [a]
withoutLast
withoutLast
-> [a]
=
=
RekursiveListenfunktionen
• WiebekommenwirdieListeohnedasletzteElement?
– DieElementewerdensolangeineinerneuenListegesammelt,bisdie
ein-elementige Listeerreichtist.
– DiesewirddanndurcheineleereListeersetztundsomitdasletzte
Elemententfernt.
withoutLast :: [a]
withoutLast [x]
withoutLast
-> [a]
= []
=
RekursiveListenfunktionen
• WiebekommenwirdieListeohnedasletzteElement?
– DieElementewerdensolangeineinerneuenListegesammelt,bisdie
ein-elementige Listeerreichtist.
– DiesewirddanndurcheineleereListeersetztundsomitdasletzte
Elemententfernt.
withoutLast :: [a]
withoutLast [x]
withoutLast (x:xs)
-> [a]
= []
= x: withoutLast xs
RekursiveListenfunktionen
withoutLast :: [a]
withoutLast [x]
withoutLast (x:xs)
-> [a]
Ungewohnt/komisch
= []
= x: withoutLast xs
• Irgendwieungewohnt,denRestderListedurcheinen
rekursivenAusdruckanzugeben.
• ABER:dieFunktionlieferteineListe!
• Somitwirddasx vorneandasErgebnisdesrekursiven
Ausdrucksangehängt.
RekursiveListenfunktionen
Zusammenfassung
unsereFunktion
*Main>
'h'
*Main>
"ello"
*Main>
'o'
*Main>
"hell"
first "hello"
rest "hello"
lastElement "hello"
withoutLast "hello"
bereitsimplementiert
*Main>
'h'
*Main>
"ello"
*Main>
'o'
*Main>
"hell"
head "hello"
tail "hello"
last "hello"
init "hello"
RekursiveListenfunktionen
SchreibenSieeineFunktion,welchedasi-te ElementeinerListe
zurückgibt.
Hilfe:
- WievieleArgumentebekommtdieFunktionundwasliefertsie
zurück?
- WiekönnenSieeinenZählerimplementieren?
- WasmussichausderListeentfernenumzumgewünschten
Elementzukommen?
RekursiveListenfunktionen
SchreibenSieeineFunktion,welchedasi-te ElementeinerListe
zurückgibt.
returnElement :: [a] -> Int -> a
returnElement (x:_) 0 = x
returnElement (_:xs) n = returnElement xs (n-1)
RekursiveListenfunktionen
SchreibenSieeineFunktion,welchedasi-te ElementeinerListe
zurückgibt.
returnElement :: [a] -> Int -> a
returnElement (x:_) 0 = x
returnElement (_:xs) n = returnElement xs (n-1)
VorimplementierteFunktion
*Main> "hello" !! 1
RekursiveListenfunktionen
• DasSiebdesEratosthenes
Listen– Lazy Evaluation
const N = 10000
var gestrichen: array [2..N] of boolean
for i = 2 to N do
gestrichen[i] = false // Initialisierung des Primzahlfeldes
end
// Siebe mit allen (Prim-) Zahlen i. Der kleinste Primfaktor einer zusammengesetzten
Zahl j kann nicht größer als die Wurzel von j <= n sein.
for i = 2 to sqrt(N) do
if not gestrichen[i] then
print i; ", "; // i ist prim, gib i aus...
for j = i*i to N step i do
gestrichen[j] = true // ...und streiche seine Vielfachen
end
end if
end
for i = sqrt(N)+1 to N do // Gib die Primzahlen größer als Wurzel(n) aus
if not gestrichen[i] then
print i; ", "; // i ist prim, gib i aus
end if
end
SiebdesEratosthenes- PseudoCode
public SieveOfEratosthenes()
{
System.out.println("--Sieve of Eratosthenes--");
//Initialisierung des Arrays (Zeile 1 - 5)
int n = 120000 ;
boolean[] gestrichen = new boolean[n];
for(int i = 0; i < gestrichen.length; i++)
{
gestrichen[i] = false;
}
//Berechnung starten
startSieving(gestrichen);
}
//Sieben und Ausgabe (Zeile 8 - 20)
private void startSieving(boolean[] gestrichen)
{
//Zeile 8
for(int i = 2; i <= (int) Math.sqrt(gestrichen.length); i++)
{
//Zeile 9
if(!gestrichen[i] == true)
{
//Zeile 10
System.out.println(i);
//Zeile 11 - 13
for(int j = i*i; j < gestrichen.length; j = j + i)
{
gestrichen[j] = true;
}
}
}
//Zeile 16 - 20
for(int i = (int)(Math.sqrt(gestrichen.length)+1); i < gestrichen.length; i++)
{
//Zeile 17
if(!gestrichen[i] == true)
{
System.out.println(i);
}
}
}
SiebdesEratosthenes- Java
primNumber = sieve [2 ..]
where
sieve (x:xs) = x:sieve [n | n <- xs, mod n x > 0]
SiebdesEratosthenes- Haskell
• Wirwollendieerstenn-ElementeeinerListe
get
get
get
get
:: Int ->
_ []
=
0 _
=
n (x:xs)=
[a] -> [a]
[]
[]
x:get (n-1) xs
• WirwollenalleElementeabderPositionn
ListenZerlegen
• Wirwollendieerstenn-ElementeeinerListe
get
get
get
get
:: Int ->
_ []
=
0 _
=
n (x:xs)=
[a] -> [a]
[]
[]
x:get (n-1) xs
• WirwollenalleElementeabderPositionn
drain
drain
drain
drain
:: Int ->
0 xs
_ []
n (_:xs)
[a] -> [a]
= xs
= []
= drain (n-1) xs
ListenZerlegen
Zusammenfassung
unsereFunktion
*Main> get 2 "hallo"
"ha"
*Main> drain 2 "hallo"
"llo"
bereitsimplementiert
*Main> take 2 "hallo"
"ha"
*Main> drop 2 "hallo"
"llo"
RekursiveListenfunktionen
• ElementeeinerListeumdrehen
*Main> reverse "regal"
"lager"
• Implementation:
RekursiveListenfunktionen
• ElementeeinerListeumdrehen
*Main> reverse "regal"
"lager"
• Implementation:
rev :: [a] -> [a]
rev []
= []
rev (x:xs) = rev xs ++ [x]
RekursiveListenfunktionen
• ListenähnelneherMengen.
*Main> [1..10]
• BeiTupeln sinddieAnzahlderElementeundderenPositionen
festvorgegeben.
• InTupeln lassensichunterschiedlicheDatentypenspeichern.
*Main> (True, 10, 'a')
Tupel
• FürTupelmit2-Elementen
*Main> fst (True, 'b')
True
*Main> snd (10, False)
False
Tupel- Zerlegen
• WiesiehtesabernunbeiTupelmitbspw.3-Elementenaus?
*Main> :t fst
fst :: (a, b) -> a
first' ::
first'
second' ::
second'
third' ::
third'
Tupel- Zerlegen
• WiesiehtesabernunbeiTupelmitbspw.3-Elementenaus?
*Main> :t fst
fst :: (a, b) -> a
first' :: (a, b, c) -> a
first'
second' :: (a, b, c) -> b
second'
third' :: (a, b, c) -> c
third'
Tupel- Zerlegen
• WiesiehtesabernunbeiTupelmitbspw.3-Elementenaus?
*Main> :t fst
fst :: (a, b) -> a
first' :: (a, b, c) -> a
first' (x, _, _) = x
second' :: (a, b, c) -> b
second' (_, y, _) = y
third' :: (a, b, c) -> c
third' (_, _, z) = z
Tupel- Zerlegen
• AndersalsbeiListenkönnenfürTupelkeinePatternformuliert
werden,beidenennureinTeilderArgumenteangegebenwird.
• UmeinPatternmatch aufeinTupelmit100Argumentenzu
machen,müssendemnachalle100angegebenwerden.
Tupel- Zerlegen
• EinzelneErgebnisse
Prelude> mod 10 3
1
Prelude> div 10 3
3
• MeistalsResultateinesErgebnispaares
*Main> :t divMod
divMod :: Integral a => a -> a -> (a, a)
*Main> divMod 10 3
(3,1)
InteressanteFunktionen
• EinzelneErgebnisse
*Main> minimum [12,0,5,4]
0
*Main> maximum [12,0,5,4]
12
• MeistalsResultateinesErgebnispaares
minMax :: (Ord a) => [a] -> (a,a)
minMax [] = error "list is empty“
minMax xs = (maximum xs, minimum xs)
InteressanteFunktionen
• Alspythagoräisches TripelwerdendreinatürlicheZahlenx,y
undz bezeichnet,diedieGleichungx2 +y2 =z2 erfüllen.
• Dabeigiltx<y <z.
Pythagoräische Tripel
WielangkönnendieSeiteneinesrechtwinkligenDreieckssein?
Pythagoräische Tripel ={(x,y,z)
ℕ3 |x2 +y2 =z2 }
ptriple :: Int -> [(Int, Int, Int)]
ptriple n = [(x, y, z) | x <- [1..n-2],
y <- [x+1..n-1],
z <- [y+1..n],
x^2 + y^2 == z^2]
Pythagoräische Tripel
• Wiekönnenwir2Listenkombinieren,umeineListeausTupel
zugenerieren?
zip'
zip'
zip'
zip'
:: [a]
_ [] =
[] _ =
(x:xs)
-> [b] -> [(a,b)]
[]
[]
(y:ys) = (x,y):zip' xs ys
ZIP