Day - 86 work

Author: mandliya

README.md

@@ -6,13 +6,13 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 123 |
-| Current Streak | 85 days |
-| Longest Streak | 85 ( August 17, 2015 - November 09, 2015 ) |
+| Total Problems | 125 |
+| Current Streak | 86 days |
+| Longest Streak | 86 ( August 17, 2015 - November 10, 2015 ) |
 
 </center>
 
-### LinkedList Problems 
+### LinkedList Problems
 | Problem | Solution |
 | :------------ | :----------: |
 | Find the nth node of linked list from last. | [nthToLastNode.cpp] (linked_list_problems/nthToLastNode.cpp) |
@@ -32,7 +32,7 @@
 | Sort a linked list using merge sort | [merge_sort.cpp] (linked_list_problems/merge_sort.cpp) |
 | Given a singly linked list L<sub>0</sub> -> L<sub>1</sub> -> … -> L<sub>n-1</sub> -> L<sub>n</sub>. Rearrange the nodes in the list (in place) so that the new formed list is : L<sub>0</sub> -> L<sub>n</sub> -> L<sub>1</sub> -> L<sub>n-1</sub> -> L<sub>2</sub> -> L<sub>n-2<sub> ....| [rearrange_list.cpp](linked_list_problems/rearrange_list.cpp)|
 
-### Include 
+### Include
 Include contains single header implementation of data structures and some algorithms.
 
 | DS/ALG |     Implementation   |
@@ -159,6 +159,7 @@ Include contains single header implementation of data structures and some algori
 | Find the maximum element in an array which is first increasing and then decreasing. Input: arr[] = {8, 10, 20, 80, 100, 200, 400, 500, 3, 2, 1}, output : 500. Array may be strictly increasing or decreasing as well. ExpectedTime complexity is O(logn).| [findMaximum.cpp](sort_search_problems/findMaximum.cpp)|
 | Given an array of positive and/or negative integers, find a pair in the array whose sum is closest to 0.| [findClosestPairToZero.cpp](sort_search_problems/findClosestPairToZero.cpp)|
 | Numeros, the Artist, had two lists A and B, such that B was a permutation of A. Numeros was very proud of these lists. Unfortunately, while transporting them from one exhibition to another, some numbers were left out of A. Can you find the missing numbers? Notes: <ul><li>If a number occurs multiple times in the lists, you must ensure that the frequency of that number in both lists is the same. If that is not the case, then it is also a missing number.</li></ul><ul><li>You have to print all the missing numbers in ascending order.</li></ul><ul><li>Print each missing number once, even if it is missing multiple times.</li></ul><ul><li>The difference between maximum and minimum number in B is less than or equal to 100.</li></ul>. <ul><li> There will be four lines of input: n - the size of the first list, This is followed by n space-separated integers that make up the first list. m - the size of the second list. This is followed by m space-separated integers that make up the second list. Output the missing numbers in ascending order.| [missingNumbers.cpp](leet_code_problems/missingNumbers.cpp)|
+| Find the closest pair from two sorted arrays. Given two sorted arrays and a number x, find the pair whose sum is closest to x and the pair has an element from each array. We are given two arrays ar1[0…m-1] and ar2[0..n-1] and a number x, we need to find the pair ar1[i] + ar2[j] such that absolute value of (ar1[i] + ar2[j] – x) is minimum.| [closestPairSorted.cpp](sort_search_problems/closestPairSorted.cpp)|
 ### Graph Problems
 | Problem | Solution |
 | :------------ | :----------: |
@@ -199,6 +200,8 @@ Include contains single header implementation of data structures and some algori
 | Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path. Note: You can only move either down or right at any point in time.| [minPath.cpp](leet_code_problems/minPath.cpp)|
 | Count the number of prime numbers less than a non-negative number, n.| [countPrimes.cpp](leet_code_problems/countPrimes.cpp)|
 | Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers. Ensure that numbers within the set are sorted in ascending order. Example : for k = 3, n = 9 result would be [[1,2,6], [1,3,5], [2,3,4]], similarly for k = 3, n = 7, result would be [[1,2,4]]. | [combinationSum3.cpp](leet_code_problems/combinationSum3.cpp) |
+| Given a non-negative integer num, repeatedly add all its digits until the result has only one digit. For example: Given num = 38, the process is like: 3 + 8 = 11, 1 + 1 = 2. Since 2 has only one digit, return it. Follow up:
+Could you do it without any loop/recursion in O(1) runtime?| [sumDigits.cpp](leet_code_problems/sumDigits.cpp)|
 
 
 

