Cedar: Katie Diaz #34
Conversation
anselrognlie
left a comment
anselrognlie
left a comment
There was a problem hiding this comment.
✨ 💫 Looks good, Katie! I left some comments on your implementation below.
🟢
| if num == 0: | ||
| raise ValueError() |
There was a problem hiding this comment.
We should raise this error for any value below the valid starting point of the sequence:
if num <= 0:
raise ValueError()| Time Complexity: O(n) | ||
| Space Complexity: O(n) |
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 == 2: | ||
| return "1 1" | ||
| new_seq = [0] * (num + 1) | ||
| new_seq[0] = 0 |
There was a problem hiding this comment.
✨ Nice use of a buffer slot to account for the 1-based calculation.
|
|
||
| i = 3 | ||
| # first 3 items | ||
| while i<=num: |
There was a problem hiding this comment.
👀 Prefer a for loop, since we know exactly how many times this will loop (especially since you went through the trouble to pre-allocate the array storage).
| i = 1 | ||
| result = [] | ||
| while (i <= num) : | ||
| # Display the sequence element | ||
| result.append(new_seq[i]) | ||
| i += 1 |
There was a problem hiding this comment.
This code is making a new array with that buffer 0 excluded. Remember that we could accomplish this with slicing.
result = new_seq[1:]| resultOutput = [str(item) for item in result] | ||
| return " ".join(resultOutput) No newline at end of file |
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 map function:
return " ".join(map(str, result))| Time Complexity: O(n) | ||
| Space Complexity: O(1) |
There was a problem hiding this comment.
✨ 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.
| maxSub = nums[0] | ||
| currentSum = nums[0] | ||
| for index in range(1, len(nums)): | ||
| currentSum = max(nums[index], currentSum + nums[index]) |
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.
| maxSub = nums[0] | ||
| currentSum = nums[0] |
| # Display the sequence element | ||
| result.append(new_seq[i]) | ||
| i += 1 | ||
| resultOutput = [str(item) for item in result] |
2 participants
No description provided.