Spruce - Zandra #42
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,12 +1,19 @@ | ||
| def max_sub_array(nums): | ||
| """ Returns the max subarray of the given list of numbers. | ||
| Returns 0 if nums is None or an empty list. | ||
| Time Complexity: O(n)? | ||
| Space Complexity: constant? | ||
| """ | ||
| if nums == None: | ||
| return 0 | ||
| if len(nums) == 0: | ||
| return 0 | ||
|
|
||
| current_max_array = nums[0] | ||
| max_sub_array = nums[0] | ||
|
|
||
| for i in range(1, len(nums)): | ||
| max_sub_array = max(max_sub_array + nums[i], nums[i]) | ||
|
There was a problem hiding this comment. ✨ This is a really nice way to represent this calculation, which captures the underlying invariant that makes Kadane's algorithm work. |
||
| current_max_array = max(current_max_array, max_sub_array) | ||
|
|
||
| return current_max_array | ||
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,10 +1,18 @@ | ||
| def newman_conway(num): | ||
| """ Returns a list of the Newman Conway numbers for the given value. | ||
| Time Complexity: O(n)? | ||
| Space Complexity: O(n)? | ||
|
Comment on lines
+3
to
+4
There was a problem hiding this comment. ✨ Great! By carefully building up the calculations and storing them for later use, we only need to perform O(n) calculations. The storage to keep those calculations is related to n (as is the converted string) giving space complexity of O(n) as well (ignoring a little bit of fiddliness related to the length of larger numbers being longer strings). |
||
| """ | ||
| if num < 1: | ||
| raise ValueError("Invalid newman conway number") | ||
| if num == 1: | ||
| return "1" | ||
|
|
||
| n = [0, 1, 1] | ||
|
There was a problem hiding this comment. ✨ Nice use of a buffer slot to account for the 1-based calculation. |
||
|
|
||
| count = 3 | ||
| while count <= num: | ||
|
There was a problem hiding this comment. 👀 Prefer a |
||
| n.append(n[n[count - 1]] + n[count - n[count - 1]]) | ||
| count += 1 | ||
|
|
||
| return ' '.join([str(item) for item in n[1:]]) | ||
|
There was a problem hiding this comment. ✨ Nice use of a list comprehension to convert the numeric values to strings. Another approach would be to use the return ' '.join(map(str, n[1:])) |
||
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
✨ Notice how better time complexity this approach achieves over a "naïve" approach of checking for the maximum achievable sum starting from every position and every length. The correctness of this approach might not be apparent, so I definitely encourage reading a bit more about it. This has a fairly good explanation, as well as a description of why this is considered a dynamic programming approach (on the face it might not "feel" like one).
Since like the fibonacci sequence, we are able to maintain a sliding window of recent values to complete our calculation, we can do it with a constant O(1) amount of storage.