Merge pull request amejiarosario#2 from amejiarosario/eslint-fixes

Eslint fixes

Author: amejiarosario

.eslintignore

@@ -0,0 +1,6 @@
+/runtimes/**
+src/data-structures/maps/hash-maps/hashing.js
+src/data-structures/maps/hash-maps/*-test.js
+src/data-structures/maps/hash-maps/hash-map-*.js
+src/data-structures/linked-lists/linked-list-*.js
+src/data-structures/custom/lru-cache-*.js

.eslintrc.js

@@ -1,23 +1,23 @@
 module.exports = {
-  "extends": "airbnb-base",
-  "env": {
-    "jest": true
+  extends: 'airbnb-base',
+  env: {
+    jest: true
+  },
+  globals: {
+    BigInt: true,
   },
   rules: {
     // https://github.com/airbnb/javascript/issues/1089
 
     // https://stackoverflow.com/a/35637900/684957
     // allow to add properties to arguments
-    "no-param-reassign": [2, { "props": false }],
+    'no-param-reassign': [2, { 'props': false }],
 
     // https://eslint.org/docs/rules/no-plusplus
     // allows unary operators ++ and -- in the afterthought (final expression) of a for loop.
-    "no-plusplus": [2, { "allowForLoopAfterthoughts": true }],
+    'no-plusplus': [2, { 'allowForLoopAfterthoughts': true }],
 
     // Allow for..of
-    "no-restricted-syntax": [0, "ForOfStatement"],
-  },
-  globals: {
-    BigInt: true,
+    'no-restricted-syntax': [0, 'ForOfStatement'],
   }
 };

.travis.yml

@@ -1,4 +1,5 @@
 language: node_js
+script: npm run ci
 node_js:
   - "node"
   - "lts/*"

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+  "workbench.colorCustomizations": {
+    "titleBar.activeBackground": "#f9e64f",
+    "titleBar.inactiveBackground": "#f9e64f99",
+    "titleBar.activeForeground": "#15202b",
+    "titleBar.inactiveForeground": "#15202b99"
+  }
+}

src/changelog.md renamed to CHANGELOG.md

@@ -1,38 +1,51 @@
 # Changelog
+
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
-### Changed
-- Fix picture on https://www.npmjs.com/package/dsa.js
-### Added
-- CI: travis
-### Removed
--
+
+### Breaking changes
+
+### New Features
+- Added Eslint and Travis ci
+
+### Patches
+- Readme improvements
+- Badges for npm versions and build status
 
 ## [1.1.0] - 2019-03-29
+
 ### Added
+
 - README.md added because NPM packages doesn't read README.adoc
 - Public API to use the package `dsa.js`
 - This changelog
 
 ### Changed
+
 - Updated dependencies (removed lodash since is not needed)
 
 ### Removed
+
 -
 
 ## [1.0.0] - 2019-03-29
+
 ### Added
+
 - Started the project
 - Book released
 - npm package published
 
 ### Changed
+
 -
+
 ### Removed
+
 -
 
 

README.md

@@ -1,12 +1,29 @@
 # Data Structures and Algorithms in JavaScript
 
+[![Build Status](https://travis-ci.com/amejiarosario/dsa.js.svg?branch=master)](https://travis-ci.com/amejiarosario/dsa.js)
+[![npm version](https://badge.fury.io/js/dsa.js.svg)](https://badge.fury.io/js/dsa.js)
+
 This repository covers the implementation of the classical algorithms and data structures in JavaScript.
 
-<!-- This goes along with [these posts series](https://adrianmejia.com/tags/tutorial-algorithms/) that explain each implementation in details and also this [book](https://gum.co/dsajs) that explain these topics and some with more examples and illustrations. -->
+## Usage
+
+You can clone the repo or install the code from NPM:
+
+```sh
+npm install dsa.js
+```
+
+and then you can import it into your programs or CLI
+
+```js
+const { LinkedList, Queue, Stack } = require('dsa.js');
+```
+
+For a full list of all the exposed data structures and algorithms [see](https://github.com/amejiarosario/dsa.js/blob/master/src/index.js).
 
 ## Book
 
-You can check out the book that goes deeper into each topic and provide addtional illustrations and explanations.
+You can check out the book that goes deeper into each topic and provide additional illustrations and explanations.
 
 - Algorithmic toolbox to avoid getting stuck while coding.
 - Explains data structures similarities and differences.
@@ -21,65 +38,67 @@ We are covering the following data structures.
 [![Interactive Data Structures](https://user-images.githubusercontent.com/418605/46118890-ba721180-c1d6-11e8-82bc-6a671428b422.png)](https://embed.kumu.io/85f1a4de5fb8430a10a1bf9c5118e015)
 
 ### Linear Data Structures
-1.  **Arrays**: Built-in in most languages so not implemented here.
+
+1. **Arrays**: Built-in in most languages so not implemented here.
     [Post](https://adrianmejia.com/blog/2018/04/28/data-structures-time-complexity-for-beginners-arrays-hashmaps-linked-lists-stacks-queues-tutorial/#Array).
 
-2.  **Linked Lists**: each data node has a link to the next (and
+2. **Linked Lists**: each data node has a link to the next (and
     previous).
     [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/linked-lists/linked-list.js)
     |
     [Post](https://adrianmejia.com/blog/2018/04/28/data-structures-time-complexity-for-beginners-arrays-hashmaps-linked-lists-stacks-queues-tutorial/#Linked-Lists).
 
-3.  **Queue**: data flows in a "first-in, first-out" (FIFO) manner.
+3. **Queue**: data flows in a "first-in, first-out" (FIFO) manner.
     [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/queues/queue.js)
     |
     [Post](https://adrianmejia.com/blog/2018/04/28/data-structures-time-complexity-for-beginners-arrays-hashmaps-linked-lists-stacks-queues-tutorial/#Queues)
 
-4.  **Stacks**: data flows in a "last-in, first-out" (LIFO) manner.
+4. **Stacks**: data flows in a "last-in, first-out" (LIFO) manner.
     [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/stacks/stack.js)
     |
     [Post](https://adrianmejia.com/blog/2018/04/28/data-structures-time-complexity-for-beginners-arrays-hashmaps-linked-lists-stacks-queues-tutorial/#Stacks).
 
 ### Non-Linear Data Structures
-1.  **Trees**: data nodes has zero or more adjacent nodes a.k.a.
+
+1. **Trees**: data nodes has zero or more adjacent nodes a.k.a.
     children. Each node can only have one parent node otherwise is a
     graph not a tree.
     [Code](https://github.com/amejiarosario/algorithms.js/tree/master/src/data-structures/trees)
     |
     [Post](https://adrianmejia.com/blog/2018/06/11/data-structures-for-beginners-trees-binary-search-tree-tutorial/)
 
-    1.  **Binary Trees**: same as tree but only can have two children at
+    1. **Binary Trees**: same as tree but only can have two children at
         most.
         [Code](https://github.com/amejiarosario/algorithms.js/tree/master/src/data-structures/trees)
         |
         [Post](https://adrianmejia.com/blog/2018/06/11/data-structures-for-beginners-trees-binary-search-tree-tutorial/#Binary-Trees)
 
-    2.  **Binary Search Trees** (BST): same as binary tree, but the
+    2. **Binary Search Trees** (BST): same as binary tree, but the
         nodes value keep this order `left < parent < rigth`.
         [Code](https://github.com/amejiarosario/algorithms.js/blob/master/src/data-structures/trees/binary-search-tree.js)
         |
         [Post](https://adrianmejia.com/blog/2018/06/11/data-structures-for-beginners-trees-binary-search-tree-tutorial/#Binary-Search-Tree-BST)
 
-    3.  **AVL Trees**: Self-balanced BST to maximize look up time.
+    3. **AVL Trees**: Self-balanced BST to maximize look up time.
         [Code](https://github.com/amejiarosario/algorithms.js/blob/master/src/data-structures/trees/avl-tree.js)
         |
         [Post](https://adrianmejia.com/blog/2018/07/16/self-balanced-binary-search-trees-with-avl-tree-data-structure-for-beginners/)
 
-    4.  **Red-Black Trees**: Self-balanced BST more loose than AVL to
+    4. **Red-Black Trees**: Self-balanced BST more loose than AVL to
         maximize insertion speed.
         [Code](https://github.com/amejiarosario/algorithms.js/blob/master/src/data-structures/trees/red-black-tree.js)
 
-2.  **Maps**: key-value store.
+2. **Maps**: key-value store.
 
-    1.  **Hash Maps**: implements map using a hash function.
+    1. **Hash Maps**: implements map using a hash function.
         [Code](https://github.com/amejiarosario/algorithms.js/blob/master/src/data-structures/hash-maps/hashmap.js)
         |
         [Post](https://adrianmejia.com/blog/2018/04/28/data-structures-time-complexity-for-beginners-arrays-hashmaps-linked-lists-stacks-queues-tutorial/#HashMaps)
 
-    2.  **Tree Maps**: implement map using a self-balanced BST.
+    2. **Tree Maps**: implement map using a self-balanced BST.
         [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/maps/tree-maps/tree-map.js)
 
-3.  **Graphs**: data **nodes** that can have a connection or **edge** to
+3. **Graphs**: data **nodes** that can have a connection or **edge** to
     zero or more adjacent nodes. Unlike trees, nodes can have multiple
     parents, loops.
     [Code](https://github.com/amejiarosario/algorithms.js/blob/master/src/data-structures/graphs/graph.js)
@@ -88,39 +107,39 @@ We are covering the following data structures.
 
 ## Algorithms
 
-  - Sorting algorithms
+- Sorting algorithms
 
-      - Bubble Sort.
-        [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/sorting/bubble-sort.js)
+  - Bubble Sort.
+    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/sorting/bubble-sort.js)
 
-      - Insertion Sort.
-        [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/sorting/insertion-sort.js)
+  - Insertion Sort.
+    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/sorting/insertion-sort.js)
 
-      - Selection Sort.
-        [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/sorting/selection-sort.js)
+  - Selection Sort.
+    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/sorting/selection-sort.js)
 
-      - Merge Sort.
-        [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/sorting/merge-sort.js)
+  - Merge Sort.
+    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/sorting/merge-sort.js)
 
-      - Quicksort.
-        [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/sorting/quick-sort.js)
+  - Quick sort.
+    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/sorting/quick-sort.js)
 
-  - Greedy Algorithms
+- Greedy Algorithms
 
-      - Fractional Knapsack Problem.
-        [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/knapsack-fractional.js)
+  - Fractional Knapsack Problem.
+    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/knapsack-fractional.js)
 
-  - Divide and Conquer
+- Divide and Conquer
 
-      - Fibonacci Numbers.
-        [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/fibonacci-recursive.js)
+  - Fibonacci Numbers.
+    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/fibonacci-recursive.js)
 
-  - Dynamic Programming
+- Dynamic Programming
 
-      - Fibonacci with memoization.
-        [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/fibanacci-dynamic-programming.js)
+  - Fibonacci with memoization.
+    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/fibanacci-dynamic-programming.js)
 
-  - Backtracking algorithms
+- Backtracking algorithms
 
-      - Word permutations.
-        [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/permutations-backtracking.js)
+  - Word permutations.
+    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/permutations-backtracking.js)

README.adoc renamed to deprecated-README.adoc

@@ -3,6 +3,9 @@
 :toclevels: 2
 Adrian Mejia <https://github.com/amejiarosario[@amejiarosario]>
 
+image:https://travis-ci.com/amejiarosario/dsa.js.svg?branch=master["Build Status", link="https://travis-ci.com/amejiarosario/dsa.js"]
+image:https://badge.fury.io/js/dsa.js.svg["npm version", link="https://badge.fury.io/js/dsa.js"]
+
 This repository covers the implementation of the classical algorithms and data structures in JavaScript.
 
 toc::[]

src/runtimes/array10.txt renamed to lab/array10.txt

@@ -2,24 +2,19 @@
   "name": "dsa.js",
   "version": "1.1.0",
   "description": "Data Structures & Algorithms in JS",
-  "main": "./src/index.js",
-  "dependencies": {
-
-  },
-  "devDependencies": {
-    "benchmark": "2.1.4",
-    "eslint": "4.19.1",
-    "eslint-config-airbnb-base": "12.1.0",
-    "eslint-plugin-import": "2.12.0",
-    "eslint-plugin-jest": "21.17.0",
-    "jest": "23.6.0",
-    "textlint-plugin-asciidoctor": "1.0.2"
+  "author": "Adrian Mejia <hi+dsajs@adrianmejia.com> (https://adrianmejia.com)",
+  "homepage": "https://github.com/amejiarosario/dsa.js",
+  "repository": {
+    "type" : "git",
+    "url" : "https://github.com/amejiarosario/dsa.js.git"
   },
+  "main": "./src/index.js",
   "scripts": {
-    "test": "jest src/ # jest # mocha src/**/*spec.js # jasmine JASMINE_CONFIG_PATH=jasmine.json # node jasmine-runner.js",
+    "test": "jest src/",
     "watch": "jest src/ --watch --coverage",
     "coverage": "jest src/ --coverage && open coverage/lcov-report/index.html",
