feat(curriculum): add JS BFS workshop (freeCodeCamp#65848)

Co-authored-by: Jeevankumar S <110320697+Jeevankumar-s@users.noreply.github.com>
Co-authored-by: majestic-owl448 <26656284+majestic-owl448@users.noreply.github.com>
Co-authored-by: Kolade <chrisjay967@gmail.com>

Author: 4 people

client/i18n/locales/english/intro.json

@@ -5707,6 +5707,12 @@
           "In this lab, you will implement a function that converts an adjacency list representation of a graph into an adjacency matrix representation."
         ]
       },
+      "workshop-breadth-first-search-js": {
+        "title": "Implement the Breadth-First Search Algorithm",
+        "intro": [
+          "In this workshop, you will use the breadth-first search algorithm to generate all valid combinations of parentheses."
+        ]
+      },
       "lab-depth-first-search-js": {
         "title": "Implement the Depth-First Search Algorithm",
         "intro": [

curriculum/challenges/english/blocks/workshop-breadth-first-search-js/6989eb65324d97775c4965fe.md

@@ -0,0 +1,44 @@
+---
+id: 6989eb65324d97775c4965fe
+title: Step 1
+challengeType: 1
+dashedName: step-1
+---
+
+# --description--
+
+In this workshop, you'll implement a function that generates all valid combinations of parentheses using a breadth-first search (BFS) approach. For example, the valid combinations of two pairs of parentheses are `(())` and `()()`.
+
+Start by creating a function named `genParentheses` with a single parameter `pairs`. For now, return an empty array from the function.
+
+# --hints--
+
+You should define a function named `genParentheses`.
+
+```js
+assert.isFunction(genParentheses);
+```
+
+Your `genParentheses` function should have a single parameter named `pairs`.
+
+```js
+const genParenthesesParams = __helpers.getFunctionParams(genParentheses.toString());
+assert.equal(genParenthesesParams[0].name, 'pairs')
+```
+
+Your function should return an empty array.
+
+```js
+assert.isArray(genParentheses(1));
+assert.lengthOf(genParentheses(1), 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+--fcc-editable-region--
+
+--fcc-editable-region--
+```

curriculum/challenges/english/blocks/workshop-breadth-first-search-js/6989ef885db3a3488a13b426.md

@@ -0,0 +1,50 @@
+---
+id: 6989ef885db3a3488a13b426
+title: Step 2
+challengeType: 1
+dashedName: step-2
+---
+
+# --description--
+
+Before implementing the core algorithm, you need to validate the input. The `pairs` parameter should be an integer, as it represents the number of parentheses pairs to generate.
+
+Add an `if` statement at the beginning of your function to check if `pairs` is not an integer. Use the `Number.isInteger()` method for that.
+
+If the condition is true, return the string `The number of pairs should be an integer`.
+
+# --hints--
+
+You should have an if statement with the condition `!Number.isInteger(pairs)` inside the `genParentheses` function.
+
+```js
+assert.match(genParentheses.toString(), /if\s*\(\s*!\s*Number\.isInteger\s*\(\s*pairs\s*\)\s*\)/);
+```
+
+You should return a string when the input is not an integer.
+
+```js
+let result = genParentheses("i");
+assert.isString(result);
+```
+
+You should return the string `The number of pairs should be an integer` when the input is a string.
+
+```js
+let result = genParentheses("i");
+assert.strictEqual(result, 'The number of pairs should be an integer');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function genParentheses(pairs) {
+--fcc-editable-region--
+  
+--fcc-editable-region--
+  return [];
+}
+```
+

curriculum/challenges/english/blocks/workshop-breadth-first-search-js/6989f10a72ad424d4ad6d514.md

@@ -0,0 +1,43 @@
+---
+id: 6989f10a72ad424d4ad6d514
+title: Step 3
+challengeType: 1
+dashedName: step-3
+---
+
+# --description--
+
+Next, you need to validate that the number of pairs is at least one, since you can't generate parentheses combinations with zero or negative pairs.
+
+Add another `if` statement to check if `pairs` is less than `1`. If this condition is true, return the string `The number of pairs should be at least 1`.
+
+# --hints--
+
+You should have a second `if` statement with the condition `pairs < 1`.
+
+```js
+assert.match(genParentheses.toString(), /if\s*\(\s*pairs\s*<\s*1\s*\)/);
+```
+
+You should return the string `The number of pairs should be at least 1` when `pairs` is less than `1`.
+
+```js
+let result = genParentheses(0);
+assert.strictEqual(result, 'The number of pairs should be at least 1');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function genParentheses(pairs) {
+  if (!Number.isInteger(pairs)) {
+    return 'The number of pairs should be an integer';
+  }
+--fcc-editable-region--
+  
+--fcc-editable-region--
+  return [];
+}
+```

curriculum/challenges/english/blocks/workshop-breadth-first-search-js/6989f1ba358acba651d5ee6b.md

@@ -0,0 +1,51 @@
+---
+id: 6989f1ba358acba651d5ee6b
+title: Step 4
+challengeType: 1
+dashedName: step-4
+---
+
+# --description--
+
+Now you'll set up the data structure to store your results. Create a variable named `result` and initialize it to an empty array. This array will store all the valid parentheses combinations you generate.
+
+Update your return statement to return `result` instead of an empty array.
+
+# --hints--
+
+You should declare a variable named `result` in your `genParentheses` function.
+
+```js
+assert.match(genParentheses.toString(), /result/);
+```
+
+You should initialize `result` to an empty array.
+
+```js
+assert.match(genParentheses.toString(), /result\s*=\s*\[\]/);
+```
+
+You should return `result` at the end of your function.
+
+```js
+assert.match(genParentheses.toString(), /return\s*result/);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function genParentheses(pairs) {
+  if (!Number.isInteger(pairs)) {
+    return 'The number of pairs should be an integer';
+  }
+  if (pairs < 1) {
+    return 'The number of pairs should be at least 1';
+  }
+--fcc-editable-region--
+  
+  return [];
+--fcc-editable-region--
+}
+```

curriculum/challenges/english/blocks/workshop-breadth-first-search-js/6989f207306332c06b0add39.md

@@ -0,0 +1,50 @@
+---
+id: 6989f207306332c06b0add39
+title: Step 5
+challengeType: 1
+dashedName: step-5
+---
+
+# --description--
+
+For the breadth-first search approach, you'll use a queue to track different states as you build the parentheses combinations. Each state will be represented as an array containing three elements:
+
+- The current string being built
+- The number of opening parentheses used so far
+- The number of closing parentheses used so far
+
+Create a variable named `queue` and initialize it to an array containing one array: `['', 0, 0]`. This represents the starting state with an empty string and zero parentheses used.
+
+# --hints--
+
+You should declare a variable named `queue` in your `genParentheses` function.
+
+```js
+assert.match(genParentheses.toString(), /queue/);
+```
+
+You should initialize `queue` with an array containing the array `['', 0, 0]`.
+
+```js
+assert.match(genParentheses.toString(), /queue\s*=\s*\[\s*\['',\s*0,\s*0\]\s*\]/);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function genParentheses(pairs) {
+  if (!Number.isInteger(pairs)) {
+    return 'The number of pairs should be an integer';
+  }
+  if (pairs < 1) {
+    return 'The number of pairs should be at least 1';
+  }
+--fcc-editable-region--
+  
+--fcc-editable-region--
+  let result = [];
+  return result;
+}
+```

curriculum/challenges/english/blocks/workshop-breadth-first-search-js/6989f2e35e6941e13e445156.md

@@ -0,0 +1,49 @@
+---
+id: 6989f2e35e6941e13e445156
+title: Step 6
+challengeType: 1
+dashedName: step-6
+---
+
+# --description--
+
+Now you'll implement the main BFS loop. Create a `while` loop that continues as long as the `queue` is not empty, that is, `queue.length` is greater than `0`.
+
+Inside the loop, log `queue` to the console.
+
+# --hints--
+
+You should create a `while` loop with the condition `queue.length > 0`.
+
+```js
+assert.match(genParentheses.toString(), /while\s*\(\s*queue\.length\s*>\s*0\s*\)/);
+```
+
+You should log `queue` to the console inside your `while` loop.
+
+```js
+assert.match(genParentheses.toString(), /while\s*\(\s*queue\.length\s*>\s*0\s*\)/);
+assert.match(genParentheses.toString(), /console\.log\s*\(\s*queue\s*\)/);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function genParentheses(pairs) {
+  if (!Number.isInteger(pairs)) {
+    return 'The number of pairs should be an integer';
+  }
+  if (pairs < 1) {
+    return 'The number of pairs should be at least 1';
+  }
+  let queue = [['', 0, 0]];
+  let result = [];
+--fcc-editable-region--
+  
+--fcc-editable-region--
+    
+  return result;
+}
+```

curriculum/challenges/english/blocks/workshop-breadth-first-search-js/6989f3632f8b8bdf168aa321.md

@@ -0,0 +1,56 @@
+---
+id: 6989f3632f8b8bdf168aa321
+title: Step 7
+challengeType: 1
+dashedName: step-7
+---
+
+# --description--
+
+Inside your `while` loop, use `queue.shift()` to remove and get the first element from the queue. This implements the first-in-first-out (FIFO) behavior characteristic of BFS.
+
+Destructure this array into three variables: `current`, `opensUsed`, and `closesUsed`.
+
+# --hints--
+
+You should use `queue.shift()` to get the first element from the queue.
+
+```js
+assert.match(genParentheses.toString(), /queue\.shift\s*\(\s*\)/);
+```
+
+You should destructure the result into three variables: `current`, `opensUsed`, and `closesUsed`.
+
+```js
+assert.match(genParentheses.toString(), /opensUsed/);
+assert.match(genParentheses.toString(), /closesUsed/);
+assert.match(genParentheses.toString(), /current/);
+assert.match(genParentheses.toString(), /queue\.shift\s*\(\s*\)/);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function genParentheses(pairs) {
+  if (!Number.isInteger(pairs)) {
+    return 'The number of pairs should be an integer';
+  }
+  if (pairs < 1) {
+    return 'The number of pairs should be at least 1';
+  }
+
+  let queue = [['', 0, 0]];
+  let result = [];
+
+  while (queue.length > 0) {
+    console.log(queue);
+--fcc-editable-region--
+    
+--fcc-editable-region--
+  }
+
+  return result;
+}
+```