Diana - Pine #41
Diana - Pine #41
Conversation
anselrognlie
left a comment
anselrognlie
left a comment
There was a problem hiding this comment.
✨ 💫 Looks good, Diana! I left some comments on your implementation below.
🟢
| Time Complexity: ? | ||
| Space Complexity: ? |
| nc_nums = [1, 1] | ||
| if num < 1: | ||
| raise ValueError("Num must be greater than 0.") | ||
| for i in range(2, num + 1): |
There was a problem hiding this comment.
Since you're always truncating the returned list using num as the end, we only need to calculate up to the same limit (num) here.
| string_list = [] | ||
| for n in nc_nums: | ||
| string_list.append(str(n)) |
There was a problem hiding this comment.
Consider using a comprehension or map to apply the str transformation to each numeric value.
string_list = [str(n) for n in nc_nums]or
string_list = map(str, nc_nums)| string_list = [] | ||
| for n in nc_nums: | ||
| string_list.append(str(n)) | ||
| return " ".join(string_list[0:num]) |
There was a problem hiding this comment.
The need to slice the array here comes from needing to handle the base case for num being 1 (you initialize your calculation array to start with [1, 1], or num = 2). If you added an earlier check for the case of num being 1, you could omit the slicing here to be
return " ".join(string_list)| 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.
| if current_sum + nums[i] > nums[i]: | ||
| current_sum += nums[i] | ||
| else: | ||
| current_sum = nums[i] |
There was a problem hiding this comment.
✨ This is a nice way to represent this calculation, which captures the underlying invariant that makes Kadane's algorithm work.
Consider using max to write it as
current_sum = max(current_sum + nums[i], nums[i])2 participants
No description provided.