Ringo - Earth

lib/problems.js

@@ -1,17 +1,61 @@
+const Stack = require('./stack');
 /*
-Time Complexity: ?
-Space Complexity: ?
+Time Complexity: O(n), the function has to visit every node once
+but operations performed in that loop are O(1)
+Space Complexity: O(n), worst case scenario the stack could have on it
+every character in the string
 */
 const balanced = (str) => {
-    throw new Error("This method has not been implemented!");
+    const stack = new Stack();
+    const pairs = { '{': '}', '[': ']', '(': ')' }
+
+    for (const char of str) {
+        if (pairs[char]) {
+            stack.push(char);
+        } else {
+            const top = stack.pop();
+            if (!(pairs[top] === char)) {
+                return false;
+            }
+        }
+    }
+
+    return stack.isEmpty();
 }
 
 /*
-Time Complexity: ?
-Space Complexity: ?
+Time Complexity: O(n), the function has to check every character in expr,
+but operations in the for loop are O(1)
+Space Complexity: O(n), the controlling factor is the height of the stack,
+which does not grow quickly with longer expr in a normal use case but I suppose
+in a worst case scenario with some weird postfix expressions would increase in size
+linear to the length of the weird expression you were using
 */
 const evaluatePostfix = (expr) => {
-    throw new Error("This method has not been implemented!");
+    const stack = new Stack();
+
+    for (const char of expr) {
+        const current = parseInt(char);
+        if (Number.isInteger(current)) {
+            stack.push(current);
+        } else {
+            const second = stack.pop();
+            const first = stack.pop();
+
+            if (char === '+') {
+                stack.push(first + second);
+            } else if (char === '-') {
+                stack.push(first - second);
+            } else if (char === '*') {
+                stack.push(first * second);
+            } else if (char === '/') {
+                const quotient = first / second;
+                quotient > 0 ? stack.push(Math.floor(quotient)) : stack.push(Math.ceil(quotient))
+            }
+        }
+    }
+
+    return stack.pop();
 }
 
 exports.balanced = balanced;

lib/queue.js

@@ -1,35 +1,58 @@
+const QUEUE_SIZE = 20;
+
 class Queue {
     constructor() {
-        // this.store = ...
-        throw new Error("This method has not been implemented!");
+        this.store = new Array(QUEUE_SIZE);
+        this.head = 0;
+        this.tail = 0;
     }
 
     enqueue(element) {
-        throw new Error("This method has not been implemented!");
+        if (this.isFull()) {
+            throw new Error("your queue is full");
+        } else {
+            this.store[this.tail] = element;
+            this.tail = (this.tail + 1) % QUEUE_SIZE;
+        }
     }
 
     dequeue() {
-        throw new Error("This method has not been implemented!");
+        const element = this.store[this.head];
+        this.store[this.head] = null;
+        this.head = (this.head + 1) % QUEUE_SIZE;
+        return element;
     }
 
     front() {
-        throw new Error("This method has not been implemented!");
+        return this.store[this.head];
     }
 
     size() {
-        throw new Error("This method has not been implemented!");
+        let count = 0;
+        let pointer = this.head;
+
+        while (this.store[pointer]) {
+            count++;
+            pointer = (pointer + 1) % QUEUE_SIZE;
+        }
+
+        return count;
     }
 
     isEmpty() {
-        throw new Error("This method has not been implemented!");
+        return this.head === this.tail;
+    }
+
+    isFull() {
+        return this.head === (this.tail + 1) % QUEUE_SIZE;
     }
 
     toString() {
         let arr;
         if (this.head > this.tail) {
             arr = this.store.slice(this.head, this.capacity).concat(this.store.slice(0, this.tail));
         } else {
-            arr = this.store
+            arr = this.store;
         }
         return JSON.stringify(arr.filter((v) => v !== null));
     }

lib/stack.js

@@ -1,19 +1,22 @@
+const LinkedList = require("./linked-list");
+
 class Stack {
     constructor() {
-        // this.store = ...
-        throw new Error("This method has not been implemented!");
+        this.store = new LinkedList();
     }
 
-    push() {
-        throw new Error("This method has not been implemented!");
+    push(value) {
+        this.store.addFirst(value);
     }
 
     pop() {
-        throw new Error("This method has not been implemented!");
+        const value = this.store.getFirst();
+        this.store.delete(value);
+        return value;
     }
 
     isEmpty() {
-        throw new Error("This method has not been implemented!");
+        return this.store.isEmpty();
     }
 
     toString() {

test/queue.test.js

@@ -101,4 +101,40 @@ describe("test queue implementation", () => {
         expect(q.toString()).toEqual('[40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210]');
     });
 
+    it('returns number of elements in queue', () => {
+        const q = new Queue();
+        q.enqueue(10);
+        q.enqueue(20);
+        q.enqueue(30);
+        q.enqueue(40);
+        q.enqueue(50);
+
+        expect(q.size()).toEqual(5);
+    });
+
+    it('returns zero on size if no elements in queue', () => {
+        const q = new Queue();
+        q.enqueue(10);
+        q.dequeue();
+
+        expect(q.size()).toEqual(0);
+    });
+
+    it('returns the first value in the queue without removing it', () => {
+        const q = new Queue();
+        q.enqueue(10);
+        q.enqueue(20);
+        q.enqueue(30);
+
+        expect(q.front()).toEqual(10);
+        expect(q.dequeue()).toEqual(10);
+    });
+
+    it('returns null for front if queue is empty', () => {
+        const q = new Queue();
+        q.enqueue(10);
+        q.dequeue();
+
+        expect(q.front()).toBeNull;
+    });
 });