Fibonacci-sekvensen - Forklaret i Python, JavaScript, C ++, Java og Swift

Fibonacci-sekvensen er pr. Definition heltalssekvensen, hvor hvert nummer efter de første to er summen af ​​de to foregående tal. For at forenkle:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,…

Det har mange applikationer inden for matematik og endda handel (ja, du læser rigtigt: handel), men det er ikke meningen med denne artikel. Mit mål i dag er at vise dig, hvordan du kan beregne ethvert udtryk i denne række numre på fem forskellige programmeringssprog ved hjælp af rekursive funktioner.

Rekursive funktioner er de funktioner, der grundlæggende kalder sig selv.

Jeg vil bemærke, at dette ikke er den bedste metode til at gøre det - faktisk kan det betragtes som den mest basale metode til dette formål. Dette skyldes, at den krævede computerkraft til at beregne større vilkår for serien er enorm. Antallet af gange, funktionen kaldes, forårsager et stackoverløb på de fleste sprog.

Alligevel skal vi begynde med henblik på denne tutorial.

Lad os først tænke på, hvordan koden skal se ud. Det inkluderer:

· En rekursiv funktion F (F for Fibonacci): at beregne værdien for den næste periode.

· Intet andet: Jeg advarede dig om, at det var helt grundlæggende.

Vores funktion vil tage n som input, som vil henvise til den n th sigt af sekvensen, at vi ønsker at blive beregnet. Så F (4) skal returnere den fjerde periode af sekvensen.

Lad os planlægge det. Koden skal uanset sprog se sådan ud:

function F(n)  if n = 0

   return 0  if n = 1

   return 1  else

   return F(n-1) + F(n-2)

Bemærk: udtrykket 0 i sekvensen betragtes som 0, så det første udtryk vil være 1; det andet, 1; den tredje, 2; og så videre. Du ved hvad jeg mener.

Lad os analysere funktionen et øjeblik. Hvis det får 0 som input, returnerer det 0. Hvis det får 1, returnerer det 1. Hvis det får 2 ... Nå, i så fald falder det ind i den anden sætning, som kalder funktionen igen for vilkår 2–1 ( 1) og 2–2 (0). Det returnerer 1 og 0, og de to resultater tilføjes og returnerer 1. Perfekt.

Nu kan du se, hvorfor rekursive funktioner i nogle tilfælde er et problem. Forestil dig, at du ville have sekvensens 100. periode. Funktionen ville kalde sig selv for den 99. og den 98., som selv ville kalde funktionen igen for det 98. og 97. og 97. og 96. udtryk ... og så videre. Det ville være rigtig langsomt.

Men den gode nyhed er, at det faktisk fungerer!

Så lad os starte med de forskellige sprog. Jeg giver ikke for mange detaljer (faktisk slet ingen detaljer) for at gøre din læseoplevelse bedre. Der er alligevel ikke for meget at detaljer.

Lad os hoppe ind i det:

Python

def F(n):  if n == 0:

   return 0  if n == 1:

   return 1  else:

   return F(n-1) + F(n-2)

Hurtig

func F(_ n: Int) -> Int {  if n == 0 {    return 0

 }  if n == 1 {    return 1

 }  else {    return F(n-1) + F(n-2)

 }}

JavaScript

function F(n) {  if(n == 0) {    return 0;

 }  if(n == 1) {    return 1;

 }  else {    return F(n-1) + F(n-2);

 }}

Java

public static int F(int n) {  if(n == 0) {    return 0;

 }  if(n == 1) {    return 1;

 }  else {    return F(n-1) + F(n-2);

 }}

C ++

int F(int n) {  if(n == 0) {    return 0;

 }  if(n == 1) {    return 1;

 }  else {    return F(n-1) + F(n-2);

 }}

Og det er det. Jeg valgte disse sprog bare baseret på popularitet - eller i det mindste fordi disse 5 er de mest almindelige, som jeg bruger. De er i ingen særlig rækkefølge. De kunne klassificeres efter syntaksbesvær, efter min mening fra Python (nemmest) til C ++ (hårdest). Men det afhænger af din personlige mening og din erfaring med hvert sprog.

Jeg håber, du kunne lide denne artikel, og hvis du har spørgsmål / anbefalinger eller bare vil sige hej, kommenter nedenfor!