Recursion 1 or 2

Author: kabhinav577

Data Structures in Java/Recursion - 1/Calculate Power.txt

@@ -0,0 +1,31 @@
+Calculate Power
+Send Feedback
+Write a program to find x to the power n (i.e. x^n). Take x and n from the user. You need to return the answer.
+Do this recursively.
+Input format :
+Two integers x and n (separated by space)
+Output Format :
+x^n (i.e. x raise to the power n)
+Constraints :
+0 <= x <= 30
+0 <= n <= 30
+Sample Input 1 :
+ 3 4
+Sample Output 1 :
+81
+Sample Input 2 :
+ 2 5
+Sample Output 2 :
+32
+
+
+/////////////---------------------<<<<<<<<<<<<<<<<<<<<.>>>>>>>>>>>>>>>>>>>>>////////
+public class Solution {
+
+	public static int power(int x, int n) {
+		if (n == 0)
+			return 1;
+		int result = x * power(x, n - 1);
+		return result;
+	}
+}

Data Structures in Java/Recursion - 1/Check Number in Array.txt

@@ -0,0 +1,53 @@
+Check Number in Array
+Send Feedback
+Given an array of length N and an integer x, you need to find if x is present in the array or not. Return true or false.
+Do this recursively.
+Input Format :
+Line 1 : An Integer N i.e. size of array
+Line 2 : N integers which are elements of the array, separated by spaces
+Line 3 : Integer x
+Output Format :
+'true' or 'false'
+Constraints :
+1 <= N <= 10^3
+Sample Input 1 :
+3
+9 8 10
+8
+Sample Output 1 :
+true
+Sample Input 2 :
+3
+9 8 10
+2
+Sample Output 2 :
+false
+
+
+/////////////////////----------------------->>>>>>>>>>>>>>>>>>>>>>>>>>>
+public class Solution {
+	
+	public static boolean checkNumber(int input[], int x) {
+		if(input.length == 0)
+		  return false;
+
+		if(input.length == 1)
+		{
+			if(input[0] == x)
+			  return true;
+			else
+			  return false; 
+		} 
+
+		if(input[0] == x)
+		 return true;
+
+		int []smallArray = new int[input.length - 1];
+		for(int i = 1; i < input.length; i++)
+           smallArray[i - 1] = input[i];
+
+		boolean checkValue = checkNumber(smallArray, x);
+		  return checkValue;   
+		
+	}
+}

Data Structures in Java/Recursion - 1/First Index of Number in Array.txt

@@ -0,0 +1,47 @@
+First Index Of a Number in an Array - Question
+Send Feedback
+Given an array of length N and an integer x, you need to find and return the first index of integer x present in the array. Return -1 if it is not present in the array.
+First index means, the index of first occurrence of x in the input array.
+Do this recursively. Indexing in the array starts from 0.
+Input Format :
+Line 1 : An Integer N i.e. size of array
+Line 2 : N integers which are elements of the array, separated by spaces
+Line 3 : Integer x
+Output Format :
+first index or -1
+Constraints :
+1 <= N <= 10^3
+Sample Input :
+4
+9 8 10 8
+8
+Sample Output :
+1
+
+///////////////////////______________----------------------->>>>>>>>>>>>>>>>>>>>
+
+
+public class Solution {
+
+	public static int firstIndex(int input[], int x) {  
+		return firstIndex(input, x, 0);
+	}
+
+	public static int firstIndex(int arr[], int x , int startIndex) {
+		 // Base case 1
+    if (startIndex == arr.length) {
+        return -1;
+    }
+
+    // Base case 2
+    if (arr[startIndex] == x) {
+        return startIndex;
+    }
+
+    // Recursive call
+    int smallAns = firstIndex(arr, x, startIndex + 1);
+
+    return smallAns;
+	}
+	
+}

Data Structures in Java/Recursion - 1/Last index of a Number in Array.txt

@@ -0,0 +1,43 @@
+Last Index Of a Number in an Array - Question
+Send Feedback
+Given an array of length N and an integer x, you need to find and return the last index of integer x present in the array. Return -1 if it is not present in the array.
+Last index means - if x is present multiple times in the array, return the index at which x comes last in the array.
+You should start traversing your array from 0, not from (N - 1).
+Do this recursively. Indexing in the array starts from 0.
+Input Format :
+Line 1 : An Integer N i.e. size of array
+Line 2 : N integers which are elements of the array, separated by spaces
+Line 3 : Integer x
+Output Format :
+last index or -1
+Constraints :
+1 <= N <= 10^3
+Sample Input :
+4
+9 8 10 8
+8
+Sample Output :
+3
+
+/////////////////------------------------>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+
+public class Solution {
+
+	public static int lastIndex(int input[], int x) {
+		return lastIndex(input, x, input.length - 1);
+	}
+
+	public static int lastIndex(int arr[], int x, int lastIdx) {
+		if(lastIdx <= 0)
+		  return -1;
+
+		if(arr[lastIdx] == x) 
+		  return lastIdx; 
+
+		int smallAns = lastIndex(arr, x, lastIdx - 1);
+
+		return smallAns;  
+	}
+	
+}

Data Structures in Java/Recursion - 1/Number of Digits.txt

