Added problems in Two-Pointer

Author: Prashant Jain

src/in/knowledgegate/dsa/twopointer/ContainerWithMostWater.java

@@ -0,0 +1,62 @@
+package in.knowledgegate.dsa.twopointer;
+
+/**
+ * You are given an integer array height of length n.
+ * There are n vertical lines drawn such that
+ * the two endpoints of the ith line are (i, 0)
+ * and (i, height[i]).
+ *
+ * Find two lines that together with the x-axis form
+ * a container, such that the container contains
+ * the most water.
+ *
+ * Return the maximum amount of water a container
+ * can store.
+ *
+ * Notice that you may not slant the container.
+ *
+ * Example 1:
+ * Input: height = [1,8,6,2,5,4,8,3,7]
+ * Output: 49
+ * Explanation: The above vertical lines are
+ * represented by array [1,8,6,2,5,4,8,3,7]. In this case,
+ * the max area of water the container can contain is 49.
+ *
+ * Example 2:
+ * Input: height = [1,1]
+ * Output: 1
+ *
+ *
+ * Constraints:
+ * n == height.length
+ * 2 <= n <= 105
+ * 0 <= height[i] <= 104
+ */
+public class ContainerWithMostWater {
+    public static void main(String[] args) {
+        ContainerWithMostWater water =
+            new ContainerWithMostWater();
+        int[] height = new int[]{1,8,6,2,5,4,8,3,7};
+        System.out.println("Output is:" + water.maxArea(height));
+    }
+
+    public int maxArea(int[] height) {
+        int maxArea = 0;
+        int left = 0, right = height.length - 1;
+        while (left < right) {
+            int minHeight = Math.min(height[left],
+                    height[right]);
+            int currArea =
+                minHeight * (right - left);
+            maxArea = Math.max(maxArea, currArea);
+
+            if (height[left] < height[right]) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+
+        return maxArea;
+    }
+}

src/in/knowledgegate/dsa/twopointer/MoveZeros.java

@@ -0,0 +1,42 @@
+package in.knowledgegate.dsa.twopointer;
+
+import java.util.Arrays;
+
+/**
+ * Given an integer array nums, move all 0's to the
+ * end of it while maintaining the relative order
+ * of the non-zero elements.
+ *
+ * Note that you must do this in-place without making
+ * a copy of the array.
+ *
+ * Example 1:
+ * Input: nums = [0,1,0,3,12]
+ * Output: [1,3,12,0,0]
+ *
+ * Example 2:
+ * Input: nums = [0]
+ * Output: [0]
+ *
+ * Constraints:
+ * 1 <= nums.length <= 104
+ * -231 <= nums[i] <= 231 - 1
+ */
+public class MoveZeros {
+    public static void main(String[] args) {
+        MoveZeros zeros = new MoveZeros();
+        int[] nums = new int[]{0,1,0,3,12};
+        zeros.moveZeroes(nums);
+        System.out.println("Output is:" + Arrays.toString(nums));
+    }
+
+    public void moveZeroes(int[] nums) {
+        int prev = 0;
+        for (int i = 0 ; i < nums.length; i++) {
+            if (nums[i] != 0) {
+                nums[prev++] = nums[i];
+                nums[i] = 0;
+            }
+        }
+    }
+}