Added 4 solutions

varunu28 · varunu28 · commit d333b34b35fd · 2018-09-22T10:55:04.000-07:00
diff --git a/Easy/Fair Candy Swap.java b/Easy/Fair Candy Swap.java
@@ -0,0 +1,30 @@
+class Solution {
+    public int[] fairCandySwap(int[] A, int[] B) {
+        int sumA = 0;
+        int sumB = 0;
+        
+        Set<Integer> set = new HashSet<>();
+        
+        for (int num : A) {
+            sumA += num;
+            set.add(num);
+        }
+        
+        for (int num : B) {
+            sumB += num;
+        }
+        
+        int diff = (sumA - sumB)/2;
+        
+        int[] ans = new int[2];
+        for (int num : B) {
+            if (set.contains(num + diff)) {
+                ans[0] = num + diff;
+                ans[1] = num;
+                break;
+            }
+        }
+            
+        return ans;
+    }
+}
diff --git a/Easy/Positions of Large Groups.java b/Easy/Positions of Large Groups.java
@@ -0,0 +1,32 @@
+class Solution {
+    public List<List<Integer>> largeGroupPositions(String S) {
+        List<List<Integer>> positions = new ArrayList<>();
+
+        int i = 1;
+        int count = 1;
+        int start = 0;
+
+        while (i < S.length()) {
+            if (S.charAt(i) == S.charAt(i-1)) {
+                count++;
+            }
+            else {
+                if (count >= 3) {
+                    List<Integer> temp = Arrays.asList(start, i-1);
+                    positions.add(temp);
+                }
+
+                start = i;
+                count = 1;
+            }
+
+            i++;
+        }
+
+        if (count >= 3) {
+            positions.add(Arrays.asList(start, i-1));
+        }
+
+        return positions;
+    }
+}
diff --git a/Easy/Transpose Matrix.java b/Easy/Transpose Matrix.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int[][] transpose(int[][] A) {
+        int rows = A.length;
+        int columns = A[0].length;
+
+        int[][] newArr = new int[columns][rows];
+
+        for (int i=0; i<columns; i++) {
+            for (int j=0; j<rows; j++) {
+                newArr[i][j] = A[j][i];
+            }
+        }
+
+        return newArr;
+    }
+}
diff --git a/Medium/Design Circular Queue.java b/Medium/Design Circular Queue.java
@@ -0,0 +1,101 @@
+class MyCircularQueue {
+
+    /** Initialize your data structure here. Set the size of the queue to be k. */
+    Node head;
+    Node curr;
+    int capacity;
+    int count = 0;
+
+    public MyCircularQueue(int k) {
+        head = new Node(-1);
+        curr = head;
+        capacity = k;
+    }
+
+    /** Insert an element into the circular queue. Return true if the operation is successful. */
+    public boolean enQueue(int value) {
+        if (count == capacity) {
+            return false;
+        }
+
+        curr.next = new Node(value);
+        curr = curr.next;
+        count++;
+
+        return true;
+    }
+
+    /** Delete an element from the circular queue. Return true if the operation is successful. */
+    public boolean deQueue() {
+        if (count <= 0) {
+            return false;
+        }
+
+        if (head.next == curr) {
+            curr = head;
+            head.next = null;
+        }
+        else {
+            head.next = head.next.next;
+        }
+
+        count--;
+
+        return true;
+    }
+
+    /** Get the front item from the queue. */
+    public int Front() {
+        if (count == 0) {
+            return -1;
+        }
+
+        return head.next.value;
+    }
+
+    /** Get the last item from the queue. */
+    public int Rear() {
+        if (count == 0) {
+            return -1;
+        }
+
+        return curr.value;
+    }
+
+    /** Checks whether the circular queue is empty or not. */
+    public boolean isEmpty() {
+        return count == 0;
+    }
+
+    /** Checks whether the circular queue is full or not. */
+    public boolean isFull() {
+        return count == capacity;
+    }
+
+    private void printList(Node node) {
+        while (node != null) {
+            System.out.print(node.value + " ");
+        }
+
+        System.out.println();
+    }
+
+    class Node {
+        int value;
+        Node next;
+        Node(int value) {
+            this.value = value;
+        }
+    }
+}
+
+/**
+ * Your MyCircularQueue object will be instantiated and called as such:
+ * MyCircularQueue obj = new MyCircularQueue(k);
+ * boolean param_1 = obj.enQueue(value);
+ * boolean param_2 = obj.deQueue();
+ * int param_3 = obj.Front();
+ * int param_4 = obj.Rear();
+ * boolean param_5 = obj.isEmpty();
+ * boolean param_6 = obj.isFull();
+ */
