3.6 Animal Shelter

Author: amejiarosario

src/linked-list/linkedlist.js

@@ -78,38 +78,53 @@ class LinkedList {
     return last.data;
   }
 
+  /**
+   * Remove first element from list
+   *
+   * O(1)
+   *
+   * @returns {*} removed element
+   */
   removeFirst() {
+    if(!this.head) { return; }
 
+    const first = this.head;
+    this.head = first.next;
+    this.length--;
+    if(this.length <= 1) { this.tail = this.head; }
+    return first.data;
   }
 
   // O(n)
-  delete(data) {
+  delete(query) {
     let n = this.head;
+    let data = n.data;
 
     // remove from head
-    if(n.data === data) {
+    if(isMatch(data, query)) {
       this.head = this.head.next;
       this.length--;
-      return;
+      return data;
     }
 
     // iterate
     while(n.next){
-      if(n.next.data === data) {
+      data = n.next.data;
+      if(isMatch(data, query)) {
         n.next = n.next.next;
         this.length--;
-        return;
+        return data;
       }
       n = n.next;
     }
   }
 
   // O(n)
-  toString() {
+  toString(key) {
     let data = [];
     let n = this.head;
     while(n) {
-      data.push(n.data);
+      data.push(key ? n.data[key] : n.data);
       n = n.next;
     }
     return data.join(' -> ');
@@ -124,4 +139,14 @@ function getNode(dataOrNode) {
   return dataOrNode instanceof Node ? dataOrNode : new Node(dataOrNode);
 }
 
+function isMatch(original, query) {
+
+  for(let key in query) {
+    if(key && query[key] !== original[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+
 module.exports = LinkedList;

src/linked-list/linkedlist.spec.js

@@ -99,6 +99,32 @@ describe('LinkedList', function () {
     });
   });
 
+  describe('.removeFirst', function () {
+    it('should handle empty', function () {
+      expect(list.removeFirst()).to.equal(undefined);
+    });
+
+    it('should remove item', function () {
+      list.add(1);
+      expect(list.removeFirst()).to.equal(1);
+    });
+
+    it('should remove multiple items and ', function () {
+      list.addLast(1);
+      list.addLast(2);
+
+      expect(list.removeFirst()).to.equal(1);
+      expect(list.tail.data).to.equal(2);
+      expect(list.head.data).to.equal(2);
+      expect(list.size()).to.equal(1);
+
+      expect(list.removeFirst()).to.equal(2);
+      expect(list.tail).to.equal(undefined);
+      expect(list.head).to.equal(undefined);
+      expect(list.size()).to.equal(0);
+    });
+  });
+
   describe('.delete', function () {
     beforeEach(function () {
       list = new LinkedList();
@@ -127,4 +153,34 @@ describe('LinkedList', function () {
     });
   });
 
+
+  describe('removeFirstByQuery', function () {
+    let dog, cat, rat;
+
+    beforeEach(function () {
+      dog = {animal: 'dog', name: 'Snoopy'};
+      cat = {animal: 'cat', name: 'Garfield'};
+      rat = {animal: 'rat', name: 'Micky'};
+
+      list.addLast(dog);
+      list.addLast(cat);
+      list.addLast(rat);
+    });
+
+    it('should remove dog', function () {
+      expect(list.toString('name')).to.equal('Snoopy -> Garfield -> Micky');
+      expect(list.delete({animal: 'dog'})).to.equal(dog);
+      expect(list.toString('name')).to.equal('Garfield -> Micky');
+    });
+
+    it('should remove the rat', function () {
+      expect(list.delete({animal: 'rat'})).to.equal(rat);
+      expect(list.toString('name')).to.equal('Snoopy -> Garfield');
+    });
+
+    it('should remove the cat', function () {
+      expect(list.delete({animal: 'cat'})).to.equal(cat);
+      expect(list.toString('name')).to.equal('Snoopy -> Micky');
+    });
+  });
 });

src/stacks-and-queues/animal-shelter.js

@@ -0,0 +1,25 @@
+const Queue = require('./queue');
+
+class AnimalShelter {
+  constructor() {
+    this.queue = new Queue();
+  }
+
+  enqueue(data) {
+    this.queue.add(data);
+  }
+
+  dequeueAny() {
+    return this.queue.remove();
+  }
+
+  dequeueDog() {
+    return this.queue.removeBy({animal: 'dog'});
+  }
+
+  dequeueCat() {
+    return this.queue.removeBy({animal: 'cat'});
+  }
+}
+
+module.exports = AnimalShelter;

src/stacks-and-queues/animal-shelter.spec.js

@@ -0,0 +1,64 @@
+const expect = require('chai').expect;
+const AnimalShelter = require('./animal-shelter');
+
+describe('Stacks: QueueViaStack', function () {
+  let shelter;
+  const cat = { animal: 'cat', name: 'Minino'};
+  const dog = { animal: 'dog', name: 'Lassie'};
+
+  beforeEach(function () {
+    shelter = new AnimalShelter();
+  });
+
+  describe('.enqueue', function () {
+    it('should enqueue a cat', function () {
+      shelter.enqueue(cat);
+      expect(shelter.queue.list.head.data).to.equal(cat);
+    });
+  });
+
+  describe('dequeueAny', function () {
+    it('should remove in FIFO order', function () {
+      shelter.enqueue(dog);
+      shelter.enqueue(cat);
+      expect(shelter.dequeueAny()).to.equal(dog);
+      expect(shelter.dequeueAny()).to.equal(cat);
+    });
+  });
+
+  describe('dequeueDog', function () {
+    it('should return first dog', function () {
+      shelter.enqueue(dog);
+      expect(shelter.dequeueDog()).to.equal(dog);
+    });
+
+    it('should not return cat', function () {
+      shelter.enqueue(cat);
+      expect(shelter.dequeueDog()).to.equal(undefined);
+    });
+
+    it('should remove a dog even if is a cat is first', function () {
+      shelter.enqueue(cat);
+      shelter.enqueue(dog);
+      expect(shelter.dequeueDog()).to.equal(dog);
+    });
+  });
+
+  describe('dequeueCat', function () {
+    it('should return first cat', function () {
+      shelter.enqueue(cat);
+      expect(shelter.dequeueCat()).to.equal(cat);
+    });
+
+    it('should not return dog', function () {
+      shelter.enqueue(dog);
+      expect(shelter.dequeueCat()).to.equal(undefined);
+    });
+
+    it('should remove a dog even if is a cat is first', function () {
+      shelter.enqueue(dog);
+      shelter.enqueue(cat);
+      expect(shelter.dequeueCat()).to.equal(cat);
+    });
+  });
+});

src/stacks-and-queues/queue.js

@@ -0,0 +1,30 @@
+const LinkedList = require('../linked-list/linkedlist');
+
+class Queue {
+  constructor(){
+    this.list = new LinkedList();
+  }
+
+  add(data) {
+    this.list.addLast(data);
+  }
+
+  remove() {
+    return this.list.removeFirst();
+  }
+
+  peek() {
+    if(this.isEmpty()) { return; }
+    return this.list.head.data;
+  }
+
+  isEmpty() {
+    return !this.list.size();
+  }
+
+  removeBy(query) {
+    return this.list.delete(query);
+  }
+}
+
+module.exports = Queue;

src/stacks-and-queues/queue.spec.js

@@ -0,0 +1,79 @@
+const expect = require('chai').expect;
+const Queue = require('./queue');
+
+describe('Queue', function () {
+  let queue;
+
+  beforeEach(function () {
+    queue = new Queue();
+  });
+
+  describe('.add', function () {
+    it('should enqueue an element', function () {
+      queue.add(1);
+      expect(queue.list.toString()).to.equal('1');
+    });
+  });
+
+  describe('.isEmpty', function () {
+    it('should be true', function () {
+      expect(queue.isEmpty()).to.equal(true);
+    });
+
+    it('should be false', function () {
+      queue.add(1);
+      expect(queue.isEmpty()).to.equal(false);
+    });
+  });
+
+  describe('.remove', function () {
+    it('should nothing', function () {
+      expect(queue.remove()).to.equal(undefined);
+    });
+
+    it('should remove element', function () {
+      queue.add(1);
+      expect(queue.remove()).to.equal(1);
+    });
+
+    it('should remove element on FIFO order', function () {
+      queue.add(1);
+      queue.add(2);
+      expect(queue.remove()).to.equal(1);
+      expect(queue.remove()).to.equal(2);
+    });
+  });
+
+  describe('.peek', function () {
+    it('should return undefined when empty', function () {
+      expect(queue.peek()).to.equal(undefined);
+    });
+
+    it('should return first in the queue', function () {
+      queue.add(1);
+      queue.add(2);
+      expect(queue.peek()).to.equal(1);
+    });
+  });
+
+  describe('remove by query', function () {
+    let dog, cat, cat2, dog2;
+    beforeEach(function () {
+      dog = {animal: 'dog', name: 'Lassie'};
+      dog2 = {animal: 'dog', name: 'Snoopy'};
+      cat  = {animal: 'cat', name: 'Tom'};
+      cat2  = {animal: 'cat', name: 'Garfield'};
+
+      queue.add(dog);
+      queue.add(dog2);
+      queue.add(cat);
+      queue.add(cat2);
+    });
+
+    it('should remove first matching', function () {
+      expect(queue.removeBy({animal: 'cat'})).to.equal(cat);
+      expect(queue.list.toString('name')).to.equal('Lassie -> Snoopy -> Garfield');
+    });
+  });
+
+});