@@ -0,0 +1,30 @@
+Number of Digits
+Send Feedback
+Given the number 'n', find out and return the number of digits present in a number .
+Input Format :
+Integer n
+Output Format :
+Count of digits
+Constraints :
+1 <= n <= 10^6
+Sample Input 1 :
+ 156
+Sample Output 1 :
+3
+Sample Input 2 :
+ 7
+Sample Output 2 :
+1
+
+//////////////////---------------<<<<<<<<<<<<<<<>>>>>>>>>>>/////////////
+public class Solution {
+static int c = 0;
+	public static int count(int n){
+		//Write your code here
+      if(n > 0) {
+            c++;
+            count(n/10);
+        }
+        return c;
+	}
+}

Data Structures in Java/Recursion - 1/Print first N natural Number.txt

@@ -0,0 +1,31 @@
+Print First N Natural Numbers - Code
+Send Feedback
+Given the number 'n', write a code to print numbers from 1 to n in increasing order recursively.
+Input Format :
+Integer n
+Output Format :
+Numbers from 1 to n (separated by space)
+Constraints :
+1 <= n <= 10000
+Sample Input 1 :
+ 6
+Sample Output 1 :
+1 2 3 4 5 6
+Sample Input 2 :
+ 4
+Sample Output 2 :
+1 2 3 4
+
+
+/////////////////-----------------<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>------------------
+
+public class Solution {
+
+	public static void print(int n){
+		//Write your code here
+		if (n > 0) {
+			print(n-1);
+			System.out.print(n + " ");
+		}
+	}
+}

Data Structures in Java/Recursion - 1/Sum of Array.txt

@@ -0,0 +1,43 @@
+Sum Of Array
+Send Feedback
+Given an array of length N, you need to find and return the sum of all elements of the array.
+Do this recursively.
+Input Format :
+Line 1 : An Integer N i.e. size of array
+Line 2 : N integers which are elements of the array, separated by spaces
+Output Format :
+Sum
+Constraints :
+1 <= N <= 10^3
+Sample Input 1 :
+3
+9 8 9
+Sample Output 1 :
+26
+Sample Input 2 :
+3
+4 2 1
+Sample Output 2 :
+7    
+
+
+//////////////////---------------------------->>>>>>>>>>>>>>>>>>>>>>>>>
+
+public class Solution {
+
+	public static int sum(int input[]) {
+		if(input.length == 0)
+		   return -1;
+		   
+                if(input.length == 1)
+		    return input[0];
+
+		int []smallArray = new int[input.length - 1];
+		for(int i = 1; i < input.length; i++)
+		    smallArray[i-1] = input[i];
+
+		int total = sum(smallArray);
+		total+=input[0];
+		return total;
+	}
+}

Data Structures in Java/Recursion - 2/Binary Search.txt

@@ -0,0 +1,13 @@
+ public static int binarySearch(int a[],int si,int ei,int x){
+        if(si>ei){
+            return -1;
+        }
+        int midIndex=(si+ei)/2;
+        if(a[midIndex]==x){
+            return midIndex;
+        }else if(a[midIndex]<x){
+            return binarySearch(a,midIndex+1,ei,x);
+        }else{
+            return binarySearch(a,si,midIndex-1,x);
+        }
+    }

Data Structures in Java/Recursion - 2/Merge Sort.txt

@@ -0,0 +1,71 @@
+Merge Sort - Problem Statement
+Send Feedback
+Sort an array A using Merge Sort.
+Change in the input array itself. So no need to return or print anything.
+Input format :
+Line 1 : Integer n i.e. Array size
+Line 2 : Array elements (separated by space)
+Output format :
+Array elements in increasing order (separated by space)
+Constraints :
+1 <= n <= 10^3
+Sample Input 1 :
+6 
+2 6 8 5 4 3
+Sample Output 1 :
+2 3 4 5 6 8
+Sample Input 2 :
+5
+2 1 5 2 3
+Sample Output 2 :
+1 2 2 3 5 
+
+
+////////////////////////////---------------------------------->>>>>>>>>>>>>>>>>>>>
+
+public class solution {
+
+	public static void merge(int s1[], int s2[], int d[])
+	{
+		int i,j,k;
+		i = j = k = 0;
+		while(i < s1.length && j < s2.length)
+		{
+			if(s1[i] <= s2[j])
+				d[k++] = s1[i++];
+			else
+				d[k++] = s2[j++];
+		}
+		
+		if(i < s1.length) {
+			while(i < s1.length)
+				d[k++] = s1[i++];
+		}
+		
+		if(j < s2.length) {
+			while(j < s2.length)
+				d[k++] = s2[j++];
+		}
+	}
+
+	public static void mergeSort(int[] input){
+		// Write your code here
+		if(input.length <= 1)
+			return;
+		
+		int mid = input.length / 2;
+		int b[] = new int[mid];
+		int c[] = new int[input.length - b.length];
+		
+		for(int i = 0; i < mid; i++)
+			b[i] = input[i];
+		
+		for(int i = mid; i < input.length; i++)
+			c[i - mid] = input[i];
+		
+		mergeSort(b);
+		mergeSort(c);
+		merge(b,c,input);
+		
+	}
+}