Add backspace string compare and maximum ascending subarray sum

Author: Gituser143

Easy/backspace-string-compare.md

@@ -0,0 +1,37 @@
+Code
+====
+
+```go
+func backspaceCompare(s string, t string) bool {
+	sol := []string{}
+	strs := []string{s, t}
+
+	for _, str := range strs {
+		newStr := ""
+		for _, c := range str {
+			if string(c) == "#" {
+				if len(newStr) > 0 {
+					newStr = newStr[:len(newStr)-1]
+				}
+			} else {
+				newStr = newStr + string(c)
+			}
+		}
+
+		sol = append(sol, newStr)
+	}
+
+	return sol[0] == sol[1]
+}
+```
+
+Solution in mind
+================
+
+-	We iterate through characters of a string and maintain a new string (`newStr`) which has the updated string post backspaces.
+
+-	If a `#` is encountered as the character, we simply check if `newStr` has any characters in it and remove the last character. If empty, we simply continue.
+
+-	In the case where the encountered character is not `#`, we simply append it as a suffix to `newStr`
+
+-	After both strings have been parsed, we compare the new strings for equality.

Easy/maximum-ascending-subarray-sum.md

@@ -0,0 +1,53 @@
+Code
+====
+
+```go
+func sum(nums []int) int {
+	sum := 0
+	for _, num := range nums {
+		sum += num
+	}
+
+	return sum
+}
+
+func maxAscendingSum(nums []int) int {
+	window := []int{}
+	windowSum := 0
+	prevNum := 0
+
+	for _, num := range nums {
+		if num > prevNum {
+			window = append(window, num)
+			prevNum = num
+		} else {
+			s := sum(window)
+			if s > windowSum {
+				windowSum = s
+			}
+			prevNum = num
+			window = []int{num}
+		}
+	}
+
+	s := sum(window)
+	if s > windowSum {
+		windowSum = s
+	}
+
+	return windowSum
+}
+```
+
+Solution in mind
+================
+
+-	We iterate through elements of the `nums` array, while keeping track of `window` and `prevNum`. Here, `window` holds the subsequence of the array that is ascending.
+
+-	As and when we encounter a number, we check if it is greater than the previous encountered number. If it is, the `window` grows in size (we append to `window`).
+
+-	If it is not, we calculate the sum of the existing window and check if it is greater than any previously encountered sum (`windowSum`) and update the sum accordingly.
+
+-	After updating the window sum, we reset the window to have only the latest encountered number in it, as the window is no longer increasing.
+
+-	After completion of iterations through elements, we return windowSum

README.md

@@ -7,7 +7,7 @@ Link to profile, [bhargavsnv100](https://leetcode.com/bhargavsnv100/)
 
 | [Easy](#easy) | [Medium](#medium) | [Hard](#hard) |
 |---------------|-------------------|---------------|
-| 42            | 69                | 12            |
+| 44            | 69                | 12            |
 
 Problems finished
 =================
@@ -16,6 +16,7 @@ Easy
 ----
 
 -	[average-of-levels-in-binary-tree.md](Easy/average-of-levels-in-binary-tree.md)
+-	[backspace-string-compare.md](Easy/backspace-string-compare.md)
 -	[best-time-to-buy-and-sell-stock.md](Easy/best-time-to-buy-and-sell-stock.md)
 -	[binary-tree-level-order-traversal-ii.md](Easy/binary-tree-level-order-traversal-ii.md)
 -	[binary-tree-paths.md](Easy/binary-tree-paths.md)
@@ -32,6 +33,7 @@ Easy
 -	[license-key-formatting.md](Easy/license-key-formatting.md)
 -	[longest-common-prefix.md](Easy/longest-common-prefix.md)
 -	[majority-element.md](Easy/majority-element.md)
+-	[maximum-ascending-subarray-sum.md](Easy/maximum-ascending-subarray-sum.md)
 -	[maximum-depth-of-binary-tree.md](Easy/maximum-depth-of-binary-tree.md)
 -	[maximum-depth-of-n-ary-tree.md](Easy/maximum-depth-of-n-ary-tree.md)
 -	[merge-sorted-array.md](Easy/merge-sorted-array.md)