Day 69, 2 leet code problems

Author: mandliya

README.md

@@ -6,9 +6,9 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 96 |
-| Current Streak | 68 days |
-| Longest Streak | 68 ( August 17, 2015 - October 23, 2015 ) |
+| Total Problems | 98 |
+| Current Streak | 69 days |
+| Longest Streak | 69 ( August 17, 2015 - October 24, 2015 ) |
 
 </center>
 
@@ -173,3 +173,5 @@ Include contains single header implementation of data structures and some algori
 | Given an unsorted integer array, find the first missing positive integer.Example: [1,2,0] should return 3 and [3,4,-1,1] should return 2. Expected time complexity O(n) and solution should use constant space| [firstMissingPositiveNum.cpp](leet_code_problems/firstMissingPositiveNum.cpp)|
 |Given an unsorted array of integers, find the length of the longest consecutive elements sequence. For example: Given [100, 4, 200, 1, 3, 2]. The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4. Algorithm should run in O(n) complexity.| [longestConsecutiveSeq.cpp](leet_code_problems/longestConsecutiveSeq.cpp)|
 |Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold additional elements from nums2. The number of elements initialized in nums1 and nums2 are m and n respectively.| [mergeArrays.cpp](leet_code_problems/mergeArrays.cpp)
+|Given an array of non-negative integers, you are initially positioned at the first index of the array. Each element in the array represents your maximum jump length at that position. Determine if you are able to reach the last index. For example: <ul><li>A = [2,3,1,1,4], return true.</li></ul><ul><li>A = [3,2,1,0,4], return false.</li></ul>| [jumpGame.cpp](leet_code_problems/jumpGame.cpp)|
+|Given a positive integer, return its corresponding column title as appear in an Excel sheet. For example 1 -> A, 2 -> B,...26 -> Z, 27 -> AA, 28 -> AB, ...705 -> AAC | [excelColSheetTitle.cpp](leet_code_problems/excelColSheetTitle.cpp)|

leet_code_problems/excelColSheetTitle.cpp

@@ -0,0 +1,50 @@
+/**
+ * Given a positive integer, return its corresponding column title as appear in an Excel sheet.
+ *
+ * For example:
+ *
+ *     1 -> A
+ *     2 -> B
+ *     3 -> C
+ *     ...
+ *     26 -> Z
+ *     27 -> AA
+ *     28 -> AB
+ *
+ * Approach:
+ *	   We need to convert the column value to effective a base 26 number, Imagine this is similar
+ *	   to converting a decimal to hexadecimal value. However, we need to be cautious of that the
+ *	   column numbers are not 0 indexed, they are indexed from 1. So every time our n % 26 is 0,
+ *	   we reduce 1 from remaining number.
+ *
+ */
+
+#include <iostream>
+#include <string>
+#include <algorithm>
+
+std::string convertToTitle(int n) {
+	std::string result("");
+	while ( n > 0) {
+		int rem = n % 26;
+		if ( rem == 0 ) {
+			result += 'Z';
+			n = (n/26) - 1;
+		} else {
+			result += char( rem-1 + 'A');
+			n = n/26;
+		}
+	}
+	std::reverse(result.begin(), result.end());
+	return result;
+}
+
+int main()
+{
+	std::cout << "Enter the column index(1 based):";
+	int col;
+	std::cin >> col;
+	std::cout << "Corresponding excel sheet title for column number "
+			  << col << " is :" << convertToTitle(col) << std::endl;
+	return 0;
+}

leet_code_problems/jumpGame.cpp

@@ -0,0 +1,58 @@
+/**
+ * Given an array of non-negative integers, you are initially positioned at the first index of the array.
+ *
+ * Each element in the array represents your maximum jump length at that position.
+ *
+ * Determine if you are able to reach the last index.
+ *
+ * For example:
+ * A = [2,3,1,1,4], return true.
+ *
+ * A = [3,2,1,0,4], return false.
+ *
+ * Approach : Here we have to observe that array value represents *maximum* value, so we can always jump j index from index i as long as j < A[i].
+ * i.e. if A[i] = 3, we can jump either 1, 2, or 3 steps.
+ * Now, We will use dynamic programing to solve this problem. Our subproblem is at any index i, what is the farthest index I can jump. If in the end
+ * if the max value index we have gathered so far is bigger than array length, we have reached the last index.
+ */
+
+#include <iostream>
+#include <vector>
+
+bool canReach( std::vector<int> & vec ) {
+	int n = vec.size();
+	if ( n == 0 ) {
+		return false;
+	}
+	if ( n == 1 ) {
+		return true;
+	}
+	int m = 0;
+	for (int i = 0; i < n; ++i ) {
+		if ( i <= m ) {
+			m = std::max( m, vec[i] + i );
+			if ( m >= n-1) {
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+void printRes( std::vector<int> & vec ) {
+	std::cout << "VEC:";
+	for ( auto v : vec ) {
+		std::cout << v << " ";
+	}
+	std::cout << std::endl;
+	std::cout << (canReach(vec) ? "True" : "False");
+	std::cout << std::endl;
+}
+
+int main() {
+	std::vector<int> vec1{ 2,3,1,1,4 };
+	std::vector<int> vec2{ 3,2,1,0,4 };
+	printRes(vec1);
+	printRes(vec2);
+	return 0;
+}