diff --git a/recurssions examples/MergeSort.java b/recurssions examples/MergeSort.java
new file mode 100755
index 0000000..2e58eac
--- /dev/null
+++ b/recurssions examples/MergeSort.java	
@@ -0,0 +1,60 @@
+package recurssion;
+
+public class MergeSort {
+
+	public static void main(String[] args) {
+		int[] one = { 11, 33, 55, 66 }, two = { 5, 7, 9, 14, 22 };
+		int[] arr = merge(one, two);
+		// for (int val : arr) {
+		// System.out.print(val + " ");
+		// }
+		int[] three = { 2, 54, 6, 23, 7, 2, 67, 44, 77, 99, 0 };
+		three = mergesort(three, 0, three.length - 1);
+		for (int val : three) {
+			System.out.print(val + " ");
+		}
+	}
+
+	public static int[] merge(int[] one, int[] two) {
+		int i = 0, j = 0, k = 0;
+		int[] arr = new int[one.length + two.length];
+		while ((i < one.length) && (j < two.length)) {
+			if (one[i] > two[j]) {
+				arr[k] = two[j];
+				++j;
+				++k;
+			} else {
+				arr[k] = one[i];
+				++i;
+				++k;
+			}
+		}
+		while (j < two.length) {
+
+			arr[k] = two[j];
+			++j;
+			++k;
+		}
+		while (i < one.length) {
+
+			arr[k] = one[i];
+			++i;
+			++k;
+		}
+		return arr;
+	}
+
+	public static int[] mergesort(int arr[], int lo, int hi) {
+		if (hi == lo) {
+			int[] b = new int[1];
+			b[0] = arr[lo];
+			return b;
+		}
+		int mid = (lo + hi) / 2;
+		int[] fhalf = mergesort(arr, lo, mid);
+		int[] shalf = mergesort(arr, mid + 1, hi);
+
+		int arr1[] = merge(fhalf, shalf);
+		return arr1;
+	}
+}
diff --git a/recurssions examples/QuickSort.java b/recurssions examples/QuickSort.java
new file mode 100755
index 0000000..8885cb8
--- /dev/null
+++ b/recurssions examples/QuickSort.java	
@@ -0,0 +1,43 @@
+package recurssion;
+
+public class QuickSort {
+
+	public static void main(String[] args) {
+
+		int[] arr = { 5, 11, 33, 66, 22 };
+		qsort(arr, 0, arr.length - 1);
+		for (int val : arr) {
+			System.out.print(val + " ");
+		}
+
+	}
+
+	public static void qsort(int[] arr, int low, int hi) {
+		if (low >= hi)
+			return;
+
+		int left = low, right = hi;
+		int mid = (low + hi) / 2;
+		int pivit = arr[mid];
+		while (left <= right) {
+			while (arr[left] < pivit) {
+				++left;
+			}
+			while (arr[right] > pivit) {
+				--right;
+			}
+
+			if (left <= right) {
+				int temp = arr[right];
+				arr[right] = arr[left];
+				arr[left] = temp;
+				right--;
+				left++;
+			}
+		}
+
+		qsort(arr, low, right);
+		qsort(arr, left, hi);
+
+	}
+}
diff --git a/recurssions examples/a6q10.java b/recurssions examples/a6q10.java
new file mode 100755
index 0000000..250f94a
--- /dev/null
+++ b/recurssions examples/a6q10.java	
@@ -0,0 +1,28 @@
+package recurssion;
+
+public class a6q10 {
+
+	public static void main(String[] args) {
+		int[] arr = { 66, 33, 55, 33, 11, 22, 44 };
+		int[] ind = indices(arr,33, 0, 0);
+		for(int val:ind)
+			System.out.print(val+"\t");
+	}
+
+	private static int[] indices(int[] arr, int data,int vidx, int count) {
+		if(vidx==arr.length)
+		{
+			int[] ind=new int[count];
+			return ind;
+		}
+		
+		if(arr[vidx]==data)
+			++count;
+		int[] ind=	indices(arr, data,vidx+1, count);
+		if(arr[vidx]==data)
+	ind[count-1]=vidx;
+	
+	return ind;
+	}
+
+}
diff --git a/recurssions examples/a6q11.java b/recurssions examples/a6q11.java
new file mode 100755
index 0000000..5035848
--- /dev/null
+++ b/recurssions examples/a6q11.java	
@@ -0,0 +1,22 @@
+package recurssion;
+
+public class a6q11 {
+	public static boolean palindrome(int[] arr,int vidx)
+	{
+		if(vidx==arr.length/2)
+			return true;
+		boolean bool=false;
+		if(arr[vidx]==arr[arr.length-1-vidx])
+		{
+		bool=palindrome(arr,vidx+1);
+		}
+		
+			return bool;
+	}
+
+	public static void main(String[] args) {
+int[] arr={1,2,3,2,1,9};
+	System.out.println(palindrome(arr,0));
+	}
+
+}
diff --git a/recurssions examples/a6q12.java b/recurssions examples/a6q12.java
new file mode 100755
index 0000000..1c634bd
--- /dev/null
+++ b/recurssions examples/a6q12.java	
@@ -0,0 +1,28 @@
+package recurssion;
+
+public class a6q12 {
+	public static void swap(int[] arr,int i,int j)
+	{
+		
+			int temp=arr[i];
+			arr[i]=arr[j];
+			arr[j]=temp;
+		
+	}
+	public static void rev(int[] arr, int vidx) {
+		if (vidx == arr.length / 2)
+			return;
+		swap(arr,vidx,(arr.length - 1 - vidx));
+		rev(arr, vidx + 1);
+	}
+
+	public static void main(String[] args) {
+		int[] arr = { 1, 2, 3, 4, 5,6 };
+		rev(arr, 0);
+		for(int val:arr)
+		{
+			System.out.print(val+" ");
+		}
+	}
+
+}
diff --git a/recurssions examples/a6q14.java b/recurssions examples/a6q14.java
new file mode 100755
index 0000000..fe763ab
--- /dev/null
+++ b/recurssions examples/a6q14.java	
@@ -0,0 +1,35 @@
+package recurssion;
+
+public class a6q14 {
+	public static void swap(int[] arr, int i, int j) {
+
+		int temp = arr[i];
+		arr[i] = arr[j];
+		arr[j] = temp;
+
+	}
+
+	public static void sort(int[] arr, int vidx, int index) {
+		if (vidx == 1)
+			return;
+
+		if (index < vidx - 1) {
+			sort(arr, vidx, index + 1);
+			if (arr[index] > arr[index + 1])
+				swap(arr, index, index + 1);
+		}
+		if (index == vidx - 1)
+			sort(arr, vidx - 1, 0);
+	}
+
+	public static void main(String[] args) {
+		int[] arr = { 66, 55, 33, 11, 22, 44 };
+		sort(arr, arr.length, 0);
+
+		for (int val : arr) {
+			System.out.print(val + " ");
+		}
+
+	}
+
+}
diff --git a/recurssions examples/a6q15.java b/recurssions examples/a6q15.java
new file mode 100755
index 0000000..4daefea
--- /dev/null
+++ b/recurssions examples/a6q15.java	
@@ -0,0 +1,36 @@
+package recurssion;
+
+public class a6q15 {
+	public static void swap(int[] arr, int i, int j) {
+
+		int temp = arr[i];
+		arr[i] = arr[j];
+		arr[j] = temp;
+
+	}
+
+	public static void sort(int[] arr, int vidx, int index) {
+		if (vidx == arr.length)
+			return;
+
+		if (index == 0)
+			sort(arr, vidx + 1, vidx + 1);
+
+		if (index > 0) {
+			sort(arr, vidx, index - 1);
+			if (arr[index] < arr[index - 1])
+				swap(arr, index, index - 1);
+		}
+	}
+
+	public static void main(String[] args) {
+		int[] arr = { 66, 55, 33, 11, 22, 44 };
+
+		sort(arr, 1, 1);
+		for (int val : arr) {
+			System.out.print(val + " ");
+		}
+
+	}
+
+}
diff --git a/recurssions examples/a6q2.java b/recurssions examples/a6q2.java
new file mode 100755
index 0000000..d6cdb21
--- /dev/null
+++ b/recurssions examples/a6q2.java	
@@ -0,0 +1,28 @@
+package recurssion;
+
+public class a6q2 {
+
+	public static int print(int i, int j) {
+		if (i == 0)
+			return 0;
+		else if (j == 0) {
+
+			print(i - 1, i - 1);
+			System.out.println();
+			return 0;
+		}
+		if (j > 0) {
+			print(i, j - 1);
+			System.out.print("*\t");
+
+			return 0;
+		}
+		return 0;
+	}
+
+	public static void main(String[] args) {
+		int k = print(3, 3);
+
+	}
+
+}
diff --git a/recurssions examples/a6q3.java b/recurssions examples/a6q3.java
new file mode 100755
index 0000000..44bc332
--- /dev/null
+++ b/recurssions examples/a6q3.java	
@@ -0,0 +1,29 @@
+package recurssion;
+
+public class a6q3 {
+
+	public static int print(int i ,int j)
+	{
+		if(i==0)
+			return 0;
+		else if(j==0)
+		{
+			System.out.println();
+			print(i-1,i-1);
+			
+		return 0;
+		}
+		if(j>0)
+		{
+		System.out.print("*\t");
+		print(i,j-1);
+		return 0;
+		}
+	return 0;	
+	}
+	public static void main(String[] args) {
+int k=print(3,3);
+
+	}
+
+}
diff --git a/recurssions examples/a6q4.java b/recurssions examples/a6q4.java
new file mode 100755
index 0000000..142b3bd
--- /dev/null
+++ b/recurssions examples/a6q4.java	
@@ -0,0 +1,42 @@
+package recurssion;
+
+public class a6q4 {
+
+	public static int print(int i, int j) {
+		if (i == -1) {
+			return 1;
+		}
+		if (j >= i) {
+			print(i - 1, 0);
+			System.out.println();
+			return 1;
+		}
+		if (j < i) {
+
+			int n = print(i, j + 1);
+			System.out.print(n);
+			n = (n * (i - j) )/ (j + 1);
+			return n;
+		}
+		return 1;
+	}
+
+	public static void printfor(int n) {
+		if (n == -1)
+			return;
+		printfor(n - 1);
+		System.out.println();
+		int num = 1;
+		for (int j = 0; j <= n; ++j) {
+			System.out.print(num + "\t");
+			num = num * (n - j) / (j + 1);
+		}
+	}
+
+	public static void main(String[] args) {
+
+		print(4, 0);
+		// printfor(6);
+	}
+
+}
diff --git a/recurssions examples/a6q6.java b/recurssions examples/a6q6.java
new file mode 100755
index 0000000..1586a68
--- /dev/null
+++ b/recurssions examples/a6q6.java	
@@ -0,0 +1,20 @@
+package recurssion;
+
+public class a6q6 {
+	public static boolean check(int[] arr, int vidx) {
+		if (vidx == arr.length - 1)
+			return true;
+		if (arr[vidx] > arr[vidx + 1])
+			return false;
+		else
+		return(check(arr, vidx + 1));
+		
+
+	}
+
+	public static void main(String[] args) {
+		int[] arr1 = { 1, 2, 3, 4, 5, 6 }, arr2 = { 1, 4, 5, 2, 0 };
+		System.out.println(check(arr2,0));
+	}
+
+}
diff --git a/recurssions examples/a6q7.java b/recurssions examples/a6q7.java
new file mode 100755
index 0000000..fbd851c
--- /dev/null
+++ b/recurssions examples/a6q7.java	
@@ -0,0 +1,22 @@
+package recurssion;
+
+public class a6q7 {
+
+	public static void main(String[] args) {
+		int[] arr = { 66, 55, 33, 11, 22, 44 };
+System.out.println(search(arr,0,33));
+	}
+
+	private static boolean search(int[] arr, int vidx, int data) {
+		
+		if(vidx==arr.length)
+			return false;
+		boolean x=false;
+		if(arr[vidx]==data)
+			return true;
+		else
+			x=search(arr, vidx+1, data);
+		return x;
+	}
+
+}
diff --git a/recurssions examples/a6q8.java b/recurssions examples/a6q8.java
new file mode 100755
index 0000000..6f1f0f7
--- /dev/null
+++ b/recurssions examples/a6q8.java	
@@ -0,0 +1,22 @@
+package recurssion;
+
+public class a6q8 {
+
+	public static void main(String[] args) {
+		int[] arr = { 66, 55, 33, 11, 22, 44,33 };
+System.out.println(search(arr,0,33));
+	}
+
+	private static int search(int[] arr, int vidx, int data) {
+		
+		if(vidx==arr.length)
+			return -1;
+		int index=-1;
+		if(arr[vidx]==data)
+			return vidx;
+		else
+			index=search(arr, vidx+1, data);
+		return index;
+	}
+
+}
diff --git a/recurssions examples/a6q9.java b/recurssions examples/a6q9.java
new file mode 100755
index 0000000..9f072e9
--- /dev/null
+++ b/recurssions examples/a6q9.java	
@@ -0,0 +1,25 @@
+package recurssion;
+
+public class a6q9 {
+
+	public static void main(String[] args) {
+		int[] arr = { 66, 55, 33, 11, 22, 44,33 };
+System.out.println(search(arr,0,33));
+	}
+
+	private static int search(int[] arr, int vidx, int data) {
+		
+		if(vidx==arr.length)
+			return -1;
+		int index=-1;
+	
+			index=search(arr, vidx+1, data);
+			if(index==-1){
+			{	if(arr[vidx]==data)
+						index= vidx;
+			}}
+
+	return index;
+	}
+
+}
diff --git a/recurssions examples/a7q11.java b/recurssions examples/a7q11.java
new file mode 100755
index 0000000..73e0902
--- /dev/null
+++ b/recurssions examples/a7q11.java	
@@ -0,0 +1,37 @@
+package recurssion;
+
+public class a7q11 {
+
+	public static void main(String[] args) {
+		System.out.println(count("aaabaaaad", "aaa"));
+
+		count1("aaaabaaad", "aaa", 0);
+	}
+
+	private static int count(String que, String find) {
+		if (que.length() < find.length()) {
+			return 0;
+		}
+		int counter = count(que.substring(1), find);
+		String poq = que.substring(0, 3);
+		if (poq.equals(find))
+			++counter;
+		return counter;
+	}
+
+	private static void count1(String que, String find, int counter) {
+		if (que.length() < find.length()) {
+			System.out.println(counter);
+			return;
+		}
+
+		String poq = que.substring(0, 3);
+		if (poq.equals(find)) {
+			++counter;
+			que = "xxx" + que.substring(3);
+		}
+		count1(que.substring(1), find, counter);
+
+	}
+
+}
diff --git a/recurssions examples/a7q12.java b/recurssions examples/a7q12.java
new file mode 100755
index 0000000..d37e7fc
--- /dev/null
+++ b/recurssions examples/a7q12.java	
@@ -0,0 +1,24 @@
+package recurssion;
+
+public class a7q12 {
+
+	public static void combi(String que, String ans) {
+		if (que.length() == 0) {
+			System.out.println(ans);
+			return;
+		}
+		String ch="";
+		for(int i=1;i<3;++i){
+			String s=que.substring(0,i);
+				for(int j=0;j<i;++j){
+					ch+=(char)(s.charAt(j)+96);
+				}
+				combi(que.substring(i),ans+ch);
+		}
+	}
+
+	public static void main(String[] args) {
+combi("1234","");
+	}
+
+}
diff --git a/recurssions examples/a7q13.java b/recurssions examples/a7q13.java
new file mode 100755
index 0000000..5ed5852
--- /dev/null
+++ b/recurssions examples/a7q13.java	
@@ -0,0 +1,25 @@
+package recurssion;
+
+public class a7q13 {
+
+	public static void inverse(int[] arr,int vidx)
+	{
+		if(vidx==arr.length)
+			return;
+		
+		int val=arr[vidx];
+		inverse(arr, vidx+1);
+		arr[val]=vidx;
+	}
+	public static void main(String[] args) {
+		
+		int[] arr={1,4,0,2,3};
+		inverse(arr, 0);
+		
+		for(int val:arr)
+		{
+			System.out.print(val+" ");
+		}
+	}
+
+}
diff --git a/recurssions examples/a7q14.java b/recurssions examples/a7q14.java
new file mode 100755
index 0000000..b0714a3
--- /dev/null
+++ b/recurssions examples/a7q14.java	
@@ -0,0 +1,31 @@
+package recurssion;
+
+import java.util.Scanner;
+
+public class a7q14 {
+
+	public static void main(String[] args) {
+		Scanner scan = new Scanner(System.in);
+		String str = scan.next();
+		print(str, "", false);
+	}
+
+	private static void print(String que, String ans, boolean b) {
+		if (ans.length() != 0 && b == false) {
+			System.out.println(ans.substring(1));
+			return;
+		}
+
+		char ch = que.charAt(0);
+
+		if (ch == '(')
+			b = true;
+		if (ch == ')')
+			b = false;
+		if (b == true) {
+			ans += ch;
+		}
+		print(que.substring(1), ans, b);
+	}
+
+}
diff --git a/recurssions examples/a7q15.java b/recurssions examples/a7q15.java
new file mode 100755
index 0000000..307f8e2
--- /dev/null
+++ b/recurssions examples/a7q15.java	
@@ -0,0 +1,49 @@
+package recurssion;
+
+public class a7q15 {
+
+	public static void main(String[] args) {
+		System.out.println(check("{a+(b+c)-[f*g]}", 0));
+	}
+
+	private static boolean check(String string, int count) {
+		if (string.length() == 0) {
+			if (count == 0)
+				return true;
+			else
+				return false;
+		}
+		char ch = string.charAt(0);
+		switch (ch) {
+		case '{': {
+			++count;
+			break;
+		}
+		case '(': {
+			++count;
+			break;
+		}
+		case '[': {
+			++count;
+			break;
+		}
+		case '}': {
+			--count;
+			break;
+		}
+		case ']': {
+			--count;
+			break;
+		}
+		case ')': {
+			--count;
+			break;
+
+		}
+		}
+		
+		boolean ans=check(string.substring(1), count);
+		return ans;
+	}
+
+}
diff --git a/recurssions examples/a7q2.java b/recurssions examples/a7q2.java
new file mode 100755
index 0000000..ffdca25
--- /dev/null
+++ b/recurssions examples/a7q2.java	
@@ -0,0 +1,17 @@
+package recurssion;
+
+public class a7q2 {
+
+public static int[] chartoint(String s){
+	int[] a =new int[s.length()];
+for(int i=0;i<s.length();++i)
+	a[i]=s.charAt(i)-48;
+	return a;
+}
+	public static void main(String[] args) {
+	int[] arr=chartoint("0123456789");
+	for(int val:arr)
+		System.out.print(val);
+	}
+
+}
diff --git a/recurssions examples/a7q3.java b/recurssions examples/a7q3.java
new file mode 100755
index 0000000..2e6d493
--- /dev/null
+++ b/recurssions examples/a7q3.java	
@@ -0,0 +1,28 @@
+package recurssion;
+
+public class a7q3 {
+
+	public static void main(String[] args) {
+		System.out.println(check("anand", "dnana"));
+	}
+
+	private static boolean check(String string1, String string2) {
+		if (string1.length() != string2.length()) {
+			return false;
+		}
+		if (string2.length() == 1) {
+			if (string1.charAt(0) == string2.charAt(0))
+				return true;
+			else
+				return false;
+		}
+		boolean ans = false;
+		if (string1.charAt(0) != string2.charAt(string2.length() - 1))
+			return ans;
+		else
+			ans = check(string1.substring(1), string2.substring(0, (string2.length() - 1)));
+		return ans;
+
+	}
+
+}
diff --git a/recurssions examples/a7q4.java b/recurssions examples/a7q4.java
new file mode 100755
index 0000000..4a1066c
--- /dev/null
+++ b/recurssions examples/a7q4.java	
@@ -0,0 +1,28 @@
+package recurssion;
+
+public class a7q4 {
+
+	public static void main(String[] args) {
+System.out.println(palindrome("abcddcba"));
+	}
+
+	private static boolean palindrome(String que) {
+
+		if(que.length()<=1)
+		{
+			return true;
+		}
+		boolean ans=false;
+		if(que.charAt(0)!=que.charAt(que.length()-1))
+			{
+			ans=false;
+			return ans;
+			}
+		else
+		{
+			ans=palindrome(que.substring(1, que.length()-1));
+		}
+		return ans;
+	}
+
+}
diff --git a/recurssions examples/a7q5.java b/recurssions examples/a7q5.java
new file mode 100755
index 0000000..5e8336c
--- /dev/null
+++ b/recurssions examples/a7q5.java	
@@ -0,0 +1,27 @@
+package recurssion;
+
+public class a7q5 {
+
+	public static void main(String[] args) {
+		seperate_duplicate("hello"," ");			//taken space because at 1st itration ans.length-1 becomes out of bonds
+	}
+
+	private static void seperate_duplicate(String que, String ans) {
+		if (que.length() == 0) {
+			System.out.println(ans);
+			return;
+		}
+		
+		char ch = que.charAt(0);
+		if(ch==ans.charAt(ans.length()-1))								//here
+			ans=ans+"*"+ch;
+		else
+			ans=ans+ch;
+
+seperate_duplicate(que.substring(1), ans);
+	
+	}
+
+
+
+}
diff --git a/recurssions examples/a7q6.java b/recurssions examples/a7q6.java
new file mode 100755
index 0000000..c55c6c1
--- /dev/null
+++ b/recurssions examples/a7q6.java	
@@ -0,0 +1,23 @@
+package recurssion;
+
+public class a7q6 {
+
+	public static void main(String[] args) {
+		seperate_duplicate("hello", " "); // taken space because at 1st itration
+											// ans.length-1 becomes out of bonds
+	}
+
+	private static void seperate_duplicate(String que, String ans) {
+		if (que.length() == 0) {
+			System.out.println(ans);
+			return;
+		}
+
+		char ch = que.charAt(0);
+		if (ch != ans.charAt(ans.length() - 1)) // here
+			ans = ans + ch;
+		seperate_duplicate(que.substring(1), ans);
+
+	}
+
+}
diff --git a/recurssions examples/a7q7.java b/recurssions examples/a7q7.java
new file mode 100755
index 0000000..d23831d
--- /dev/null
+++ b/recurssions examples/a7q7.java	
@@ -0,0 +1,24 @@
+package recurssion;
+
+public class a7q7 {
+
+	public static void main(String[] args) {
+		shift("abxexdvxg", "", 'x');
+	}
+
+	private static void shift(String que, String ans, char c) {
+		if (que.length() == 0) {
+			System.out.println(ans);
+			return;
+
+		}
+		char ch = que.charAt(0);
+		if (ch == c)
+			ans = ans + ch;
+		else
+			ans = ch + ans;
+		shift(que.substring(1), ans, c);
+
+	}
+
+}
diff --git a/recurssions examples/a7q8.java b/recurssions examples/a7q8.java
new file mode 100755
index 0000000..4597cad
--- /dev/null
+++ b/recurssions examples/a7q8.java	
@@ -0,0 +1,23 @@
+package recurssion;
+public class a7q8 {
+	public static String repl(String que, String find) {
+		if (que.length() < find.length()) {
+			return que;
+		}
+		char ch=que.charAt(0);
+		String rr = repl(que.substring(1), find);
+
+rr=ch+rr;
+		if (rr.substring(0, 2).equals(find))
+			rr = "bye" + rr.substring(2);
+
+		return rr;
+	}
+
+	public static void main(String[] args) {
+		// Scanner scan = new Scanner(System.in);
+		// String s = scan.next();
+		System.out.println(repl("hinamehi", "hi"));
+	}
+
+}
diff --git a/recurssions examples/a8bq7.java b/recurssions examples/a8bq7.java
new file mode 100755
index 0000000..3c5e9e2
--- /dev/null
+++ b/recurssions examples/a8bq7.java	
@@ -0,0 +1,68 @@
+package recurssion;
+
+import java.util.Arrays;
+import java.util.HashMap;
+
+public class a8bq7 {
+
+	public static void main(String[] args) {
+		int n = 15;
+		HashMap<Integer, Integer> ladder = new HashMap<>();
+		int left = 2, right = 15;
+		boolean[] arr = soe(n);
+		
+		while (left < right) {
+
+			while (!arr[left]) {
+				++left;
+			}
+
+			while (!arr[right]) {
+				--right;
+			}
+
+			if (left < right) {
+				ladder.put(left, right);
+				++left;
+				--right;
+			}
+		}
+
+		ans(0, n, "", ladder);
+	}
+
+	public static boolean[] soe(int n) {
+		boolean[] arr = new boolean[n + 1];
+		Arrays.fill(arr, true);
+		arr[0] = arr[1] = false;
+		for (int i = 2; i * i <= n; ++i) {
+			if (arr[i] == false) {
+				continue;
+			}
+
+			for (int ja = 2; ja * i <= n; ++ja) {
+				arr[ja * i] = false;
+			}
+		}
+		return arr;
+	}
+
+	public static void ans(int curr, int end, String psf, HashMap<Integer, Integer> ladder) {
+
+		if (end == curr) {
+			System.out.println(psf);
+		}
+		if (end < curr) {
+			return;
+		}
+
+		for (int i = 1; i < 7; ++i) {
+			if (ladder.containsKey(curr)) {
+				ans(ladder.get(curr), end, psf + "[L" + curr + "->" + ladder.get(curr) + "]", ladder);
+			} else {
+				ans(curr + i, end, psf + "[" + i + "]", ladder);
+			}
+		}
+
+	}
+}
diff --git a/recurssions examples/a8q1.java b/recurssions examples/a8q1.java
new file mode 100755
index 0000000..91bdeff
--- /dev/null
+++ b/recurssions examples/a8q1.java	
@@ -0,0 +1,25 @@
+package recurssion;
+
+public class a8q1 {
+
+	public static void main(String[] args) {
+	System.out.println(permu("abc", "",0));
+	}
+
+	private static int permu(String que, String ans,int count) {
+		if (que.length() == 0) {
+			System.out.println(ans);
+			++count;
+			return count;
+		}
+
+			char ch = que.charAt(0);
+
+//			count=permu(que.substring(1), ans,count);
+			if(ans.length()<3){
+			count=permu(que.substring(1), ans + ch,count);}
+ return count;
+
+	}
+
+}
diff --git a/recurssions examples/a8q10.java b/recurssions examples/a8q10.java
new file mode 100755
index 0000000..8b8a9ec
--- /dev/null
+++ b/recurssions examples/a8q10.java	
@@ -0,0 +1,51 @@
+package recurssion;
+
+public class a8q10 {
+
+	public static int permu(String que, String ans, String q) {
+		if (que.length() == 0) {
+			System.out.println(ans);
+			if (ans.equals(q))
+				return -1;
+			return 1;
+		}
+		int n = -1;
+		for (int i = 0; i < que.length(); ++i) {
+			char ch = que.charAt(i);
+			String roq = que.substring(0, i) + que.substring(i + 1);
+			n = permu(roq, ans + ch, q);
+			if (n == -1)
+				break;
+		}
+		return n;
+	}
+
+	public static String sort(String str) {
+
+		StringBuilder sb = new StringBuilder();
+		for (int i = 0; i < str.length(); ++i)
+			sb.append(str.charAt(i));
+
+		for (int i = 0; i < sb.length() - 1; ++i) {
+			for (int j = 0; j < sb.length() - i - 1; ++j) {
+				if (sb.charAt(j) > sb.charAt(j + 1)) {
+					char ch = sb.charAt(j + 1);
+					sb.setCharAt((j + 1), sb.charAt(j));
+					sb.setCharAt(j, ch);
+				}
+			}
+		}
+
+		return sb.toString();
+
+	}
+
+	public static void main(String[] args) {
+
+		String s = "string";
+		String s1=sort(s);
+
+		permu(s1, "", s);
+	}
+
+}
diff --git a/recurssions examples/a8q2.java b/recurssions examples/a8q2.java
new file mode 100755
index 0000000..3e1b351
--- /dev/null
+++ b/recurssions examples/a8q2.java	
@@ -0,0 +1,25 @@
+package recurssion;
+
+public class a8q2 {
+
+	public static void main(String[] args) {
+	System.out.println(permu("abc", "",0));
+	}
+
+	private static int permu(String que, String ans,int count) {
+		if (que.length() == 0) {
+			System.out.println(ans);
+			++count;
+			return count;
+		}
+
+			char ch = que.charAt(0);
+
+			count=permu(que.substring(1), ans,count);
+			count=permu(que.substring(1), ans + ch,count);
+			count=permu(que.substring(1), ans+(int)(ch), count);
+ return count;
+
+	}
+
+}
diff --git a/recurssions examples/a8q3.java b/recurssions examples/a8q3.java
new file mode 100755
index 0000000..14fd436
--- /dev/null
+++ b/recurssions examples/a8q3.java	
@@ -0,0 +1,59 @@
+package recurssion;
+
+public class a8q3 {
+	
+	public static String getcode(char key) {
+		if (key == '1') {
+			return "abc";
+		}
+		if (key == '2') {
+			return "def";
+		}
+		if (key == '3') {
+			return "ghi";
+		}
+		if (key == '4') {
+			return "jkl";
+		}
+		if (key == '5') {
+			return "mno";
+		}
+		if (key == '6') {
+			return "pqrs";
+		}
+		if (key == '7') {
+			return "tuv";
+		}
+		if (key == '8') {
+			return "wx";
+		}
+		if (key == '9') {
+			return "yx";
+		}
+		if (key == '0') {
+			return ".,";
+		}
+		return "null";
+
+	}
+
+	public static void main(String[] args) {
+		print("628","");
+
+	}
+
+	private static void print(String que, String ans) {
+		if (que.length() == 0) {
+			System.out.println(ans);
+			return;
+		}
+		char ch= que.charAt(0);
+		String code=getcode(ch);
+		for(int i=0;i<code.length();++i)
+		{
+			print(que.substring(1), code.charAt(i)+ans);
+		}
+
+	}
+
+}
diff --git a/recurssions examples/a8q4.java b/recurssions examples/a8q4.java
new file mode 100755
index 0000000..fcc5559
--- /dev/null
+++ b/recurssions examples/a8q4.java	
@@ -0,0 +1,49 @@
+package recurssion;
+
+import java.util.ArrayList;
+
+public class a8q4 {
+
+	public static void main(String[] args) {
+//		permu("abc", "", 0);
+		ArrayList<String> s1 = permu1("abc");
+		System.out.println(s1);
+	}
+
+	private static ArrayList<String> permu1(String que) {
+
+		if (que.length() == 0) {
+			ArrayList<String> blank = new ArrayList<>();
+			blank.add("");
+			return blank;
+		}
+		char ch=que.charAt(0);
+		String roq=que.substring(1);
+		ArrayList<String> rr = permu1(roq);
+		ArrayList<String> mr = new ArrayList<>();
+
+		for(String s:rr )
+		{
+			for(int i=0;i<=s.length();++i){
+				  String ms=s.substring(0, i)+ch+s.substring(i);
+
+			mr.add(ms);
+			}
+		}
+	return mr;
+
+	}
+
+	private static void permu(String que, String ans, int count) {
+		if (que.length() == 0) {
+			System.out.println(ans);
+			return;
+		}
+		for (int i = 0; i < que.length(); ++i) {
+			char ch = que.charAt(i);
+			permu(que.substring(0, i) + que.substring(i + 1), ans + ch, count);
+		}
+
+	}
+
+}
diff --git a/recurssions examples/a8q6.java b/recurssions examples/a8q6.java
new file mode 100755
index 0000000..af5bb46
--- /dev/null
+++ b/recurssions examples/a8q6.java	
@@ -0,0 +1,89 @@
+package recurssion;
+
+import java.util.ArrayList;
+
+public class a8q6 {
+
+	public static void main(String[] args) {
+		int[] arr = { 1,  7, 3, 5 ,0};
+		int target = 0;
+		for (int val : arr)
+			target += val;
+		// ArrayList<String> ans = pair(arr, 0, 0, target);
+		// System.out.println(ans);
+
+		// printpair(arr, 0, 0, target, "");
+
+		 System.out.println(countpair(arr, 0, 0, target));
+
+//		count(arr, 0, 0, target);
+//		System.out.println(count);
+
+	}
+
+	public static ArrayList<String> pair(int[] arr, int pos, int sum, int target) {
+		if (sum > target / 2) {
+			ArrayList<String> blank = new ArrayList<>();
+			// blank = null;
+			return blank;
+		}
+		if (2 * sum == target) {
+			ArrayList<String> blank = new ArrayList<>();
+			blank.add("");
+			return blank;
+		}
+		ArrayList<String> rr = new ArrayList<>();
+
+		for (int i = pos; i < arr.length; ++i) {
+			rr = pair(arr, i + 1, sum + arr[i], target);
+
+			rr.add("true");
+
+		}
+		return rr;
+	}
+
+	public static void printpair(int[] arr, int pos, int sum, int target, String ans) {
+		if (sum > target / 2) {
+			return;
+		}
+		if (2 * sum == target) {
+			System.out.println("[" + ans + "]");
+		}
+
+		for (int i = pos; i < arr.length; ++i)
+			printpair(arr, i + 1, sum + arr[i], target, ans + arr[i] + " ");
+
+	}
+
+	public static int countpair(int[] arr, int pos, int sum, int target) {
+		if (sum > target / 2) {
+			return 0;
+		}
+		if (2 * sum == target) {
+			return 1;
+		}
+		int count = 0;
+		for (int i = pos; i < arr.length; ++i)
+			count += countpair(arr, i + 1, sum + arr[i], target);
+
+		return count;
+	}
+
+	static int count;
+
+	public static void count(int[] arr, int pos, int sum, int target) {
+		if (sum > target / 2) {
+			return;
+		}
+		if (2 * sum == target) {
+			++count;
+//			return;
+		}
+		for (int i = pos; i < arr.length; ++i)
+			count(arr, i + 1, sum + arr[i], target);
+
+		return;
+	}
+
+}
diff --git a/recurssions examples/a8q8.java b/recurssions examples/a8q8.java
new file mode 100755
index 0000000..d69f27e
--- /dev/null
+++ b/recurssions examples/a8q8.java	
@@ -0,0 +1,17 @@
+package recurssion;
+public class a8q8 {
+	public static void main(String[] args) {
+		printLexico(1, 1000);
+	}
+	public static void printLexico(int num, int max) {
+		System.out.println(num);
+		for (int i = 0; i <= 9; i++) {
+			if (num * 10 + i <= max) {
+				printLexico(num * 10 + i, max);
+			}
+		}
+		if (num < 9) {
+			printLexico(num + 1, max);
+		}
+	}
+}
\ No newline at end of file
diff --git a/recurssions examples/a8q9.java b/recurssions examples/a8q9.java
new file mode 100755
index 0000000..945cbe5
--- /dev/null
+++ b/recurssions examples/a8q9.java	
@@ -0,0 +1,52 @@
+package recurssion;
+
+public class a8q9 {
+
+	public static void permu(String que, String ans, String q) {
+		if (que.length() == 0) {
+			if(flag)
+			System.out.println(ans);
+			if (ans.equals(q))
+				flag=true;
+				return ;
+		}
+
+		for (int i = 0; i < que.length(); ++i) {
+			char ch = que.charAt(i);
+			String roq = que.substring(0, i) + que.substring(i + 1);
+			permu(roq, ans + ch, q);
+			
+		}
+	
+	}
+	static boolean flag=false;
+
+	public static String sort(String str) {
+
+		StringBuilder sb = new StringBuilder();
+		for (int i = 0; i < str.length(); ++i)
+			sb.append(str.charAt(i));
+
+		for (int i = 0; i < sb.length() - 1; ++i) {
+			for (int j = 0; j < sb.length() - i - 1; ++j) {
+				if (sb.charAt(j) > sb.charAt(j + 1)) {
+					char ch = sb.charAt(j + 1);
+					sb.setCharAt((j + 1), sb.charAt(j));
+					sb.setCharAt(j, ch);
+				}
+			}
+		}
+
+		return sb.toString();
+
+	}
+
+	public static void main(String[] args) {
+
+		String s = "string";
+		String s1=sort(s);
+
+		permu(s1, "", s);
+	}
+
+}
diff --git a/recurssions examples/all_indices.java b/recurssions examples/all_indices.java
new file mode 100755
index 0000000..2724d86
--- /dev/null
+++ b/recurssions examples/all_indices.java	
@@ -0,0 +1,28 @@
+package recurssion;
+
+public class all_indices {
+
+	public static void main(String[] args) {
+		int[] arr = { 66, 33, 55, 33, 11, 22, 44 };
+		int[] ind = indices(arr,33, 0, 0);
+		for(int val:ind)
+			System.out.print(val+"\t");
+	}
+
+	private static int[] indices(int[] arr, int data,int vidx, int count) {
+		if(vidx==arr.length)
+		{
+			int[] ind=new int[count];
+			return ind;
+		}
+		
+		if(arr[vidx]==data)
+			++count;
+		int[] ind=	indices(arr, data,vidx+1, count);
+		if(arr[vidx]==data)
+	ind[count-1]=vidx;
+	
+	return ind;
+	}
+
+}
diff --git a/recurssions examples/arrayOperations.java b/recurssions examples/arrayOperations.java
new file mode 100755
index 0000000..83e306f
--- /dev/null
+++ b/recurssions examples/arrayOperations.java	
@@ -0,0 +1,61 @@
+package recurssion;
+
+public class arrayOperations {
+
+	public static void displayrev(int[] arr, int vidx) {
+		if (vidx == arr.length)
+			return;
+		displayrev(arr, vidx + 1);
+		System.out.println(arr[vidx]);
+	}
+
+	public static int max(int[] arr, int vidx) {
+		if (vidx == arr.length) {
+			return 0;
+		}
+		int max = arr[vidx];
+
+		int m = max(arr, vidx + 1);
+		if (m < max)
+			return max;
+		else
+			return m;
+
+	}
+
+	public static int findfirst(int[] arr, int vidx, int data) {
+		if (vidx == arr.length)
+			return -1;
+		if (arr[vidx] == data)
+			return vidx;
+		int pos = findfirst(arr, vidx + 1, data);
+		return pos;
+	}
+
+	public static int findlast(int[] arr, int vidx, int data) {
+		if (vidx < 0)
+			return -1;
+		if (arr[vidx] == data)
+			return vidx;
+		int pos = findlast(arr, vidx - 1, data);
+		return pos;
+	}
+
+	public static boolean find(int[] arr, int vidx, int data) {
+		if (vidx == arr.length)
+			return false;
+		if (arr[vidx] == data)
+			return true;
+		boolean b = find(arr, vidx + 1, data);
+		return b;
+	}
+
+	public static void main(String[] args) {
+		int[] arr = { 55, 44, 11, 22, 33, 99, 44 };
+		 System.out.println(max(arr, 0));
+		 System.out.println(findfirst(arr,0,44));
+		 System.out.println(findlast(arr,arr.length-1,44));
+		System.out.println(find(arr, 0, 454));
+	}
+
+}
diff --git a/recurssions examples/arrlist.java b/recurssions examples/arrlist.java
new file mode 100755
index 0000000..ed750bf
--- /dev/null
+++ b/recurssions examples/arrlist.java	
@@ -0,0 +1,33 @@
+package recurssion;
+
+import java.util.ArrayList;
+
+public class arrlist {
+
+	public static void main(String[] args) {
+		int[] arr1 = { 1, 1, 1, 2, 2, 3, 5 }, arr2 = { 1, 1, 2, 2, 4, 5 };
+ ArrayList<Integer> arr3=getIntersection(arr1,arr2);
+ System.out.println(arr3);
+	}
+
+	public static ArrayList<Integer> getIntersection(int[] arr1, int[] arr2) {
+		ArrayList<Integer> rv = new ArrayList<>();
+		int i=0,j=0;
+		while((i!=arr1.length)&&(j!=arr2.length))
+		{
+			if(arr1[i]==arr2[j])
+			{
+				rv.add(arr1[i]);
+				++i;
+				++j;
+			}
+			else if(arr1[i]>arr2[j]){
+				++j;
+			}
+			else {
+				++i;
+			}
+		}
+		return rv;
+	}
+}
diff --git a/recurssions examples/boardpath.java b/recurssions examples/boardpath.java
new file mode 100755
index 0000000..cac8b69
--- /dev/null
+++ b/recurssions examples/boardpath.java	
@@ -0,0 +1,31 @@
+package recurssion;
+
+public class boardpath {
+
+	public static void path(int curr,int end ,String ans)
+	{
+		if(curr==end)
+		{
+			System.out.println(ans);
+			return;
+		}
+		
+		if(curr>end)
+		{
+			return;
+		}
+		
+		for(int i=1;i<=6;++i)
+		{
+			
+			path(curr+i, end, ans+i);
+		}
+	}
+	
+	
+	public static void main(String[] args) {
+
+		path(0, 10, "");
+	}
+
+}
diff --git a/recurssions examples/combi1.java b/recurssions examples/combi1.java
new file mode 100755
index 0000000..2dd57a3
--- /dev/null
+++ b/recurssions examples/combi1.java	
@@ -0,0 +1,37 @@
+package recurssion;
+
+import java.util.ArrayList;
+
+public class combi1 {
+
+	public static void main(String[] args) {
+String s="abc";
+ArrayList<String> s1=permu(s);
+System.out.println(s1);
+	}
+
+	
+	public static ArrayList<String> permu(String s)
+	{
+//		String ch1="\n";
+		if(s.length()==0)
+		{
+			 ArrayList<String> blank=new ArrayList<>();
+			 blank.add(s);
+			 return blank;
+		}
+		char ch=s.charAt(0);
+		String smaller=s.substring(1);
+		ArrayList<String> rr=permu(smaller);								//rec result
+		ArrayList<String> mr=new ArrayList<>();
+		for(String rs:rr){
+			mr.add(rs);
+//			mr.add(ch1);
+			mr.add(ch+rs);
+//			mr.add(ch1);
+			mr.add(((int)(ch)+rs));
+//			mr.add(ch1);
+		}
+		return mr;
+	}
+}
diff --git a/recurssions examples/counthi.java b/recurssions examples/counthi.java
new file mode 100755
index 0000000..7707716
--- /dev/null
+++ b/recurssions examples/counthi.java	
@@ -0,0 +1,27 @@
+package recurssion;
+
+import java.util.Scanner;
+
+public class counthi {
+	public static void find(String que,String s,int count )
+	{
+		if(que.length()==1)
+		{
+			System.out.println(count);
+			return;
+		}
+		if(s.equals(que.substring(0,2)))
+		{
+			++count;
+		}
+		String roq=que.substring(1);
+		find(roq,s,count);
+	}
+
+	public static void main(String[] args) {
+		Scanner scan = new Scanner(System.in);
+		String s = scan.next();
+		find(s, "hi", 0);
+	}
+
+}
diff --git a/recurssions examples/factorial.java b/recurssions examples/factorial.java
new file mode 100755
index 0000000..cb95168
--- /dev/null
+++ b/recurssions examples/factorial.java	
@@ -0,0 +1,15 @@
+package recurssion;
+
+public class factorial {
+
+	public static int fact(int n){
+		
+		if(n==0)
+			return 1;
+		return n*fact(n-1);
+	}
+	public static void main(String[] args) {
+System.out.println(fact(5));
+	}
+
+}
diff --git a/recurssions examples/fibonacci.java b/recurssions examples/fibonacci.java
new file mode 100755
index 0000000..f691150
--- /dev/null
+++ b/recurssions examples/fibonacci.java	
@@ -0,0 +1,15 @@
+package recurssion;
+
+public class fibonacci {
+	
+	public static void fibo(int n)
+	{
+		fibo(n-1);
+		
+	}
+
+	public static void main(String[] args) {
+
+	}
+
+}
diff --git a/recurssions examples/hanoi.java b/recurssions examples/hanoi.java
new file mode 100755
index 0000000..699858f
--- /dev/null
+++ b/recurssions examples/hanoi.java	
@@ -0,0 +1,25 @@
+package recurssion;
+import java.util.Scanner;
+public class hanoi {
+
+	public static void main(String[] args) {
+	    Scanner scan= new Scanner(System.in);
+	    int n = scan.nextInt();
+		han(n, "T1","T3","T2");
+		System.out.println(count);
+	}
+public static int count=0;
+	private static void han(int n, String from, String aux, String to) {
+		if (n == 0) {
+			return;
+		}
+
+		han(n - 1, from, to, aux);
+		System.out.println("Move " + (n) + "th disc from " + from + " to " + to);
+		++count;
+		han(n - 1, aux, from, to);
+
+	}
+
+}
+
diff --git a/recurssions examples/indices.java b/recurssions examples/indices.java
new file mode 100755
index 0000000..b611cc1
--- /dev/null
+++ b/recurssions examples/indices.java	
@@ -0,0 +1,34 @@
+package recurssion;
+
+public class indices {
+
+	public static int[] indices(int[] arr, int vidx, int data, int count) {
+
+		if (vidx == arr.length) {
+			int[] index = new int[arr.length];
+			return index;
+		}
+		if (arr[vidx] == data)
+			++count;
+
+		int[] index = indices(arr, vidx + 1, data, count);
+		if (arr[vidx] == data) {
+			index[count] = vidx;
+			++count;
+		}
+		return index;
+	}
+
+	public static void main(String[] args) {
+		int[] arr = { 1, 2, 5, 6, 2, 5, 2, 2, };
+		int[] arr1 = new int[arr.length];
+		arr1 = indices(arr, 0, 2, -1);
+		if (arr[0] == 0)
+			System.out.println(arr[0]);
+		for (int val : arr1) {
+			if (val != 0)
+				System.out.println(val);
+		}
+	}
+
+}
diff --git a/recurssions examples/keypad.java b/recurssions examples/keypad.java
new file mode 100755
index 0000000..684838a
--- /dev/null
+++ b/recurssions examples/keypad.java	
@@ -0,0 +1,71 @@
+package recurssion;
+
+import java.util.ArrayList;
+
+public class keypad {
+
+	public static void main(String[] args) {
+		String s = "68";
+		ArrayList<String> s1 = getkpc(s);
+		System.out.println(s1);
+	}
+
+	public static String getcode(char key) {
+		if (key == '1') {
+			return "abc";
+		}
+		if (key == '2') {
+			return "def";
+		}
+		if (key == '3') {
+			return "ghi";
+		}
+		if (key == '4') {
+			return "jkl";
+		}
+		if (key == '5') {
+			return "mno";
+		}
+		if (key == '6') {
+			return "pqrs";
+		}
+		if (key == '7') {
+			return "tuv";
+		}
+		if (key == '8') {
+			return "wx";
+		}
+		if (key == '9') {
+			return "yx";
+		}
+		if (key == '0') {
+			return ".,";
+		}
+		return "null";
+
+	}
+
+	public static ArrayList<String> getkpc(String s) {
+
+		if (s.length() == 0) {
+			ArrayList<String> blank = new ArrayList<>();
+			blank.add(s);
+			return blank;
+		}
+
+		String opt = getcode(s.charAt(0));
+		String smaller = s.substring(1);
+		ArrayList<String> rr = getkpc(smaller);
+
+		ArrayList<String> mr = new ArrayList<>();
+		for (String rs : rr) {
+			for (int k = 0; k < opt.length(); ++k) {
+				char ch = opt.charAt(k);
+				String ms = ch + rs;
+				mr.add(ms);
+
+			}
+		}
+		return mr;
+	}
+}
diff --git a/recurssions examples/keypad1.java b/recurssions examples/keypad1.java
new file mode 100755
index 0000000..8814330
--- /dev/null
+++ b/recurssions examples/keypad1.java	
@@ -0,0 +1,61 @@
+package recurssion;
+
+public class keypad1 {
+	public static String getcode(char key) {
+		if (key == '1') {
+			return "abc";
+		}
+		if (key == '2') {
+			return "def";
+		}
+		if (key == '3') {
+			return "ghi";
+		}
+		if (key == '4') {
+			return "jkl";
+		}
+		if (key == '5') {
+			return "mno";
+		}
+		if (key == '6') {
+			return "pqrs";
+		}
+		if (key == '7') {
+			return "tuv";
+		}
+		if (key == '8') {
+			return "wx";
+		}
+		if (key == '9') {
+			return "yx";
+		}
+		if (key == '0') {
+			return ".,";
+		}
+		return "null";
+
+	}
+
+
+	public static void pkp(String que,String ans)
+	{
+		if(que.length()==0)
+		{
+			System.out.println(ans);
+			return;
+		}
+		char num=que.charAt(0);
+		String code=getcode(num);
+		String roq=que.substring(1);
+		for(int i=0;i<code.length();++i)
+		{
+			pkp(roq,ans+code.charAt(i));
+		}
+	}
+	public static void main(String[] args) {
+		
+		pkp("12","");
+
+	}
+
+}
diff --git a/recurssions examples/ladder.java b/recurssions examples/ladder.java
new file mode 100755
index 0000000..12e9ca6
--- /dev/null
+++ b/recurssions examples/ladder.java	
@@ -0,0 +1,32 @@
+package recurssion;
+
+import java.util.ArrayList;
+
+public class ladder {
+
+	public static void main(String[] args) {
+
+		System.out.println(ladder1(0,10));
+		System.out.println(ladder1(0,10).size());
+
+	}
+
+	public static ArrayList<String> ladder1(int curr, int end) {
+		if (curr == end) {
+			ArrayList<String> blank = new ArrayList<>();
+			blank.add("");
+			return blank;
+		}
+		ArrayList<String> mrdice = new ArrayList<>();
+		ArrayList<String> mr = new ArrayList<>();
+		for (int dice = 1; dice <= 6; ++dice) {
+			if(dice+curr<=end){
+			mrdice = ladder1(dice + curr, end);
+			for (String ms : mrdice) {
+				mr.add(dice+ms);
+			}
+		}
+		}
+		return mr;
+	}
+}
diff --git a/recurssions examples/lexico.java b/recurssions examples/lexico.java
new file mode 100755
index 0000000..6fa6bff
--- /dev/null
+++ b/recurssions examples/lexico.java	
@@ -0,0 +1,17 @@
+package recurssion;
+public class lexico {
+	public static void main(String[] args) {
+		printLexico(1, 1000);
+	}
+	public static void printLexico(int num, int max) {
+		System.out.println(num);
+		for (int i = 0; i <= 9; i++) {
+			if (num * 10 + i <= max) {
+				printLexico(num * 10 + i, max);
+			}
+		}
+		if (num < 9) {
+			printLexico(num + 1, max);
+		}
+	}
+}
\ No newline at end of file
diff --git a/recurssions examples/maze.java b/recurssions examples/maze.java
new file mode 100755
index 0000000..13a751e
--- /dev/null
+++ b/recurssions examples/maze.java	
@@ -0,0 +1,43 @@
+package recurssion;
+
+import java.util.ArrayList;
+
+public class maze {
+
+	public static ArrayList<String> maz(int cr, int cc, int er, int ec) {
+		if ((cr == er) && (cc == ec)) {
+			ArrayList<String> blank = new ArrayList<>();
+			blank.add("");
+			return blank;
+		}
+
+		ArrayList<String> mr = new ArrayList<>();
+		ArrayList<String> rr1 , rr2;
+		if (cr < er) {
+			rr1 = maz(cr + 1, cc, er, ec);
+			for (String rs : rr1) {
+				String s = 'v' + rs;
+				mr.add(s);
+			}
+		}
+
+		if (cc < ec) {
+			rr2 = maz(cr, cc + 1, er, ec);
+			for (String rs : rr2) {
+				String s = 'h' + rs;
+				mr.add(s);
+			}
+		}
+
+		
+		
+		    return mr;
+
+	}
+
+	public static void main(String[] args) {
+		ArrayList<String> mr=maz(0,0,2,2);
+		System.out.println(mr);
+	}
+
+}
diff --git a/recurssions examples/maze1.java b/recurssions examples/maze1.java
new file mode 100755
index 0000000..c6e40ea
--- /dev/null
+++ b/recurssions examples/maze1.java	
@@ -0,0 +1,23 @@
+package recurssion;
+
+public class maze1 {
+
+	public static void maze(int cr, int cc, int er, int ec, String ans) {
+		if (cr == er && cc == ec) {
+			System.out.println(ans);
+			return;
+		}
+		if (cr > er || cc > ec) {
+			return;
+		}
+		maze(cr + 1, cc, er, ec, ans + "v");
+		maze(cr , cc+1, er, ec, ans + "h");
+		maze(cr + 1, cc+1, er, ec, ans + "d");
+	}
+
+	public static void main(String[] args) {
+
+	maze(0, 0, 2, 2, "");
+	}
+
+}
diff --git a/recurssions examples/mazeadv.java b/recurssions examples/mazeadv.java
new file mode 100755
index 0000000..39a7330
--- /dev/null
+++ b/recurssions examples/mazeadv.java	
@@ -0,0 +1,59 @@
+package recurssion;
+
+import java.util.ArrayList;
+
+public class mazeadv {
+
+	public static ArrayList<String> maz(int cr, int cc, int er, int ec) {
+		if ((cr == er) && (cc == ec)) {
+			ArrayList<String> blank = new ArrayList<>();
+			blank.add("");
+			return blank;
+		}
+
+		ArrayList<String> mr = new ArrayList<>();
+		ArrayList<String> rr1 , rr2,rrd1,rrd2;
+		if (cr < er) {
+			rr1 = maz(cr + 1, cc, er, ec);
+			for (String rs : rr1) {
+				String s = 'v' + rs;
+				mr.add(s);
+			}
+		}
+
+		if (cc < ec) {
+			rr2 = maz(cr, cc + 1, er, ec);
+			for (String rs : rr2) {
+				String s = 'h' + rs;
+				mr.add(s);
+			}
+		}
+		
+		if(cc==cr&&cc<ec&&cr<er){
+			rrd1 = maz(cr+1, cc + 1, er, ec);
+			for (String rs : rrd1) {
+				String s = "d1" + rs;
+				mr.add(s);
+			}
+		}
+
+		if(cc+cr==ec&&cc>0&&cr<er){
+			rrd2 = maz(cr+1, cc - 1, er, ec);
+			for (String rs : rrd2) {
+				String s = "d2" + rs;
+				mr.add(s);
+			}
+		}
+		
+		
+		    return mr;
+
+	}
+
+	public static void main(String[] args) {
+		ArrayList<String> mr=maz(0,0,2,2);
+		System.out.println(mr);
+		System.out.println(mr.size());
+	}
+
+}
diff --git a/recurssions examples/mazeadv1.java b/recurssions examples/mazeadv1.java
new file mode 100755
index 0000000..84fe89a
--- /dev/null
+++ b/recurssions examples/mazeadv1.java	
@@ -0,0 +1,51 @@
+package recurssion;
+
+import java.util.ArrayList;
+
+public class mazeadv1 {
+
+	public static ArrayList<String> maz(int cr, int cc, int er, int ec) {
+		if ((cr == er) && (cc == ec)) {
+			ArrayList<String> blank = new ArrayList<>();
+			blank.add("");
+			return blank;
+		}
+		if ((cr > er) || (cc > ec)) {
+			ArrayList<String> blank = new ArrayList<>();
+			return blank;
+		}
+
+		ArrayList<String> mr = new ArrayList<>();
+		ArrayList<String> rr1, rr2, rrd1;
+
+		rr1 = maz(cr + 1, cc, er, ec);
+		for (String rs : rr1) {
+			String s = 'v' + rs;
+			mr.add(s);
+		}
+
+		rr2 = maz(cr, cc + 1, er, ec);
+		for (String rs : rr2) {
+			String s = 'h' + rs;
+			mr.add(s);
+		}
+
+		if (cc == cr || cc + cr == ec) {
+			rrd1 = maz(cr + 1, cc + 1, er, ec);
+			for (String rs : rrd1) {
+				String s = "d" + rs;
+				mr.add(s);
+			}
+		}
+
+		return mr;
+
+	}
+
+	public static void main(String[] args) {
+		ArrayList<String> mr = maz(0, 0, 2, 2);
+		System.out.println(mr);
+		System.out.println(mr.size());
+	}
+
+}
diff --git a/recurssions examples/nQueen.java b/recurssions examples/nQueen.java
new file mode 100755
index 0000000..3cabe6d
--- /dev/null
+++ b/recurssions examples/nQueen.java	
@@ -0,0 +1,55 @@
+package recurssion;
+
+public class nQueen {
+	public static void pnq(boolean[][] board, int row, String ans) {
+		if (row == board.length) {
+			System.out.println(ans);
+			return;
+		}
+
+		for (int col = 0; col < board[0].length; ++col) {
+			if (safe(board, row, col) == true) {
+				board[row][col] = true;
+				pnq(board, row + 1, ans + "[" + row + col + "]");
+				board[row][col] = false;
+			}
+		}
+	}
+
+	private static boolean safe(boolean[][] board, int row, int col) {
+
+		int i = row, j = col;
+		while (i > 0 && j > 0) {
+			i--;
+			j--;
+			if (board[i][j] == true) {
+				return false;
+			}
+		}
+		i = row;
+		j = col;
+		while (i > 0 && j < board[0].length - 1) {
+			i--;
+			j++;
+			if (board[i][j] == true) {
+				return false;
+			}
+		}
+		i = row;
+		while (i > 0) {
+			i--;
+
+			if (board[i][col] == true) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public static void main(String[] args) {
+		boolean[][] board = new boolean[5][5];
+		pnq(board, 0, "");
+
+	}
+
+}
diff --git a/recurssions examples/nknights.java b/recurssions examples/nknights.java
new file mode 100755
index 0000000..3ba6127
--- /dev/null
+++ b/recurssions examples/nknights.java	
@@ -0,0 +1,47 @@
+package recurssion;
+
+public class nknights {
+
+	public static void main(String[] args) {
+		boolean[][] board = new boolean[3][3];
+		Nknights(1, board, " ", 0);
+	}
+
+	private static void Nknights(int cellno, boolean[][] board, String psf, int kpsf) {
+		if (kpsf == board.length) {
+			++count;
+			System.out.println(count + psf);
+		}
+		for (int i = cellno; i <= board.length * board.length; ++i) {
+			int cr = (i - 1) / board.length;
+			int cc = (i - 1) % board.length;
+			if (isitsafetoplace(cr, cc, board)) {
+				board[cr][cc] = true;
+				// call
+				Nknights(i + 1, board, psf + "[" + cr + " " + cc + "] ", kpsf + 1);
+				board[cr][cc] = false;
+
+			}
+		}
+	}
+
+	public static int count = 0;
+
+	private static boolean isitsafetoplace(int cr, int cc, boolean[][] board) {
+
+		if (cc + 1 < board.length && cr - 2 >= 0 && board[cr - 2][cc + 1] == true)
+			return false;
+
+		if (cc - 1 >= 0 && cr - 2 >= 0 && board[cr - 2][cc - 1] == true)
+			return false;
+
+		if (cc + 2 < board.length && cr - 1 >= 0 && board[cr - 1][cc + 2] == true)
+			return false;
+
+		if (cc - 2 >= 0 && cr - 1 >= 0 && board[cr - 1][cc - 2] == true)
+			return false;
+
+		return true;
+	}
+
+}
diff --git a/recurssions examples/pattern.java b/recurssions examples/pattern.java
new file mode 100755
index 0000000..74d553f
--- /dev/null
+++ b/recurssions examples/pattern.java	
@@ -0,0 +1,25 @@
+package recurssion;
+
+import java.util.Scanner;
+
+public class pattern {
+
+	public static void pattern(int row) {
+
+		if (row == 0) {
+			return;
+		}
+		for (int i = 0; i < row; ++i)
+			System.out.print("*\t");
+		System.out.println();
+		pattern(row - 1);
+	
+	}
+
+	public static void main(String[] args) {
+		Scanner scan = new Scanner(System.in);
+		pattern(scan.nextInt());
+
+	}
+
+}
diff --git a/recurssions examples/permu1.java b/recurssions examples/permu1.java
new file mode 100755
index 0000000..2fa0d1b
--- /dev/null
+++ b/recurssions examples/permu1.java	
@@ -0,0 +1,36 @@
+package recurssion;
+
+import java.util.ArrayList;
+
+public class permu1 {
+
+	public static void main(String[] args) {
+String s="abc";
+ArrayList<String> s1=permu(s);
+System.out.println(s1);
+	}
+
+	
+	public static ArrayList<String> permu(String s)
+	{
+
+		if(s.length()==1)
+		{
+			 ArrayList<String> blank=new ArrayList<>();
+			 blank.add(s);
+			 return blank;
+		}
+		char ch=s.charAt(0);
+		String smaller=s.substring(1);
+		ArrayList<String> rr=permu(smaller);
+		ArrayList<String> mr=new ArrayList<>();
+		for(String rs:rr){
+		  for(int i=0;i<=rs.length();++i)
+		  {
+			  String ms=rs.substring(0, i)+ch+rs.substring(i);
+			  mr.add(ms);
+		  }
+		}
+		return mr;
+	}
+}
diff --git a/recurssions examples/permuadv.java b/recurssions examples/permuadv.java
new file mode 100755
index 0000000..0015b97
--- /dev/null
+++ b/recurssions examples/permuadv.java	
@@ -0,0 +1,22 @@
+package recurssion;
+
+public class permuadv {
+	public static void printpermu(String qst, String ans) {
+		if (qst.length() == 0) {
+			System.out.println(ans);
+			return;
+		}
+		for (int i = 0; i < qst.length(); ++i) {
+			char ch = qst.charAt(i);
+System.out.println("hi "+ch);
+			String roq = qst.substring(0, i) + qst.substring(i + 1);
+			printpermu(roq, ans + ch);
+			System.out.println("bye "+ch);
+		}
+	}
+
+	public static void main(String[] args) {
+		printpermu("abc", "");
+	}
+
+}
diff --git a/recurssions examples/power.java b/recurssions examples/power.java
new file mode 100755
index 0000000..08bb55b
--- /dev/null
+++ b/recurssions examples/power.java	
@@ -0,0 +1,17 @@
+package recurssion;
+
+public class power {
+
+	public static int power(int x,int y)
+	{
+		if(y==0)
+			return 1;
+		else
+		 return power(x,y-1)*x;
+	}
+	public static void main(String[] args) {
+		System.out.println(power(2,3));
+
+	}
+
+}
diff --git a/recurssions examples/powerfast.java b/recurssions examples/powerfast.java
new file mode 100755
index 0000000..e53bd9c
--- /dev/null
+++ b/recurssions examples/powerfast.java	
@@ -0,0 +1,21 @@
+package recurssion;
+
+public class powerfast {
+	public static int power(int x, int y) {
+		if (y == 0)
+			return 1;
+		int k = power(x, y / 2);
+		if (y % 2 == 0) {
+			return k * k;
+		} else {
+
+			return k * k * x;
+		}
+	}
+
+	public static void main(String[] args) {
+
+		System.out.println(power(3, 5));
+	}
+
+}
diff --git a/recurssions examples/powersum.java b/recurssions examples/powersum.java
new file mode 100755
index 0000000..5e29ab1
--- /dev/null
+++ b/recurssions examples/powersum.java	
@@ -0,0 +1,26 @@
+package recurssion;
+
+public class powersum {
+	public static int calc(int que, int pow, int count,String ans,int i) {
+		if (que  == 0) {
+			++count;
+//			System.out.println(ans);
+			return count;
+		}
+if(Math.pow(i, pow)>que){
+	return count;
+}
+		for (int j = i; (int) Math.pow(j, pow) <= que; ++j) {
+			ans+=i+" ";
+			count = calc(que-(int) Math.pow(j, pow), pow, count,ans,i+1);
+		}
+		return count;
+	}
+
+	public static void main(String[] args) {
+
+		System.out.println(calc(100, 2, 0,"",1));
+
+	}
+
+}
diff --git a/recurssions examples/q1.java b/recurssions examples/q1.java
new file mode 100755
index 0000000..aab3b3b
--- /dev/null
+++ b/recurssions examples/q1.java	
@@ -0,0 +1,18 @@
+package recurssion;
+
+public class q1 {
+public static void func(int n)
+{
+	if(n==0)
+		return ;
+	if(n%2!=0)
+		System.out.println("hi "+n);
+	func(n-1);
+	if(n%2==0)
+	System.out.println("bye "+n);
+}
+	public static void main(String[] args) {
+func(7);
+	}
+
+}
diff --git a/recurssions examples/queen.java b/recurssions examples/queen.java
new file mode 100755
index 0000000..e2b799d
--- /dev/null
+++ b/recurssions examples/queen.java	
@@ -0,0 +1,55 @@
+package recurssion;
+
+import java.util.ArrayList;
+
+public class queen {
+
+	public static ArrayList<String> maz(int cr, int cc, int er, int ec) {
+		if ((cr == er) && (cc == ec)) {
+			ArrayList<String> blank = new ArrayList<>();
+			blank.add("");
+			return blank;
+		}
+		if ((cr > er) || (cc > ec)) {
+			ArrayList<String> blank = new ArrayList<>();
+			return blank;
+		}
+
+		ArrayList<String> mr = new ArrayList<>();
+		ArrayList<String> rr1, rr2, rrd1;
+
+		for (int i = 1; i <=(er); ++i) {
+			rr1 = maz(cr + i, cc, er, ec);
+			for (String rs : rr1) {
+				String s = "v" + i + rs;
+				mr.add(s);
+			}
+		}
+
+		for (int j = 1; j <=ec; ++j) {
+			rr2 = maz(cr, cc + j, er, ec);
+			for (String rs : rr2) {
+				String s = "h" + j + rs;
+				mr.add(s);
+			}
+
+		}
+		for (int i = 1; (i<=er&&i<=ec); ++i) {
+			rrd1 = maz(cr + i, cc + i, er, ec);
+			for (String rs : rrd1) {
+				String s = "d" + i + rs;
+				mr.add(s);
+			}
+		}
+
+		return mr;
+
+	}
+
+	public static void main(String[] args) {
+		System.out.println(maz(0, 0, 2, 2).size());
+		System.out.println(maz(0, 0, 2, 2));
+
+	}
+
+}
diff --git a/recurssions examples/snakeladder.java b/recurssions examples/snakeladder.java
new file mode 100755
index 0000000..6f5cc89
--- /dev/null
+++ b/recurssions examples/snakeladder.java	
@@ -0,0 +1,78 @@
+package recurssion;
+
+import java.util.Scanner;
+
+public class snakeladder {
+	public static boolean prime(int n) {
+		for (int i = 2; i * i <= n; ++i) {
+			if (n % i == 0) {
+				return false;
+			}
+		}
+		return true;
+
+	}
+
+	public static void main(String[] args) {
+
+		Scanner scan = new Scanner(System.in);
+//		int n = scan.nextInt();
+		int n=20;
+		int[] arr = new int[n + 1];
+		int count = 2, i = 0;
+		while (count <= n) {
+			if (prime(count) == true) {
+				arr[i] = count;
+				++i;
+			}
+			++count;
+		}
+		scan.close();
+		int counter = 0;
+		for (int val : arr) {
+			if (val != 0) {
+//				System.out.print(val + "\t");
+				++counter;
+			}
+		}
+//		System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
+
+		int[] list = new int[n + 1];
+		for (i = 0; i < counter / 2; i++) {
+			if (i % 2 == 0)
+				list[arr[i]] = arr[counter - i - 1];
+			else {
+				list[arr[counter - i - 1]] = arr[i];
+			}
+		}
+
+		
+		int[] arr1={1,1,1,1,2,4};
+	System.out.println(	bm(0, 10, list, arr1, 0));
+	}
+
+	public static boolean bm(int curr, int end, int[] snlarray, int[] movesarray, int move) {
+		if (curr == end) {
+//			System.out.println("true");
+			return true;
+
+		}
+		boolean c=false;
+		if(move>movesarray.length)
+		{
+			return false;
+		}
+
+		if (snlarray[curr] != 0) {
+			c=bm(snlarray[curr], end, snlarray, movesarray, move);
+		}
+		
+			if(curr+movesarray[move]<=end)
+			
+				c=bm(curr+movesarray[move], end, snlarray, movesarray, move+1);
+			
+		
+		return c;
+	}
+
+}
diff --git a/recurssions examples/subsetadv.java b/recurssions examples/subsetadv.java
new file mode 100755
index 0000000..ed6d431
--- /dev/null
+++ b/recurssions examples/subsetadv.java	
@@ -0,0 +1,19 @@
+package recurssion;
+
+public class subsetadv {
+
+public static void printss(String qst,String ans){
+	if(qst.length()==0){
+		System.out.println(ans);
+		return;
+	}
+char ch=qst.charAt(0);
+String roq=qst.substring(1);
+printss(roq,ans+"");
+printss(roq,ans+ch);
+}
+	public static void main(String[] args) {
+printss("abc","");
+	}
+
+}
diff --git a/recurssions examples/subsetasciadv.java b/recurssions examples/subsetasciadv.java
new file mode 100755
index 0000000..267c330
--- /dev/null
+++ b/recurssions examples/subsetasciadv.java	
@@ -0,0 +1,20 @@
+package recurssion;
+
+public class subsetasciadv {
+
+public static void printss(String qst,String ans){
+	if(qst.length()==0){
+		System.out.println(ans);
+		return;
+	}
+char ch=qst.charAt(0);
+String roq=qst.substring(1);
+printss(roq,ans+"");
+printss(roq,ans+ch);
+printss(roq,(ans+(int)(ch)));
+}
+	public static void main(String[] args) {
+printss("abc","");
+	}
+
+}