Added 4 design questions

varunu28 · varunu28 · commit 1d4086c58938 · 2018-10-05T20:38:37.000-07:00
diff --git a/Medium/Design Log Storage System.java b/Medium/Design Log Storage System.java
@@ -0,0 +1,56 @@
+class LogSystem {
+
+    List<LogEntry> logEntries;
+    Map<String, Integer> granualityMap = new HashMap<>();
+    String[] grans = "Year:Month:Day:Hour:Minute:Second".split(":");
+    int[] gransIndex = {4,7,10,13,16,19};
+
+    public LogSystem() {
+        logEntries = new ArrayList<>();
+        for (int i=0; i<grans.length; i++) {
+            granualityMap.put(grans[i], gransIndex[i]);
+        }
+    }
+
+    public void put(int id, String timestamp) {
+        logEntries.add(new LogEntry(id, timestamp));
+    }
+
+    public List<Integer> retrieve(String s, String e, String gra) {
+        List<Integer> list = new ArrayList<>();
+        Iterator<LogEntry> logIterator = logEntries.iterator();
+        int substringEnd = granualityMap.get(gra);
+
+        String start = s.substring(0, substringEnd);
+        String end = e.substring(0, substringEnd);
+
+        while (logIterator.hasNext()) {
+            LogEntry entry = logIterator.next();
+            String entryTimeStamp = entry.timestamp;
+
+            if (entryTimeStamp.substring(0, substringEnd).compareTo(start) >= 0 &&
+                entryTimeStamp.substring(0, substringEnd).compareTo(end) <= 0) {
+                list.add(entry.id);
+            }
+        }
+
+        return list;
+    }
+}
+
+class LogEntry {
+    int id;
+    String timestamp;
+
+    public LogEntry(int id, String timestamp) {
+        this.id = id;
+        this.timestamp = timestamp;
+    }
+}
+
+/**
+ * Your LogSystem object will be instantiated and called as such:
+ * LogSystem obj = new LogSystem();
+ * obj.put(id,timestamp);
+ * List<Integer> param_2 = obj.retrieve(s,e,gra);
+ */
diff --git a/Medium/Flatten 2D Vector.java b/Medium/Flatten 2D Vector.java
@@ -0,0 +1,38 @@
+public class Vector2D implements Iterator<Integer> {
+    Iterator<List<Integer>> iterator;
+    Iterator<Integer> listIterator;
+
+    public Vector2D(List<List<Integer>> vec2d) {
+        if (vec2d == null || vec2d.isEmpty()) {
+            return;
+        }
+
+        iterator = vec2d.iterator();
+        listIterator = iterator.next().iterator();
+        checkForValidity();
+    }
+
+    private void checkForValidity() {
+        while (!listIterator.hasNext() && iterator.hasNext()) {
+            listIterator = iterator.next().iterator();
+        }
+    }
+
+    @Override
+    public Integer next() {
+        int num = listIterator.next();
+        checkForValidity();
+        return num;
+    }
+
+    @Override
+    public boolean hasNext() {
+        return listIterator != null && listIterator.hasNext();
+    }
+}
+
+/**
+ * Your Vector2D object will be instantiated and called as such:
+ * Vector2D i = new Vector2D(vec2d);
+ * while (i.hasNext()) v[f()] = i.next();
+ */
diff --git a/Medium/Flatten Nested List Iterator.java b/Medium/Flatten Nested List Iterator.java
@@ -0,0 +1,61 @@
+/**
+ * // This is the interface that allows for creating nested lists.
+ * // You should not implement it, or speculate about its implementation
+ * public interface NestedInteger {
+ *
+ *     // @return true if this NestedInteger holds a single integer, rather than a nested list.
+ *     public boolean isInteger();
+ *
+ *     // @return the single integer that this NestedInteger holds, if it holds a single integer
+ *     // Return null if this NestedInteger holds a nested list
+ *     public Integer getInteger();
+ *
+ *     // @return the nested list that this NestedInteger holds, if it holds a nested list
+ *     // Return null if this NestedInteger holds a single integer
+ *     public List<NestedInteger> getList();
+ * }
+ */
+public class NestedIterator implements Iterator<Integer> {
+    List<Integer> list;
+    int index;
+    int size;
+    public NestedIterator(List<NestedInteger> nestedList) {
+        list = new ArrayList<>();
+        index = 0;
+        for (NestedInteger n : nestedList) {
+            dfsHelper(n);
+        }
+        
+        size = list.size();
+    }
+    
+    private void dfsHelper(NestedInteger n) {
+        if (n.isInteger()) {
+            list.add(n.getInteger());
+        }
+        else {
+            for (NestedInteger ni : n.getList()) {
+                dfsHelper(ni);
+            }
+        }
+    }
+
+    @Override
+    public Integer next() {
+        if (index < size) {
+            return list.get(index++);
+        }
+        return -1;
+    }
+
+    @Override
+    public boolean hasNext() {
+        return !(index == size);        
+    }
+}
+
+/**
+ * Your NestedIterator object will be instantiated and called as such:
+ * NestedIterator i = new NestedIterator(nestedList);
+ * while (i.hasNext()) v[f()] = i.next();
+ */
diff --git a/Medium/Zigzag Iterator.java b/Medium/Zigzag Iterator.java
@@ -0,0 +1,54 @@
+public class ZigzagIterator {
+    
+    List<Integer> l1;
+    List<Integer> l2;
+    int start1;
+    int start2;
+    int end1;
+    int end2;
+    boolean flag;
+    
+    public ZigzagIterator(List<Integer> v1, List<Integer> v2) {
+        l1 = v1;
+        l2 = v2;
+        start1 = 0;
+        start2 = 0;
+        end1 = l1.size();
+        end2 = l2.size();
+        flag = true;
+    }
+
+    public int next() {
+        if (start1 < end1 && start2 < end2) {
+            int ans = -1;
+            if (flag) {
+                ans = l1.get(start1);
+                start1++;
+                flag = !flag;
+            }
+            else {
+                ans = l2.get(start2);
+                start2++;
+                flag = !flag;
+            }
+            
+            return ans;
+        }
+        else if (start1 < end1) {
+            return l1.get(start1++);
+        }
+        else {
+            return l2.get(start2++);
+        }
+    }
+
+    public boolean hasNext() {
+        return !(start1 == end1 && start2 == end2);
+    }
+}
+
+/**
+ * Your ZigzagIterator object will be instantiated and called as such:
+ * ZigzagIterator i = new ZigzagIterator(v1, v2);
+ * while (i.hasNext()) v[f()] = i.next();
+ */
