Mock interview1

Problem1.java

@@ -1 +1,23 @@
 
+import java.io.*;
+
+class Problem1 {
+
+    static int search(int[] ar, int size) {
+        int a = 0, b = size - 1;
+        int mid;
+
+        while ((b - a) > 1) {
+            mid = (a + b) / 2;
+
+            if ((ar[a] - a) != (ar[mid] - mid)) {
+                b = mid;
+            } else if ((ar[b] - b) != (ar[mid] - mid)) {
+                a = mid;
+            }
+        }
+
+        return ar[a] + 1;
+    }
+
+}

Problem2.java

@@ -1 +1,80 @@
 
+class Problem2 {
+    private int[] heap;
+    private int size;
+    private int maxSize;
+
+    public MyMinHeap(int capacity) {
+        this.maxSize = capacity;
+        this.size = 0;
+        heap = new int[capacity];
+    }
+
+    private int parent(int i) {
+        return (i - 1) / 2;
+    }
+
+    private int leftChild(int i) {
+        return 2 * i + 1;
+    }
+
+    private int rightChild(int i) {
+        return 2 * i + 2;
+    }
+
+    private boolean isLeaf(int i) {
+        return i >= size / 2 && i < size;
+    }
+
+    private void swap(int i, int j) {
+        int temp = heap[i];
+        heap[i] = heap[j];
+        heap[j] = temp;
+    }
+
+    private void heapify(int i) {
+        if (isLeaf(i)) return;
+
+        int left = leftChild(i);
+        int right = rightChild(i);
+        int smallest = i;
+
+        if (left < size && heap[left] < heap[smallest]) {
+            smallest = left;
+        }
+        if (right < size && heap[right] < heap[smallest]) {
+            smallest = right;
+        }
+
+        if (smallest != i) {
+            swap(i, smallest);
+            heapify(smallest);
+        }
+    }
+
+    public void insert(int val) {
+        if (size >= maxSize) return;
+
+        heap[size] = val;
+        int current = size;
+        size++;
+
+        while (current > 0 && heap[current] < heap[parent(current)]) {
+            swap(current, parent(current));
+            current = parent(current);
+        }
+    }
+
+    public int removeMin() {
+        if (size == 0) return -1;
+
+        int min = heap[0];
+        heap[0] = heap[size - 1];
+        size--;
+        heapify(0);
+        return min;
+    }
+
+
+
+}