Merge pull request #25 from alberthu16/day36

Day 36: Longest consecutive sequence (sorting?)

Author: Albert Hu

day36/README.md

@@ -0,0 +1,40 @@
+Question of the day: https://leetcode.com/problems/longest-consecutive-sequence/#/description
+
+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`.  
+
+Your algorithm should run in `O(n)` complexity.
+
+## Ideas
+
+Clarification questions: can I make any assumptions about the integers in the
+input array? I.e. is there a range like 0 - 100? Are all integers in the input
+array unique or can there be duplicates? Do duplicates count in consecutive
+sequences?
+
+Radix sort allows me to do a tradeoff on space for faster time complexity. The
+radix I can use here instead of digit-by-digit, is to treat the max valued element
+of the array as the limit of a single, theoretical digit. That way, in one
+additional pass through, I will have the input sorted. In a third pass through,
+I can count the longest consecutive sequence.
+
+This approach is fine for input arrays with elements that aren't too large.
+However, the runtime is actually proportional to the value of the largest element.
+Both the runtime and space complexity are `O(k)` where `k` is the value of
+the largest element.
+
+Is there a better approach? Not sure. Let's code up the first solution and
+see if I can think of anything by the end.
+
+## Code
+
+[Python](./longestConsecutive.py)
+
+## Follow up
+
+Welp.. didn't actually solve the problem under the right constraints. How can I 
+be more efficient?

day36/longestConsecutive.py

@@ -0,0 +1,34 @@
+def longestConsecutive(nums):
+    if len(nums) <= 1:
+        return len(nums)
+
+    buckets = [False for i in xrange(max(nums)+1)]
+    for num in nums:
+        buckets[num] = True
+    if len(buckets) == 1:
+        return 1
+
+    maxLongestCount, longestCount = 0, 1
+    for prev, curr in zip(buckets, buckets[1:]):
+        if prev and curr:
+            longestCount += 1
+        else:
+            longestCount = 1
+        maxLongestCount = max(maxLongestCount, longestCount)
+
+    return maxLongestCount
+
+def testLongestConsecutive():
+    assert longestConsecutive([100, 4, 200, 1, 3, 2]) == 4
+    assert longestConsecutive([]) == 0
+    assert longestConsecutive([0]) == 1
+    assert longestConsecutive([0, 0]) == 1 # assume duplicates don't count
+    assert longestConsecutive([0, 1, 2]) == 3
+    assert longestConsecutive([2, 1, 0]) == 3
+    assert longestConsecutive([1, 50, 2, 51, 3, 52, 4, 53, 54]) == 5
+
+def main():
+    testLongestConsecutive()
+
+if __name__ == "__main__":
+    main()