#7.9 Kotlin Tutorial TAILREC Function - Use Recursion in Optimised way

hi registering to the arts and welcome
to the next video of functions in Kotlin
in this video we will talk about the
tail drag functions in case of Ortolan
so this function uses recursion in more
optimized way than any other language
such as Java or C programming and so on
now what is the meaning of recursion
recursion means calling its own function
from within the function that is we will
call a function from inside its own
function now in case of Cortland
whenever we call the same function
multiple number of times such as
hundreds of thousands of time then that
recursive process is actually optimized
and the Kotlin simply prevents the stack
overflow exception because calling the
same function recursively can simply
blow up the stack memory so in that case
the court lin simply optimize the code
call the function recursively right and
now to define a tail risk function we
have to use the keyboard of tail rec now
inside the IntelliJ IDE I will simply
write my code to find the Fibonacci
series now what do we mean by the
Fibonacci series is that suppose I have
the number zero and the next number is
when so the next number will be the sum
of 1 and 0 that is 1 again and the next
number will be 1 plus 1 equal to 2 and
then we will have 2 plus 1 such as 3
similarly 3 plus 2 such as 5 and next
will be 5 plus 3 8 and then 8 plus 5 13
and so on
like this let's say 21 right and the
series goes on so let us write a program
to find the Fibonacci series so for that
let us define our function so here I
simply defined a method of get Fibonacci
number at the NS position right and Here
I am passing two parameters of a and B
that determines the starting point of
the Fibonacci series such as 0 and 1
these two values we have to give so that
we can get the third number right by
adding these two numbers and now this
simply returns the value or the
Fibonacci number at the N it
Asian suppose I pass six so the six
number is actually eight so this
function will simply return it right now
Here I am using the big integer now the
purpose of using the big integer is that
this big integer class can hold a very
large number or integer value so you can
call this big integer as the big boss of
the integer class right and now here I
am simply writing some if-else condition
so if part is totally understandable but
here in the else part you can see I am
simply calling get Fibonacci number
which is actually its own method here
right so if the else part is executed it
simply execute this method again
recursively so the recursion goes on
like this infinite number of times
suppose if this n is 10000 so it will
simply loop through 10,000 times like
this right and now here let us solve
this error by simply pressing Alt +
Enter so simply import the big integer
right and now from inside the main
method I will simply call this method so
as to get the Fibonacci number so here
this is my main method inside which I am
simply calling println get Fibonacci
number and simply passing 5 as a
parameter and the starting position as 1
and 0 right if I run the code right now
I will get let's say some value among
these number present at the fifth
position so let us now run the code and
here we get 5 as the output so let us
try something different
let us try 7 and let's see what happens
and here we get 13 so at the 7th
position we have 13 right so the 7th
Fibonacci number is we are getting 13 if
we type here 8 then we will get let's
say 21 like that so the series goes on
like this so as many times so whatever n
value get we will give here the else
part will be executed and the recursion
will goes on that is that is it will
simply call its own method again and
again till it finds the result that is
till this point gets executed right now
suppose if
I type here 100 let's see what happens
so here we get a very big number value
that is a number the Fibonacci number at
the hundred position is this one now if
I type ten thousand let's see what
happens so here our program has crashed
just because we have just ran out of the
stack memory so the java virtual machine
has simply printed out the stack
overflow error that is it has simply
thrown out this error of stack overflow
so we are now out of stack memory so
this is a usual scenario in all the
programming language if you write the
same code in case of Java C or C++ then
it was simply going to throw this error
right but in Coeur d'Alene the things
are different you can simply use the
tail rec keyword so this function now
becomes the tail recursive right
and now here let us first try with 100
number so I guess our code will execute
normally so here we get the output right
but this time using the Taylor expansion
if I use 10,000 as an innate value then
let's see what happens so in the output
we have a very huge number right and
this number goes on till the end you
cannot find the end right here because
the number is too large so in Kotlin we
have a tail rect function that simply
execute the recursion internally that is
without affecting the stack memory so
without affecting the stack memory it
simply execute this method recursively
about 10,000 number of times without
affecting your application in the
runtime by saving memory right so the
court link provides an alternative
solution for the stack overflow error so
this was all about the tail drag
function in case of Cortlandt so now I
guess slowly and steadily you will fall
in love with Courtland because Cortland
is very very powerful version of Java
or you can see it is the future of
Android so thanks for watching and have
a good day