Day 3 - MoveZeroes & TwoSumII complete

Author: OmnicWolf

src/main/java/io/coffeelessprogrammer/leetcode/twopointers/MoveZeroes.java

@@ -0,0 +1,66 @@
+package io.coffeelessprogrammer.leetcode.twopointers;
+
+/*
+ * Problem: 283. Move Zeroes
+ * Difficulty: Easy
+ * Acceptance Rate: 60.8%
+ * URL: https://leetcode.com/problems/move-zeroes/
+ *
+ * Runtime: 2 ms, faster than 76.96% of Java online submissions for Move Zeroes.
+ * Memory Usage: 43.8 MB, less than 85.98% of Java online submissions for Move Zeroes.
+ */
+public class MoveZeroes {
+
+    public void bubble(int[] nums) {
+        if(nums.length < 2) return;
+
+        int leftmostZero=nextZeroIndex(nums, 0);
+        if(leftmostZero == -1) return;  // Array has no zeroes
+
+        int leftmostNumber = nextNonZeroIndex(nums, leftmostZero+1);
+
+        while(leftmostNumber > -1) {
+            nums[leftmostZero] = nums[leftmostNumber];
+            nums[leftmostNumber] = 0;
+
+            leftmostZero = nextZeroIndex(nums, leftmostZero+1);
+            leftmostNumber = nextNonZeroIndex(nums, leftmostNumber+1);
+        }
+    }
+
+    private static int nextZeroIndex(int[] nums, final int startFrom) {
+        for(int i=startFrom; i<nums.length; ++i) {
+            if(nums[i]==0) return i;
+        }
+
+        return -1;
+    }
+
+    private static int nextNonZeroIndex(int[] nums, final int startFrom) {
+        for(int i=startFrom; i<nums.length; ++i) {
+            if(nums[i]!=0) return i;
+        }
+
+        return -1;
+    }
+
+    //#region LeetcodeResearch
+
+    public void moveZeroes(int[] nums) {
+        int firstInsignificantIndex=0;
+
+        // Move all significant numbers left
+        for(int i=0; i<nums.length; ++i){
+            if(nums[i] != 0){
+                nums[firstInsignificantIndex] = nums[i];
+                ++firstInsignificantIndex;
+            }
+        }
+
+        // Fill remaining indices with 0
+        for(int j=firstInsignificantIndex; j<nums.length; ++j)
+            nums[j]=0;
+    }
+
+    //#endRegion
+}

src/main/java/io/coffeelessprogrammer/leetcode/twopointers/RotateArray1d.java

@@ -44,12 +44,37 @@ public void rotateInplace(int[] nums, int k) {
         else
             k = k%nums.length;
 
-        // System.out.println("Before: " + Arrays.toString(nums));
+        // Setup
+        final int lcm = BasicMath.leastCommonMultiple(nums.length, k);
+        final int cycleAfter = lcm/k;
+
+        // Rotate
+        int currentCycle = 0;
+
+        for(int position=0, j=0; j < nums.length; ++j) {
+            if(j/cycleAfter > currentCycle) {
+                ++currentCycle;
+                ++position;
+            }
+            position = (position+k) % nums.length;
+            Array.swapIndices(nums, currentCycle, position);
+        }
+    }
+
+    public void rotateInplaceVerbose(int[] nums, int k) {
+        // Sanitize input
+        if(k%nums.length==0)
+            return;
+        else
+            k = k%nums.length;
 
         // Setup
         final int lcm = BasicMath.leastCommonMultiple(nums.length, k);
         final int cycleAfter = lcm/k;
 
+        System.out.printf("k=%d, iterationsPerCycle=%d\n", k, cycleAfter);
+        System.out.printf("Before: %s\n\n", Arrays.toString(nums));
+
         // Rotate
         int currentCycle = 0;
 
@@ -58,13 +83,14 @@ public void rotateInplace(int[] nums, int k) {
                 ++currentCycle;
                 ++position;
             }
+            System.out.printf("iteration=%d, currentCycle=%d\n", j, currentCycle);
             position = (position+k) % nums.length;
-            // System.out.printf("\tSwapping:  nums[%d]=%d\tnums[%d]=%d\n", currentCycle, nums[currentCycle], position, nums[position]);
+            System.out.printf("\tSwapping:  nums[%d]=%d\tnums[%d]=%d\n", currentCycle, nums[currentCycle], position, nums[position]);
             Array.swapIndices(nums, currentCycle, position);
-            // System.out.printf("\tPost-swap: %s\n\n", Arrays.toString(nums));
+            System.out.printf("\tPost-swap: %s\n\n", Arrays.toString(nums));
         }
 
