feat(curriculum): daily challenges 264-278 (freeCodeCamp#67117)

Co-authored-by: majestic-owl448 <26656284+majestic-owl448@users.noreply.github.com>

Author: moT01

curriculum/challenges/english/blocks/daily-coding-challenges-javascript/69cfca90e8a0a6d4d6871c4e.md

@@ -0,0 +1,76 @@
+---
+id: 69cfca90e8a0a6d4d6871c4e
+title: "Challenge 264: Anagram Groups"
+challengeType: 28
+dashedName: challenge-264
+---
+
+# --description--
+
+Given an array of words, return a 2d array of the words grouped into anagrams.
+
+- Words are anagrams if they contain the same letters in any order.
+- Each word belongs to exactly one group.
+- Return order doesn't matter.
+
+For example, given `["listen", "silent", "hello", "enlist", "world"]`, return `[["listen", "silent", "enlist"], ["hello"], ["world"]]`.
+
+# --hints--
+
+`groupAnagrams(["listen", "silent", "hello", "enlist", "world"])` should return `[["listen", "silent", "enlist"], ["hello"], ["world"]]`.
+
+```js
+const groups = groupAnagrams(["listen", "silent", "hello", "enlist", "world"]);
+const sorted = groups.map(g => g.sort()).sort((a, b) => a[0].localeCompare(b[0]));
+assert.deepEqual(sorted, [["enlist", "listen", "silent"], ["hello"], ["world"]]);
+```
+
+`groupAnagrams(["eat", "tea", "tan", "ate", "nat", "bat"])` should return `[["ate", "eat", "tea"], ["bat"], ["nat", "tan"]]`.
+
+```js
+const groups = groupAnagrams(["eat", "tea", "tan", "ate", "nat", "bat"]);
+const sorted = groups.map(g => g.sort()).sort((a, b) => a[0].localeCompare(b[0]));
+assert.deepEqual(sorted, [["ate", "eat", "tea"], ["bat"], ["nat", "tan"]]);
+```
+
+`groupAnagrams(["care", "race", "acre", "pots", "stop", "tops", "opts", "post", "spot", "evil", "vile", "live", "veil"])` should return `[["acre", "care", "race"], ["evil", "live", "veil", "vile"], ["opts", "post", "pots", "spot", "stop", "tops"]]`.
+
+```js
+const groups = groupAnagrams(["care", "race", "acre", "pots", "stop", "tops", "opts", "post", "spot", "evil", "vile", "live", "veil"]);
+const sorted = groups.map(g => g.sort()).sort((a, b) => a[0].localeCompare(b[0]));
+assert.deepEqual(sorted, [["acre", "care", "race"], ["evil", "live", "veil", "vile"], ["opts", "post", "pots", "spot", "stop", "tops"]]);
+
+```
+
+`groupAnagrams(["algorithms", "logarithms", "education", "cautioned", "auctioned", "triangle", "integral", "alerting", "relating"])` should return `[["alerting", "integral", "relating", "triangle"], ["algorithms", "logarithms"], ["auctioned", "cautioned", "education"]]`.
+
+```js
+const groups = groupAnagrams(["algorithms", "logarithms", "education", "cautioned", "auctioned", "triangle", "integral", "alerting", "relating"]);
+const sorted = groups.map(g => g.sort()).sort((a, b) => a[0].localeCompare(b[0]));
+assert.deepEqual(sorted, [["alerting", "integral", "relating", "triangle"], ["algorithms", "logarithms"], ["auctioned", "cautioned", "education"]]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function groupAnagrams(words) {
+
+  return words;
+}
+```
+
+# --solutions--
+
+```js
+function groupAnagrams(words) {
+  const map = {};
+  for (const word of words) {
+    const key = word.split('').sort().join('');
+    if (!map[key]) map[key] = [];
+    map[key].push(word);
+  }
+  return Object.values(map);
+}
+```

curriculum/challenges/english/blocks/daily-coding-challenges-javascript/69cfca90e8a0a6d4d6871c4f.md

@@ -0,0 +1,83 @@
+---
+id: 69cfca90e8a0a6d4d6871c4f
+title: "Challenge 265: Deepest Brackets"
+challengeType: 28
+dashedName: challenge-265
+---
+
+# --description--
+
+Given a string containing balanced brackets, return the content of the deepest nested brackets.
+
+- Brackets can be any of the three types: `()`, `[]`, and `{}`.
+- The input will always have a single deepest group.
+
+For example, given `"(hello (world))"`, return `"world"`.
+
+# --hints--
+
+`getDeepestBrackets("(hello (world))")` should return `"world"`.
+
+```js
+assert.equal(getDeepestBrackets("(hello (world))"), "world");
+```
+
+`getDeepestBrackets("[outer [inner] outer]")` should return `"inner"`.
+
+```js
+assert.equal(getDeepestBrackets("[outer [inner] outer]"), "inner");
+```
+
+`getDeepestBrackets("{a{b}c{d{e}f}g}")` should return `"e"`.
+
+```js
+assert.equal(getDeepestBrackets("{a{b}c{d{e}f}g}"), "e");
+```
+
+`getDeepestBrackets("[the {quick (brown [fox] jumped) over (the) lazy} dog]")` should return `"fox"`.
+
+```js
+assert.equal(getDeepestBrackets("[the {quick (brown [fox] jumped) over (the) lazy} dog]"), "fox");
+```
+
+`getDeepestBrackets("f[(r)e{e}C{o[(d){e(C)}a]m}]p")` should return `"C"`.
+
+```js
+assert.equal(getDeepestBrackets("f[(r)e{e}C{o[(d){e(C)}a]m}]p"), "C");
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function getDeepestBrackets(str) {
+
+  return str;
+}
+```
+
+# --solutions--
+
+```js
+function getDeepestBrackets(str) {
+  let maxDepth = 0, depth = 0, content = '';
+  let start = 0;
+
+  for (let i = 0; i < str.length; i++) {
+    if ('([{'.includes(str[i])) {
+      depth++;
+      if (depth > maxDepth) {
+        maxDepth = depth;
+        start = i + 1;
+      }
+    } else if (')]}'.includes(str[i])) {
+      if (depth === maxDepth) {
+        content = str.slice(start, i);
+      }
+      depth--;
+    }
+  }
+  return content;
+}
+```

curriculum/challenges/english/blocks/daily-coding-challenges-javascript/69cfca90e8a0a6d4d6871c50.md

@@ -0,0 +1,72 @@
+---
+id: 69cfca90e8a0a6d4d6871c50
+title: "Challenge 266: Good Day"
+challengeType: 28
+dashedName: challenge-266
+---
+
+# --description--
+
+Given a time string in `"HH:MM"` format (24-hour clock), return:
+
+- `"Good morning"` for times `05:00` to `11:59`
+- `"Good afternoon"` for times `12:00` to `17:59`
+- `"Good evening"` for times `18:00` to `21:59`
+- `"Good night"` for times `22:00` to `04:59`
+
+# --hints--
+
+`getGreeting("06:30")` should return `"Good morning"`.
+
+```js
+assert.equal(getGreeting("06:30"), "Good morning");
+```
+
+`getGreeting("12:00")` should return `"Good afternoon"`.
+
+```js
+assert.equal(getGreeting("12:00"), "Good afternoon");
+```
+
+`getGreeting("21:59")` should return `"Good evening"`.
+
+```js
+assert.equal(getGreeting("21:59"), "Good evening");
+```
+
+`getGreeting("00:01")` should return `"Good night"`.
+
+```js
+assert.equal(getGreeting("00:01"), "Good night");
+```
+
+`getGreeting("11:30")` should return `"Good morning"`.
+
+```js
+assert.equal(getGreeting("11:30"), "Good morning");
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function getGreeting(time) {
+
+  return time;
+}
+```
+
+# --solutions--
+
+```js
+function getGreeting(time) {
+  const [hours, minutes] = time.split(':').map(Number);
+  const total = hours * 60 + minutes;
+
+  if (total >= 300 && total < 720) return 'Good morning';
+  if (total >= 720 && total < 1080) return 'Good afternoon';
+  if (total >= 1080 && total < 1320) return 'Good evening';
+  return 'Good night';
+}
+```

curriculum/challenges/english/blocks/daily-coding-challenges-javascript/69cfca90e8a0a6d4d6871c51.md

@@ -0,0 +1,82 @@
+---
+id: 69cfca90e8a0a6d4d6871c51
+title: "Challenge 267: Parsec Converter"
+challengeType: 28
+dashedName: challenge-267
+---
+
+# --description--
+
+In a distant galaxy, parsecs are used to measure both time and distance. Given an integer number of parsecs, return its equivalent in time or distance.
+
+- If the given integer is odd, it represents time. If it's even, it represents distance.
+
+Use these conversion rates:
+
+| Parsecs | Time/Distance |
+| - | - |
+| 1 | 2 hours |
+| 2 | 6 light years |
+
+Return the converted value as an integer.
+
+# --hints--
+
+`convertParsecs(1)` should return `2`.
+
+```js
+assert.equal(convertParsecs(1), 2);
+```
+
+`convertParsecs(2)` should return `6`.
+
+```js
+assert.equal(convertParsecs(2), 6);
+```
+
+`convertParsecs(31)` should return `62`.
+
+```js
+assert.equal(convertParsecs(31), 62);
+```
+
+`convertParsecs(88)` should return `264`.
+
+```js
+assert.equal(convertParsecs(88), 264);
+```
+
+`convertParsecs(17)` should return `34`.
+
+```js
+assert.equal(convertParsecs(17), 34);
+```
+
+`convertParsecs(14)` should return `42`.
+
+```js
+assert.equal(convertParsecs(14), 42);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertParsecs(parsecs) {
+
+  return parsecs;
+}
+```
+
+# --solutions--
+
+```js
+function convertParsecs(parsecs) {
+  if (parsecs % 2 !== 0) {
+    return parsecs * 2;
+  } else {
+    return parsecs * 3;
+  }
+}
+```