Updated explanation file according to template

Author: hanzel-sc

Arrays & Strings/Two Sum/Explanation.md

@@ -1,59 +1,115 @@
-Explanation (C solution):
+## 🧮 Two Sum II - Input Array Is Sorted
 
-## Two Sum II - Input Array is Sorted
+Difficulty: Easy
+Category: Arrays, Two Pointers
+Leetcode Link: https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/
 
-### Difficulty : Easy
-### Category : Arrays, Two pointer
+### 📝 Introduction
 
-Leetcode Link : https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/
+You're given a sorted array of integers in non-decreasing order and a target value. The task is to find the indices of the two numbers such that they add up to the target value. The return should be in 1-based indexing, and you can assume exactly one solution exists and no element is reused.
 
-### Introduction 
+### 💡 Approach & Key Insights
 
-Two Sum II, a slightly modified version of Two Sum I where we get a sorted array and a target. We need to find two numbers in the array such that they add up to the target and return their indices in 1-based indexing. 
+    Key Insight: Since the array is sorted, we can use the two-pointer technique instead of brute force.
 
-### Intuition and Naive Approach/Brute Force
+    Naive approach checks all pairs — this is simple but inefficient (O(n²)).
 
-At first glance it seems simple. We could use two loops and check all the pairs and return the pair whose sum matches the target.
+    Optimized approach uses two pointers (start and end) to shrink the search space intelligently in O(n) time.
 
-for(int i=0; i < n; i++) {
-    for(int j=i+1; j < n; j++){
-        if (num[i] + num[j] == target)
-        return [i+1, j+1]
-    }
-}
+    We return a dynamically allocated array in C to store the result as C functions can’t directly return multiple values.
 
-While this would give us the result it would totally negate any advantage we have with the array being sorted and furthermore it would result in a time complexity of O(n^2)
+### 🛠️ Breakdown of Approaches
 
-Space complexity: O(1)
+### 1️⃣ Brute Force / Naive Approach
 
-### Optimized Solution
-The solution's optimized with the utilization of two pointers - at the start and end of the array respectively, let's say l and r.
-We move inwards into the array until our start and end pointers don't cross over i.e left > right.
-We check if the value at array[l] + array[r] (which is our sum) == target.
+Explanation:
+Check every pair (i, j) where i < j. If numbers[i] + numbers[j] == target, return their 1-based indices.
 
-Since it's a sorted array. If: 
-1. Sum is greater than Target
--Then we know we need a smaller value to match or get close to the target, hence we decrease the end pointer , pointing to a smaller value (second largest value and so on..).
-2. Sum is lesser than Target
--Then we need a larger value to match or get close to the target, hence we increase the start pointer, pointing to a larger value(second smallest value and so on..).
+Time Complexity: O(n²)
+Each element is paired with every other element ahead of it.
 
-If Sum is equal to our target:
--Store the indexes of the two values in the malloced array (dynamic array since we can't directly return two values from a function in C)
--We've increased the index by 1 to facilitate 1-based indexing as given in the problem.
--Return the malloced array.
+Space Complexity: O(1)
+No extra space is used apart from result.
+
+Example / Dry Run:
+
+Example input: [2, 7, 11, 15], target = 9
+Steps:
+
+    2+7=9 → match found
+    Output: [1, 2]
+
+### 2️⃣ Optimized Approach
+
+Explanation:
+Use two pointers:
+
+    Start l = 0
+
+    End r = n - 1
+
+Repeat:
+
+    If numbers[l] + numbers[r] == target → return [l+1, r+1]
+
+    If sum is greater → move right pointer left
+
+    If sum is less → move left pointer right
 
 Time Complexity: O(n)
-Space complexity: O(1)
+Only one pass through the array.
+
+Space Complexity: O(1)
+Only two pointers and result array of size 2.
+
+Example / Dry Run:
+
+Input: [2, 7, 11, 15], target = 9
+Steps:
+
+    l = 0, r = 3 → 2 + 15 = 17 → too big → r--
+
+    l = 0, r = 2 → 2 + 11 = 13 → still big → r--
+
+    l = 0, r = 1 → 2 + 7 = 9 → match!
+    Output: [1, 2]
+
+### 3️⃣ Best / Final Optimized Approach (Same as above)
+
+Since the optimized two-pointer approach is already the most efficient for this problem, no further optimization is needed.
+
+### 📊 Complexity Analysis
+
+| Approach      | Time Complexity | Space Complexity |
+| ------------- | --------------- | ---------------- |
+| Brute Force   | O(n²)           | O(1)             |
+| Optimized     | O(n)            | O(1)             |
+| Best Approach | O(n)            | O(1)             |
+
+### 📉 Optimization Ideas
+
+    You can’t use hashing effectively here since the input is sorted, and space must be O(1).
+
+    No need to explore binary search as two-pointer provides linear time with constant space.
+
+### 📌 Example Walkthroughs & Dry Runs
+
+Example 1:
+
+Input: [2, 7, 11, 15], target = 9
 
-### Example
-Numbers = [2, 7, 11, 15], target = 9
+Initial pointers:
+l = 0 → 2
+r = 3 → 15
 
-The working :
+Step 1: 2 + 15 = 17 → too big → r = 2
+Step 2: 2 + 11 = 13 → still big → r = 1
+Step 3: 2 + 7 = 9 → match found → return [1, 2]
 
-l = 0, r = 3 → 2 + 15 = 17 → sum larger than target, reduce right pointer
+### 🔗 Additional Resources
 
-l = 0, r = 2 → 2 + 11 = 13 → sum larger than target, reduce right pointer
+- [Understanding Two Pointer Technique - GeeksForGeeks](https://www.geeksforgeeks.org/two-pointers-technique/)
 
-l = 0, r = 1 → 2 + 7 = 9 → sum equal → return [1, 2]
 
-Output: [1, 2]
+Author: hanzel-sc
+Date: 07/07/2025