fixing JSDOCS for some files in Recursive folder

Author: mohmmadAyesh

Diff for: 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

Diff for: 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
  */

Diff for: 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])

Diff for: 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)

Diff for: 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}`)