add eslint (#883)

Co-authored-by: Thuvarakan Tharmarajasingam <thuva4.dev@gmail.com>

Author: thuva4

algorithms/JavaScript/.eslintrc.json

@@ -0,0 +1,15 @@
+{
+ "env": {
+ "browser": true,
+ "commonjs": true,
+ "es2021": true
+ },
+ "extends": [
+ "google"
+ ],
+ "parserOptions": {
+ "ecmaVersion": 12
+ },
+ "rules": {
+ }
+}

algorithms/JavaScript/BinarySearch/__test__/index.test.js

@@ -1,17 +1,17 @@
 const binarySearch = require('../index');
 
-describe("BinarySearch", () => {
+describe('BinarySearch', () => {
  let array = null;
 
  beforeEach(() => {
- array = [1,2,3,4,5,6,7,8,9,10]
+ array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  });
 
- it("should return -1 if element is not in the array", () => {
- expect(binarySearch(array, 11)).toEqual(-1)
+ it('should return -1 if element is not in the array', () => {
+ expect(binarySearch(array, 11)).toEqual(-1);
  });
 
- it("should return index of the element if element is in the array", () => {
+ it('should return index of the element if element is in the array', () => {
  expect(binarySearch(array, 6)).toEqual(5);
  expect(binarySearch(array, 9)).toEqual(8);
  expect(binarySearch(array, 2)).toEqual(1);

algorithms/JavaScript/BinarySearch/index.js

@@ -1,21 +1,24 @@
 /**
- * Search a value into a sorted array by repeatedly dividing the search interval in half.
+ * Search a value into a sorted array by repeatedly
+ * dividing the search interval in half.
  * @param {Array} arr Array to search into
  * @param {Number} k Value to search
  * @return {Number} index of found item or -1 for not found
  */
 const binarySearch = (arr, k) => {
- let min = 0
- let max = arr.length - 1
- 
+ let min = 0;
+ let max = arr.length - 1;
+
  while (min <= max) {
- const cur = Math.floor((min + max) / 2)
- if (arr[cur] === k) { return cur }
- (arr[cur] > k)
- ? max = cur - 1
- : min = cur + 1
+ const cur = Math.floor((min + max) / 2);
+ if (arr[cur] === k) {
+ return cur;
+ }
+ (arr[cur] > k) ?
+ max = cur - 1 :
+ min = cur + 1;
  }
- return -1
-}
+ return -1;
+};
 
-module.exports = binarySearch;
+module.exports = binarySearch;

algorithms/JavaScript/BreadthFirstSearch/__test__/index.test.js

@@ -1,66 +1,66 @@
-const {GraphFactory, BFS} = require('../index');
+const {GraphFactory, bfs} = require('../index');
 
-describe("BreadthFirstSearch", () => {
+describe('BreadthFirstSearch', () => {
  let graph = null;
 
  beforeEach(() => {
  graph = GraphFactory.getGraph();
  });
 
- it("should throw error on bad graph", () => {
+ it('should throw error on bad graph', () => {
  expect(() => {
- BFS({});
- }).toThrow("Graph should implement a getNeighbors function");
+ bfs({});
+ }).toThrow('Graph should implement a getNeighbors function');
  });
 
- it("should throw error on no source vertex", () => {
+ it('should throw error on no source vertex', () => {
  expect(() => {
- BFS(graph);
- }).toThrow("source should be a number");
+ bfs(graph);
+ }).toThrow('source should be a number');
  });
 
- it("simple bi-directional graph where target is reachable", () => {
+ it('simple bi-directional graph where target is reachable', () => {
  graph.addEdge(0, 1);
  graph.addEdge(0, 3);
  graph.addEdge(1, 2);
- expect(BFS(graph, 0, 3)).toEqual({
+ expect(bfs(graph, 0, 3)).toEqual({
  order: [0, 1, 3, 2],
- found: true
+ found: true,
  });
  });
 
- it("complex bi-directional graph where target is reachable", () => {
+ it('complex bi-directional graph where target is reachable', () => {
  graph.addEdge(0, 1);
  graph.addEdge(0, 2);
  graph.addEdge(1, 3);
  graph.addEdge(3, 4);
  graph.addEdge(4, 2);
- expect(BFS(graph, 0, 3)).toEqual({
+ expect(bfs(graph, 0, 3)).toEqual({
  order: [0, 1, 2, 3, 4],
- found: true
+ found: true,
  });
  });
- 
- it("complex uni-directional graph where target is reachable", () => {
+
+ it('complex uni-directional graph where target is reachable', () => {
  graph.addEdge(0, 1, false);
  graph.addEdge(0, 2, false);
  graph.addEdge(1, 3, false);
  graph.addEdge(3, 4, false);
  graph.addEdge(3, 5, false);
  graph.addEdge(4, 2, false);
- expect(BFS(graph, 0, 3)).toEqual({
+ expect(bfs(graph, 0, 3)).toEqual({
  order: [0, 1, 2, 3, 4, 5],
- found: true
+ found: true,
  });
  });
 
- it("simple bi-directional graph where target is not present", () => {
+ it('simple bi-directional graph where target is not present', () => {
  graph.addEdge(0, 1);
  graph.addEdge(0, 3);
  graph.addEdge(1, 2);
- expect(BFS(graph, 0, 5)).toEqual({
+ expect(bfs(graph, 0, 5)).toEqual({
  order: [0, 1, 3, 2],
- found: false
+ found: false,
  });
  });
 });

algorithms/JavaScript/BreadthFirstSearch/index.js

@@ -1,16 +1,16 @@
-const BFS = (graph, source, target = -1) => {
+const bfs = (graph, source, target = -1) => {
  // Some error handling
- if (typeof graph.getNeighbors !== "function") {
- throw "Graph should implement a getNeighbors function";
+ if (typeof graph.getNeighbors !== 'function') {
+ throw new Error('Graph should implement a getNeighbors function');
  }
- if (typeof source !== "number") {
- throw "source should be a number";
+ if (typeof source !== 'number') {
+ throw new Error('source should be a number');
  }
- 
- const Q = [], // The queue that will be used
-  order = [], // Array to hold the order of visit. Mainly for unit testing
-   visited = {}; // Keep track of visited vertices
- 
+
+ const Q = []; // The queue that will be used
+ const order = []; // Array to hold the order of visit. Mainly for unit testing
+ const visited = {}; // Keep track of visited vertices
+
  let found = false;
  Q.push(source);
  visited[source] = true;
@@ -28,7 +28,7 @@ const BFS = (graph, source, target = -1) => {
  }
  }
  }
- return { order, found };
+ return {order, found};
 };
 
 const GraphFactory = (() => {
@@ -51,16 +51,16 @@ const GraphFactory = (() => {
  },
  printGraph() {
  console.log(JSON.stringify(this._graph, null, 2));
- }
+ },
  };
- 
+
  return {
  getGraph() {
  const Graph = Object.assign({}, GraphTemplate);
  Graph.init();
  return Graph;
- }
+ },
  };
 })();
 
-module.exports = { GraphFactory,  BFS };
+module.exports = {GraphFactory, bfs};

algorithms/JavaScript/BubbleSort/__test__/index.test.js

@@ -1,15 +1,15 @@
 const bubbleSort = require('../index');
 
-describe("BubbleSort", () => {
+describe('BubbleSort', () => {
  let array = null;
 
- it("sort given distinct element array", () => {
- array = [10,9,8,7,6,5,4,3,2,1]
- expect(bubbleSort(array)).toEqual([1,2,3,4,5,6,7,8,9,10]);
+ it('sort given distinct element array', () => {
+ array = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
+ expect(bubbleSort(array)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
  });
 
- it("sort array repeated elements", () => {
- array = [10,9,8,7,7,5,5,3,2,1]
- expect(bubbleSort(array)).toEqual([1,2,3,5,5,7,7,8,9,10]);
+ it('sort array repeated elements', () => {
+ array = [10, 9, 8, 7, 7, 5, 5, 3, 2, 1];
+ expect(bubbleSort(array)).toEqual([1, 2, 3, 5, 5, 7, 7, 8, 9, 10]);
  });
 });

algorithms/JavaScript/BubbleSort/index.js

@@ -1,8 +1,9 @@
+/* eslint-disable require-jsdoc */
 /**
  * Sort array in O(n^2)
- * Bubble Sort will be faster for small number of elements 
+ * Bubble Sort will be faster for small number of elements
  * In-place sort without extra space
- * @param {Array} arr Array to search into
+ * @param {Array} array Array to search into
  * @return {Array} Sorted array
  */
 function bubbleSort(array) {
@@ -23,4 +24,4 @@ function swap(array, firstIndex, secondIndex) {
 }
 
 
-module.exports = bubbleSort;
+module.exports = bubbleSort;

algorithms/JavaScript/CountingSort/index.js

@@ -1,27 +1,31 @@
-function counting_sort(array) {
-let high = highest_element(array);
-let aux_array = new Array(high-1);
-let final_array = new Array(array.length);
-for(let i = 0; i < aux_array.length; i++) {
-aux_array[i] = 0;
-}
-for(let j = 0; j < aux_array.length; j++) {
-aux_array[array[j]] = aux_array[array[j]-1] + 1;
-}
-for(let i = 1; i<high; i++) {
-aux_array[i] = aux_array[i] + aux_array[i-1];
-}
-for(let j = array.length; j>0; j-- ) {
-final_array[aux_array[array[j]-1]-1] = array[j];
-aux_array[array[j]]--;
-}
+/* eslint-disable require-jsdoc */
+function countingSort(array) {
+ const high = highestElement(array);
+ const auxArray = new Array(high-1);
+ const finalArray = new Array(array.length);
+ for (let i = 0; i < auxArray.length; i++) {
+ auxArray[i] = 0;
+ }
+ for (let j = 0; j < auxArray.length; j++) {
+ auxArray[array[j]] = auxArray[array[j]-1] + 1;
+ }
+ for (let i = 1; i<high; i++) {
+ auxArray[i] = auxArray[i] + auxArray[i-1];
+ }
+ for (let j = array.length; j>0; j-- ) {
+ finalArray[auxArray[array[j]-1]-1] = array[j];
+ auxArray[array[j]]--;
+ }
 }
 
-function highest_element(array) {
-let high = 0;
-for(let i in array) {
-if(array[i] > high)
-high = array[i];
-}
-return high;
-}
+function highestElement(array) {
+ let high = 0;
+ for (const i in array) {
+ if (array[i] > high) {
+ high = array[i];
+ }
+ }
+ return high;
+}
+
+module.exports = {countingSort};