add two pointers pattern

Author: ashishps1

patterns/c#/TwoPointers.cs

@@ -0,0 +1,59 @@
+using System;
+
+public class TwoPointers {
+    // Move Zeroes using Two Pointers
+    public void MoveZeroesTwoPointers(int[] nums) {
+        int left = 0; // Pointer for placing non-zero elements
+
+        // Iterate with right pointer
+        for (int right = 0; right < nums.Length; right++) {
+            if (nums[right] != 0) {
+                // Swap elements if right pointer finds a non-zero
+                (nums[left], nums[right]) = (nums[right], nums[left]);
+                left++; // Move left pointer forward
+            }
+        }
+    }
+
+    // Brute Force approach for Container with Most Water
+    public int MaxAreaBruteForce(int[] height) {
+        int n = height.Length;
+        int maxArea = 0;
+
+        // Check all pairs (i, j)
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                // Compute the minimum height and width
+                int minHeight = Math.Min(height[i], height[j]);
+                int width = j - i;
+                int area = minHeight * width; // Compute water contained
+
+                maxArea = Math.Max(maxArea, area); // Update max water
+            }
+        }
+        return maxArea;
+    }
+
+    // Two Pointers approach for Container with Most Water
+    public int MaxAreaTwoPointers(int[] height) {
+        int left = 0, right = height.Length - 1;
+        int maxArea = 0;
+
+        // Move pointers toward each other
+        while (left < right) {
+            int width = right - left; // Distance between lines
+            int minHeight = Math.Min(height[left], height[right]); // Compute height
+            int area = minHeight * width; // Compute water contained
+
+            maxArea = Math.Max(maxArea, area); // Update max water
+
+            // Move the pointer pointing to the shorter height
+            if (height[left] < height[right]) {
+                left++; // Move left pointer forward
+            } else {
+                right--; // Move right pointer backward
+            }
+        }
+        return maxArea;
+    }
+}

patterns/c++/TwoPointers.cpp

@@ -0,0 +1,64 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+class TwoPointers {
+public:
+    // Move Zeroes using Two Pointers
+    void moveZeroesTwoPointers(vector<int>& nums) {
+        int left = 0; // Pointer for placing non-zero elements
+
+        // Iterate with right pointer
+        for (int right = 0; right < nums.size(); right++) {
+            if (nums[right] != 0) {
+                // Swap elements if right pointer finds a non-zero
+                swap(nums[left], nums[right]);
+                left++; // Move left pointer forward
+            }
+        }
+    }
+
+    // Brute Force approach for Container with Most Water
+    int maxAreaBruteForce(vector<int>& height) {
+        int n = height.size();
+        int maxArea = 0;
+
+        // Check all pairs (i, j)
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                // Compute the minimum height and width
+                int minHeight = min(height[i], height[j]);
+                int width = j - i;
+                int area = minHeight * width; // Compute water contained
+
+                maxArea = max(maxArea, area); // Update max water
+            }
+        }
+        return maxArea;
+    }
+
+    // Two Pointers approach for Container with Most Water
+    int maxAreaTwoPointers(vector<int>& height) {
+        int left = 0, right = height.size() - 1;
+        int maxArea = 0;
+
+        // Move pointers toward each other
+        while (left < right) {
+            int width = right - left; // Distance between lines
+            int minHeight = min(height[left], height[right]); // Compute height
+            int area = minHeight * width; // Compute water contained
+
+            maxArea = max(maxArea, area); // Update max water
+
+            // Move the pointer pointing to the shorter height
+            if (height[left] < height[right]) {
+                left++; // Move left pointer forward
+            } else {
+                right--; // Move right pointer backward
+            }
+        }
+        return maxArea;
+    }
+};

patterns/go/two_pointers.go

@@ -0,0 +1,69 @@
+package main
+
+// Move Zeroes using Two Pointers
+func moveZeroesTwoPointers(nums []int) {
+	left := 0 // Pointer for placing non-zero elements
+
+	// Iterate with right pointer
+	for right := 0; right < len(nums); right++ {
+		if nums[right] != 0 {
+			// Swap elements if right pointer finds a non-zero
+			nums[left], nums[right] = nums[right], nums[left]
+			left++ // Move left pointer forward
+		}
+	}
+}
+
+// Brute Force approach for Container with Most Water
+func maxAreaBruteForce(height []int) int {
+	n := len(height)
+	maxArea := 0
+
+	// Check all pairs (i, j)
+	for i := 0; i < n; i++ {
+		for j := i + 1; j < n; j++ {
+			// Compute the minimum height and width
+			minHeight := min(height[i], height[j])
+			width := j - i
+			area := minHeight * width // Compute water contained
+
+			if area > maxArea {
+				maxArea = area // Update max water
+			}
+		}
+	}
+	return maxArea
+}
+
+// Two Pointers approach for Container with Most Water
+func maxAreaTwoPointers(height []int) int {
+	left, right := 0, len(height)-1
+	maxArea := 0
+
+	// Move pointers toward each other
+	for left < right {
+		width := right - left                         // Distance between lines
+		minHeight := min(height[left], height[right]) // Compute height
+		area := minHeight * width                     // Compute water contained
+
+		if area > maxArea {
+			maxArea = area // Update max water
+		}
+
+		// Move the pointer pointing to the shorter height
+		if height[left] < height[right] {
+			left++ // Move left pointer forward
+		} else {
+			right-- // Move right pointer backward
+		}
+	}
+	return maxArea
+}
+
+// Helper function to return the minimum of two integers
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

