✨ Challenge #4: Reverse the Parentheses

Author: monicatvera

2023/challenge-04/README.md

@@ -1,52 +1,29 @@
-# Box inside a box and another...
+# Challenge #4: 😵‍💫 Reverse the Parentheses
 
-## 🔢 Instructions
+In Santa's workshop 🎅, some Christmas messages have been written in a peculiar way: the letters inside the parentheses should be read backward.
 
-Santa Claus needs to review his gift boxes to make sure he can pack them all in his sleigh. He has a series of **boxes of different sizes, characterized by their length, width, and height**.
+Santa needs these messages to be correctly formatted. Your task is to write a function that takes a text string and reverses the characters inside each pair of parentheses, removing the parentheses in the final message.
 
-Your task is to **write a function** that, given a list of boxes with their sizes, determines whether it is possible to pack **all the boxes in one so that each box contains another** (which in turn contains another, and so on).
+However, keep in mind that there may be nested parentheses, so you must reverse the characters in the correct order.
 
-Each box represents its measures with an object. For example: `{l: 2, w: 3, h: 2}`. This means that the box has a length of 2, a width of 3 and a height of 2.
-
-A box fits into another box if all the sides of the first are smaller than the sides of the second. **The elves have told us that the boxes cannot be rotated**, so you cannot put a box of 2x3x2 in a box of 3x2x2. Let's see some examples:
+## Example:
 
 ```javascript
-fitsInOneBox([
-  { l: 1, w: 1, h: 1 },
-  { l: 2, w: 2, h: 2 }
-]); // true
-```
+const a = decode('hola (odnum)')
+console.log(a) // hola mundo
 
-In the previous example, the smallest box fits into the largest box. Therefore, it is possible to pack all the boxes in one. Now let's see a case that does not:
+const b = decode('(olleh) (dlrow)!')
+console.log(b) // hello world!
 
-```javascript
-const boxes = [
-  { l: 1, w: 1, h: 1 },
-  { l: 2, w: 2, h: 2 },
-  { l: 3, w: 1, h: 3 }
-];
+const c = decode('sa(u(cla)atn)s')
+console.log(c) // santaclaus
 
-fitsInOneBox(boxes); // false
+// Step by step:
+// 1. Reverse the nested -> sa(ualcatn)s
+// 2. Reverse the remaining -> santaclaus
 ```
+## Notes:
 
-In the previous example, the smallest box fits into the middle box, but the middle box does not fit into the largest box. Therefore, it is not possible to pack all the boxes in one.
-
-Note that the boxes may not come in order:
-
-```javascript
-const boxes = [
-  { l: 1, w: 1, h: 1 },
-  { l: 3, w: 3, h: 3 },
-  { l: 2, w: 2, h: 2 }
-];
-
-fitsInOneBox(boxes); // true
-```
-
-In the previous example, the first box fits into the third, and the third into the second. Therefore, it is possible to pack all the boxes in one.
-
-**Things to keep in mind**:
-
-- The boxes cannot be rotated because the elves have told us that the machine is not ready.
-- The boxes may come in any order.
-- The boxes are not always squares, they could be rectangles.
+- The input strings will always be well-formed with correctly matching parentheses; no need to validate them.
+- There should be no parentheses left in the final message.
+- The maximum nesting level is 2.

2023/challenge-04/solution.js

@@ -0,0 +1,16 @@
+function decode(message) {
+  let i;
+  while ((i = message.lastIndexOf("(")) + 1) {
+    const j = message.indexOf(")", i);
+    if (j + 1)
+      message =
+        message.slice(0, i) +
+        message
+          .slice(i + 1, j)
+          .split("")
+          .reverse()
+          .join("") +
+        message.slice(j + 1);
+  }
+  return message;
+}

2023/challenge-04/solution.spec.js

@@ -0,0 +1,39 @@
+import { decode } from "./solution";
+
+describe("Challenge #4: 😵‍💫 Reverse the Parentheses", () => {
+  const testCases = [
+    createTestCase(
+      ["hola (odnum)"],
+      "hola mundo",
+      "should reverse characters inside parentheses"
+    ),
+    createTestCase(
+      ["(olleh) (dlrow)!"],
+      "hello world!",
+      "should reverse characters inside parentheses, multiple occurrences"
+    ),
+    createTestCase(
+      ["sa(u(cla)atn)s"],
+      "santaclaus",
+      "should handle nested parentheses"
+    ),
+    createTestCase(
+      [""],
+      "",
+      "should return an empty string when the input is an empty string"
+    ),
+    createTestCase(
+      ["abcde (12345)"],
+      "edcba 54321",
+      "should reverse characters inside parentheses, alphanumeric content"
+    ),
+  ];
+
+  it.each(testCases)("#$# $description", ({ input, expected, description }) => {
+    expect(decode(...input)).toEqual(expected);
+  });
+});
+
+function createTestCase(input, expected, description) {
+  return { input, expected, description };
+}

README.md

@@ -100,6 +100,7 @@ This repository contains the solutions to the challenges proposed by [@midudev](
 | 01  |   [First repeat gift!](2023/challenge-01)    |       🟢       | [Show](2023/challenge-01/solution.js) |
 | 02  |  [Factory in Action!](2023/challenge-02)  |       🟢       | [Show](2023/challenge-02/solution.js) |
 | 03  | [The naughty elf](2023/challenge-03) |       🟢       | [Show](2023/challenge-03/solution.js) |
+| 04  |     [Reverse the Parentheses](2023/challenge-04)      |       🟠       | [Show](2023/challenge-04/solution.js) |
 
 [^1]: **Difficulty**: 🟢 Easy 🟠 Medium 🔴 Hard 🟣 Very Hard