Added 4 design solutions

varunu28 · varunu28 · commit 708e5421b5ba · 2018-10-02T16:24:53.000-07:00
diff --git a/Easy/Design Compressed String Iterator.java b/Easy/Design Compressed String Iterator.java
@@ -0,0 +1,64 @@
+class StringIterator {
+    int letterPointer = 0;
+    int numberPointer = letterPointer + 1;
+    int counter;
+    char c;
+    String s;
+    StringBuilder num;
+
+    public StringIterator(String compressedString) {
+        s = compressedString;
+        c = s.charAt(letterPointer);
+        
+        num = new StringBuilder();
+        while (numberPointer<s.length() && Character.isDigit(s.charAt(numberPointer))) {
+            num.append(s.charAt(numberPointer));
+            numberPointer++;
+        }
+        counter = Integer.parseInt(num.toString());
+
+        letterPointer = numberPointer;
+        numberPointer = letterPointer + 1;
+    }
+
+    public char next() {
+        if (counter == 0) {
+            if (numberPointer <= s.length()-1) {
+                c = s.charAt(letterPointer);
+                num = new StringBuilder();
+                while (numberPointer<s.length() && Character.isDigit(s.charAt(numberPointer))) {
+                    num.append(s.charAt(numberPointer));
+                    numberPointer++;
+                }
+                counter = Integer.parseInt(num.toString()) - 1;
+
+                letterPointer = numberPointer;
+                numberPointer = letterPointer + 1;
+            }
+            else {
+                c = ' ';
+            }
+        }
+        else {
+            counter--;
+        }
+
+        return c;
+    }
+
+    public boolean hasNext() {
+        if (counter == 0) {
+            if (numberPointer > s.length()-1) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+/**
+ * Your StringIterator object will be instantiated and called as such:
+ * StringIterator obj = new StringIterator(compressedString);
+ * char param_1 = obj.next();
+ * boolean param_2 = obj.hasNext();
+ */
diff --git a/Easy/Two Sum III - Data Structure Design.java b/Easy/Two Sum III - Data Structure Design.java
@@ -0,0 +1,44 @@
+class TwoSum {
+
+    /** Initialize your data structure here. */
+    List<Integer> list;
+    Map<Integer, Integer> map;
+    public TwoSum() {
+        list = new ArrayList<>();
+        map = new HashMap<>();
+    }
+    
+    /** Add the number to an internal data structure.. */
+    public void add(int number) {
+        if (map.containsKey(number)) {
+            map.put(number, map.get(number) + 1);
+        }
+        else {
+            map.put(number, 1);
+            list.add(number);
+        }
+    }
+    
+    /** Find if there exists any pair of numbers which sum is equal to the value. */
+    public boolean find(int value) {
+        for (int num : list) {
+            int diff = value - num;
+            if (diff != num && map.containsKey(diff)) {
+                return true;
+            }
+            
+            if (diff == num && map.get(diff) > 1) {
+                return true;
+            }
+        }
+        
+        return false;
+    }
+}
+
+/**
+ * Your TwoSum object will be instantiated and called as such:
+ * TwoSum obj = new TwoSum();
+ * obj.add(number);
+ * boolean param_2 = obj.find(value);
+ */
diff --git a/Medium/Plus One Linked List.java b/Medium/Plus One Linked List.java
@@ -0,0 +1,54 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode plusOne(ListNode head) {
+        ListNode rev = reverse(head);
+        ListNode prev = null;
+        int carry = 1;
+        ListNode curr = rev;
+        while (curr != null) {
+            int temp = curr.val + carry;
+            if (temp > 9) {
+                carry = 1;
+                temp = temp - 10;
+            }
+            else {
+                carry = 0;
+            }
+            
+            prev = curr;
+            
+            curr.val = temp;
+            curr = curr.next;
+        }
+        
+        if (carry != 0) {
+            prev.next = new ListNode(carry);
+        }
+        
+        ListNode ans = reverse(rev);
+        
+        return ans;
+    }
+    
+    private ListNode reverse(ListNode node) {
+        ListNode curr = node;
+        ListNode prev = null;
+        ListNode next = null;
+        
+        while (curr != null) {
+            next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+        
+        return prev;
+    }
+}
diff --git a/Medium/Unique Word Abbrevation.java b/Medium/Unique Word Abbrevation.java
@@ -0,0 +1,43 @@
+class ValidWordAbbr {
+
+    Map<String, String> map;
+    public ValidWordAbbr(String[] dictionary) {
+        map = new HashMap<>();
+
+        for (String word : dictionary) {
+            String abbr = getAbbr(word);
+            if (map.containsKey(abbr)) {
+                if (!map.get(abbr).equals(word)) {
+                    map.put(abbr, "");
+                }
+            }
+            else {
+                map.put(abbr, word);
+            }
+        }
+    }
+
+    public boolean isUnique(String word) {
+        String abbr = getAbbr(word);
+        return !map.containsKey(abbr) || map.get(abbr).equals(word);
+    }
+
+    private String getAbbr(String word) {
+        if (word.length() <= 2) {
+            return word;
+        }
+
+        int num = word.length() - 2;
+        StringBuilder sb = new StringBuilder();
+        sb.append(word.charAt(0)).append(String.valueOf(num)).append(word.charAt(word.length()-1));
+
+        return sb.toString();
+    }
+}
+
+
+/**
+ * Your ValidWordAbbr object will be instantiated and called as such:
+ * ValidWordAbbr obj = new ValidWordAbbr(dictionary);
+ * boolean param_1 = obj.isUnique(word);
+ */
