[N-0] add 457

Author: fishercoder1534

README.md

@@ -230,6 +230,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |460|[LFU Cache](https://leetcode.com/problems/lfu-cache/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_460.java) | O(1) |O(n) | Hard| Design, LinkedHashMap, HashMap
 |459|[Repeated Substring Pattern](https://leetcode.com/problems/repeated-substring-pattern/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_459.java)| O(n)|O(n) | Easy| String, KMP
 |458|[Poor Pigs](https://leetcode.com/problems/poor-pigs/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_458.java) | O(1) |O(1) | Easy| Math
+|457|[Circular Array Loop](https://leetcode.com/problems/circular-array-loop/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_457.java) | O(n) |O(1) | Medium |
 |456|[132 Pattern](https://leetcode.com/problems/132-pattern/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_456.java) | O(n) |O(n) | Medium| Stack
 |455|[Assign Cookies](https://leetcode.com/problems/assign-cookies/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_455.java)| O(n)|O(1) | Easy|
 |454|[4Sum II](https://leetcode.com/problems/4sum-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_454.java) | O(n) |O(n) | Medium| HashMap

src/main/java/com/fishercoder/solutions/_457.java

@@ -0,0 +1,63 @@
+package com.fishercoder.solutions;
+
+/**
+ * 457. Circular Array Loop
+ *
+ * You are given an array of positive and negative integers.
+ * If a number n at an index is positive, then move forward n steps.
+ * Conversely, if it's negative (-n), move backward n steps.
+ *
+ * Assume the first element of the array is forward next to the last element,
+ * and the last element is backward next to the first element.
+ * Determine if there is a loop in this array.
+ * A loop starts and ends at a particular index with more than 1 element along the loop. The loop must be "forward" or "backward'.
+ *
+ * Example 1: Given the array [2, -1, 1, 2, 2], there is a loop, from index 0 -> 2 -> 3 -> 0.
+ * Example 2: Given the array [-1, 2], there is no loop.
+ *
+ * Note: The given array is guaranteed to contain no element "0".
+ *
+ * Can you do it in O(n) time complexity and O(1) space complexity?
+ */
+public class _457 {
+    public static class Solution1 {
+        /**
+         * credit: https://discuss.leetcode.com/topic/66894/java-slow-fast-pointer-solution
+         */
+        public boolean circularArrayLoop(int[] nums) {
+            int n = nums.length;
+            for (int i = 0; i < n; i++) {
+                if (nums[i] == 0) {
+                    continue;
+                }
+                // slow/fast pointer
+                int j = i, k = getIndex(i, nums);
+                while (nums[k] * nums[i] > 0 && nums[getIndex(k, nums)] * nums[i] > 0) {
+                    if (j == k) {
+                        // check for loop with only one element
+                        if (j == getIndex(j, nums)) {
+                            break;
+                        }
+                        return true;
+                    }
+                    j = getIndex(j, nums);
+                    k = getIndex(getIndex(k, nums), nums);
+                }
+                // loop not found, set all element along the way to 0
+                j = i;
+                int val = nums[i];
+                while (nums[j] * val > 0) {
+                    int next = getIndex(j, nums);
+                    nums[j] = 0;
+                    j = next;
+                }
+            }
+            return false;
+        }
+
+        public int getIndex(int i, int[] nums) {
+            int n = nums.length;
+            return i + nums[i] >= 0 ? (i + nums[i]) % n : n + ((i + nums[i]) % n);
+        }
+    }
+}

src/test/java/com/fishercoder/_457Test.java

@@ -0,0 +1,42 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._457;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _457Test {
+    private static _457.Solution1 solution1;
+    private static int[] nums;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _457.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        nums = new int[]{2, -1, 1, 2, 2};
+        assertEquals(true, solution1.circularArrayLoop(nums));
+    }
+
+    @Test
+    public void test2() {
+        nums = new int[]{-1, 2};
+        assertEquals(false, solution1.circularArrayLoop(nums));
+    }
+
+    @Test
+    public void test3() {
+        nums = new int[]{-1, 2, 3};
+        assertEquals(false, solution1.circularArrayLoop(nums));
+    }
+
+    @Test
+    public void test4() {
+        nums = new int[]{2, 1, 9};
+        assertEquals(false, solution1.circularArrayLoop(nums));
+    }
+
+}