b'\n_START_ARTICLE_\nRekursioon\n_START_SECTION_\nRekursiooni t\xc3\xbc\xc3\xbcbid\n_START_PARAGRAPH_\nOlenevalt viisist, kuidas funktsioon ja selle n\xc3\xb5rgema(te) astme(te) v\xc3\xa4ljakutse toimub, eristatakse j\xc3\xa4rgmisi rekursiooni vorme.\n_START_SECTION_\nLineaarne\n_START_PARAGRAPH_\nFunktsiooni kehas kutsutakse funktsiooni ennast v\xc3\xa4lja maksimaalselt ainult \xc3\xbche korra. Seda v\xc3\xb5ib ette kujutada kui naturaalarvude loendamist kasvavalt, kus v\xc3\xa4ljakutseks on n+1 ja ekraanile prinditakse enne v\xc3\xa4ljakutset n ise.\n_START_SECTION_\nPuurekursioon, binaarne rekursioon\n_START_PARAGRAPH_\nPuurekursiooni puhul toimub \xc3\xbches funktsioonis rohkem kui \xc3\xbcks sama funktsiooni v\xc3\xa4ljakutset. Nende arv ei ole piiratud, aga arvesse tuleb v\xc3\xb5tta ka arvutamiseks kuluv aeg. V\xc3\xa4ljakutsete ja tasemete suurendamisel on programmi t\xc3\xb6\xc3\xb6 ajakulu h\xc3\xbcpe eksponentsiaalne. Binaarne rekursioon on puurekursiooni lihtsaim vorm, kus funktsioon kutsub ennast ainult 2 korda v\xc3\xa4lja. Fibonacci arvude arvutamine on viimase kohta v\xc3\xa4ga levinud n\xc3\xa4ide.\n_START_SECTION_\nVastastikune\n_START_PARAGRAPH_\nSelle vormi korral on defineeritud kaks erinevat funktsiooni. V\xc3\xa4ljakutse toimub viisil, kus esimene kutsub teist ja teine kutsub esimest. Iseennast kumbki funktsioon v\xc3\xa4lja ei kutsu. Rekursiivseks kutsutakse seda vormi sellep\xc3\xa4rast, et esimesele funktsioonile antud argument kandub \xc3\xbcle teisele ja vastupidi. Olenevalt \xc3\xbclesandest toimub argumendi edasiandmine kas kahanevalt v\xc3\xb5i kasvavalt.\n_START_SECTION_\nSisestatud\n_START_PARAGRAPH_\nSee on keeruline ja arvutusmahukas variant. Siin on funktsiooni iseenda v\xc3\xa4ljakutse \xc3\xbcheks v\xc3\xb5i enamaks argumendiks funktsioon ise, kus alles toimub vastava argumendi kahanemine. Ka siin on ajakulu kasv argumentide suurendamisega eksponentsiaalne. Levinud n\xc3\xa4ide selle kohta on Ackermanni funktsioon, mida ei nimetata primitiivseks rekursiooniks nagu eelnevaid vorme.\n_START_SECTION_\nErijuht: sabarekursioon\n_START_PARAGRAPH_\nTavalises rekursioonis toimub iga v\xc3\xa4ljakutse korral \xc3\xbclesande lahendamine j\xc3\xa4rk-j\xc3\xa4rgult n\xc3\xb5rgima variandini ja siis tulemuste saatmine tagasi \xc3\xbclespoole ning alles siis summeerimine. Sabarekursioonis toimub iga astme korral arvutuste tegemine enne j\xc3\xa4rgnevat rekursiivset v\xc3\xa4ljakutset. See t\xc3\xa4hendab \xc3\xbche lisaargumendi lisamist funktsiooni p\xc3\xa4isesse, mis k\xc3\xa4itub kui konteiner eelnevate arvutuste summeerimiseks. Sabarekursioon on koodiridade poolest pikem aga programmi interpretaatorile kergem k\xc3\xa4sitleda, sest ei ole vaja m\xc3\xa4lus hoida lahtisena igat rekursiooni astet, mis ootavad lahendusi madalamatelt juhtudelt.\n_START_SECTION_\nRekursiooni limiit\n_START_PARAGRAPH_\nSee termin on programmeerimiskeele interpretaatori spetsiifiline. Viimastel on \xc3\xbcldiselt paika pandud mingi limiit, kui kaugele rekursioon v\xc3\xb5ib minna. Pythoni interpretaator IDLE  lubab vaikeseadena 1000 astet. Seda saab lisakoodiridade abil muuta vastava programmi n\xc3\xb5uetele vastavaks. Kui n\xc3\xa4iteks tahetakse rekursiivselt \xc3\xbckshaaval lugeda ja ekraanile printida naturaalarve 1002-st 1-ni, siis tuleb eels\xc3\xa4testatud limiiti t\xc3\xb5sta.\n_START_SECTION_\nRekursiivne faktoriaal\n_START_PARAGRAPH_\ndef faktoriaal(n):_NEWLINE_    if n == 0:_NEWLINE_         return 1_NEWLINE_    else:_NEWLINE_         return n * faktoriaal(n-1)_NEWLINE_Mis siin toimub? Arvutatakse matemaatikast tuntud faktoriaali. V\xc3\xb5tame arutuluse alla faktoriaali 5-st, mis t\xc3\xa4hendab 5! = 1*2*3*4*5 = 120. Kuidas programm selle leiab? Tehes selle funktsiooni v\xc3\xa4ljakutse print(faktoriaal(5)), algab j\xc3\xa4rgmine protsess:_NEWLINE_K\xc3\xb5ik astmed, mis siin l\xc3\xa4bi k\xc3\xa4iakse, ootavad lahendust oma alamastmelt. Kui rekursioon j\xc3\xb5uab oma baasjuhuni, milleks on n == 0, siis lisatakse kogu korrutisse lihtsalt 1, sest matemaatiliselt on defineeritud 0! = 1. L\xc3\xb5puks prinditakse ekraanile 120.\n_START_SECTION_\nSabarekursiivne faktoriaal\n_START_PARAGRAPH_\nTehes funktsiooni v\xc3\xa4ljakutse print(sabafaktoriaal(5,1)) algab j\xc3\xa4rgmine protsess:_NEWLINE_NB! Konteineri algv\xc3\xa4\xc3\xa4rtuseks valime 1, sest tegu on korrutamisega._NEWLINE_Teadagi 0 * mistahes arv = 0. Seega antud funkts. n\xc3\xb5uab 1-te._NEWLINE_Summa leidmise korral tuleks loomulikult konteiner panna v\xc3\xb5rduma 0-ga._NEWLINE_Nagu n\xc3\xa4ha, toimuvad k\xc3\xb5ik arvutused enne uut rekursiivset v\xc3\xa4ljakutset. See ei pruugi kohe arusaadav olla, aga kujutlegem konteinerit kui kalkulaatorit, mida funktsioon endaga kaasas kannab. Enne uue v\xc3\xa4ljakutse peale minemist l\xc3\xbc\xc3\xbcakse kalkulaatorisse uued numbrid sisse ja leitakse juba vastus. Iga uue astme peal lihtsalt lisatakse tegur juba olemasolevale vastusele. L\xc3\xb5pus kui n v\xc3\xa4\xc3\xa4rtus j\xc3\xb5uab 0-ni, siis tagastatakse konteiner ja ekraanile prinditakse 120.\n_START_SECTION_\nFibonacci arvud\n_START_PARAGRAPH_\n13. sajandi alguses kasutas Leonardo Fibonacci seda arvude jada kirjeldamaks j\xc3\xa4neste populatsiooni kasvu. Selles jadas on iga j\xc3\xa4rgmine liige kahe eelneva summa ja algab nullist. Seega on jada j\xc3\xa4rgmine: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ..._NEWLINE_def leiaFib(n):_NEWLINE_    if n == 0:_NEWLINE_        return 0_NEWLINE_    elif n == 1:_NEWLINE_        return 1_NEWLINE_    else:_NEWLINE_        return leiaFib(n-1) + leiaFib(n-2)_NEWLINE_Siin on tegemist eelpool mainitud puurekursiooniga. Puuoksad saavad ilmsiks juba leiaFib(4) v\xc3\xa4ljakutsel, seega pole m\xc3\xb5tet hakata leidma jada kaugemaid arve funktsiooni t\xc3\xb6\xc3\xb6 demonstreerimiseks._NEWLINE_NB! Normaalse loendamise loogika \xc3\xbctleb, et Fibonacci jada neljas element peaks olema 2. Kuna arvutiteadustes algab _NEWLINE_paljude asjade loendamine 0-st, siis leiaFib(4) otsib tegelikult jada viiendat elementi, mis on t\xc3\xb5esti 3.\n_START_SECTION_\nVastastikune rekursioon\n_START_PARAGRAPH_\nFunktsioon paaris kutsub v\xc3\xa4lja funktsiooni paaritu ja vastupidi niikaua kuni j\xc3\xb5utakse baasjuhuni. Kuna m\xc3\xb5lema funktsiooni baasjuhu tingimus on samasugune, siis tagastatav string ehk s\xc3\xb5ne s\xc3\xb5ltub sellest, kumb funktsioon enne baasjuhuni j\xc3\xb5uab. Kuna funktsiooni t\xc3\xb6\xc3\xb6k\xc3\xa4ik on lineaarne ja seega triviaalne, siis on siin esitatud ainult m\xc3\xb5ne v\xc3\xa4ljakutse vastused:_NEWLINE_Esmapilgul tundub imelik, et miks tagastatavad v\xc3\xa4\xc3\xa4rtused ei v\xc3\xb5iks olla "Paarisarv" ja "Paaritu arv". Siis oleks kohe \xc3\xb5igel kujul vastus olemas ning poleks vaja tagastatavat   _NEWLINE_stringi edasi t\xc3\xb6\xc3\xb6delda. See viiks aga kohati valede tulemusteni olenevalt sellest kummale funktsioonile uuritav arv enne antakse. Pealegi kasutatakse arvutiteadustes   _NEWLINE_kahendmuutuja t\xc3\xbc\xc3\xbcpi True or False v\xc3\xa4\xc3\xa4rtusi palju ning m\xc3\xb5ne \xc3\xbcksiku lisakoodirea kirjutamine nende v\xc3\xa4\xc3\xa4rtuste kasutamiseks on kerge.\n_START_SECTION_\nArvuti looming\n_START_PARAGRAPH_\nFraktalite joonistamiseks on loodud palju erinevat tarkvara. On nii vabavaralisi kui ka kommertslikke. Google\'i otsingusse otsiv\xc3\xa4ljendi "fractal generator" v\xc3\xb5i "best fractal program" sisestamise j\xc3\xa4rel v\xc3\xb5ib leida juba esimeselt lehek\xc3\xbcljelt suure valiku neist.\n_START_SECTION_\nLooduse ilu\n_START_PARAGRAPH_\nEluslooduses leidub palju fraktalitaolisi struktuure, sealhulgas kolmem\xc3\xb5\xc3\xb5tmelisi.\n_START_SECTION_\nK\xc3\xb5nekeeles\n_START_PARAGRAPH_\n[ta n\xc3\xa4eb und]_NEWLINE_[ta n\xc3\xa4eb und, et [ta n\xc3\xa4eb und]]_NEWLINE_[ta n\xc3\xa4eb und, et [ta n\xc3\xa4eb und, et [ta n\xc3\xa4eb und]]]_NEWLINE_jne._NEWLINE_Igat lauset v\xc3\xb5ib j\xc3\xa4tkata l\xc3\xb5putult, tehes selle osaks suuremast lausest sama struktuuriga. Ei eksisteeri pikimat lauset, kuid selliseid lauseid ei moodustata ainult samadest s\xc3\xb5nadest, k\xc3\xbcll aga peab s\xc3\xb5nade t\xc3\xa4hendus j\xc3\xa4\xc3\xa4ma samaks.\n_START_SECTION_\nKunstis\n_START_PARAGRAPH_\nKunstis on \xc3\xbcks tuntumaid n\xc3\xa4iteid "Droste effect", mis sai nime \xc3\xbche hollandi kakaopurgi j\xc3\xa4rgi. Meie idanaabrite matrjo\xc5\xa1ka nukud on vast k\xc3\xb5igile teada-kuuldud. Suurima nuku sees on v\xc3\xa4iksem nukk, selle sees veel v\xc3\xa4iksem ja nii edasi.\n_START_SECTION_\nMuusikas\n_START_PARAGRAPH_\n1981. aastal andis b\xc3\xa4nd The Look  v\xc3\xa4lja singli "I am the beat". Mis teeb selle vin\xc3\xbc\xc3\xbclplaadile kirjutatud loo huvitavaks, on selle l\xc3\xb5putus. Vin\xc3\xbc\xc3\xbclplaadi viimane rida on tehtud ringjooneks ja see m\xc3\xa4ngib trummide osa, mis on pandud t\xc3\xa4pselt vastavusse plaadim\xc3\xa4ngija 45 plaadip\xc3\xb6\xc3\xb6rdega minutis. Sellep\xc3\xa4rast lugu muudkui kestab ja kestab._NEWLINE_Klassikalisest muusikast on tuntud n\xc3\xa4ide Johann Sebastian Bachi "Canon per Tonos" ooperist "Das Musikalische Opfer", mida kutsutakse l\xc3\xb5putult t\xc3\xb5usvaks kaanoniks. Teatud hetkest see pala moduleerib nii, et l\xc3\xa4heb k\xc3\xb5rgemaks \xc3\xbche tooni v\xc3\xb5rra iga korduse kohta. Kaanon tervikuna on C-mollis, aga j\xc3\xa4\xc3\xa4b mulje, et l\xc3\xb5petab D-mollis. Selle l\xc3\xb5pp \xc3\xbchendub sujuvalt algusega ja kogu protsess algab otsast peale, aga seekord D-mollis ja l\xc3\xb5peb E-mollis. P\xc3\xa4rast kuut sellist modulatsiooni on pala tagasi C-molli alguses, aga oktaavi v\xc3\xb5rra k\xc3\xb5rgem ja kogu protsess saab otsast peale alata.'