From 06045a1e6c8fa9d6984d34cbdfe788be8ae6ef61 Mon Sep 17 00:00:00 2001
From: Neel <manineel25@gmail.com>
Date: Mon, 22 Apr 2019 17:04:10 +0530
Subject: [PATCH 01/10] Add files via upload

---
 challenges/April22.java | 46 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 challenges/April22.java

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); 
+	    } 
+	
+
+}

From 532c22b2eb37a1fa1265492eeefc8ae70b68d983 Mon Sep 17 00:00:00 2001
From: Neel <manineel25@gmail.com>
Date: Sun, 28 Apr 2019 23:38:38 +0530
Subject: [PATCH 02/10] Add files via upload

---
 challenges/ArrayProdExclude_Itself.java |  48 ++++++++++
 challenges/FstMissngPosInt.java         | 120 ++++++++++++++++++++++++
 challenges/Xor_linked_list.java         |   5 +
 3 files changed, 173 insertions(+)
 create mode 100644 challenges/ArrayProdExclude_Itself.java
 create mode 100644 challenges/FstMissngPosInt.java
 create mode 100644 challenges/Xor_linked_list.java

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/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/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 {
+
+}

From 5f9624c309c4d29ba2fcb99fbd5f1e5ed62667a8 Mon Sep 17 00:00:00 2001
From: Neel <manineel25@gmail.com>
Date: Sun, 19 May 2019 14:00:58 +0530
Subject: [PATCH 03/10] Add files via upload

This problem was asked by Facebook.

Given a string of round, curly, and square open and closing brackets, return whether the brackets are balanced (well-formed).

For example, given the string "([])[]({})", you should return true.

Given the string "([)]" or "((()", you should return false.
---
 challenges/DCP27braces.java | 43 +++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 challenges/DCP27braces.java

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");
+	}
+
+}

From 742e9aa836ac667cfc3dfa2d698d1e5b57efeda0 Mon Sep 17 00:00:00 2001
From: Neel <manineel25@gmail.com>
Date: Mon, 3 Jun 2019 02:19:36 +0530
Subject: [PATCH 04/10] Add files via upload

day #42
---
 challenges/SmSubSet.java | 52 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 challenges/SmSubSet.java

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);
+	}
+
+}

From 359aaae01d61e540fd16c1abd02e8178599a52ef Mon Sep 17 00:00:00 2001
From: Neel <manineel25@gmail.com>
Date: Tue, 4 Jun 2019 11:38:04 +0530
Subject: [PATCH 05/10] Add files via upload

---
 challenges/Inversion_day44.java | 77 +++++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100644 challenges/Inversion_day44.java

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); 
+	    
+	}
+} 
+
+

From 22fe445894a1ad9d4ced081a0cc9d8271cdcafbe Mon Sep 17 00:00:00 2001
From: Neel <manineel25@gmail.com>
Date: Tue, 4 Jun 2019 20:43:46 +0530
Subject: [PATCH 06/10] Add files via upload

---
 challenges/Itinerary_day41.java | 45 +++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 challenges/Itinerary_day41.java

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++;
+					}
+				}
+				
+			}
+		}
+		
+
+

From 7060d9989f529fbb7d49f05eea54833d02f01e1a Mon Sep 17 00:00:00 2001
From: Neel <manineel25@gmail.com>
Date: Wed, 5 Jun 2019 17:28:42 +0530
Subject: [PATCH 07/10] Add files via upload

---
 challenges/uniqueelem_day40.java | 37 ++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 challenges/uniqueelem_day40.java

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;
+				}
+			 
+		}
+	}
+}

From a5e51fceb11bf225e80cc2c466d103bbd42a2f9c Mon Sep 17 00:00:00 2001
From: Neel <manineel25@gmail.com>
Date: Thu, 6 Jun 2019 11:53:03 +0530
Subject: [PATCH 08/10] Add files via upload

---
 challenges/LongestPal_day45.java | 73 ++++++++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 challenges/LongestPal_day45.java

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;
+			}
+		}
+	}
+	
+}

From a861ca78c56dcd23005ea40ca39605ad8fbcc662 Mon Sep 17 00:00:00 2001
From: Neel <manineel25@gmail.com>
Date: Mon, 10 Jun 2019 13:12:17 +0530
Subject: [PATCH 09/10] Add files via upload
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This problem was asked by Microsoft.

Suppose an arithmetic expression is given as a binary tree. Each leaf is an integer and each internal node is one of '+', '−', '∗', or '/'.

Given the root to such a tree, write a function to evaluate it.

For example, given the following tree:

    *
   / \
  +    +
 / \  / \
3  2  4  5
You should return 45, as it is (3 + 2) * (4 + 5).
---
 challenges/EvaluationTree_day50.java | 89 ++++++++++++++++++++++++++++
 1 file changed, 89 insertions(+)
 create mode 100644 challenges/EvaluationTree_day50.java

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) 
+  */
+}
+}

From 2c345cc4284f04f276b5a133fd5e06813c1d985f Mon Sep 17 00:00:00 2001
From: Neel <manineel25@gmail.com>
Date: Mon, 10 Jun 2019 21:20:05 +0530
Subject: [PATCH 10/10] Add files via upload

---
 challenges/MaxConti_day49.java | 42 ++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 challenges/MaxConti_day49.java

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);
+		
+	}
+
+}