Merge pull request #834 from sir-gon/develop

sir-gon · web-flow · commit 910cd5b94610 · 2025-10-06T16:10:30.000-03:00
[BUGFIX] SonarQube: Prefer `Number.parseInt` over `parseInt`.
diff --git a/package-lock.json b/package-lock.json
diff --git a/src/hackerrank/interview_preparation_kit/arrays/cruch_bruteforce.ts b/src/hackerrank/interview_preparation_kit/arrays/cruch_bruteforce.ts
@@ -8,7 +8,7 @@ import { logger as console } from '../../../logger';
 function arrayManipulation(n: number, queries: number[][]): number {
   const LENGTH = n + 1;
   const SURROGATE_VALUE = 0;
-  const result: number[] = Array<number>(LENGTH).fill(SURROGATE_VALUE);
+  const result: number[] = new Array<number>(LENGTH).fill(SURROGATE_VALUE);
   let maximum = 0;
 
   queries.forEach((query) => {
diff --git a/src/hackerrank/interview_preparation_kit/arrays/cruch_optimized.ts b/src/hackerrank/interview_preparation_kit/arrays/cruch_optimized.ts
@@ -8,7 +8,7 @@ function arrayManipulation(n: number, queries: number[][]): number {
   //   last slot for storing accumSum result
   const LENGTH = n + 2;
   const INITIAL_VALUE = 0;
-  const result = Array(LENGTH).fill(INITIAL_VALUE);
+  const result = new Array(LENGTH).fill(INITIAL_VALUE);
   let maximum = 0;
 
   queries.forEach((query) => {
diff --git a/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams.ts b/src/hackerrank/interview_preparation_kit/dictionaries_and_hashmaps/sherlock_and_anagrams.ts
@@ -6,7 +6,9 @@
 import { logger as console } from '../../../logger';
 
 function extraLongFactorials(n: number): bigint {
-  const rs = [...Array<number>(n)].reduce((a, b, i) => a * BigInt(i + 1), 1n);
+  const rs = new Array<bigint>(n)
+    .fill(1n)
+    .reduce((a, _b, i) => a * BigInt(i + 1), 1n);
   return rs;
 }
 
diff --git a/src/hackerrank/interview_preparation_kit/miscellaneous/flipping-bits.ts b/src/hackerrank/interview_preparation_kit/miscellaneous/flipping-bits.ts
@@ -19,7 +19,7 @@ function flippingBits(n: number): number {
     }
   });
 
-  return parseInt(resultBinStr, __BINARY_BASE__);
+  return Number.parseInt(resultBinStr, __BINARY_BASE__);
 }
 
 export default { flippingBits };
diff --git a/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/recursive_digit_sum.ts b/src/hackerrank/interview_preparation_kit/recursion_and_backtracking/recursive_digit_sum.ts
@@ -6,12 +6,12 @@ const __RADIX__ = 10;
 
 function superDigitCompute(n: string): number {
   if (n.length === 1) {
-    return parseInt(n, __RADIX__);
+    return Number.parseInt(n, __RADIX__);
   }
 
   let partial = 0;
   for (const digit of n) {
-    partial += parseInt(digit, __RADIX__);
+    partial += Number.parseInt(digit, __RADIX__);
   }
 
   return superDigitCompute(`${partial}`);
diff --git a/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor.ts b/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor.ts
@@ -8,7 +8,7 @@ function whatFlavorsCompute(cost: number[], money: number): number[] | null {
   const cache: Record<number, number> = {};
 
   for (const [key, price] of Object.entries(cost)) {
-    const i = parseInt(key, __RADIX__);
+    const i = Number.parseInt(key, __RADIX__);
     const diff = money - price;
 
     if (Number.isInteger(cache?.[diff])) {
diff --git a/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_bruteforce.ts b/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_bruteforce.ts
@@ -6,7 +6,7 @@ function whatFlavorsBruteforceCompute(cost: number[], money: number): number[] {
   const RADIX = 10;
 
   for (const key of Object.keys(cost)) {
-    const i: number = parseInt(key, RADIX);
+    const i: number = Number.parseInt(key, RADIX);
     const x: number = cost[i];
 
     const budget = money - x;
diff --git a/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_optimized.ts b/src/hackerrank/interview_preparation_kit/search/ctci_ice_cream_parlor_optimized.ts
@@ -15,7 +15,7 @@ function whatFlavorsCompute(cost: number[], money: number): number[] {
   }
 
   for (const key of Object.keys(cost)) {
-    const i = parseInt(key, __RADIX__);
+    const i = Number.parseInt(key, __RADIX__);
 
     const v1 = cost[i];
     const v2 = money - v1;
@@ -35,7 +35,7 @@ function whatFlavorsCompute(cost: number[], money: number): number[] {
 
   const result = new Set<number>();
   for (const key of Object.keys(cost)) {
-    const x = parseInt(key, __RADIX__);
+    const x = Number.parseInt(key, __RADIX__);
 
     if (cost[x] === ans1 || cost[x] === ans2) {
       result.add(x + 1);
diff --git a/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.ts b/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.ts
@@ -104,13 +104,14 @@ function swapNodes(indexes: number[][], queries: number[]): number[][] {
 
   nodeCollector = Object.fromEntries(
     Object.entries(nodeCollector).sort(
-      ([a], [b]) => parseInt(a, __RADIX__) - parseInt(b, __RADIX__)
+      ([a], [b]) =>
+        Number.parseInt(a, __RADIX__) - Number.parseInt(b, __RADIX__)
     )
   );
 
   for (const query of queries) {
     for (const [level, nodeList] of Object.entries(nodeCollector)) {
-      const tLevel: number = parseInt(level, __RADIX__);
+      const tLevel: number = Number.parseInt(level, __RADIX__);
 
       if (tLevel % query === 0) {
         for (const node of nodeList) {
diff --git a/src/hackerrank/interview_preparation_kit/string_manipulation/sherlock_and_valid_string.ts b/src/hackerrank/interview_preparation_kit/string_manipulation/sherlock_and_valid_string.ts
@@ -34,8 +34,8 @@ function isValidCompute(s: string): boolean {
     );
     const __RADIX__ = 10;
     const __TOLERANCE__ = 1;
-    const minorFreq: number = parseInt(frequenciesList[0][0], __RADIX__);
-    const majorFreq: number = parseInt(frequenciesList[1][0], __RADIX__);
+    const minorFreq: number = Number.parseInt(frequenciesList[0][0], __RADIX__);
+    const majorFreq: number = Number.parseInt(frequenciesList[1][0], __RADIX__);
 
     if (
       frequencies[minorFreq] === __TOLERANCE__ &&
diff --git a/src/hackerrank/warmup/solveMeFirst.ts b/src/hackerrank/warmup/solveMeFirst.ts
@@ -8,7 +8,7 @@ function solveMeFirst(inputLines: string[]): number {
   let result = 0;
 
   inputLines.forEach((v) => {
-    result += parseInt(v, __RADIX__);
+    result += Number.parseInt(v, __RADIX__);
   });
 
   return result;
diff --git a/src/hackerrank/warmup/timeConversion.ts b/src/hackerrank/warmup/timeConversion.ts
@@ -8,7 +8,7 @@ function timeConversion(s: string): string {
 
   const timeStr = s.substring(0, s.length - 2);
   const time = timeStr.split(':');
-  let hour = parseInt(time[0], 10);
+  let hour = Number.parseInt(time[0], 10);
 
   if (hour >= 12) {
     hour = 0;
diff --git a/src/projecteuler/problem0013-alt.ts b/src/projecteuler/problem0013-alt.ts
@@ -18,7 +18,7 @@ function problem0013alt(
 
   console.debug(`Sum: ${sum}`);
 
-  const firstDigits = parseInt(
+  const firstDigits = Number.parseInt(
     sum.toString().slice(0, numberOfFirstDigits),
     radix
   );
diff --git a/src/projecteuler/problem0013.ts b/src/projecteuler/problem0013.ts
@@ -12,7 +12,7 @@ function problem0013(arrayOfNumbers: string[], _firtsDigits: number): number {
 
   console.debug(`Sum: ${sum}`);
 
-  const first = parseInt(sum.slice(0, _firtsDigits), radix);
+  const first = Number.parseInt(sum.slice(0, _firtsDigits), radix);
 
   console.log(`First ${_firtsDigits} digits of huge sume are ${first}`);
 
diff --git a/src/projecteuler/problem0016-alt.ts b/src/projecteuler/problem0016-alt.ts
@@ -35,7 +35,7 @@ function problem0016alt(base: string, exponent: number): string {
 
   let result = 0;
   digits.forEach((num: string) => {
-    result += parseInt(num, __RADIX__);
+    result += Number.parseInt(num, __RADIX__);
   });
 
   console.log(`Sum of Digits: (${result})`);

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,9 @@`
`6`	`6`	`import { logger as console } from '../../../logger';`
`7`	`7`
`8`	`8`	`function extraLongFactorials(n: number): bigint {`
`9`		`- const rs = [...Array<number>(n)].reduce((a, b, i) => a * BigInt(i + 1), 1n);`
	`9`	`+ const rs = new Array<bigint>(n)`
	`10`	`+ .fill(1n)`
	`11`	`+ .reduce((a, _b, i) => a * BigInt(i + 1), 1n);`
`10`	`12`	`return rs;`
`11`	`13`	`}`
`12`	`14`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ function flippingBits(n: number): number {`
`19`	`19`	`}`
`20`	`20`	`});`
`21`	`21`
`22`		`- return parseInt(resultBinStr, __BINARY_BASE__);`
	`22`	`+ return Number.parseInt(resultBinStr, __BINARY_BASE__);`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`export default { flippingBits };`
Original file line number	Diff line number	Diff line change
`@@ -6,12 +6,12 @@ const __RADIX__ = 10;`
`6`	`6`
`7`	`7`	`function superDigitCompute(n: string): number {`
`8`	`8`	`if (n.length === 1) {`
`9`		`- return parseInt(n, __RADIX__);`
	`9`	`+ return Number.parseInt(n, __RADIX__);`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`let partial = 0;`
`13`	`13`	`for (const digit of n) {`
`14`		`- partial += parseInt(digit, __RADIX__);`
	`14`	`+ partial += Number.parseInt(digit, __RADIX__);`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	return superDigitCompute(`${partial}`);