feat(js): add modular solution and documentation for normal challenge 4 - Knapsack Dynamic Programming

Author: IbatoLionDev

2-NORMAL/JavaScript/2-merge-sort-implementation/proposed-solution/main.js

@@ -1,18 +1,17 @@
-
 /*
 Challenge: Develop a function that implements the Merge Sort algorithm to sort an array.
 Evaluate the efficiency of your implementation and consider cases with large arrays.
 */
 
 // main.js - Example usage of MergeSort
 
-import MergeSort from './mergeSort.js';
+import MergeSort from "./mergeSort.js";
 
 function main() {
-    const sampleArray = [38, 27, 43, 3, 9, 82, 10];
-    console.log("Original array:", sampleArray);
-    const sortedArray = MergeSort.mergeSort(sampleArray);
-    console.log("Sorted array:", sortedArray);
+  const sampleArray = [38, 27, 43, 3, 9, 82, 10];
+  console.log("Original array:", sampleArray);
+  const sortedArray = MergeSort.mergeSort(sampleArray);
+  console.log("Sorted array:", sortedArray);
 }
 
 main();

2-NORMAL/JavaScript/2-merge-sort-implementation/proposed-solution/mergeSort.js

@@ -1,30 +1,31 @@
 // mergeSort.js - Merge Sort implementation
 
 class MergeSort {
-    static mergeSort(arr) {
-        if (arr.length <= 1) {
-            return arr;
-        }
-        const mid = Math.floor(arr.length / 2);
-        const left = MergeSort.mergeSort(arr.slice(0, mid));
-        const right = MergeSort.mergeSort(arr.slice(mid));
-        return MergeSort.merge(left, right);
+  static mergeSort(arr) {
+    if (arr.length <= 1) {
+      return arr;
     }
+    const mid = Math.floor(arr.length / 2);
+    const left = MergeSort.mergeSort(arr.slice(0, mid));
+    const right = MergeSort.mergeSort(arr.slice(mid));
+    return MergeSort.merge(left, right);
+  }
 
-    static merge(left, right) {
-        const result = [];
-        let i = 0, j = 0;
-        while (i < left.length && j < right.length) {
-            if (left[i] < right[j]) {
-                result.push(left[i]);
-                i++;
-            } else {
-                result.push(right[j]);
-                j++;
-            }
-        }
-        return result.concat(left.slice(i)).concat(right.slice(j));
+  static merge(left, right) {
+    const result = [];
+    let i = 0,
+      j = 0;
+    while (i < left.length && j < right.length) {
+      if (left[i] < right[j]) {
+        result.push(left[i]);
+        i++;
+      } else {
+        result.push(right[j]);
+        j++;
+      }
     }
+    return result.concat(left.slice(i)).concat(right.slice(j));
+  }
 }
 
 export default MergeSort;

2-NORMAL/JavaScript/3-longest-unique-substring/proposed-solution/longestUniqueSubstring.js

@@ -1,24 +1,24 @@
 // longestUniqueSubstring.js - Implementation of longest unique substring using sliding window technique
 
 class LongestUniqueSubstring {
-    static lengthOfLongestSubstring(s) {
-        const charIndexMap = new Map();
-        let left = 0;
-        let maxLength = 0;
-        let maxSubstring = "";
+  static lengthOfLongestSubstring(s) {
+    const charIndexMap = new Map();
+    let left = 0;
+    let maxLength = 0;
+    let maxSubstring = "";
 
-        for (let right = 0; right < s.length; right++) {
-            if (charIndexMap.has(s[right]) && charIndexMap.get(s[right]) >= left) {
-                left = charIndexMap.get(s[right]) + 1;
-            }
-            charIndexMap.set(s[right], right);
-            if (right - left + 1 > maxLength) {
-                maxLength = right - left + 1;
-                maxSubstring = s.substring(left, right + 1);
-            }
-        }
-        return { maxLength, maxSubstring };
+    for (let right = 0; right < s.length; right++) {
+      if (charIndexMap.has(s[right]) && charIndexMap.get(s[right]) >= left) {
+        left = charIndexMap.get(s[right]) + 1;
+      }
+      charIndexMap.set(s[right], right);
+      if (right - left + 1 > maxLength) {
+        maxLength = right - left + 1;
+        maxSubstring = s.substring(left, right + 1);
+      }
     }
+    return { maxLength, maxSubstring };
+  }
 }
 
 export default LongestUniqueSubstring;

2-NORMAL/JavaScript/3-longest-unique-substring/proposed-solution/main.js

@@ -5,14 +5,18 @@ Use sliding window techniques to optimize the solution's performance.
 
 // main.js - Example usage of LongestUniqueSubstring
 
-import LongestUniqueSubstring from './longestUniqueSubstring.js';
-
+import LongestUniqueSubstring from "./longestUniqueSubstring.js";
 
 function main() {
-    const testString = "abcabcbb";
-    const { maxLength, maxSubstring } = LongestUniqueSubstring.lengthOfLongestSubstring(testString);
-    console.log(`Length of longest substring without repeating characters: ${maxLength}`);
-    console.log(`Longest substring without repeating characters: ${maxSubstring}`);
+  const testString = "abcabcbb";
+  const { maxLength, maxSubstring } =
+    LongestUniqueSubstring.lengthOfLongestSubstring(testString);
+  console.log(
+    `Length of longest substring without repeating characters: ${maxLength}`
+  );
+  console.log(
+    `Longest substring without repeating characters: ${maxSubstring}`
+  );
 }
 
 main();

2-NORMAL/JavaScript/4-knapsack-dynamic-programming/article.md

@@ -0,0 +1,96 @@
+# Challenge Description and Solution
+
+## English Version
+
+### Challenge Description
+Solve the 0/1 knapsack problem using dynamic programming. Given a set of items with weights and values, determine the combination that maximizes value without exceeding the capacity.
+
+### Code Explanation
+The solution uses a 2D dynamic programming table `dp` where `dp[i][w]` represents the maximum value achievable with the first `i` items and capacity `w`.
+
+For each item, the algorithm decides whether to include it or not based on maximizing the total value without exceeding the capacity.
+
+### Relevant Code Snippet
+
+```javascript
+class Knapsack {
+    static knapsack(weights, values, capacity) {
+        const n = weights.length;
+        const dp = Array.from({ length: n + 1 }, () => Array(capacity + 1).fill(0));
+
+        for (let i = 1; i <= n; i++) {
+            for (let w = 0; w <= capacity; w++) {
+                if (weights[i - 1] <= w) {
+                    dp[i][w] = Math.max(
+                        values[i - 1] + dp[i - 1][w - weights[i - 1]],
+                        dp[i - 1][w]
+                    );
+                } else {
+                    dp[i][w] = dp[i - 1][w];
+                }
+            }
+        }
+        return dp[n][capacity];
+    }
+}
+```
+
+### Example Usage
+
+```javascript
+import Knapsack from './knapsack.js';
+
+const weights = [2, 3, 4, 5];
+const values = [3, 4, 5, 6];
+const capacity = 5;
+const maxValue = Knapsack.knapsack(weights, values, capacity);
+console.log(`Maximum value in knapsack with capacity ${capacity}: ${maxValue}`);
+```
+
+---
+
+## Versión en Español
+
+### Descripción del Reto
+Resuelve el problema de la mochila 0/1 usando programación dinámica. Dado un conjunto de objetos con pesos y valores, determina la combinación que maximiza el valor sin exceder la capacidad.
+
+### Explicación del Código
+La solución utiliza una tabla 2D de programación dinámica `dp` donde `dp[i][w]` representa el valor máximo alcanzable con los primeros `i` objetos y capacidad `w`.
+
+Para cada objeto, el algoritmo decide si incluirlo o no basado en maximizar el valor total sin exceder la capacidad.
+
+### Fragmento de Código Relevante
+
+```javascript
+class Knapsack {
+    static knapsack(weights, values, capacity) {
+        const n = weights.length;
+        const dp = Array.from({ length: n + 1 }, () => Array(capacity + 1).fill(0));
+
+        for (let i = 1; i <= n; i++) {
+            for (let w = 0; w <= capacity; w++) {
+                if (weights[i - 1] <= w) {
+                    dp[i][w] = Math.max(
+                        values[i - 1] + dp[i - 1][w - weights[i - 1]],
+                        dp[i - 1][w]
+                    );
+                } else {
+                    dp[i][w] = dp[i - 1][w];
+                }
+            }
+        }
+        return dp[n][capacity];
+    }
+}
+```
+
+### Ejemplo de Uso
+
+```javascript
+import Knapsack from './knapsack.js';
+
+const weights = [2, 3, 4, 5];
+const values = [3, 4, 5, 6];
+const capacity = 5;
+const maxValue = Knapsack.knapsack(weights, values, capacity);
+console.log(`Valor máximo en la mochila con capacidad ${capacity}: ${maxValue}`);

2-NORMAL/JavaScript/4-knapsack-dynamic-programming/proposed-solution/knapsack.js

@@ -0,0 +1,24 @@
+// knapsack.js - 0/1 Knapsack problem using dynamic programming
+
+class Knapsack {
+  static knapsack(weights, values, capacity) {
+    const n = weights.length;
+    const dp = Array.from({ length: n + 1 }, () => Array(capacity + 1).fill(0));
+
+    for (let i = 1; i <= n; i++) {
+      for (let w = 0; w <= capacity; w++) {
+        if (weights[i - 1] <= w) {
+          dp[i][w] = Math.max(
+            values[i - 1] + dp[i - 1][w - weights[i - 1]],
+            dp[i - 1][w]
+          );
+        } else {
+          dp[i][w] = dp[i - 1][w];
+        }
+      }
+    }
+    return dp[n][capacity];
+  }
+}
+
+export default Knapsack;

2-NORMAL/JavaScript/4-knapsack-dynamic-programming/proposed-solution/main.js

@@ -0,0 +1,20 @@
+// main.js - Example usage of Knapsack
+
+import Knapsack from "./knapsack.js";
+
+/*
+Challenge: Solve the 0/1 knapsack problem using dynamic programming.
+Given a set of items with weights and values, determine the combination that maximizes value without exceeding the capacity.
+*/
+
+function main() {
+  const weights = [2, 3, 4, 5];
+  const values = [3, 4, 5, 6];
+  const capacity = 5;
+  const maxValue = Knapsack.knapsack(weights, values, capacity);
+  console.log(
+    `Maximum value in knapsack with capacity ${capacity}: ${maxValue}`
+  );
+}
+
+main();