chore: merge js branch into main with no fast-forward

Author: IbatoLionDev

3-HARD/JavaScript/1-travelling-salesman-bitmasking/README.md

@@ -0,0 +1,80 @@
+# Travelling Salesman Problem - Bitmasking Approach
+
+## English
+
+The Travelling Salesman Problem (TSP) is a classic algorithmic problem in the field of computer science and operations research. It focuses on optimization. In this problem, a salesman is given a list of cities and must determine the shortest possible route that visits each city exactly once and returns to the origin city.
+
+This challenge requires implementing the TSP using bitmasking and dynamic programming to efficiently explore all possible routes without redundant calculations. The solution is implemented in JavaScript using Object-Oriented Programming (OOP) principles and follows DRY (Don't Repeat Yourself) best practices.
+
+### Relevant Code Snippet
+
+```javascript
+class TravellingSalesman {
+  constructor(distanceMatrix) {
+    this.distanceMatrix = distanceMatrix;
+    this.n = distanceMatrix.length;
+    this.memo = Array.from({ length: this.n }, () => []);
+  }
+
+  tsp(mask = 1, pos = 0) {
+    if (mask === (1 << this.n) - 1) {
+      return this.distanceMatrix[pos][0];
+    }
+    if (this.memo[pos][mask] !== undefined) {
+      return this.memo[pos][mask];
+    }
+
+    let minCost = Infinity;
+    for (let city = 0; city < this.n; city++) {
+      if ((mask & (1 << city)) === 0) {
+        const newCost = this.distanceMatrix[pos][city] + this.tsp(mask | (1 << city), city);
+        if (newCost < minCost) {
+          minCost = newCost;
+        }
+      }
+    }
+    this.memo[pos][mask] = minCost;
+    return minCost;
+  }
+}
+```
+
+---
+
+## Español
+
+El Problema del Viajante de Comercio (TSP) es un problema clásico en el campo de la informática y la investigación operativa. Se centra en la optimización. En este problema, un viajante debe determinar la ruta más corta posible que visite cada ciudad exactamente una vez y regrese a la ciudad de origen.
+
+Este reto requiere implementar el TSP usando bitmasking y programación dinámica para explorar eficientemente todas las rutas posibles sin cálculos redundantes. La solución está implementada en JavaScript usando principios de Programación Orientada a Objetos (POO) y siguiendo las mejores prácticas de DRY (No te repitas).
+
+### Fragmento de Código Relevante
+
+```javascript
+class TravellingSalesman {
+  constructor(distanceMatrix) {
+    this.distanceMatrix = distanceMatrix;
+    this.n = distanceMatrix.length;
+    this.memo = Array.from({ length: this.n }, () => []);
+  }
+
+  tsp(mask = 1, pos = 0) {
+    if (mask === (1 << this.n) - 1) {
+      return this.distanceMatrix[pos][0];
+    }
+    if (this.memo[pos][mask] !== undefined) {
+      return this.memo[pos][mask];
+    }
+
+    let minCost = Infinity;
+    for (let city = 0; city < this.n; city++) {
+      if ((mask & (1 << city)) === 0) {
+        const newCost = this.distanceMatrix[pos][city] + this.tsp(mask | (1 << city), city);
+        if (newCost < minCost) {
+          minCost = newCost;
+        }
+      }
+    }
+    this.memo[pos][mask] = minCost;
+    return minCost;
+  }
+}

3-HARD/JavaScript/1-travelling-salesman-bitmasking/proposed-solution/TravellingSalesman.js

@@ -0,0 +1,33 @@
+// TravellingSalesman.js - TSP solver using Bitmasking and Dynamic Programming with OOP and DRY principles
+
+class TravellingSalesman {
+  constructor(distanceMatrix) {
+    this.distanceMatrix = distanceMatrix;
+    this.n = distanceMatrix.length;
+    this.memo = Array.from({ length: this.n }, () => []);
+  }
+
+  tsp(mask = 1, pos = 0) {
+    if (mask === (1 << this.n) - 1) {
+      return this.distanceMatrix[pos][0];
+    }
+    if (this.memo[pos][mask] !== undefined) {
+      return this.memo[pos][mask];
+    }
+
+    let minCost = Infinity;
+    for (let city = 0; city < this.n; city++) {
+      if ((mask & (1 << city)) === 0) {
+        const newCost =
+          this.distanceMatrix[pos][city] + this.tsp(mask | (1 << city), city);
+        if (newCost < minCost) {
+          minCost = newCost;
+        }
+      }
+    }
+    this.memo[pos][mask] = minCost;
+    return minCost;
+  }
+}
+
+export default TravellingSalesman;

3-HARD/JavaScript/1-travelling-salesman-bitmasking/proposed-solution/main.js

@@ -0,0 +1,22 @@
+/*
+Challenge:  
+Given a set of cities and the distances between every pair of cities, find the shortest possible route that visits each city exactly once and returns to the origin city.  
+This challenge requires implementing the Travelling Salesman Problem (TSP) using bitmasking and dynamic programming to optimize the solution.
+*/
+
+import TravellingSalesman from "./TravellingSalesman.js";
+
+function main() {
+  const distanceMatrix = [
+    [0, 10, 15, 20],
+    [10, 0, 35, 25],
+    [15, 35, 0, 30],
+    [20, 25, 30, 0],
+  ];
+
+  const tspSolver = new TravellingSalesman(distanceMatrix);
+  const minCost = tspSolver.tsp();
+  console.log("Minimum cost to visit all cities:", minCost);
+}
+
+main();

3-HARD/JavaScript/10-word-break/README.md

@@ -0,0 +1,99 @@
+# Word Break
+
+## English
+
+The word break problem is a classic example of recursion with memoization, commonly used in natural language processing and text segmentation tasks. It efficiently explores multiple segmentation paths while avoiding redundant computations.
+
+This challenge involves returning all possible valid sentences that can be formed from a string using words from a dictionary.
+
+### Relevant Code Snippet
+
+```javascript
+class WordBreak {
+  constructor(s, wordDict) {
+    this.s = s;
+    this.wordDict = new Set(wordDict);
+    this.memo = new Map();
+  }
+
+  wordBreak(start = 0) {
+    if (start === this.s.length) {
+      return [""];
+    }
+
+    if (this.memo.has(start)) {
+      return this.memo.get(start);
+    }
+
+    const sentences = [];
+    for (let end = start + 1; end <= this.s.length; end++) {
+      const word = this.s.substring(start, end);
+      if (this.wordDict.has(word)) {
+        const subsentences = this.wordBreak(end);
+        for (const subsentence of subsentences) {
+          const sentence = word + (subsentence ? " " + subsentence : "");
+          sentences.push(sentence);
+        }
+      }
+    }
+
+    this.memo.set(start, sentences);
+    return sentences;
+  }
+}
+```
+
+### History
+
+The word break problem has been widely studied in computer science and is commonly used in natural language processing and text segmentation.
+
+---
+
+## Español
+
+Segmentación de Palabras
+
+El problema de segmentación de palabras es un ejemplo clásico de recursión con memoización, comúnmente usado en procesamiento de lenguaje natural y tareas de segmentación de texto. Explora eficientemente múltiples caminos de segmentación evitando cálculos redundantes.
+
+Este reto consiste en devolver todas las posibles oraciones válidas que se pueden formar a partir de una cadena usando palabras de un diccionario.
+
+### Fragmento de Código Relevante
+
+```javascript
+class WordBreak {
+  constructor(s, wordDict) {
+    this.s = s;
+    this.wordDict = new Set(wordDict);
+    this.memo = new Map();
+  }
+
+  wordBreak(start = 0) {
+    if (start === this.s.length) {
+      return [""];
+    }
+
+    if (this.memo.has(start)) {
+      return this.memo.get(start);
+    }
+
+    const sentences = [];
+    for (let end = start + 1; end <= this.s.length; end++) {
+      const word = this.s.substring(start, end);
+      if (this.wordDict.has(word)) {
+        const subsentences = this.wordBreak(end);
+        for (const subsentence of subsentences) {
+          const sentence = word + (subsentence ? " " + subsentence : "");
+          sentences.push(sentence);
+        }
+      }
+    }
+
+    this.memo.set(start, sentences);
+    return sentences;
+  }
+}
+```
+
+### Historia
+
+El problema de segmentación de palabras ha sido ampliamente estudiado en ciencias de la computación y es comúnmente usado en procesamiento de lenguaje natural y segmentación de texto.

3-HARD/JavaScript/10-word-break/proposed-solution/WordBreak.js

@@ -0,0 +1,36 @@
+// WordBreak.js - Word Break problem using recursion with memoization in JavaScript
+
+class WordBreak {
+  constructor(s, wordDict) {
+    this.s = s;
+    this.wordDict = new Set(wordDict);
+    this.memo = new Map();
+  }
+
+  wordBreak(start = 0) {
+    if (start === this.s.length) {
+      return [""];
+    }
+
+    if (this.memo.has(start)) {
+      return this.memo.get(start);
+    }
+
+    const sentences = [];
+    for (let end = start + 1; end <= this.s.length; end++) {
+      const word = this.s.substring(start, end);
+      if (this.wordDict.has(word)) {
+        const subsentences = this.wordBreak(end);
+        for (const subsentence of subsentences) {
+          const sentence = word + (subsentence ? " " + subsentence : "");
+          sentences.push(sentence);
+        }
+      }
+    }
+
+    this.memo.set(start, sentences);
+    return sentences;
+  }
+}
+
+export default WordBreak;

3-HARD/JavaScript/10-word-break/proposed-solution/main.js

@@ -0,0 +1,21 @@
+/*
+Challenge:
+Given a string and a dictionary, return all possible valid sentences that can be formed using recursion with memoization.
+
+This solution follows DRY principles and is implemented in JavaScript.
+*/
+
+import WordBreak from "./WordBreak.js";
+
+function main() {
+  const s = "catsanddog";
+  const wordDict = ["cat", "cats", "and", "sand", "dog"];
+
+  const wordBreak = new WordBreak(s, wordDict);
+  const sentences = wordBreak.wordBreak();
+
+  console.log("Possible sentences:");
+  sentences.forEach((sentence) => console.log(sentence));
+}
+
+main();