style: fix basic eslint warnings (#230)

Author: vil02

backtracking/all_combinations_of_size_k.ts

@@ -10,8 +10,8 @@
  *   and repeat the same process for the next number.
  */
 export function generateCombinations(n: number, k: number): number[][] {
-  let combinationsAcc: number[][] = [];
-  let currentCombination: number[] = [];
+  const combinationsAcc: number[][] = [];
+  const currentCombination: number[] = [];
 
   function generateAllCombos(
     n: number,

bit_manipulation/add_binary.ts

@@ -8,7 +8,7 @@
 export function addBinary(firstBinaryNo: string, secondBinaryNo: string): string {
     let lengthOfFirstNumber: number = firstBinaryNo.length - 1;
     let lengthOfSecondNumber: number = secondBinaryNo.length - 1;
-    let solution: string[] = [];
+    const solution: string[] = [];
     let carry: number = 0;
 
     while ( lengthOfFirstNumber >= 0 || lengthOfSecondNumber >= 0) {

data_structures/heap/heap.ts

@@ -50,7 +50,7 @@ export abstract class Heap<T> {
   }
 
   public extract(): T {
-    let maxElement = this.heap[0];
+    const maxElement = this.heap[0];
     this.heap[0] = this.heap[this.size() - 1];
     this.heap.pop();
     this.sinkDown();
@@ -162,8 +162,8 @@ export class PriorityQueue<T> extends MinHeap<T> {
   }
 
   protected swap(a: number, b: number) {
-    let akey = this.keys_index(this.heap[a]);
-    let bkey = this.keys_index(this.heap[b]);
+    const akey = this.keys_index(this.heap[a]);
+    const bkey = this.keys_index(this.heap[b]);
     [this.keys[akey], this.keys[bkey]] = [this.keys[bkey], this.keys[akey]];
     super.swap(a, b);
   }
@@ -188,7 +188,7 @@ export class PriorityQueue<T> extends MinHeap<T> {
       this.insert(value);
       return;
     }
-    let key = this.keys[idx];
+    const key = this.keys[idx];
     if (this.compare(this.heap[key], value)) {
       // Do not do anything if the value in the heap already has a higher priority.
       return;

data_structures/heap/test/heap.test.ts

@@ -8,7 +8,7 @@ describe("MaxHeap", () => {
 
   beforeEach(() => {
     heap = new MaxHeap();
-    for (let element of elements) {
+    for (const element of elements) {
       heap.insert(element);
     }
   });
@@ -61,7 +61,7 @@ describe("MinHeap", () => {
 
   beforeEach(() => {
     heap = new MinHeap();
-    for (let element of elements) {
+    for (const element of elements) {
       heap.insert(element);
     }
   });
@@ -106,7 +106,7 @@ describe("MinHeap", () => {
   });
 
   it("should increase priority", () => {
-    let heap = new PriorityQueue((a: number) => { return a; }, elements.length);
+    const heap = new PriorityQueue((a: number) => { return a; }, elements.length);
     elements.forEach((element: number) => {
       heap.insert(element);
     });

data_structures/queue/linked_queue.ts

@@ -55,7 +55,7 @@ export class LinkedQueue<T> implements Queue<T> {
         }
 
         this.size--;
-        let head = this.head; // We store the head in order not to lose track of it
+        const head = this.head; // We store the head in order not to lose track of it
         this.head = this.head.next; // Update the the head to the next node
         return head.value; // Return the value of the head
     }

data_structures/stack/test/linked_list_stack.test.ts

@@ -1,7 +1,7 @@
 import { LinkedListStack } from "../linked_list_stack";
 
 describe("Linked List Stack", () => {
-    let stack: LinkedListStack<number> = new LinkedListStack<number>(4);
+    const stack: LinkedListStack<number> = new LinkedListStack<number>(4);
 
     stack.push(1);
     stack.push(2);

dynamic_programming/knapsack.ts

@@ -23,7 +23,7 @@ export const knapsack = (
   const numberOfItems = weights.length;
 
   // Declaring a data structure to store calculated states/values
-  let dp: number[][] = new Array(numberOfItems + 1);
+  const dp: number[][] = new Array(numberOfItems + 1);
 
   for (let i = 0; i < dp.length; i++) {
     // Placing an array at each index of dp to make it a 2d matrix

graph/bellman_ford.ts

@@ -12,7 +12,7 @@
 export const bellmanFord = (graph: [number, number][][], start: number): number[] | undefined => {
   // We save the shortest distance to each node in `distances`. If a node is
   // unreachable from the start node, its distance is Infinity.
-  let distances = Array(graph.length).fill(Infinity);
+  const distances = Array(graph.length).fill(Infinity);
   distances[start] = 0;
 
   // On the i'th iteration, we compute all shortest paths that consists of i+1

graph/dijkstra.ts

@@ -13,17 +13,17 @@ import { MinHeap, PriorityQueue } from '../data_structures/heap/heap';
 export const dijkstra = (graph: [number, number][][], start: number): number[] => {
   // We use a priority queue to make sure we always visit the closest node. The
   // queue makes comparisons based on path weights.
-  let priorityQueue = new PriorityQueue((a: [number, number]) => { return a[0] }, graph.length, (a: [number, number], b: [number, number]) => { return a[1] < b[1] });
+  const priorityQueue = new PriorityQueue((a: [number, number]) => { return a[0] }, graph.length, (a: [number, number], b: [number, number]) => { return a[1] < b[1] });
   priorityQueue.insert([start, 0]);
   // We save the shortest distance to each node in `distances`. If a node is
   // unreachable from the start node, its distance is Infinity.
-  let distances = Array(graph.length).fill(Infinity);
+  const distances = Array(graph.length).fill(Infinity);
   distances[start] = 0;
 
   while (priorityQueue.size() > 0) {
     const [node, _] = priorityQueue.extract();
     graph[node].forEach(([child, weight]) => {
-      let new_distance = distances[node] + weight;
+      const new_distance = distances[node] + weight;
       if (new_distance < distances[child]) {
         // Found a new shortest path to child node. Record its distance and add child to the queue.
         // If the child already exists in the queue, the priority will be updated. This will make sure the queue will be at most size V (number of vertices).

graph/floyd_warshall.ts

@@ -10,12 +10,12 @@
  */
 export const floydWarshall = (graph: number[][]): number[][] => {
   let distances = structuredClone(graph);
-  let N = graph.length;
+  const N = graph.length;
 
   // We begin by setting the weighted adjacency matrix as the shortest paths.
   // For the k'th iteration, we try to relax the shortest paths by including node k in the path.
   for (let k = 0; k < N; ++k) {
-    let newDistances = [];
+    const newDistances = [];
     for (let i = 0; i < N; ++i) {
       newDistances.push(Array(N).fill(Infinity));
     }