53: partial

Author: Laz4rz

README.md

@@ -1,5 +1,9 @@
 Literally **THE MOST** important thing in doing Leetcodes is: **MAKING SURE YOU UNDERSTOOD THE TASK**. I spent so much time thinking about non-existing problems, just because I misread or misunderstood something. For many of you English is not the first language. I know you know English well tho. I also understand English well. But understanding English and perfectly understanding the algorithmic task you are to implement, can someone mean two different things. Go slowly, it's just you and the task. You got it.
 
+## Learning problems
+
+Problems I want to describe in-depth, so that they will serve as examples for all the other ones. 
+
 #### 9. Palindrome Number (Easy)
 
 ```python
@@ -61,8 +65,68 @@ class Solution(object):
 
 **Rewritten instruction**: Find the maximum sum of consecutive elements of the array.
 
-**Main intuition**: If the current element will make the sum of the rest elements of the array smaller, than it would be without it, then skip it. Our question is basically:
+##### Solution(s)
+
+The first, obvious and with zero intuition, approach is to just double loop over the array elements. This works, but it's not good. Wanna guess the time complexity? You're right: $O(n^2)$.
+
+**Why? Quicky on double loop time complexity:**
+
+For each of the outer loops iteration $i$, we get $n-i$ inner loop iterations. Therefore the total of all iterations is:
+
+$$S = (n-1) + (n-2) + (n-3) +...+1$$
+
+Back to primary school: how to calculate the sum of arithmetic progressions? In general the arithmetic progression is something that starts at some $a_0$, has constant additive element $d$, and is bounded by the number of elements $n$ (it turns into arithmetic series when the number of elements is not bounded: $n \to \infty$). 
+
+**Derivation of the arithmetic progression sum formula:**
+
+We will an example of the progression in a normal form, and reversed. 
+
+$$S_f = 1 + 2 + ... + (n-1) + n$$
+
+$$S_r = n + (n-1) + ... + 2 + 1$$
+
+Now eyeball it. First term on both, second term on both... 
+
+$$S_f + S_r = (n+1) + (n+1) + (n+1)... = 2S$$
+
+Yeaaah, it's all coming together. How many terms is there: $n$. Each term is: $n+1$. So it's all just:
+
+$$2S = n(n+1)$$
+
+$$S = \frac{n(n + 1)}{2}$$
+
+Now, being absolutely sure, we understand how many iteration we have down to atomic level, we can get back to how we come up with complexity $O(n^2)$.
+
+We calculate the big-O complexity, by finding the dominating factor as $n$ grows towards infinity. If you ever calculated series sums. It's the same principle. You look for whatever term that outgrows others by orders of magnitude as $n$ grows. In this case, when we multiply the upper term:
+
+$$S = \frac{n^2+n}{2}$$
+
+Quadratic function grows faster than the linear one. Graphical way to understand why $n^2$ dominates for bigger $n$. You'd literally have to take something like $n=\frac{1}{3}$, for n to be bigger. 
+
+![alt text](images/complexity_n2_n.png)
+
+Now, we can finally see the naive and bad solution, understanding why it's naive and bad. 
+
+```python
+def maxSubArray(self, nums):
+    """
+    :type nums: List[int]
+    :rtype: int
+    """
+    top = float("-inf")
+    acc = 0
+    n = len(nums)
+
+    for i in range(n):
+        acc = nums[i]
+        if acc > top:
+            top = acc
+        for j in range(i+1, n):
+            acc += nums[j]
+            if acc > top:
+                top = acc
+    return top
+```
 
-$$\text{sum(nums)}[i] + \text{sum(nums)}[i+1:] > \text{sum(nums)}[i+1:]$$
+Now remember the intuition I wrote above. That's why reading the instruction **very** slowly is so important. We do not have to iterate so many times.
 
-Because remember, we only care about consecutive sums.