patterns/java/TwoPointers.java

@@ -0,0 +1,59 @@
+package patterns.java;
+
+public class TwoPointers {
+
+    public void moveZeroesTwoPointers(int[] nums) {
+        int left = 0; // Pointer for placing non-zero elements
+
+        // Iterate with right pointer
+        for (int right = 0; right < nums.length; right++) {
+            if (nums[right] != 0) {
+                // Swap elements if right pointer finds a non-zero
+                int temp = nums[left];
+                nums[left] = nums[right];
+                nums[right] = temp;
+                left++; // Move left pointer forward
+            }
+        }
+    }
+
+    public int maxAreaBruteForce(int[] height) {
+        int n = height.length;
+        int maxArea = 0;
+
+        // Check all pairs (i, j)
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                // Height of the container
+                int minHeight = Math.min(height[i], height[j]);
+                int width = j - i; // Distance between lines
+                int area = minHeight * width; // Compute water contained
+
+                maxArea = Math.max(maxArea, area); // Update max water
+            }
+        }
+        return maxArea;
+    }
+
+    public int maxAreaTwoPointers(int[] height) {
+        int left = 0, right = height.length - 1;
+        int maxArea = 0;
+
+        // Move pointers toward each other
+        while (left <= right) {
+            int width = right - left; // Distance between lines
+            int minHeight = Math.min(height[left], height[right]);
+            int area = minHeight * width; // Compute water contained
+
+            maxArea = Math.max(maxArea, area); // Update max water
+
+            // Move the pointer pointing to the shorter height
+            if (height[left] < height[right]) {
+                left++; // Move left pointer forward
+            } else {
+                right--; // Move right pointer backward
+            }
+        }
+        return maxArea;
+    }    
+}

patterns/javascript/twoPointers.js

@@ -0,0 +1,68 @@
+class TwoPointers {
+    /**
+     * Move Zeroes using Two Pointers
+     * @param {number[]} nums - Input array
+     */
+    moveZeroesTwoPointers(nums) {
+        let left = 0; // Pointer for placing non-zero elements
+
+        // Iterate with right pointer
+        for (let right = 0; right < nums.length; right++) {
+            if (nums[right] !== 0) {
+                // Swap elements if right pointer finds a non-zero
+                [nums[left], nums[right]] = [nums[right], nums[left]];
+                left++; // Move left pointer forward
+            }
+        }
+    }
+
+    /**
+     * Brute Force approach for Container with Most Water
+     * @param {number[]} height - Array of heights
+     * @return {number} - Maximum water that can be contained
+     */
+    maxAreaBruteForce(height) {
+        let maxArea = 0;
+        let n = height.length;
+
+        // Check all pairs (i, j)
+        for (let i = 0; i < n; i++) {
+            for (let j = i + 1; j < n; j++) {
+                // Compute the minimum height and width
+                let minHeight = Math.min(height[i], height[j]);
+                let width = j - i;
+                let area = minHeight * width; // Compute water contained
+
+                maxArea = Math.max(maxArea, area); // Update max water
+            }
+        }
+        return maxArea;
+    }
+
+    /**
+     * Two Pointers approach for Container with Most Water
+     * @param {number[]} height - Array of heights
+     * @return {number} - Maximum water that can be contained
+     */
+    maxAreaTwoPointers(height) {
+        let left = 0, right = height.length - 1;
+        let maxArea = 0;
+
+        // Move pointers toward each other
+        while (left < right) {
+            let width = right - left; // Distance between lines
+            let minHeight = Math.min(height[left], height[right]); // Compute height
+            let area = minHeight * width; // Compute water contained
+
+            maxArea = Math.max(maxArea, area); // Update max water
+
+            // Move the pointer pointing to the shorter height
+            if (height[left] < height[right]) {
+                left++; // Move left pointer forward
+            } else {
+                right--; // Move right pointer backward
+            }
+        }
+        return maxArea;
+    }
+}

patterns/python/two_pointers.py

@@ -0,0 +1,48 @@
+class TwoPointers:
+    # Move Zeroes using Two Pointers
+    def move_zeroes_two_pointers(self, nums):
+        left = 0  # Pointer for placing non-zero elements
+
+        # Iterate with right pointer
+        for right in range(len(nums)):
+            if nums[right] != 0:
+                # Swap elements if right pointer finds a non-zero
+                nums[left], nums[right] = nums[right], nums[left]
+                left += 1  # Move left pointer forward
+
+    # Brute Force approach for Container with Most Water
+    def max_area_brute_force(self, height):
+        n = len(height)
+        max_area = 0
+
+        # Check all pairs (i, j)
+        for i in range(n):
+            for j in range(i + 1, n):
+                # Compute the minimum height and width
+                min_height = min(height[i], height[j])
+                width = j - i
+                area = min_height * width  # Compute water contained
+
+                max_area = max(max_area, area)  # Update max water
+        return max_area
+
+    # Two Pointers approach for Container with Most Water
+    def max_area_two_pointers(self, height):
+        left, right = 0, len(height) - 1
+        max_area = 0
+
+        # Move pointers toward each other
+        while left < right:
+            width = right - left  # Distance between lines
+            min_height = min(height[left], height[right])  # Compute height
+            area = min_height * width  # Compute water contained
+
+            max_area = max(max_area, area)  # Update max water
+
+            # Move the pointer pointing to the shorter height
+            if height[left] < height[right]:
+                left += 1  # Move left pointer forward
+            else:
+                right -= 1  # Move right pointer backward
+
+        return max_area