Q:-1 Write a program print n to 1 by using recursion.

Input:-5
Output:-5 4 3 2 1
import [Link];
public class RecursionDemo {
public static void main(String[] args) {
Scanner sc=new Scanner([Link]);
[Link]("Enter number");
int n=[Link]();
printDec(n);
}
public static void printDec(int n)
{
if(n==0)
{
return;
}
[Link](n+" ");
printDec(n-1);
}
}
Q:-2 Write program a print 1 to N by using recursion.
Input:-5
Output:-1 2 3 4 5
import [Link];
public class RecursionDemo {
public static void main(String[] args) {
Scanner sc=new Scanner([Link]);
[Link]("Enter number");
int n=[Link]();
printIec(n);
}
 public static void printIec(int n)
{
if(n==0) {
return;
}
printIec(n-1);
[Link](n+" ");
}
}

Q:-3 Write a program print N to 1 and 1 to N by using recursion.

Input:-5
Output:-5 4 3 2 1 1 2 3 4 5
import [Link];
public class RecursionDemo {
public static void main(String[] args) {
Scanner sc=new Scanner([Link]);
[Link]("Enter number");
int n=[Link]();
printDecIec(n);
}
public static void printDecIec(int n)
{
if(n==0) {
return;
}
[Link](n+" ");
printDecIec(n-1);
[Link](n+" ");
}
}
Q:-4 Find the factorial of N.
Input:- 5
Output:-120
import [Link];
public class RecursionDemo {
public static void main(String[] args) {
Scanner sc=new Scanner([Link]);
[Link]("Enter number");
int n=[Link]();
[Link]("Factrial of "+n+ " is "+factorial(n));
}
public static int factorial(int n)
{
if(n==1) {
return 1;
}
int fact= factorial(n-1);
int fn=fact*n;
return fn;

}
}

Q:-5 Write a program to calculate power(x,n).

Input:- 2 3
Output:- 8
import [Link];
public class RecursionDemo {
public static void main(String[] args) {
Scanner sc=new Scanner([Link]);
[Link]("Enter Base");
int x=[Link]();
 [Link]("Enter Power");
int n=[Link]();
[Link]("power = "+power(x,n));
}
public static int power(int x,int n)
{
if(n==0)
{
return 1;
}
int xr=power(x,n-1);
int xp=x*xr;
return xp;
}
}
Q:-6 Write a program to print Zig-Zag.
import [Link];
public class RecursionDemo {
public static void main(String[] args) {
Scanner sc=new Scanner([Link]);
[Link]("Enter Number");
int n=[Link]();
printZigZag(n);
}
public static void printZigZag(int n)
{
if(n==0)
{
return ;
}
[Link]("PRE:: "+n);
printZigZag(n-1);
 [Link]("IN:: "+n);
printZigZag(n-1);
[Link]("POST:: "+n);
}
}
Result:-
Enter Number
2
PRE:: 2
PRE:: 1
IN:: 1
POST:: 1
IN:: 2
PRE:: 1
IN:: 1
POST:: 1
POST:: 2

Q:-7 Tower of Hanai by using recursion.

import [Link];
public class RecursionDemo {
public static void main(String[] args) {
Scanner sc=new Scanner([Link]);
[Link]("Enter Number Of Disc");
int n=[Link]();
[Link]("Enter Size of Lower Disc");
int sdisc=[Link]();
[Link]("Enter Size of Medium Disc");
int mdisc=[Link]();
[Link]("Enter Size of Larger Disc");
int ldisc=[Link]();
tower(n,sdisc,mdisc,ldisc);
 }
public static void tower(int n,int sdisc,int mdisc,int ldisc)
{
if(n==0)
{
return;
}
tower(n-1,sdisc,ldisc,mdisc);
[Link](n+" "+sdisc+" "+mdisc);
tower(n-1,ldisc,mdisc,sdisc);
}
}

Result:-
Enter Number Of Disc
3
Enter Size of Lower Disc
10
Enter Size of Medium Disc
11
Enter Size of Larger Disc
12
1 10 11
2 10 12
1 11 12
3 10 11
1 12 10
2 12 11
1 10 11
Q:-8 Print array by using recursion.
public class RecursionDemo {
public static void main(String[] args) {
 int []arr={1,2,3,4,5,6,7,8,9,10};
new RecursionDemo().print(arr,0);
}
public void print(int[]arr,int n)
{
if([Link]==n)
{
return;
}
[Link](arr[n]+" ");
print(arr,n+1);
}
}

Q:-9 Print array in reverse order by using recursion.

