adding fix #1342 fixing docs for FenWickTree and DepthFirstSearch

Conversions/BinaryToDecimal.js

@@ -1,3 +1,9 @@
+/**
+ * Converts a binary string to a decimal number.
+ *
+ * @param {string} binaryString - The binary string to be converted to decimal.
+ * @returns {number} The decimal representation of the binary string.
+ */
 export default function binaryToDecimal(binaryString) {
   let decimalNumber = 0
   const binaryDigits = binaryString.split('').reverse() // Splits the binary number into reversed single digits

Conversions/RGBToHex.js

@@ -1,3 +1,12 @@
+/**
+ * Converts RGB color values to a hexadecimal color code.
+ *
+ * @param {number} r - The red color value (0-255).
+ * @param {number} g - The green color value (0-255).
+ * @param {number} b - The blue color value (0-255).
+ * @returns {string} The hexadecimal color code representing the RGB values.
+ * @throws {TypeError} If any of the arguments is not a number.
+ */
 function RGBToHex(r, g, b) {
   if (typeof r !== 'number' || typeof g !== 'number' || typeof b !== 'number') {
     throw new TypeError('argument is not a Number')

Dynamic-Programming/UniquePaths.js

@@ -12,7 +12,7 @@
  *  More info: https://leetcode.com/problems/unique-paths/
  */
 
-/*
+/**
  * @param {number} m
  * @param {number} n
  * @return {number}

Dynamic-Programming/ZeroOneKnapsack.js

@@ -3,6 +3,11 @@
  * https://en.wikipedia.org/wiki/Knapsack_problem
  *
  * Time and Space Complexity: O(n*cap)
+ * @param {Array<[number, number]>} arr - An array of tuples representing the weights and values of items.
+ * @param {number} n - The number of items available.
+ * @param {number} cap - The capacity of the thief's bag.
+ * @param {Array<Array<number>>} cache - A 2D array to cache computed values for dynamic programming.
+ * @returns {number} The maximum value that can be stolen.
  */
 const zeroOneKnapsack = (arr, n, cap, cache) => {
   // Base Case: No capacity or no items

Graphs/BinaryLifting.js

@@ -1,7 +1,8 @@
 /**
  * Author: Adrito Mukherjee
+ * @class BinaryLifting
  * Binary Lifting implementation in Javascript
- * Binary Lifting is a technique that is used to find the kth ancestor of a node in a rooted tree with N nodes
+ * @classdesc Binary Lifting is a technique that is used to find the kth ancestor of a node in a rooted tree with N nodes
  * The technique requires preprocessing the tree in O(N log N) using dynamic programming
  * The technique can answer Q queries about kth ancestor of any node in O(Q log N)
  * It is faster than the naive algorithm that answers Q queries with complexity O(Q K)
@@ -10,6 +11,12 @@
  */
 
 export class BinaryLifting {
+  /**
+   * Creates an instance of BinaryLifting.
+   * @template T
+   * @param {T} root
+   * @param {Array<[T, T]>} tree - The edges of the tree represented as an array of pairs.
+   */
   constructor(root, tree) {
     this.root = root
     this.connections = new Map()

Maths/ArmstrongNumber.js

@@ -5,7 +5,8 @@
  * An Armstrong number is equal to the sum of its own digits each raised to the power of the number of digits.
  * For example, 370 is an Armstrong number because 3*3*3 + 7*7*7 + 0*0*0 = 370.
  * An Armstrong number is often called Narcissistic number.
- *
+ * @param {number} num - The number to check if it is an Armstrong number.
+ * @returns {boolean} - True if the number is an Armstrong number, false otherwise.
  */
 
 const armstrongNumber = (num) => {

Maths/AverageMedian.js

@@ -7,7 +7,11 @@
  * if the length of the array is even number, the median value will be the average of the two middle numbers
  * else if the length of the array is odd number, the median value will be the middle number in the array
  */
-
+/**
+ * Function to find the median value of an array of numbers.
+ * @param {number[]}
+ * @returns {number} - The median value of the array.
+ */
 const averageMedian = (sourceArrayOfNumbers) => {
   const numbers = [...sourceArrayOfNumbers].sort(sortNumbers)
   const numLength = numbers.length
@@ -16,7 +20,12 @@ const averageMedian = (sourceArrayOfNumbers) => {
     ? (numbers[numLength / 2 - 1] + numbers[numLength / 2]) / 2
     : numbers[Math.floor(numLength / 2)]
 }
-
+/**
+ * Comparator function to sort numbers in ascending order.
+ * @param {number} num1
+ * @param {number} num2
+ * @returns {number}
+ */
 const sortNumbers = (num1, num2) => num1 - num2
 
 export { averageMedian }

Maths/CheckKishnamurthyNumber.js

@@ -6,6 +6,10 @@
 */
 
 // factorial utility method.
+/**
+ * @param {Number} n
+ * @returns {Number} the factiorial of n
+ */
 const factorial = (n) => {
   let fact = 1
   while (n !== 0) {

Maths/Coordinate.js

@@ -4,12 +4,25 @@
  Example: coorDistance(2,2,14,11) will return 15
  Wikipedia reference: https://en.wikipedia.org/wiki/Geographical_distance#Flat-surface_formulae
 */
+/**
+ * @param {number} longitude1 - The longitude of the first point.
+ * @param {number} latitude1 - The latitude of the first point.
+ * @param {number} longitude2 - The longitude of the second point.
+ * @param {number} latitude2 - The latitude of the second point.
+ * @returns {number} - The Euclidean distance between the two points.
+ */
 const euclideanDistance = (longitude1, latitude1, longitude2, latitude2) => {
   const width = longitude2 - longitude1
   const height = latitude2 - latitude1
   return Math.sqrt(width * width + height * height)
 }
-
+/*
+ * @param {number} longitude1 - The longitude of the first point.
+ * @param {number} latitude1 - The latitude of the first point.
+ * @param {number} longitude2 - The longitude of the second point.
+ * @param {number} latitude2 - The latitude of the second point.
+ * @returns {number} - The Manhattan distance between the two points.
+ */
 const manhattanDistance = (longitude1, latitude1, longitude2, latitude2) => {
   const width = Math.abs(longitude2 - longitude1)
   const height = Math.abs(latitude2 - latitude1)

Maths/EulersTotient.js

@@ -7,10 +7,12 @@
   Complexity:
     O(sqrt(n))
 */
-
+/**
+ *
+ * @param {Number} n
+ * @returns {Number} count of numbers b/w 1 and n that are coprime to n
+ */
 export const EulersTotient = (n) => {
-  // input: n: int
-  // output: phi(n): count of numbers b/w 1 and n that are coprime to n
   let res = n
   for (let i = 2; i * i <= n; i++) {
     if (n % i === 0) {

Maths/EulersTotientFunction.js

@@ -7,7 +7,12 @@
     so EulersTotientFunction(n) (or phi(n)) is the count of numbers in {1,2,3,....,n} that are relatively
     prime to n, i.e., the numbers whose GCD (Greatest Common Divisor) with n is 1.
 */
-
+/**
+ *
+ * @param {Number} x
+ * @param {Number} y
+ * @returns {Number} compute greatest common divisor for x and y
+ */
 const gcdOfTwoNumbers = (x, y) => {
   // x is smaller than y
   // let gcd of x and y is gcdXY

Maths/Factors.js

@@ -6,7 +6,9 @@
  *      https://www.mathsisfun.com/definitions/factor.html
  *
  */
-
+/**
+ * @param {Number} [number=0]
+ */
 const factorsOfANumber = (number = 0) => {
   return Array.from(Array(number + 1).keys()).filter(
     (num) => number % num === 0

Maths/FindHcf.js

@@ -3,7 +3,12 @@
     More about HCF:
         https://en.wikipedia.org/wiki/Greatest_common_divisor
  */
-
+/**
+ *
+ * @param {Number} x
+ * @param {Number} y
+ * @returns {(string|number)}
+ */
 const findHCF = (x, y) => {
   // If the input numbers are less than 1 return an error message.
   if (x < 1 || y < 1) {

Maths/FindLcm.js

@@ -14,6 +14,12 @@
 import { findHCF } from './FindHcf'
 
 // Find the LCM of two numbers.
+/**
+ *
+ * @param {Number} num1
+ * @param {Number} num2
+ * @returns
+ */
 const findLcm = (num1, num2) => {
   // If the input numbers are less than 1 return an error message.
   if (num1 < 1 || num2 < 1) {

Maths/FriendlyNumbers.js

@@ -4,7 +4,10 @@
   Source: https://en.wikipedia.org/wiki/Friendly_number
   See also: https://mathworld.wolfram.com/FriendlyNumber.html#:~:text=The%20numbers%20known%20to%20be,numbers%20have%20a%20positive%20density.
 */
-
+/**
+ * @param {Number} firstNumber,
+ * @param {Number} secondNumber
+ */
 export const FriendlyNumbers = (firstNumber, secondNumber) => {
   // input: two integers
   // output: true if the two integers are friendly numbers, false if they are not friendly numbers
@@ -22,11 +25,17 @@ export const FriendlyNumbers = (firstNumber, secondNumber) => {
 
   return abundancyIndex(firstNumber) === abundancyIndex(secondNumber)
 }
-
+/**
+ * @param {Number} number
+ */
 function abundancyIndex(number) {
   return sumDivisors(number) / number
 }
-
+/**
+ *
+ * @param {Number} number
+ * @returns
+ */
 function sumDivisors(number) {
   let runningSumDivisors = number
   for (let i = 0; i < number / 2; i++) {

Maths/IsDivisible.js

@@ -1,5 +1,11 @@
 // Checks if a number is divisible by another number.
-
+/**
+ *
+ * @param {Number} num1
+ * @param {Number} num2
+ * @throws {TypeError}
+ * @returns {boolean}
+ */
 export const isDivisible = (num1, num2) => {
   if (!Number.isFinite(num1) || !Number.isFinite(num2)) {
     throw new TypeError('Expected a valid real number')

Maths/LinearSieve.js

@@ -1,3 +1,8 @@
+/**
+ *
+ * @param {Number} n
+ * @returns {Number[]} array of prime numbers until number n
+ */
 const LinearSieve = (n) => {
   /*
    * Calculates prime numbers till a number n

Maths/MatrixExponentiationRecursive.js

@@ -7,7 +7,11 @@
     where: d is the dimension of the square matrix
            n is the power the matrix is raised to
 */
-
+/**
+ *
+ * @param {Number} n
+ * @returns {Number[][]}
+ */
 const Identity = (n) => {
   // Input: n: int
   // Output: res: Identity matrix of size n x n

Maths/ModularBinaryExponentiationRecursive.js

@@ -5,7 +5,6 @@
   Explanation:
     https://en.wikipedia.org/wiki/Exponentiation_by_squaring
 */
-
 const modularBinaryExponentiation = (a, n, m) => {
   // input: a: int, n: int, m: int
   // returns: (a^n) % m: int

Maths/PerfectCube.js

@@ -3,6 +3,7 @@
  * License: GPL-3.0 or later
  *
  * This uses `round` instead of `floor` or `trunc`, to guard against potential `cbrt` accuracy errors
+ * @param {Number} num
  */
 
 const perfectCube = (num) =>

Recursive/KochSnowflake.js

@@ -13,8 +13,17 @@
  * https://natureofcode.com/book/chapter-8-fractals/ #84-the-koch-curve-and-the-arraylist-technique).
  */
 
-/** Class to handle the vector calculations. */
+/** Class to handle the vector calculations.
+ * @class Vector2
+ */
 export class Vector2 {
+  /**
+   * Creates a new Vector2 instance.
+   * @constructor
+   * @param {number} x - The x component of the vector.
+   * @param {number} y - The y component of the vector.
+   */
+
   constructor(x, y) {
     this.x = x
     this.y = y

Recursive/LetterCombination.js

@@ -11,7 +11,7 @@
  *  More info: https://leetcode.com/problems/letter-combinations-of-a-phone-number/
  */
 
-/*
+/**
  * @param {string} digits
  * @returns {string[]} all the possible combinations
  */

Recursive/PalindromePartitioning.js

@@ -5,12 +5,23 @@ import { palindrome } from './Palindrome'
  * A palindrome partitioning partitions a string into palindromic substrings.
  * @see https://www.cs.columbia.edu/~sedwards/classes/2021/4995-fall/proposals/Palindrome.pdf
  */
+/**
+ * Returns all possible palindrome partitionings of a given string.
+ * @param {string} s
+ * @returns {string[][]} - Array of arrays containing all possible palindrome partitionings.
+ */
 const partitionPalindrome = (s) => {
   const result = []
   backtrack(s, [], result)
   return result
 }
 
+/**
+ * Backtracking function to find palindrome partitionings.
+ * @param {string} s - The remaining part of the string to be checked for partitioning.
+ * @param {string[]} path - Current partitioning path.
+ * @param {string[][]} result - Array to store all valid palindrome partitionings.
+ */
 const backtrack = (s, path, result) => {
   if (s.length === 0) {
     result.push([...path])

Recursive/SubsequenceRecursive.js

@@ -18,7 +18,14 @@
  * https://en.wikipedia.org/wiki/Subsequence
  * https://en.wikipedia.org/wiki/Lexicographic_order
  */
-
+/**
+ * Find all distinct, non-empty subsequences of a given string in lexicographical order using a recursive approach.
+ * @param {string} str
+ * @param {string} seq
+ * @param {number} low
+ * @param {string[]} [output=[]]
+ * @returns {string[]}
+ */
 export const subsequence = (str, seq, low, output = []) => {
   if (low <= str.length && str.length !== 0) {
     output.push(seq)

Recursive/TowerOfHanoi.js

@@ -1,6 +1,14 @@
 // wiki - https://en.wikipedia.org/wiki/Tower_of_Hanoi
 // Recursive Javascript function to solve tower of hanoi
-
+/**
+ * Solves the Tower of Hanoi problem recursively.
+ * @param {number} n - The number of disks to move.
+ * @param {string} from - The rod from which to move the disks.
+ * @param {string} to - The rod to which to move the disks.
+ * @param {string} aux - The auxiliary rod for moving disks.
+ * @param {string[]} [output=[]] - Optional array to store the sequence of moves.
+ * @returns {string[]} The sequence of moves to solve the Tower of Hanoi problem.
+ */
 export function TowerOfHanoi(n, from, to, aux, output = []) {
   if (n === 1) {
     output.push(`Move disk 1 from rod ${from} to rod ${to}`)