-    "linter": "npx eslint --fix -f codeframe src/"
+    "lint": "npx eslint --fix --format codeframe src/",
+    "ci": "npx eslint src/ && npm test"
   },
   "keywords": [
     "algorithms",
@@ -29,6 +24,20 @@
     "linked lists",
     "binary search trees"
   ],
-  "author": "Adrian Mejia <hi+dsajs@adrianmejia.com>",
-  "license": "ISC"
+  "license": "MIT",
+  "dependencies": {
+
+  },
+  "devDependencies": {
+    "benchmark": "2.1.4",
+    "eslint": "4.19.1",
+    "eslint-config-airbnb-base": "^13.1.0",
+    "eslint-plugin-import": "^2.16.0",
+    "eslint-plugin-jest": "21.17.0",
+    "jest": "23.6.0",
+    "textlint-plugin-asciidoctor": "1.0.2"
+  },
+  "engines": {
+    "node" : ">=10.0.0"
+  }
 }

src/runtimes/array1000.txt renamed to lab/array1000.txt

@@ -16,8 +16,8 @@ function merge(array1, array2 = []) {
   // merge elements on a and b in asc order. Run-time O(a + b)
   for (let index = 0, i1 = 0, i2 = 0;
     index < mergedLength; index++) { // <1>
-    if (i2 >= array2.length ||
-      (i1 < array1.length && array1[i1] <= array2[i2])) {
+    if (i2 >= array2.length
+      || (i1 < array1.length && array1[i1] <= array2[i2])) {
       mergedArray[index] = array1[i1]; // <2>
       i1 += 1;
     } else {
@@ -45,7 +45,7 @@ function splitSort(array) {
   // base case
   if (size < 2) {
     return array;
-  } else if (size === 2) {
+  } if (size === 2) {
     return array[0] < array[1] ? array : [array[1], array[0]]; // <1>
   }
 

src/runtimes/array100k.txt renamed to lab/array100k.txt

@@ -1,9 +1,12 @@
-
 /**
- * Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and put.
+ * Design and implement a data structure for Least Recently Used (LRU) cache.
+ * It should support the following operations: get and put.
 
-    get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
-    put(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.
+    get(key) - Get the value (will always be positive) of the key
+        if the key exists in the cache, otherwise return -1.
+    put(key, value) - Set or insert the value if the key is not already present.
+        When the cache reached its capacity, it should invalidate the least
+        recently used item before inserting a new item.
 
     Follow up:
     Could you do both operations in O(1) time complexity?
@@ -27,46 +30,41 @@
  *
  * @param {number} capacity
  */
-const LRUCache = function (capacity) {
-  this.map = new Map();
-  this.capacity = capacity;
-};
+class LRUCache {
+  constructor(capacity) {
+    this.map = new Map();
+    this.capacity = capacity;
+  }
 
-/**
-* @param {number} key
-* @return {number}
-*/
-LRUCache.prototype.get = function (key) {
-  const value = this.map.get(key);
-  if (value) {
-    this.moveToTop(key);
-    return value;
+  get(key) {
+    const value = this.map.get(key);
+    if (value) {
+      this.moveToTop(key);
+      return value;
+    }
+    return -1;
   }
-  return -1;
-};
 
-/**
-* @param {number} key
-* @param {number} value
-* @return {void}
-*/
-LRUCache.prototype.put = function (key, value) {
-  this.map.set(key, value);
-  this.rotate(key);
-};
+  put(key, value) {
+    this.map.set(key, value);
+    this.rotate(key);
+  }
 
-LRUCache.prototype.rotate = function (key) {
-  this.moveToTop(key);
-  while (this.map.size > this.capacity) {
-    const it = this.map.keys();
-    this.map.delete(it.next().value);
+  rotate(key) {
+    this.moveToTop(key);
+    while (this.map.size > this.capacity) {
+      const it = this.map.keys();
+      this.map.delete(it.next().value);
+    }
   }
-};
 
-LRUCache.prototype.moveToTop = function (key) {
-  if (this.map.has(key)) {
-    const value = this.map.get(key);
-    this.map.delete(key);
-    this.map.set(key, value);
+  moveToTop(key) {
+    if (this.map.has(key)) {
+      const value = this.map.get(key);
+      this.map.delete(key);
+      this.map.set(key, value);
+    }
   }
-};
+}
+
+module.exports = LRUCache;

src/runtimes/array1M.txt renamed to lab/array1M.txt

@@ -1,5 +1,5 @@
-const Node = require('./node');
 const util = require('util');
+const Node = require('./node');
 
 // tag::constructor[]
 /**

src/runtimes/linear/find-max.js renamed to lab/linear/find-max.js

@@ -74,4 +74,3 @@ module.exports = HashMap;
 // assert.equal(hashMap.get('cat'), 8); // got overwritten by art 😱
 // assert.equal(hashMap.get('rat'), 8); // got overwritten by art 😱
 // assert.equal(hashMap.get('dog'), 8); // got overwritten by art 😱
-

src/runtimes/linear/get-min.js renamed to lab/linear/get-min.js

@@ -1,3 +1,5 @@
+/* eslint-disable */
+
 // tag::naiveHashCode[]
 /**
  * Naïve implementation of a non-cryptographic hashing function

src/runtimes/linear/is-even.js renamed to lab/linear/is-even.js

@@ -32,6 +32,7 @@ class Queue {
   dequeue() {
     return this.items.removeFirst();
   }
+
   // end::dequeue[]
   /**
    * Size of the queue
@@ -66,4 +67,3 @@ queue.dequeue(); //↪️ b
 queue.dequeue(); //↪️ c
 // end::snippet[]
 // */
-

src/runtimes/sortedArray1e1.txt renamed to lab/sortedArray1e1.txt

@@ -85,4 +85,3 @@ class ArraySet {
 }
 
 module.exports = ArraySet;
-

src/runtimes/sortedArray1e3.txt renamed to lab/sortedArray1e3.txt

@@ -87,4 +87,3 @@ class HashMapSet {
 }
 
 module.exports = HashMapSet;
-

src/runtimes/sortedArray1e4.txt renamed to lab/sortedArray1e4.txt

@@ -72,4 +72,3 @@ class MapSet {
 }
 
 module.exports = MapSet;
-

src/runtimes/test1e3.txt renamed to lab/test1e3.txt

@@ -37,4 +37,3 @@ Stack.prototype.push = Stack.prototype.add;
 Stack.prototype.pop = Stack.prototype.remove;
 
 module.exports = Stack;
-

src/runtimes/wrapper.js renamed to lab/wrapper.js

@@ -67,4 +67,3 @@ stack.remove(); //↪️ c
 stack.remove(); //↪️ a
 // end::snippet[]
 // */
-

package-lock.json

@@ -24,14 +24,14 @@ function balance(node) {
     // left subtree is higher than right subtree
     if (node.left.balanceFactor > 0) {
       return rightRotation(node);
-    } else if (node.left.balanceFactor < 0) {
+    } if (node.left.balanceFactor < 0) {
       return leftRightRotation(node);
     }
   } else if (node.balanceFactor < -1) {
     // right subtree is higher than left subtree
     if (node.right.balanceFactor < 0) {
       return leftRotation(node);
-    } else if (node.right.balanceFactor > 0) {
+    } if (node.right.balanceFactor > 0) {
       return rightLeftRotation(node);
     }
   }

package.json

@@ -69,7 +69,7 @@ class BinarySearchTree {
   findNodeAndParent(value, node = this.root, parent = null) {
     if (!node || node.value === value) {
       return { found: node, parent };
-    } else if (value < node.value) {
+    } if (value < node.value) {
       return this.findNodeAndParent(value, node.left, node);
     }
     return this.findNodeAndParent(value, node.right, node);

src/algorithms/sorting/merge-sort.js

@@ -27,12 +27,9 @@ describe('RedBlackTree', () => {
     });
 
     it('should balance tree by rotating left', () => {
-      const n1 = tree.add(1);
-      const n2 = tree.add(2);
-      const n3 = tree.add(3);
-
-      // console.log(n3)
-
+      tree.add(1);
+      tree.add(2);
+      tree.add(3);
       expect(tree.size).toBe(3);
 
       expect(tree.toArray()).toEqual([

src/data-structures/custom/lru-cache.js

@@ -1,5 +1,6 @@
 /**
  * Return true if an array is empty and false otherwise
+ * Check for objects keys as well
  * @param {array|string|object} thing
  * @example
  *      isEmpty() // => true
@@ -30,4 +31,7 @@ function isEmpty(thing) {
 }
 // end::isEmpty[]
 
-module.exports = isEmpty;
+module.exports = {
+  isEmpty,
+  isEmpty2,
+};

src/data-structures/linked-lists/linked-list.js

@@ -18,9 +18,9 @@ function binarySearchRecursive(array, search, offset = 0) {
 
   if (current === search) {
     return offset + half;
-  } else if (array.length < 2) {
+  } if (array.length < 2) {
     return -1;
-  } else if (search > current) {
+  } if (search > current) {
     const right = array.slice(half);
     return binarySearchRecursive(right, search, offset + half);
   }
@@ -49,7 +49,7 @@ function binarySearchIterative(array, search) {
 
     if (current === search) {
       return currentIndex;
-    } else if (search > current) {
+    } if (search > current) {
       start = currentIndex;
     } else if (search < current) {
       end = currentIndex;
@@ -62,24 +62,26 @@ function binarySearchIterative(array, search) {
 // const binarySearch = binarySearchRecursive;
 const binarySearch = binarySearchIterative;
 
-function test() {
-  const directory = ['Adrian', 'Bella', 'Charlotte', 'Daniel', 'Emma', 'Hanna', 'Isabella', 'Jayden', 'Kaylee', 'Luke', 'Mia', 'Nora', 'Olivia', 'Paisley', 'Riley', 'Thomas', 'Wyatt', 'Xander', 'Zoe'];
+// function test() {
+//  const directory = ['Adrian', 'Bella', 'Charlotte', 'Daniel',
+//  'Emma', 'Hanna', 'Isabella', 'Jayden', 'Kaylee', 'Luke', 'Mia',
+//  'Nora', 'Olivia', 'Paisley', 'Riley', 'Thomas', 'Wyatt', 'Xander', 'Zoe'];
+//
+//   const assert = require('assert');
+//   assert.equal(binarySearch([], 'not found'), -1);
+//   assert.equal(binarySearch([1], 2), -1);
+//   assert.equal(binarySearch([1], 1), 0);
+//   assert.equal(binarySearch([1, 2, 3], 1), 0);
+//   assert.equal(binarySearch([1, 2, 3], 2), 1);
+//   assert.equal(binarySearch([1, 2, 3], 3), 2);
+//   assert.equal(binarySearch([1, 2, 3], 31), -1);
+//   assert.equal(binarySearch(directory, 'Adrian'), 0);
+//   assert.equal(binarySearch(directory, 'Hanna'), 5);
+//   assert.equal(binarySearch(directory, 'Zoe'), 18);
+//   assert.equal(binarySearch(directory, 'not found'), -1);
+// }
 
-  const assert = require('assert');
-  assert.equal(binarySearch([], 'not found'), -1);
-  assert.equal(binarySearch([1], 2), -1);
-  assert.equal(binarySearch([1], 1), 0);
-  assert.equal(binarySearch([1, 2, 3], 1), 0);
-  assert.equal(binarySearch([1, 2, 3], 2), 1);
-  assert.equal(binarySearch([1, 2, 3], 3), 2);
-  assert.equal(binarySearch([1, 2, 3], 31), -1);
-  assert.equal(binarySearch(directory, 'Adrian'), 0);
-  assert.equal(binarySearch(directory, 'Hanna'), 5);
-  assert.equal(binarySearch(directory, 'Zoe'), 18);
-  assert.equal(binarySearch(directory, 'not found'), -1);
-}
-
-test();
+// test();
 
 
-module.exports = binarySearch;
+module.exports = { binarySearch, binarySearchIterative, binarySearchRecursive };

src/data-structures/maps/hash-maps/hash-map-1.js

@@ -19,7 +19,7 @@ function findXYZ({ start = 0, end = 10 } = {}) {
   for (let x = start; x < end; x++) {
     for (let y = start; y < end; y++) {
       for (let z = start; z < end; z++) {
-        if (3 * x + 9 * y + 8 * z === 79) {
+        if (3 * x + 9 * y + 8 * z === 79) { // eslint-disable-line
           solutions.push({ x, y, z });
         }
       }