import [Link];
public class RecursionDemo {
public static void main(String[] args) {
int []arr={1,2,3,4,5,6,7,8,9,10};
new RecursionDemo().print(arr,0);
}
public void print(int[]arr,int n)
{
if([Link]==n)
{
return;
}
print(arr,n+1);
[Link](arr[n]+" ");
}
}
Q:-9 Find max from array by using recursion.
public class RecursionDemo {
public static void main(String[] args) {
int []arr={15,22,11,23,44,1,5,2};
[Link](new RecursionDemo().findMax(arr,0));
}
public int findMax(int []arr, int idx)
{
if(idx==[Link]-1)
{
return arr[idx];
}
int tmax=findMax(arr,idx+1);
if(tmax>arr[idx])
{
return tmax;
}
else
{
return arr[idx];
}
}
}
Q:-10 Find first index value of given target.
public class RecursionDemo {
public static void main(String[] args) {
int []arr={15,21,11,23,44,11,22,2};
[Link](new
RecursionDemo().firstOccurance(arr,0,2));
}
public int firstOccurance(int []arr,int idx,int target)
{
 if(idx==[Link])
{
return -1;
}
if(target==arr[idx])
{
return idx;
}
else
{
return firstOccurance(arr,idx+1,target);
}
}
}
Q:-11 Find the last occurrence.
public class RecursionDemo {
public static void main(String[] args) {
int[]arr={1,2,3,3,4,4,5,6,3,2};
[Link](new
RecursionDemo().lastOccurance(arr,1,0));
}
public int lastOccurance(int []arr, int target,int idx)
{
if([Link]==idx)
{
return -1;
}
int loc=lastOccurance(arr,target,idx+1);
if(loc==-1)
{
if(arr[idx]==target)
{
 return idx;
}
else
{
return -1;
}
}
else {
return loc;
}
}
}

Q:-12 Print nth fibonacci number.

public class RecursionDemo {
public static void main(String[] args)
{
[Link](new RecursionDemo().fibo(3));
}
public int fibo(int n)
{
if(n<=1)
{
return n;
}
return fibo(n-1)+fibo(n-2);
}
}

Result:- 2

Q:-13 Print all Indices.

public class RecursionDemo {
public static void main(String[] args)
{
int[]arr={1,1,2,2,3,3,6,7,3};
int rarr[]=new RecursionDemo().allindices(arr,3,0,0);
for (int i=0;i<[Link];i++)
{
[Link](rarr[i]+" ");
}
}
public int[] allindices(int[]arr, int target, int idx, int count
)
{
if (idx== [Link])
{
return new int[count];
}
if (arr[idx]==target)
{
int []iarr=allindices(arr,target,idx+1,count+1);
iarr[count]=idx;
return iarr;
}
else
{
int []iarr=allindices(arr,target,idx+1,count);
return iarr;
}
}
}

Result:- 4 5 8
Q:- QuickSort.
public class QuickSortDemo {
public static void main(String[] args) {
int[]arr={8,5,1,3,7,2,9,6};
//int z=new QuickSortDemo().partion(arr,0,[Link]-
1,arr[[Link]-1]);
// [Link](z);
new QuickSortDemo().quicksort(arr,0,[Link]-1);
for(int x:arr)
{
[Link](x+" ");
}

}
public void quicksort(int []arr,int lo,int hi)
{
if(lo>=hi)
{
return;
}
int pivot=arr[hi];
int pi=partion(arr,lo,hi,pivot);
quicksort(arr,lo,pi-1);
quicksort(arr,pi+1,hi);
}
public int partion(int arr[], int lo, int hi,int p)
{
int i=lo;
int j=lo;
while (i<=hi) {
if (arr[i] <= p) {
 swap(arr, i, j);
i++;
j++;
} else {
i++;
}
}
return j-1;
}
public void swap(int []arr, int i,int j)
{
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
Q:-Merge Sort.
public class MergeSortDemo {
public static void main(String[] args) {
int []arr={3,9,6,5,1,2,4,8,7};
int []arr2=new MergeSortDemo().mergeSort(arr,0,[Link]-
1);
for(int x:arr2)
{
[Link](x+" ");
}
}
public int[] mergeSort(int arr[], int start, int end)
{
if(start==end)
{
int [] temparr=new int[1];
 temparr[0]=arr[start];
return temparr;
}
int mid=(start+end)/2;
int firsthalf[]=mergeSort(arr,start,mid);
int secondhalf[]=mergeSort(arr,mid+1,end);
int finalArray[]=merge(firsthalf,secondhalf);
return finalArray;

}
public int [] merge(int []arr1, int []arr2 )
{
int arr3[]=new int[[Link]+[Link]];
int i=0;
int j=0;
int k=0;
while (i<[Link] && j<[Link]) {
if (arr1[i] < arr2[j]) {
arr3[k] = arr1[i];
i++;
k++;
} else {
arr3[k] = arr2[j];
j++;
k++;
}
}
while(i<[Link])
{
arr3[k] = arr1[i];
i++;
k++;
 }
while (j<[Link])
{
arr3[k] = arr2[j];
j++;
k++;
}
return arr3;
}
}

Q:- CoinChange.
public class CoinChangeDemo
{
public static void main(String[] args)
{
CoinChangeDemo cc=new CoinChangeDemo();
int []coin={2,3,5};
[Link](0,coin,0,7,"");
}
public void coinChange(int index,int[]coin, int currentamt,int
totalamt,String add)
{
if(index==[Link])
{
if(currentamt==totalamt)
{
[Link](add + ".");
}
return;
}
coinChange(index+1,coin,currentamt+coin[index],totalamt,add+coin[ind
ex]+"-");
coinChange(index+1,coin,currentamt,totalamt,add);
}
}