diff --git a/challenges/April22.java b/challenges/April22.java
new file mode 100644
index 0000000..e53ce29
--- /dev/null
+++ b/challenges/April22.java
@@ -0,0 +1,46 @@
+package hanson;
+/*Good morning! Here's your coding interview problem for today.
+
+This problem was recently asked by Google.
+
+Given a list of numbers and a number k, return whether any two numbers from the list add up to k.
+
+For example, given [10, 15, 3, 7] and k of 17, return true since 10 + 7 is 17.
+
+Bonus: Can you do this in one pass?*/
+import java.io.*; 
+import java.util.HashSet; 
+
+public class April22 
+{
+	
+	  
+	
+	    static void printpairs(int arr[],int sum) 
+	    {        
+	        HashSet<Integer> s = new HashSet<Integer>(); 
+	        for (int i=0; i<arr.length; ++i) 
+	        { 
+	            int temp = sum-arr[i]; 
+	  
+	            // checking for condition 
+	            if (temp>=0 && s.contains(temp)) 
+	            { 
+	                System.out.println("Pair with given sum " + 
+	                                    sum + " is (" + arr[i] + 
+	                                    ", "+temp+")"); 
+	            } 
+	            s.add(arr[i]); 
+	        } 
+	    } 
+	  
+	    // Main to test the above function 
+	    public static void main (String[] args) 
+	    { 
+	        int A[] = {10,15,3,7}; 
+	        int n = 17; 
+	        printpairs(A,  n); 
+	    } 
+	
+
+}
diff --git a/challenges/ArrayProdExclude_Itself.java b/challenges/ArrayProdExclude_Itself.java
new file mode 100644
index 0000000..9dba152
--- /dev/null
+++ b/challenges/ArrayProdExclude_Itself.java
@@ -0,0 +1,48 @@
+package hanson;
+/* #02
+  This problem was asked by Uber.
+
+Given an array of integers, return a new array such that each element at index i of the new array is the product of all the numbers in the original array except the one at i.
+
+For example, if our input was [1, 2, 3, 4, 5], the expected output would be [120, 60, 40, 30, 24]. If our input was [3, 2, 1], the expected output would be [2, 3, 6].
+
+Follow-up: what if you can't use division? */
+
+//import java.io.*;
+/*using division tech , we can solve this in O(n) time.
+we cannot use division technique.. */
+
+public class ArrayProdExclude_Itself
+{
+	static int[] res_arr=new int[100];
+	
+	
+	static void calc(int arr[],int n)
+	{
+		int prod=1;
+		for (int i=0;i<n;i++)
+		{	
+			prod=1;
+			for(int j=0;j<n;j++)
+			{
+				if(!(i==j))
+				{
+					prod*=arr[j];
+				}
+				
+			}
+			res_arr[i]=prod;
+		}
+    }
+	
+	public static void main(String arg[])
+	{
+		int[] arry= {2,3,4};
+		calc(arry,3);
+		for(int i=0;i<arry.length;i++)
+		{
+			System.out.print(res_arr[i]+",");
+		}
+	}
+		
+}
diff --git a/challenges/DCP27braces.java b/challenges/DCP27braces.java
new file mode 100644
index 0000000..602fea5
--- /dev/null
+++ b/challenges/DCP27braces.java
@@ -0,0 +1,43 @@
+package handson;
+
+public class DCP27braces 
+{
+	char[] stac=new char[10];
+	int top=-1;
+	void push(char ch)
+	{
+		stac[++top]=ch;
+	}
+	char pop()
+	{
+		return stac[top--];
+	}	
+	public static void main(String ag[])
+	{	char res='a';
+		int flag=1;
+		DCP27braces ob=new DCP27braces();
+		String s="[{[]}]{}";
+		for(int i=0;i<s.length();i++)
+		{
+			if(s.charAt(i)=='{' || s.charAt(i)=='(' || s.charAt(i)=='[')
+				ob.push(s.charAt(i));
+			
+			else if(s.charAt(i)=='}' || s.charAt(i)==')' || s.charAt(i)==']')
+			{
+				res=ob.pop();
+			
+			
+				if ((s.charAt(i)=='}' && res != '{')||( s.charAt(i)==']' && res !='[')||( s.charAt(i)==')'&& res !='('))
+				{
+					flag=0;
+				}
+			}
+			
+		}
+		if( flag ==0)
+			System.out.println("no");
+		else
+		    System.out.print("es");
+	}
+
+}
diff --git a/challenges/EvaluationTree_day50.java b/challenges/EvaluationTree_day50.java
new file mode 100644
index 0000000..a28992c
--- /dev/null
+++ b/challenges/EvaluationTree_day50.java
@@ -0,0 +1,89 @@
+package handson;
+
+
+// Class to represent the nodes of syntax tree 
+
+class nod
+{   	
+	nod left;
+	nod right;
+	int data;
+	nod(char value)
+	{
+        left = null;
+        data = value;
+        right = null;
+	}
+}
+public class EvaluationTree_day50
+{
+	
+
+// This function receives a node of the syntax tree 
+// and recursively evaluate it 
+static nod root;
+public static int evaluateExpressionTree(nod root)
+{
+
+    // empty tree 
+    if (root == null) 
+        return 0;
+  
+    //leaf node 
+    if( (root.left == null) && (root.right == null) )
+    {
+    	int val=Character.getNumericValue(root.data);
+    	return val;
+    }
+  
+    //evaluate left tree 
+    int left_sum = evaluateExpressionTree(root.left) ;
+  
+    // evaluate right tree 
+    int right_sum = evaluateExpressionTree(root.right) ;
+  
+    // check which operation to apply 
+    if (root.data == '+') 
+        return left_sum + right_sum ;
+      
+    else if( root.data == '-') 
+        return left_sum - right_sum ;
+      
+    else if (root.data == '*') 
+        return left_sum * right_sum ;
+      
+    else 
+        return (left_sum / right_sum );
+}
+
+// Driver function to test above problem 
+public static void main(String arg[])
+{
+
+    //EvalTree e=new EvalTree();  
+    // creating a sample tree 
+    root = new nod('+');
+    root.left =new nod('*') ;
+    root.left.left =new nod('5') ;
+    root.left.right =new nod('4'); 
+    root.right = new nod('-') ;
+    root.right.left =new nod('2') ;
+    root.right.right =new nod('1'); 
+    System.out.println( evaluateExpressionTree(root)); 
+    
+   /* root = None
+  
+    #creating a sample tree 
+    root = node('+') 
+    root.left = node('*') 
+    root.left.left = node('5') 
+    root.left.right = node('4') 
+    root.right = node('-') 
+    root.right.left = node('100') 
+    root.right.right = node('/') 
+    root.right.right.left = node('20') 
+    root.right.right.right = node('2') 
+    print evaluateExpressionTree(root) 
+  */
+}
+}
diff --git a/challenges/FstMissngPosInt.java b/challenges/FstMissngPosInt.java
new file mode 100644
index 0000000..70921cd
--- /dev/null
+++ b/challenges/FstMissngPosInt.java
@@ -0,0 +1,120 @@
+package hanson;
+//#04
+/*This problem was asked by Stripe.
+
+Given an array of integers, find the first missing positive integer in linear time and constant space. In other words, find the lowest positive integer that does not exist in the array. The array can contain duplicates and negative numbers as well.
+
+For example, the input [3, 4, -1, 1] should give 2. The input [1, 2, 0] should give 3.
+
+You can modify the input array in-place.
+
+
+
+A naive method to solve this problem is to search all positive integers, starting from 1 in the given array. We may have to search at most n+1 numbers in the given array. So this solution takes O(n^2) in worst case.
+
+We can use sorting to solve it in lesser time complexity. We can sort the array in O(nLogn) time. Once the array is sorted, then all we need to do is a linear scan of the array. So this approach takes O(nLogn + n) time which is O(nLogn).
+
+We can also use hashing. We can build a hash table of all positive elements in the given array. Once the hash table is built. We can look in the hash table for all positive integers, starting from 1. As soon as we find a number which is not there in hash table, we return it. This approach may take O(n) time on average, but it requires O(n) extra space.
+
+
+ 
+ */
+
+
+/*
+ * Following is the two step algorithm.
+1) Segregate positive numbers from others i.e., move all non-positive numbers to left side. In the following code, segregate() function does this part.
+2) Now we can ignore non-positive elements and consider only the part of array which contains all positive elements.
+ We traverse the array containing all positive numbers and to mark presence of an element x,
+  we change the sign of value at index x to negative. We traverse the array again and print the first index which has positive value. In the following code,
+   findMissingPositive() function does this part. Note that in findMissingPositive, we have subtracted 1 from the values as indexes start from 0 in C.
+ */
+
+public class FstMissngPosInt
+{
+
+	 
+	   
+	    /* Utility function that puts all non-positive  
+	       (0 and negative) numbers on left side of  
+	       arr[] and return count of such numbers */
+	    static int segregate (int arr[], int size) 
+	    { 
+	        int j = 0, i; 
+	        for(i = 0; i < size; i++) 
+	        { 
+	           if (arr[i] <= 0)   
+	           { 
+	               int temp; 
+	               temp = arr[i]; 
+	               arr[i] = arr[j]; 
+	               arr[j] = temp; 
+	               // increment count of non-positive  
+	               // integers 
+	               j++;   
+	           } 
+	        } 
+	       
+	        return j; 
+	    } 
+	       
+	    /* Find the smallest positive missing  
+	       number in an array that contains 
+	       all positive integers */
+	    static int findMissingPositive(int arr[], int size) 
+	    { 
+	      int i; 
+	       
+	      // Mark arr[i] as visited by making  
+	      // arr[arr[i] - 1] negative. Note that  
+	      // 1 is subtracted because index start  
+	      // from 0 and positive numbers start from 1 
+	      for(i = 0; i < size; i++) 
+	      { 
+	        int x = Math.abs(arr[i]); 
+	        if(x - 1 < size && arr[x - 1] > 0) 
+	          arr[x - 1] = -arr[x - 1]; 
+	      } 
+	       
+	      // Return the first index value at which  
+	      // is positive 
+	      for(i = 0; i < size; i++) 
+	        if (arr[i] > 0) 
+	          return i+1;  // 1 is added becuase indexes  
+	                       // start from 0 
+	       
+	      return size+1; 
+	    } 
+	       
+	    /* Find the smallest positive missing  
+	       number in an array that contains 
+	       both positive and negative integers */
+	    static int findMissing(int arr[], int size) 
+	    { 
+	       // First separate positive and  
+	       // negative numbers 
+	       int shift = segregate (arr, size); 
+	       int arr2[] = new int[size-shift]; 
+	       int j=0; 
+	       for(int i=shift;i<size;i++) 
+	           { 
+	               arr2[j] = arr[i]; 
+	               j++; 
+	           }     
+	       // Shift the array and call  
+	       // findMissingPositive for 
+	       // positive part 
+	       return findMissingPositive(arr2, j); 
+	    } 
+	    // main function 
+	    public static void main (String[] args)  
+	    { 
+	        int arr[] = {0, 10, 2, -10, -20}; 
+	        int arr_size = arr.length; 
+	        int missing = findMissing(arr, arr_size); 
+	        System.out.println("The smallest positive missing number is "+  
+	                            missing); 
+	    } 
+	} 
+
+
diff --git a/challenges/Inversion_day44.java b/challenges/Inversion_day44.java
new file mode 100644
index 0000000..837c219
--- /dev/null
+++ b/challenges/Inversion_day44.java
@@ -0,0 +1,77 @@
+package handson;
+
+
+/* Java program for Merge Sort */
+class MergeSort 
+{ 
+	static int finalSum=0;//stores the number of inversion 
+	public static void mergeSort(int[] a, int n) {
+	    if (n < 2)
+	    {
+	        return;
+	    }
+	    int mid = n / 2;
+	    int[] l = new int[mid];
+	    int[] r = new int[n - mid];
+	 
+	    for (int i = 0; i < mid; i++) {
+	        l[i] = a[i];
+	    }
+	    for (int i = mid; i < n; i++) {
+	        r[i - mid] = a[i];
+	    }
+	    mergeSort(l, mid);
+	    mergeSort(r, n - mid);
+	 
+	    merge(a, l, r, mid, n - mid);
+	
+	    }
+	public static void merge(int[] a, int[] l, int[] r, int left, int right) 
+	{
+			    int sum=0;//count the no. of inversions in each merge of the arrays
+			    int i = 0, j = 0, k = 0;
+			    while (i < left && j < right) {
+			        if (l[i] <= r[j]) {
+			            a[k++] = l[i++];
+			        }
+			        else {
+			        	sum+=left-i;//increase the count if elem from 2nd array if placed fst to elem from from fst array 
+			            a[k++] = r[j++];//increases by the no. of element left in 1st array
+			        }
+			    }
+			    while (i < left) {
+			        a[k++] = l[i++];
+			    }
+			    while (j < right) {
+			        a[k++] = r[j++];
+			        
+			    }
+			    finalSum+=sum;
+	}
+	static void printArray(int arr[]) 
+    { 
+        int n = arr.length; 
+        for (int i=0; i<n; ++i) 
+            System.out.print(arr[i] + " "); 
+        System.out.println(); 
+    } 
+	public static void main(String a[])
+	{
+	    int[] actual = { 2,4,1,3,5 };
+	    System.out.println("Given Array"); 
+        printArray(actual); 
+  
+	    
+	    MergeSort.mergeSort(actual, actual.length);
+	   
+  
+       
+  
+        System.out.println("\nSorted array"); 
+        printArray(actual); 
+        System.out.println(finalSum); 
+	    
+	}
+} 
+
+
diff --git a/challenges/Itinerary_day41.java b/challenges/Itinerary_day41.java
new file mode 100644
index 0000000..3efb7c1
--- /dev/null
+++ b/challenges/Itinerary_day41.java
@@ -0,0 +1,45 @@
+package handson;
+/* This problem was asked by Facebook.
+
+Given an unordered list of flights taken by someone, each represented as (origin, destination) pairs, and a starting airport, compute the person's itinerary. If no such itinerary exists, return null. If there are multiple possible itineraries, return the lexicographically smallest one. All flights must be used in the itinerary.
+
+For example, given the list of flights [('SFO', 'HKO'), ('YYZ', 'SFO'), ('YUL', 'YYZ'), ('HKO', 'ORD')] and starting airport 'YUL', you should return the list ['YUL', 'YYZ', 'SFO', 'HKO', 'ORD'].
+
+Given the list of flights [('SFO', 'COM'), ('COM', 'YYZ')] and starting airport 'COM', you should return null.
+
+Given the list of flights [('A', 'B'), ('A', 'C'), ('B', 'C'), ('C', 'A')] and starting airport 'A', 
+you should return the list ['A', 'B', 'C', 'A', 'C'] even though ['A', 'C', 'A', 'B', 'C'] is also a valid itinerary. However, the first one is lexicographically smaller.
+ 
+ */
+
+public class Itinerary_day41 
+{
+		
+		public static String hashe[][]= {{"a","b"},{"a","c"},{"b","c",},{"c","a"}};
+		public static int vis[]= {0,0,0,0};	
+		public static int count=0;
+	    public static void main(String a[])
+		{
+			String toSearch="a";
+			int j=0;
+			System.out.print(toSearch+",");
+				while(count !=4)//no. of flights. here its=4				
+				{  
+					if(toSearch.equals(hashe[j][0])&&vis[j]==0)//to match the origin flight and ensure its not taken again since there there is different origin from same destination, so if ignored can be mistakenly taken as cycle
+					{   count++;
+						vis[j]=1;
+						System.out.print(hashe[j][1]+",");
+						toSearch=hashe[j][1];
+						j=0;
+					}
+					else 
+					{ 
+						j++;
+					}
+				}
+				
+			}
+		}
+		
+
+
diff --git a/challenges/LongestPal_day45.java b/challenges/LongestPal_day45.java
new file mode 100644
index 0000000..9da38f8
--- /dev/null
+++ b/challenges/LongestPal_day45.java
@@ -0,0 +1,73 @@
+package handson;
+
+public class LongestPal_day45
+{
+	static String s="bananasannanab";
+	public static int max(int a,int b)// to find maximum of two
+	{
+		return (a>b)?a:b;
+	}
+	public static void dispSubstring(int start,int end)// to display part of string from start to end 
+	{
+		System.out.println("longest substring is:-");
+		for(int i=start;i<=end;i++)
+		{
+			System.out.print(s.charAt(i));
+		}
+	}
+	public static void main(String a[])
+	{
+		
+		
+		int arr[][]=new int[s.length()][s.length()];  // a 2d array of nXn size
+		for(int i=1;i<s.length();i++) 
+		// first we ll find length of longest pal substring	                                       // for filling 0 in the lower half of the array
+		for(int j=0;j<s.length()-1;j++)
+			arr[i][j]=0;
+		
+		for(int i=0;i<s.length();i++)                 // for filling 1 in the diagonal of the array
+			arr[i][i]=1;
+		
+		for(int k=1;k<s.length();k++)                 // for filling the uper half of the array
+		{	
+			int i=0,j=k;
+			for(int l=s.length()-k;l>=1;l--)                   // for diagonl movement of the array
+			{
+				if(s.charAt(i)!=s.charAt(j))
+					arr[i][j]=max(arr[i][j-1],arr[i+1][j]);
+				else
+					arr[i][j]=2+arr[i+1][j-1];
+				i++;j++;
+				
+			}
+		}
+		System.out.println("Dynamic table developed is:-");;
+		for(int i=0;i<s.length();i++)
+		{
+			for(int j=0;j<s.length();j++)
+				System.out.print(arr[i][j]+",");
+		    System.out.println();
+		}
+		System.out.println("length of longest palindromic substring is= "+arr[0][s.length()-1]);
+		// to find the substring
+		int i=0,j=s.length()-1,start=0,end=0;
+		while(j>=1)                                               // back tracking the table from top 
+		{
+			if(arr[i+1][j] < arr[i][j] && arr[i][j-1] < arr[i][j])
+			{	start=i;
+				end=j;
+				dispSubstring(start,end);
+				break;
+			}
+			else
+			{
+				if(arr[i+1][j] == arr[i][j])
+					i=i+1;
+				if(arr[i][j-1] == arr[i][j])
+					j=j-1;
+				continue;
+			}
+		}
+	}
+	
+}
diff --git a/challenges/MaxConti_day49.java b/challenges/MaxConti_day49.java
new file mode 100644
index 0000000..30daadc
--- /dev/null
+++ b/challenges/MaxConti_day49.java
@@ -0,0 +1,42 @@
+package handson;
+/*
+ * This problem was asked by Amazon.
+
+Given an array of numbers, find the maximum sum of any contiguous subarray of the array.
+
+For example, given the array [34, -50, 42, 14, -5, 86], the maximum sum would be 137, since we would take elements 42, 14, -5, and 86.
+
+Given the array [-5, -1, -8, -9], the maximum sum would be 0, since we would not take any elements.
+
+Do this in O(N) time.
+ */
+
+public class MaxConti_day49
+{
+	public static int  max(int a,int b)
+	{
+		return (a>b)?a:b;
+	}
+	public static void eval(int array[])
+	{   int sum=0;
+		for(int i=0;i<array.length;i++)
+		{
+			if(array[i]<0)
+				sum=max(sum+array[i],0);
+			else
+				sum=sum+array[i];
+			
+		}
+		System.out.println("required sum is "+sum);
+	}
+	public static void main(String a[])
+	{
+		
+		int arr1[]= {34,-50,42,14,-5,86};
+		int arr2[]= {-5,-1,-8,-9};
+		eval(arr1);
+		eval(arr2);
+		
+	}
+
+}
diff --git a/challenges/SmSubSet.java b/challenges/SmSubSet.java
new file mode 100644
index 0000000..668ac7b
--- /dev/null
+++ b/challenges/SmSubSet.java
@@ -0,0 +1,52 @@
+package handson;
+/* This problem was asked by Google.
+
+Given a list of integers S and a target number k, write a function that returns a subset of S that adds up to k. If such a subset cannot be made, then return null.
+
+Integers can appear more than once in the list. You may assume all numbers in the list are positive.
+
+For example, given S = [12, 1, 61, 5, 9, 2] and k = 24, return [12, 9, 2, 1] since it sums up to 24.
+*/
+
+
+public class SmSubSet
+{
+	//int[] x=new int[4];int m;
+	int[] x= {0,0,0,0,0,0};
+	int[] w= {1,2,5,9,12,61};
+	int m=24;
+	public void disp(int[] ar)
+	{
+		for (int i = 0; i <w.length; i++)
+		{
+			if(ar[i]==1)
+				System.out.print(w[i]+",");
+		}
+		System.out.println();
+	}
+		
+	public void sos(int s,int k,int r)
+	{	
+		x[k]=1;
+		if(s+w[k]==m)
+			disp(x);
+		
+		else if(s+w[k]+w[k+1]<=m)
+			sos(s+w[k],k+1,r-w[k]);
+		
+		if((s+r-w[k]>=m)&&(s+w[k+1]<=m))
+		{
+			x[k]=0;
+			sos(s,k+1,r-w[k]);
+		}
+		
+		
+	}
+	public static void main(String arg[])
+	{
+		SmSubSet s=new SmSubSet();
+		
+		s.sos(0,0,90);
+	}
+
+}
diff --git a/challenges/Xor_linked_list.java b/challenges/Xor_linked_list.java
new file mode 100644
index 0000000..3ce89a2
--- /dev/null
+++ b/challenges/Xor_linked_list.java
@@ -0,0 +1,5 @@
+package hanson;
+
+public class Xor_linked_list {
+
+}
diff --git a/challenges/uniqueelem_day40.java b/challenges/uniqueelem_day40.java
new file mode 100644
index 0000000..a6b706e
--- /dev/null
+++ b/challenges/uniqueelem_day40.java
@@ -0,0 +1,37 @@
+package handson;
+/*
+ * This problem was asked by Google.
+
+Given an array of integers where every integer occurs three times except for one integer, which only occurs once, find and return the non-duplicated integer.
+
+For example, given [6, 1, 3, 3, 3, 6, 6], return 1. Given [13, 19, 13, 13], return 19.
+
+Do this in O(N) time and O(1) space.
+ */
+
+public class uniqueelem_day40
+{
+	public static void main(String a[])
+	{   int arr[]= {6,1,3,3,3,6,6};
+		int largest=0;
+		for(int i=0;i<arr.length;i++)//to find the size of hash table
+		{
+			largest=(largest>arr[i])?largest:arr[i];
+		}
+		int hash[]=new int[largest+1];//creating hash table of ssize of largest element of array
+		
+		for(int i=0;i<arr.length;i++)//increasing the count of each element in the given array
+		{
+			hash[arr[i]]++;
+		}
+		for(int i=0;i<hash.length;i++)
+		{
+			if(hash[i]==1)//if count is 1
+				{
+					System.out.println(hash[i]);
+					break;
+				}
+			 
+		}
+	}
+}