[REFACTOR] ESLint manual fixes

Author: Gonzalo Diaz

src/hackerrank/implementation/breakingRecords.ts

@@ -3,7 +3,7 @@
  */
 
 export function breakingRecords(scores: number[]): number[] {
-  if (scores.length == 0) {
+  if (scores.length === 0) {
     throw new Error('Empty input');
   }
 

src/hackerrank/implementation/kangaroo.ts

@@ -8,8 +8,8 @@ export function kangaroo(
   x2: number,
   v2: number
 ): string {
-  if (v1 == v2) {
-    if (x1 != x2) return 'NO';
+  if (v1 === v2) {
+    if (x1 !== x2) return 'NO';
     return 'YES';
   }
 

src/hackerrank/implementation/migratoryBirds.ts

@@ -9,7 +9,7 @@ interface Birds {
 }
 
 export function migratoryBirds(arr: number[]): number {
-  if (arr.length == 0) {
+  if (arr.length === 0) {
     throw new Error('Empty input');
   }
 
@@ -28,7 +28,7 @@ export function migratoryBirds(arr: number[]): number {
     console.debug(`bird = ${bird} ~> map[bird] = ${map[bird]}`);
     console.debug(`max = ${max} ~> map[max] = ${map[max]}`);
 
-    if (map[bird] > map[max] || (map[bird] == map[max] && bird < max))
+    if (map[bird] > map[max] || (map[bird] === map[max] && bird < max))
       max = bird;
   }
 

src/hackerrank/implementation/minimumAbsoluteDifference.ts

@@ -5,7 +5,7 @@
 import { logger as console } from '../../logger';
 
 export function minimumAbsoluteDifference(arr: number[]): number {
-  if (arr.length == 0) {
+  if (arr.length === 0) {
     throw new Error('Empty input');
   }
 

src/hackerrank/implementation/sockMerchant.ts

@@ -19,10 +19,10 @@ export function sockMerchant(n: number, ar: number[]): number {
 
   console.debug(matches);
 
-  for (const k in matches) {
-    console.debug(matches[k]);
+  for (const match of Object.values(matches)) {
+    console.debug(match);
 
-    result += Math.floor(matches[k] / 2);
+    result += Math.floor(match / 2);
   }
 
   return result;

src/hackerrank/interview_preparation_kit/arrays/cruch_bruteforce.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from '@jest/globals';
 import { logger as console } from '../../../logger';
 
-import { default as TEST_CASES } from './cruch_testcases_test.json';
+import TEST_CASES from './cruch_testcases_test.json';
 
 import { arrayManipulation } from './cruch_bruteforce';
 

src/hackerrank/interview_preparation_kit/arrays/cruch_bruteforce.ts

@@ -12,11 +12,11 @@ export function arrayManipulation(n: number, queries: number[][]): number {
   let maximum = 0;
 
   queries.forEach((query) => {
-    const [a_start, b_end, k_value] = query;
+    const [aStart, bEnd, kValue] = query;
     console.debug(`start -> ${result}`);
 
-    for (let i = a_start; i <= b_end; i++) {
-      result[i] += k_value;
+    for (let i = aStart; i <= bEnd; i++) {
+      result[i] += kValue;
       console.debug(`result -> ${result}`);
     }
   });
@@ -27,3 +27,5 @@ export function arrayManipulation(n: number, queries: number[][]): number {
 
   return maximum;
 }
+
+export default { arrayManipulation };

src/hackerrank/interview_preparation_kit/arrays/cruch_optimized.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from '@jest/globals';
 import { logger as console } from '../../../logger';
 
-import { default as TEST_CASES } from './cruch_testcases_test.json';
+import TEST_CASES from './cruch_testcases_test.json';
 
 import { arrayManipulation } from './cruch_optimized';
 

src/hackerrank/interview_preparation_kit/arrays/cruch_optimized.ts

@@ -5,25 +5,27 @@
 export function arrayManipulation(n: number, queries: number[][]): number {
   // why adding 2?
   //   first slot to adjust 1-based index and
-  //   last slot for storing accum_sum result
+  //   last slot for storing accumSum result
   const LENGTH = n + 2;
   const INITIAL_VALUE = 0;
   const result = Array(LENGTH).fill(INITIAL_VALUE);
   let maximum = 0;
 
   queries.forEach((query) => {
-    const [a_start, b_end, k_value] = query;
+    const [aStart, bEnd, kValue] = query;
 
-    result[a_start] += k_value;
-    result[b_end + 1] -= k_value;
+    result[aStart] += kValue;
+    result[bEnd + 1] -= kValue;
   });
 
-  let accum_sum = 0;
+  let accumSum = 0;
 
   result.forEach((value) => {
-    accum_sum += value;
-    maximum = Math.max(maximum, accum_sum);
+    accumSum += value;
+    maximum = Math.max(maximum, accumSum);
   });
 
   return maximum;
 }
+
+export default { arrayManipulation };

src/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation.ts

@@ -2,19 +2,19 @@
  * @link Problem definition [[docs/hackerrank/interview_preparation_kit/arrays/ctci_array_left_rotation.md]]
  */
 
-export function rotLeftOne(a_numbers: number[]): number[] {
-  const first = a_numbers.shift();
-  if (first != undefined) {
-    a_numbers.push(first);
+export function rotLeftOne(aNumbers: number[]): number[] {
+  const first = aNumbers.shift();
+  if (first !== undefined) {
+    aNumbers.push(first);
   }
 
-  return a_numbers;
+  return aNumbers;
 }
 
-export function rotLeft(a_numbers: number[], d_rotations: number): number[] {
-  let output = [...a_numbers];
+export function rotLeft(aNumbers: number[], dRotations: number): number[] {
+  let output = [...aNumbers];
 
-  for (let i = 0; i < d_rotations; i++) {
+  for (let i = 0; i < dRotations; i++) {
     output = rotLeftOne(output);
   }
 

src/hackerrank/interview_preparation_kit/arrays/minimum_swaps_2.ts

@@ -3,18 +3,18 @@
  */
 
 export function minimumSwaps(arr: number[]): number {
-  const indexed_group = arr.map((x) => x - 1);
+  const indexedGroup = arr.map((x) => x - 1);
   let swaps = 0;
   let index = 0;
-  const size = indexed_group.length;
+  const size = indexedGroup.length;
 
   while (index < size) {
-    if (indexed_group[index] == index) {
+    if (indexedGroup[index] === index) {
       index += 1;
     } else {
-      const temp = indexed_group[index];
-      indexed_group[index] = indexed_group[temp];
-      indexed_group[temp] = temp;
+      const temp = indexedGroup[index];
+      indexedGroup[index] = indexedGroup[temp];
+      indexedGroup[temp] = temp;
       swaps += 1;
     }
   }

src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1_bruteforce.ts

@@ -13,7 +13,7 @@ export function countTriplets(arr: number[], ratio: number): number {
       for (let k = j + 1; k < size; k++) {
         console.debug(`${arr[i]}, ${arr[j]}, ${arr[k]}`);
 
-        if (ratio * arr[i] == arr[j] && ratio * arr[j] == arr[k]) {
+        if (ratio * arr[i] === arr[j] && ratio * arr[j] === arr[k]) {
           counter += 1;
         }
       }

src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/count_triplets_1_optmized.ts

@@ -6,7 +6,7 @@
 export function countTriplets(arr: number[], ratio: number): number {
   let triplets = 0;
 
-  const a_counter: Record<number, number> = arr.reduce(
+  const aCounter: Record<number, number> = arr.reduce(
     (accumulator: Record<number, number>, entry: number) => {
       if (entry in accumulator) {
         accumulator[entry] += 1;
@@ -18,20 +18,20 @@ export function countTriplets(arr: number[], ratio: number): number {
     {}
   );
 
-  const b_counter: Record<number, number> = {};
+  const bCounter: Record<number, number> = {};
 
   arr.forEach((x) => {
     const j = Math.floor(x / ratio);
     const k = x * ratio;
-    a_counter[x] -= 1;
-    if (b_counter[j] && a_counter[k] && x % ratio == 0) {
-      triplets += b_counter[j] * a_counter[k];
+    aCounter[x] -= 1;
+    if (bCounter[j] && aCounter[k] && x % ratio === 0) {
+      triplets += bCounter[j] * aCounter[k];
     }
 
-    if (x in b_counter) {
-      b_counter[x] += 1;
+    if (x in bCounter) {
+      bCounter[x] += 1;
     } else {
-      b_counter[x] = 1;
+      bCounter[x] = 1;
     }
   });
 

src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/frequency_queries_bruteforce.ts

@@ -6,7 +6,7 @@
 // Complete the freqQuery function below.
 export function freqQuery(queries: number[][]): number[] {
   const result: number[] = [];
-  const data_map: Record<number, number> = {};
+  const dataMap: Record<number, number> = {};
 
   const __INITIAL__ = 0;
   const __INSERT__ = 1;
@@ -19,17 +19,17 @@ export function freqQuery(queries: number[][]): number[] {
   queries.forEach((query) => {
     const [operation, data] = query;
 
-    const current = data_map?.[data] ?? __INITIAL__;
+    const current = dataMap?.[data] ?? __INITIAL__;
 
     switch (operation) {
       case __INSERT__:
-        data_map[data] = current + 1;
+        dataMap[data] = current + 1;
         break;
       case __DELETE__:
-        data_map[data] = Math.max(0, current - 1);
+        dataMap[data] = Math.max(0, current - 1);
         break;
       case __SELECT__: {
-        const uniqueDatavalues = new Set(Object.values(data_map));
+        const uniqueDatavalues = new Set(Object.values(dataMap));
         if (uniqueDatavalues.has(data)) {
           result.push(__FOUND__);
         } else {

src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams.ts

@@ -24,42 +24,41 @@ export function sherlockAndAnagrams(s: string): number {
       // Add substrings to a candidate list.
       // two strings are anagrams if sorted strings are the same.
 
-      const anagram_candidate = substr
+      const anagramCandidate = substr
         .split('')
         .sort((a: string, b: string) => a.localeCompare(b))
         .join('');
-      if (anagram_candidate in candidates) {
-        candidates[anagram_candidate].push(substr);
+      if (anagramCandidate in candidates) {
+        candidates[anagramCandidate].push(substr);
       } else {
-        candidates[anagram_candidate] = [substr];
+        candidates[anagramCandidate] = [substr];
       }
     }
   }
 
   let total: bigint = BigInt(0);
-  let q_candidates = 0;
+  let qCandidates = 0;
   // Final Anagram list
   for (const word of Object.keys(candidates)) {
-    const quantity_of_anagrams = candidates[word].length;
+    const quantityOfAnagrams = candidates[word].length;
     const k = 2;
 
-    if (quantity_of_anagrams <= 1) {
+    if (quantityOfAnagrams <= 1) {
       delete candidates[word];
     } else {
       // Binomial coefficient: https://en.wikipedia.org/wiki/Binomial_coefficient
-      q_candidates += quantity_of_anagrams;
+      qCandidates += quantityOfAnagrams;
 
       const count =
-        extraLongFactorials(quantity_of_anagrams) /
-        (extraLongFactorials(k) *
-          extraLongFactorials(quantity_of_anagrams - k));
+        extraLongFactorials(quantityOfAnagrams) /
+        (extraLongFactorials(k) * extraLongFactorials(quantityOfAnagrams - k));
       total += count;
 
       console.debug(`'Partial anagrams of ${word}: ${count}`);
     }
   }
   console.debug(
-    `'sherlockAndAnagrams(${s}) Filtered # candidates: ${q_candidates}`
+    `'sherlockAndAnagrams(${s}) Filtered # candidates: ${qCandidates}`
   );
   console.debug(`'sherlockAndAnagrams(${s}) # anagrams: ${total}`);
 

src/hackerrank/interview_preparation_kit/dynamic_programming/max_array_sum.ts

@@ -9,26 +9,26 @@ const bigIntMax = (...args: bigint[]): bigint =>
 export function maxSubsetSum(arr: number[]): number {
   const arrCopy: bigint[] = arr.map((x: number): bigint => BigInt(x));
 
-  if (arrCopy.length == 0) {
+  if (arrCopy.length === 0) {
     return 0;
   }
 
   const total = arrCopy.length;
 
-  if (total == 1) {
+  if (total === 1) {
     return Number(arrCopy[0]);
   }
 
-  let t_max = bigIntMax(arrCopy[0], arrCopy[1]);
-  arrCopy[1] = t_max;
+  let tMax = bigIntMax(arrCopy[0], arrCopy[1]);
+  arrCopy[1] = tMax;
 
   for (let i = 2; i < total; i++) {
-    t_max = bigIntMax(arrCopy[i - 2] + arrCopy[i], t_max);
-    t_max = bigIntMax(arrCopy[i], t_max);
-    arrCopy[i] = t_max;
+    tMax = bigIntMax(arrCopy[i - 2] + arrCopy[i], tMax);
+    tMax = bigIntMax(arrCopy[i], tMax);
+    arrCopy[i] = tMax;
   }
 
-  return Number(t_max);
+  return Number(tMax);
 }
 
 export default { maxSubsetSum };

src/hackerrank/interview_preparation_kit/greedy_algorithms/angry_children.ts

@@ -17,3 +17,5 @@ export function maxMin(k: number, arr: number[]): number {
 
   return result;
 }
+
+export default { maxMin };

src/hackerrank/interview_preparation_kit/greedy_algorithms/greedy_florist.ts

@@ -11,10 +11,10 @@ export function getMinimumCost(k: number, c: number[]): number {
   let total: number = 0;
 
   let i: number = 0;
-  flowers.forEach((flower_cost) => {
+  flowers.forEach((flowerCost) => {
     const position = Math.floor(i / k);
 
-    total += (position + 1) * flower_cost;
+    total += (position + 1) * flowerCost;
     i += 1;
   });
 

src/hackerrank/interview_preparation_kit/greedy_algorithms/minimum_absolute_difference_in_an_array.ts

@@ -3,17 +3,17 @@
  */
 
 export function minimumAbsoluteDifference(arr: number[]): number {
-  const sorted_nums = arr
+  const sortedNums = arr
     .map((x: number): number => x)
     .sort((a: number, b: number): number => b - a);
 
-  let result = Math.abs(sorted_nums[sorted_nums.length - 1] - sorted_nums[0]);
+  let result = Math.abs(sortedNums[sortedNums.length - 1] - sortedNums[0]);
 
-  for (let i = 0; i < sorted_nums.length - 1; i++) {
-    const a_value = sorted_nums[i];
-    const b_value = sorted_nums[i + 1];
+  for (let i = 0; i < sortedNums.length - 1; i++) {
+    const aValue = sortedNums[i];
+    const bValue = sortedNums[i + 1];
 
-    const diff = Math.abs(a_value - b_value);
+    const diff = Math.abs(aValue - bValue);
 
     result = Math.min(result, diff);
   }