leet_code_problems/addDigits.cpp

@@ -0,0 +1,41 @@
+/**
+ * Given a non-negative integer num, repeatedly add all its digits until the result has only one digit.
+ *
+ * For example:
+ *
+ * Given num = 38, the process is like: 3 + 8 = 11, 1 + 1 = 2. Since 2 has only one digit, return it.
+ *
+ * Follow up:
+ * Could you do it without any loop/recursion in O(1) runtime?
+ *
+ * solution approach:
+ * Look at the pattern which emerges when we sum the values and eventually reduce it to single digit. By observing carefully, we will see a pattern.
+ *
+ * This is calculating digital root of a number (https://en.wikipedia.org/wiki/Digital_root)
+ * The formula is:
+ * dr(n) = 0 if n = 0,
+ * 		   9 if n != 0 and  (n % 9 == 0)
+ * 		   n % 9
+ *
+ */
+
+#include <iostream>
+
+
+int sumDigits( int num ) {
+	if ( num == 0 ) {
+		return 0;
+	} else if ( num % 9 == 0 ) {
+		return 9;
+	}
+	return num % 9;
+}
+
+int main() {
+	int n;
+	std::cout << "Enter a number:";
+	std::cin >> n;
+	std::cout << "Digital root of " << n << " is :" << sumDigits(n) << std::endl;
+	return 0;
+}
+

leet_code_problems/run

@@ -0,0 +1,75 @@
+/**
+ * Find the closest pair from two sorted arrays
+ * Given two sorted arrays and a number x, find the pair whose sum is closest to x and the pair has an element from each array.
+ * We are given two arrays ar1[0…m-1] and ar2[0..n-1] and a number x, we need to find the pair ar1[i] + ar2[j] such that absolute value of (ar1[i] + ar2[j] – x) is minimum.
+ * Input:  ar1[] = {1, 4, 5, 7};
+ *         ar2[] = {10, 20, 30, 40};
+ *         x = 32
+ *         Output:  1 and 30
+ *
+ *         Input:  ar1[] = {1, 4, 5, 7};
+ *         ar2[] = {10, 20, 30, 40};
+ *         x = 50
+ *         Output:  7 and 40
+ */
+
+#include <iostream>
+#include <vector>
+#include <utility>
+#include <limits>
+#include <cmath>
+
+std::pair<int,int> closestPair( std::vector<int> & vec1, std::vector<int> & vec2, int x ) {
+	size_t left = 0;
+	size_t right = vec2.size() - 1;
+	int minDiff = std::numeric_limits<int>::max();
+	int leftRes, rightRes;
+	while (left < vec1.size() && right >= 0 ) {
+		int diff = std::abs(vec1[left] + vec2[right] - x);
+		if ( diff < minDiff ) {
+			minDiff = diff;
+			leftRes = left;
+			rightRes = right;
+		}
+		if ( vec1[left] + vec2[right] > x ) {
+			--right;
+		} else {
+			++left;
+		}
+	}
+	return std::make_pair(vec1[leftRes], vec2[rightRes]);
+}
+
+void printVec( std::vector<int> & vec ) {
+	for ( auto v : vec ) {
+		std::cout << v << " ";
+	}
+	std::cout << std::endl;
+}
+
+int main() {
+	std::vector<int> vec1  {1, 4, 5, 7};
+	std::vector<int> vec2 {10, 20, 30, 40};
+	std::cout << "Vec1: ";
+	printVec(vec1);
+	std::cout << "Vec2: ";
+	printVec(vec2);
+	int x = 32;
+	std::cout << "x : " << x << std::endl;
+	std::pair<int,int> result = closestPair(vec1, vec2, x);
+	std::cout << "The closest pair from the above two sorted vectors to " << x << " is "
+			  << "(" << result.first << ", " << result.second << ")" << std::endl;
+
+	std::vector<int> vec3 {1, 4, 5, 7};
+	std::vector<int> vec4 {10, 20, 30, 40};
+	std::cout << "Vec3: ";
+	printVec(vec3);
+	std::cout << "Vec4: ";
+	printVec(vec4);
+	x = 50;
+	std::cout << "x : " << x << std::endl;
+	std::pair<int,int> result2 = closestPair(vec3, vec4, x);
+	std::cout << "The closest pair from the above two sorted vectors to " << x << " is "
+			  << "(" << result2.first << ", " << result2.second << ")" << std::endl;
+	return 0;
+}