281 (1) first try

stevencooks · stevencooks · commit 6a78bd85ab8b · 2015-10-02T10:19:13.000-04:00
diff --git a/src/_281_ZigzagIterator/Practice.java b/src/_281_ZigzagIterator/Practice.java
@@ -0,0 +1,50 @@
+/**
+ ***************************************************************************
+ * Description:
+ * 
+ * Given two 1d vectors, implement an iterator to return their elements alternately. 
+ * 
+ * For example, given two 1d vectors: 
+ *  v1 = [1, 2] 
+ *  v2 = [3, 4, 5, 6] 
+ * By calling next repeatedly until hasNext returns false, the order of elements 
+ * returned by next should be: [1, 3, 2, 4, 5, 6]. 
+ * 
+ * Follow up: What if you are given k 1d vectors? 
+ * How well can your code be extended to such cases? 
+ * 
+ * Clarification for the follow up question - Update (2015-09-18): 
+ * The "Zigzag" order is not clearly defined and is ambiguous for k > 2 cases. 
+ * If "Zigzag" does not look right to you, replace "Zigzag" with "Cyclic". 
+ * For example, given the following input: 
+ * 
+ *  [1,2,3] 
+ *  [4,5,6,7] 
+ *  [8,9] 
+ * 
+ * It should return [1,4,8,2,5,9,3,6,7].
+ *
+ ***************************************************************************
+ * @tag : Design
+ * {@link https://leetcode.com/problems/zigzag-iterator/ }
+ */
+package _281_ZigzagIterator;
+
+import java.util.List;
+
+/** see test {@link _281_ZigzagIterator.PracticeTest } */
+public class Practice {
+    
+    
+    public Practice(List<Integer> v1, List<Integer> v2) {
+    }
+
+    public int next() {
+        return 0;
+    }
+
+    public boolean hasNext() {
+        return false;
+    }
+
+}
diff --git a/src/_281_ZigzagIterator/Solution.java b/src/_281_ZigzagIterator/Solution.java
@@ -0,0 +1,70 @@
+/**
+ * Time : O() ; Space: O()
+ * @tag : Design
+ * @by  : Steven Cooks
+ * @date: Oct 2, 2015
+ ***************************************************************************
+ * Description:
+ * 
+ * Given two 1d vectors, implement an iterator to return their elements alternately. 
+ * 
+ * For example, given two 1d vectors: 
+ *  v1 = [1, 2] 
+ *  v2 = [3, 4, 5, 6] 
+ * By calling next repeatedly until hasNext returns false, the order of elements 
+ * returned by next should be: [1, 3, 2, 4, 5, 6]. 
+ * 
+ * Follow up: What if you are given k 1d vectors? 
+ * How well can your code be extended to such cases? 
+ * 
+ * Clarification for the follow up question - Update (2015-09-18): 
+ * The "Zigzag" order is not clearly defined and is ambiguous for k > 2 cases. 
+ * If "Zigzag" does not look right to you, replace "Zigzag" with "Cyclic". 
+ * For example, given the following input: 
+ * 
+ *  [1,2,3] 
+ *  [4,5,6,7] 
+ *  [8,9] 
+ * 
+ * It should return [1,4,8,2,5,9,3,6,7].
+ *
+ ***************************************************************************
+ * {@link https://leetcode.com/problems/zigzag-iterator/ }
+ */
+package _281_ZigzagIterator;
+
+import java.util.Iterator;
+import java.util.List;
+
+/** see test {@link _281_ZigzagIterator.SolutionTest } */
+public class Solution {
+    
+    Iterator<Integer> i1;
+    
+    Iterator<Integer> i2;
+    
+    Iterator<Integer> cur;
+    
+    public Solution(List<Integer> v1, List<Integer> v2) {
+        i1 = v1.iterator();
+        i2 = v2.iterator();
+        cur = i1;
+    }
+
+    public int next() {
+        int next = -1;
+        if (cur == i1) {
+            next = i1.hasNext() ? i1.next() : i2.next();
+            cur = i2;
+        } else {
+            next = i2.hasNext() ? i2.next() : i1.next();
+            cur = i1;
+        }
+        return next;
+    }
+
+    public boolean hasNext() {
+        return i1.hasNext() || i2.hasNext();
+    }
+
+}
diff --git a/test/_281_ZigzagIterator/PracticeTest.java b/test/_281_ZigzagIterator/PracticeTest.java
@@ -0,0 +1,73 @@
+package _281_ZigzagIterator;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.Timeout;
+
+public class PracticeTest {
+    
+    /** Test method for {@link _281_ZigzagIterator.Practice } */
+    Practice solution;
+
+    @Rule
+    public Timeout globalTimeout = new Timeout(200);
+
+    @Test
+    public void Test1() {
+        List<Integer> v1 = Arrays.asList(1, 2);
+        List<Integer> v2 = Arrays.asList(3, 4, 5, 6);
+        Practice i = new Practice(v1, v2);
+        List<Integer> actual = new ArrayList<>();
+        while (i.hasNext()) {
+            actual.add(i.next());
+        }
+        List<Integer> expected = Arrays.asList(1, 3, 2, 4, 5, 6);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void Test2() {
+        List<Integer> v1 = Arrays.asList(1, 2);
+        List<Integer> v2 = Arrays.asList(3);
+        Practice i = new Practice(v1, v2);
+        List<Integer> actual = new ArrayList<>();
+        while (i.hasNext()) {
+            actual.add(i.next());
+        }
+        List<Integer> expected = Arrays.asList(1, 3, 2);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void Test3() {
+        List<Integer> v1 = Arrays.asList();
+        List<Integer> v2 = Arrays.asList(3, 5);
+        Practice i = new Practice(v1, v2);
+        List<Integer> actual = new ArrayList<>();
+        while (i.hasNext()) {
+            actual.add(i.next());
+        }
+        List<Integer> expected = Arrays.asList(3, 5);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void Test4() {
+        List<Integer> v1 = Arrays.asList(4);
+        List<Integer> v2 = Arrays.asList();
+        Practice i = new Practice(v1, v2);
+        List<Integer> actual = new ArrayList<>();
+        while (i.hasNext()) {
+            actual.add(i.next());
+        }
+        List<Integer> expected = Arrays.asList(4);
+        assertEquals(expected, actual);
+    }
+
+}
diff --git a/test/_281_ZigzagIterator/SolutionTest.java b/test/_281_ZigzagIterator/SolutionTest.java
@@ -0,0 +1,73 @@
+package _281_ZigzagIterator;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.Timeout;
+
+public class SolutionTest {
+    
+    /** Test method for {@link _281_ZigzagIterator.Solution } */
+    Solution solution;
+
+    @Rule
+    public Timeout globalTimeout = new Timeout(200);
+
+    @Test
+    public void Test1() {
+        List<Integer> v1 = Arrays.asList(1, 2);
+        List<Integer> v2 = Arrays.asList(3, 4, 5, 6);
+        Solution i = new Solution(v1, v2);
+        List<Integer> actual = new ArrayList<>();
+        while (i.hasNext()) {
+            actual.add(i.next());
+        }
+        List<Integer> expected = Arrays.asList(1, 3, 2, 4, 5, 6);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void Test2() {
+        List<Integer> v1 = Arrays.asList(1, 2);
+        List<Integer> v2 = Arrays.asList(3);
+        Solution i = new Solution(v1, v2);
+        List<Integer> actual = new ArrayList<>();
+        while (i.hasNext()) {
+            actual.add(i.next());
+        }
+        List<Integer> expected = Arrays.asList(1, 3, 2);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void Test3() {
+        List<Integer> v1 = Arrays.asList();
+        List<Integer> v2 = Arrays.asList(3, 5);
+        Solution i = new Solution(v1, v2);
+        List<Integer> actual = new ArrayList<>();
+        while (i.hasNext()) {
+            actual.add(i.next());
+        }
+        List<Integer> expected = Arrays.asList(3, 5);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void Test4() {
+        List<Integer> v1 = Arrays.asList(4);
+        List<Integer> v2 = Arrays.asList();
+        Solution i = new Solution(v1, v2);
+        List<Integer> actual = new ArrayList<>();
+        while (i.hasNext()) {
+            actual.add(i.next());
+        }
+        List<Integer> expected = Arrays.asList(4);
+        assertEquals(expected, actual);
+    }
+
+}
