feat(curriculum): daily challenges 120-143 (freeCodeCamp#64173)

Author: moT01

curriculum/challenges/english/blocks/daily-coding-challenges-javascript/69162d64f96574d9bb629efe.md

@@ -12,6 +12,7 @@ Given a distance in miles as a number, return the equivalent distance in kilomet
 - The input will always be a non-negative number.
 - 1 mile equals 1.60934 kilometers.
 - Round the result to two decimal places.
+- Remove unnecessary trailing zeros from the rounded result.
 
 # --hints--
 

curriculum/challenges/english/blocks/daily-coding-challenges-javascript/69162d64f96574d9bb629f00.md

@@ -18,7 +18,7 @@ A valid ordered list item in Markdown must:
 
 If the string doesn't have the exact format above, return `"Invalid format"`. Otherwise, wrap the list item text in `li` tags and return the string.
 
-For example, given `"1. My item"`, return  `"<li>My item</li>"`
+For example, given `"1. My item"`, return `"<li>My item</li>"`.
 
 Note: The console may not display HTML tags in strings when logging messages. Check the browser console to see logs with tags included.
 

curriculum/challenges/english/blocks/daily-coding-challenges-javascript/691b559495c5cb5a37b9b480.md

@@ -0,0 +1,72 @@
+---
+id: 691b559495c5cb5a37b9b480
+title: "Challenge 120: Pounds to Kilograms"
+challengeType: 28
+dashedName: challenge-120
+---
+
+# --description--
+
+Given a weight in pounds as a number, return the string `"(lbs) pounds equals (kgs) kilograms."`.
+
+- Replace `"(lbs)"` with the input number.
+- Replace `"(kgs)"` with the input converted to kilograms, rounded to two decimals and always include two decimal places in the value.
+- 1 pound equals 0.453592 kilograms.
+- If the input is `1`, use `"pound"` instead of `"pounds"`.
+- If the converted value is `1`, use `"kilogram"` instead of `"kilograms"`.
+
+# --hints--
+
+`convertToKgs(1)` should return `"1 pound equals 0.45 kilograms."`.
+
+```js
+assert.equal(convertToKgs(1), "1 pound equals 0.45 kilograms.");
+```
+
+`convertToKgs(0)` should return `"0 pounds equals 0.00 kilograms."`.
+
+```js
+assert.equal(convertToKgs(0), "0 pounds equals 0.00 kilograms.");
+```
+
+`convertToKgs(100)` should return `"100 pounds equals 45.36 kilograms."`.
+
+```js
+assert.equal(convertToKgs(100), "100 pounds equals 45.36 kilograms.");
+```
+
+`convertToKgs(2.5)` should return `"2.5 pounds equals 1.13 kilograms."`.
+
+```js
+assert.equal(convertToKgs(2.5), "2.5 pounds equals 1.13 kilograms.");
+```
+
+`convertToKgs(2.20462)` should return `"2.20462 pounds equals 1.00 kilogram."`.
+
+```js
+assert.equal(convertToKgs(2.20462), "2.20462 pounds equals 1.00 kilogram.");
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertToKgs(lbs) {
+  return lbs;
+}
+```
+
+# --solutions--
+
+```js
+function convertToKgs(lbs) {
+  const KG_PER_POUND = 0.453592;
+  const kgs = (lbs * KG_PER_POUND).toFixed(2);
+
+  const poundWord = lbs === 1 ? "pound" : "pounds";
+  const kilogramWord = kgs === "1.00" ? "kilogram" : "kilograms";
+
+  return `${lbs} ${poundWord} equals ${kgs} ${kilogramWord}.`;
+}
+```

curriculum/challenges/english/blocks/daily-coding-challenges-javascript/691b559495c5cb5a37b9b481.md

@@ -0,0 +1,68 @@
+---
+id: 691b559495c5cb5a37b9b481
+title: "Challenge 121: Most Frequent"
+challengeType: 28
+dashedName: challenge-121
+---
+
+# --description--
+
+Given an array of elements, return the element that appears most frequently.
+
+- There will always be a single most frequent element.
+
+# --hints--
+
+`mostFrequent(["a", "b", "a", "c"])` should return `"a"`.
+
+```js
+assert.equal(mostFrequent(["a", "b", "a", "c"]), "a");
+```
+
+`mostFrequent([2, 3, 5, 2, 6, 3, 2, 7, 2, 9])` should return `2`.
+
+```js
+assert.equal(mostFrequent([2, 3, 5, 2, 6, 3, 2, 7, 2, 9]), 2);
+```
+
+`mostFrequent([true, false, "false", "true", false])` should return `false`.
+
+```js
+assert.isFalse(mostFrequent([true, false, "false", "true", false]));
+```
+
+`mostFrequent([40, 20, 70, 30, 10, 40, 10, 50, 40, 60])` should return `40`.
+
+```js
+assert.equal(mostFrequent([40, 20, 70, 30, 10, 40, 10, 50, 40, 60]), 40);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function mostFrequent(arr) {
+  return arr;
+}
+```
+
+# --solutions--
+
+```js
+function mostFrequent(arr) {
+  const freq = {};
+  let maxCount = 0;
+  let mostElem = null;
+
+  for (const el of arr) {
+    freq[el] = (freq[el] || 0) + 1;
+    if (freq[el] > maxCount) {
+      maxCount = freq[el];
+      mostElem = el;
+    }
+  }
+
+  return mostElem;
+}
+```

curriculum/challenges/english/blocks/daily-coding-challenges-javascript/691b559495c5cb5a37b9b482.md

@@ -0,0 +1,72 @@
+---
+id: 691b559495c5cb5a37b9b482
+title: "Challenge 122: Markdown Bold Parser"
+challengeType: 28
+dashedName: challenge-122
+---
+
+# --description--
+
+Given a string that may include some bold text in Markdown, return the equivalent HTML string.
+
+- Bold text in Markdown is any text that starts and ends with two asterisks (`**`) or two underscores (`__`).
+- There cannot be any spaces between the text and the asterisks or underscores, but there can be
+  spaces in the text itself.
+- Convert all bold occurrences to HTML `b` tags and return the string.
+
+For example, given `"**This is bold**"`, return `"<b>This is bold</b>"`.
+
+Note: The console may not display HTML tags in strings when logging messages. Check the browser console to see logs with tags included.
+
+# --hints--
+
+`parseBold("**This is bold**")` should return `"<b>This is bold</b>"`.
+
+```js
+assert.equal(parseBold("**This is bold**"), "<b>This is bold</b>");
+```
+
+`parseBold("__This is also bold__")` should return `"<b>This is also bold</b>"`.
+
+```js
+assert.equal(parseBold("__This is also bold__"), "<b>This is also bold</b>");
+```
+
+`parseBold("**This is not bold **")` should return `"**This is not bold **"`.
+
+```js
+assert.equal(parseBold("**This is not bold **"), "**This is not bold **");
+```
+
+`parseBold("__ This is also not bold__")` should return `"__ This is also not bold__"`.
+
+```js
+assert.equal(parseBold("__ This is also not bold__"), "__ This is also not bold__");
+```
+
+`parseBold("The **quick** brown fox __jumps__ over the **lazy** dog.")` should return `"The <b>quick</b> brown fox <b>jumps</b> over the <b>lazy</b> dog."`.
+
+```js
+assert.equal(parseBold("The **quick** brown fox __jumps__ over the **lazy** dog."), "The <b>quick</b> brown fox <b>jumps</b> over the <b>lazy</b> dog.");
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function parseBold(markdown) {
+  return markdown;
+}
+```
+
+# --solutions--
+
+```js
+function parseBold(markdown) {
+  markdown = markdown.replace(/\*\*(\S(?:.*?\S)?)\*\*/g, "<b>$1</b>");
+  markdown = markdown.replace(/__(\S(?:.*?\S)?)__/g, "<b>$1</b>");
+
+  return markdown;
+}
+```

curriculum/challenges/english/blocks/daily-coding-challenges-javascript/691b559495c5cb5a37b9b483.md

@@ -0,0 +1,103 @@
+---
+id: 691b559495c5cb5a37b9b483
+title: "Challenge 123: Roman Numeral Builder"
+challengeType: 28
+dashedName: challenge-123
+---
+
+# --description--
+
+Given an integer, return its equivalent value in Roman numerals.
+
+Roman numerals use these symbols:
+
+| Symbol | Value |
+| ------ | ----- |
+| I      | 1     |
+| V      | 5     |
+| X      | 10    |
+| L      | 50    |
+| C      | 100   |
+| D      | 500   |
+| M      | 1000  |
+
+Roman numerals are written from largest to smallest, left to right using the following rules:
+
+- Addition is used when a symbol is followed by one of equal or smaller value. For example, `18` is written as `XVIII` (10 + 5 + 1 + 1 + 1 = 18).
+- Subtraction is used when a smaller symbol appears before a larger one, to represent 4 or 9 in any place value. For example, 19 is written as `XIX` (10 + (10 - 1)).
+- No symbol may be repeated more than three times in a row. Subtraction is used when you would otherwise need to write a symbol more than three times in a row. So the largest number you can write is 3999.
+
+Here's one more example: given `1464`, return `"MCDLXIV"` (1000 + (500 - 100) + 50 + 10 + (5 - 1)).
+
+# --hints--
+
+`toRoman(18)` should return `"XVIII"`.
+
+```js
+assert.equal(toRoman(18), "XVIII");
+```
+
+`toRoman(19)` should return `"XIX"`.
+
+```js
+assert.equal(toRoman(19), "XIX");
+```
+
+`toRoman(1464)` should return `"MCDLXIV"`.
+
+```js
+assert.equal(toRoman(1464), "MCDLXIV");
+```
+
+`toRoman(2025)` should return `"MMXXV"`.
+
+```js
+assert.equal(toRoman(2025), "MMXXV");
+```
+
+`toRoman(3999)` should return `"MMMCMXCIX"`.
+
+```js
+assert.equal(toRoman(3999), "MMMCMXCIX");
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function toRoman(num) {
+  return num;
+}
+```
+
+# --solutions--
+
+```js
+function toRoman(num) {
+  const symbols = [
+    ["M", 1000],
+    ["CM", 900],
+    ["D", 500],
+    ["CD", 400],
+    ["C", 100],
+    ["XC", 90],
+    ["L", 50],
+    ["XL", 40],
+    ["X", 10],
+    ["IX", 9],
+    ["V", 5],
+    ["IV", 4],
+    ["I", 1]
+  ];
+
+  let result = "";
+  for (const [sym, val] of symbols) {
+    while (num >= val) {
+      result += sym;
+      num -= val;
+    }
+  }
+  return result;
+}
+```