Exponent (LISP - Scheme)

Exponent - Lisp

In this post we will discuss how to make a normal program using which we can calculate exponent of the given numbers. i.e. 2^3 or 52^40 etc. I mean google it and you won't get a precise answer for 52^40 but using lisp you can get a more accurate answer. So lets get started...

So basic approach to calculate b^n is multiply b n times. So if you have followed my previous posts you might know how to proceed further as its very similar to the methods we used earlier to solve the problems. 

So the function for exponent is like : 

Firstly we will start by defining the function which will take in 2 arguments b & n.

(define (expo b n)

After that we want to multiply b n times and till n becomes 0 and when that happens we will then return 1 i.e. b^0 = 1. So the code will do something like b*(b^(n-1)) till n-1 = = 0.

So in further code its like this :

(cond ((= n 0) 1)
           (else (* b (expo b (- n 1))))))

Written By,

Sarvesh Bhatnagar

Reverse of a number - LISP(SCHEME)

Reverse of a number - LISP(Scheme)

Reverse of a given number involves 2 main task , 

1. Finding what the last digit is
2. Finding the remains number aside from last digit

If we solve these tasks then we can easily find the reverse of a given number by simply recursively finding the last digit and trimming the original number. 

Aside from this , there is one other problem which we might face which is : the problem of storing the last digit obtained... We can solve that by the following method:

1. Intitalize a variable temp which will hold the reversed number with 0.
2. perform temp = (temp * 10 ) + last digit.

we initialise temp = 0 only once whereas 2nd step is done at every step, in second step we are actually creating a space for last digit by multiplying it with 10, after which we can simply add the last digit to it.

Now the code for finding out reverse of a given number can be written as :

Now, we basically solve the first problem of finding last digit by using modulo operator...
i.e (modulo number 10) , we solve the second problem by finding the quotient of the number, So our code turns out as keep finding the reverse until the original number becomes 0 , and when that happens return the reversed number.

Written By,

Sarvesh Bhatnagar

Factorial - LISP(Scheme)

A Program for finding factorial using Scheme

Factorials n or n! is defined as product of all positive integers upto n.  Simply n! 

for example : 

5! = 5 * 4 * 3 * 2 * 1

Now there are two ways to calculate factorials, one is if we go in a backward direction i.e  in a decremental manner in which we recursively multiply the factorial(n-1) with n or we can go in an incremental manner in which we start from one and progress towards n i.e. 1 * 2 * 3 * ... * n-1 * n.

Aside from that , another condition which we need to know is 0! = 1.

In this post we will look how to implement the same in scheme.

When going in backward direction our scheme code will look like :

(define (fact n)(cond ((= n 1) 1)

                                   ((= n 0) 1)

                                   (else (* n (fact (- n 1))))))

In the above code we simply handle the possible edge cases first and continue until we reach the edge case. i.e. n == 1 or n == 0

Similarly we can define for an incremental iterative approach as : 

(define (fact n t)(cond((> n 0) (fact (- n 1) (* t n)))
                                     ( else t)))

Benefit of the incremental iterative approach is that if we know the state values, we can start directly from that particular state for example :
2nd state of 5! is :  t = 5 , n = 4
3rd state of 5! is :   t = 20 , n = 3
and so on...

Written By,

Sarvesh Bhatnagar