Day - 81 work

Author: mandliya

README.md

@@ -6,9 +6,9 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 117 |
-| Current Streak | 80 days |
-| Longest Streak | 80 ( August 17, 2015 - November 04, 2015 ) |
+| Total Problems | 119 |
+| Current Streak | 81 days |
+| Longest Streak | 81 ( August 17, 2015 - November 05, 2015 ) |
 
 </center>
 
@@ -194,5 +194,10 @@ Include contains single header implementation of data structures and some algori
 |Suppose a sorted array is rotated at some pivot unknown to you beforehand. (i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2). Find the minimum element. You may assume no duplicate exists in the array.| [find_min_rotated.cpp](leet_code_problems/find_min_rotated.cpp)|
 |Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.| [threeSumClosest.cpp](leet_code_problems/threeSumClosest.cpp)|
 |Given n non-negative integers a<sub>1</sub>, a<sub>2</sub>, ..., a<sub>n</sub>, where each represents a point at coordinate (i, a<sub>i</sub>). n vertical lines are drawn such that the two endpoints of line i is at (i, a<sub>i</sub>) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water. Note: You may not slant the container.| [maxArea.cpp](leet_code_problems/maxArea.cpp)|
+| Given a binary tree containing digits from 0-9 only, each root-to-leaf path could represent a number. An example is the root-to-leaf path 1->2->3 which represents the number 123. Find the total sum of all root-to-leaf numbers. Example in solution comments | [sumRootToLeafNumbers.cpp](leet_code_problems/sumRootToLeafNumbers.cpp)|
+| Say you have an array for which the ith element is the price of a given stock on day i. If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.| [maxProfitStock.cpp](leet_code_problems/maxProfitStock.cpp)|
+
+
+
 
 

leet_code_problems/maxProfitStock.cpp

@@ -0,0 +1,44 @@
+/**
+ * Say you have an array for which the ith element is the price of a given stock on day i.
+ * If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock),
+ * Design an algorithm to find the maximum profit.
+ */
+
+#include <iostream>
+#include <vector>
+
+int maxProfit(std::vector<int>& prices) {
+	if (prices.size() == 0 ) {
+		return 0;
+	}
+	std::vector<int> dp(prices.size());
+	dp[0] = 0;
+	int buyPrice = prices[0];
+	int mostProfit = 0;
+	for ( size_t i = 1; i < prices.size(); ++i ) {
+		if ( prices[i] >= buyPrice ) {
+			dp[i] = dp[i-1] + prices[i] - prices[i-1];
+		} else {
+			dp[i] = 0;
+			buyPrice = prices[i];
+		}
+		if (mostProfit < dp[i]) {
+			mostProfit = dp[i];
+		}
+	}
+	return mostProfit;
+}
+
+void printStocks( std::vector<int> & stocks ) {
+	std::cout << "Stock prices:";
+	for ( auto stock : stocks ) {
+		std::cout << stock << " ";
+	}
+	std::cout << std::endl;
+}
+int main() {
+	std::vector<int> prices{ 45, 33, 66, 78, 90, 47 };
+	printStocks(prices);
+	std::cout << "Max profit from above price range:" << maxProfit(prices) << std::endl;
+	return 0;
+}

leet_code_problems/run

@@ -0,0 +1,69 @@
+/**
+ *
+ * Given a binary tree containing digits from 0-9 only, each root-to-leaf path could represent a number.
+ *
+ * An example is the root-to-leaf path 1->2->3 which represents the number 123.
+ *
+ * Find the total sum of all root-to-leaf numbers.
+ *
+ * For example,
+ *
+ *			  1
+ *			 / \
+ *			2   3
+ *          The root-to-leaf path 1->2 represents the number 12.
+ *          The root-to-leaf path 1->3 represents the number 13.
+ *
+ *          Return the sum = 12 + 13 = 25.
+ */
+
+#include <iostream>
+#include <vector>
+
+struct TreeNode {
+	int val;
+	TreeNode * left;
+	TreeNode * right;
+	TreeNode( int data ) : val{ data }, left{ nullptr }, right{ nullptr } { }
+};
+
+void rootToLeafSum( TreeNode* root, int & total, int & curr ) {
+	if( root == nullptr ) {
+		return;
+	}
+	curr = (10*curr) + root->val;
+	if (root && root->left == nullptr && root->right == nullptr ) {
+		total += curr;
+	}
+	int oldCurr = curr;
+	rootToLeafSum(root->left, total, curr);
+	rootToLeafSum(root->right, total, oldCurr);
+}
+
+
+int sumNumbers(TreeNode* root) {
+	int total = 0;
+	int curr = 0;
+	rootToLeafSum(root, total, curr);
+	return total;
+}
+
+
+void printTree( TreeNode * root ) {
+	if ( root ) {
+		printTree( root->left );
+		std::cout << root->val << " ";
+		printTree( root->right );
+	}
+}
+
+
+int main() {
+	TreeNode * root = new TreeNode( 1 );
+	root->left = new TreeNode( 2 );
+	root->right = new TreeNode( 3 );
+	std::cout << "Tree in order:";
+	printTree(root);
+	std::cout << "Output : " << sumNumbers(root) << std::endl;
+	return 0;
+}