-        // System.out.println("After:  " + Arrays.toString(nums));
+         System.out.println("After:  " + Arrays.toString(nums));
     }
 
     //#region LeetcodeResearch

src/main/java/io/coffeelessprogrammer/leetcode/twopointers/TwoSumII.java

@@ -0,0 +1,30 @@
+package io.coffeelessprogrammer.leetcode.twopointers;
+
+/*
+ * Problem: 167. Two Sum II - Input Array Is Sorted
+ * Difficulty: Medium
+ * Acceptance Rate: 38.7%
+ * URL: https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/
+ *
+ * Runtime: 1 ms, faster than 99.24% of Java online submissions for Two Sum II - Input Array Is Sorted.
+ * Memory Usage: 49.9 MB, less than 55.19% of Java online submissions for Two Sum II - Input Array Is Sorted.
+ */
+public class TwoSumII {
+
+    public int[] twoSum(int[] nums, int target) {
+        int sum;
+
+        for(int i=0, j=nums.length-1; i < j; ) {
+            sum = nums[i] + nums[j];
+
+            if(sum == target)
+                return new int[]{i+1, j+1};
+            else if(sum > target)
+                --j;
+            else ++i;
+        }
+
+        return null;
+    }
+
+}

src/test/java/io/coffeelessprogrammer/leetcode/TwoPointersTests.java

@@ -1,5 +1,6 @@
 package io.coffeelessprogrammer.leetcode;
 
+import io.coffeelessprogrammer.leetcode.twopointers.MoveZeroes;
 import io.coffeelessprogrammer.leetcode.twopointers.RotateArray1d;
 import io.coffeelessprogrammer.leetcode.twopointers.SquaresOfSortedArray;
 import org.junit.jupiter.api.Test;
@@ -31,7 +32,7 @@ final void SortedSquares_Basic2() {
     private RotateArray1d rotateArray1d = new RotateArray1d();
 
     @Test
-    final void RotateArray1d() {
+    final void RotateArray1d_LinearSpace() {
         final int[] arr = {1,2,3,4,5,6,7};
 
         rotateArray1d.rotate(arr, 3);
@@ -40,30 +41,54 @@ final void RotateArray1d() {
     }
 
     @Test
-    final void RotateArray1d_2() {
+    final void RotateArray1d_Inplace() {
+        final int[] arr = {1,2,3,4,5,6,7};
+
+        rotateArray1d.rotateInplace(arr, 3);
+
+        assertArrayEquals(new int[]{5,6,7,1,2,3,4}, arr);
+    }
+
+    @Test
+    final void RotateArray1d_Inplace_1CycleOscillation() {
         final int[] arr = {-1,-100,3,99};
 
-        rotateArray1d.rotate(arr, 2);
+        rotateArray1d.rotateInplace(arr, 2);
 
         assertArrayEquals(new int[]{3,99,-1,-100}, arr);
     }
 
     @Test
-    final void RotateArray1d_Inplace1() {
-        final int[] arr = {1,2,3,4,5,6,7};
+    final void RotateArray1d_Inplace_2CycleOscillation() {
+        final int[] arr = {2,4,8,16,32,64};
 
-        rotateArray1d.rotateInplace(arr, 3);
+        rotateArray1d.rotateInplace(arr, 4);
 
-        assertArrayEquals(new int[]{5,6,7,1,2,3,4}, arr);
+        assertArrayEquals(new int[]{8,16,32,64,2,4}, arr);
     }
 
     @Test
-    final void RotateArray1d_Inplace2() {
-        final int[] arr = {-1,-100,3,99};
+    final void RotateArray1d_Inplace_2CycleOscillation_Verbose() {
+        final int[] arr = {2,4,8,16,32,64};
 
-        rotateArray1d.rotateInplace(arr, 2);
+        rotateArray1d.rotateInplaceVerbose(arr, 4);
 
-        assertArrayEquals(new int[]{3,99,-1,-100}, arr);
+        assertArrayEquals(new int[]{8,16,32,64,2,4}, arr);
+    }
+
+    //#endRegion
+
+    //#region MoveZeroes
+
+    private MoveZeroes moveZeroes = new MoveZeroes();
+
+    @Test
+    final void MoveZeroes_Inplace() {
+        final int[] arr = {0,1,0,3,12};
+
+        moveZeroes.bubble(arr);
+
+        assertArrayEquals(new int[]{1,3,12,0,0}, arr);
     }
 
     //#endRegion