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