add 2022

Author: monicatvera

2022/challenge-01/README.md

@@ -0,0 +1,28 @@
+# Automating Christmas gift wrapping!
+
+## 🔢 Instructions
+
+This year the elves have bought a gift wrapping machine. But... it's not programmed! **We need to create an algorithm that helps it in the task**.
+
+The machine receives an array with the gifts. Each gift is a `string`. We need the machine to wrap each gift in wrapping paper and place it in an array of wrapped gifts.
+
+The wrapping paper is the `*` symbol and to wrap a gift the `*` symbol is placed so that it completely surrounds the string on all sides. For example:
+
+```javascript
+const gifts = ['book', 'game', 'socks'];
+const wrapped = wrapping(gifts);
+console.log(wrapped);
+/* [
+  "******\n*book*\n******",
+  "******\n*game*\n******",
+  "*******\n*socks*\n*******"
+] */
+```
+
+As you can see, the wrapping paper wraps the string. On top and bottom, so as not to leave any gaps, the corners are also covered with wrapping paper.
+
+**Note**: `\n` is the character that represents a line break.
+
+**Watch out!** Make sure you put the right number of \* to wrap completely the string.
+
+**Good luck!**

2022/challenge-01/solution.js

@@ -0,0 +1,8 @@
+const wrapping = gifts => {
+  return gifts.map(gift => {
+    const wrapper = '*'.repeat(gift.length + 2);
+    return `${wrapper}\n*${gift}*\n${wrapper}`;
+  });
+};
+
+export { wrapping };

2022/challenge-01/solution.spec.js

@@ -0,0 +1,24 @@
+import { wrapping } from './solution';
+
+describe('Challenge 01: ¡Automatizando envolver regalos de Navidad!', () => {
+  describe('wrapping(...)', () => {
+    const testCases = [
+      createTestCase(
+        [['book', 'game', 'socks']],
+        ['******\n*book*\n******', '******\n*game*\n******', '*******\n*socks*\n*******'],
+        'should return a list of wrapped gifts (1)'
+      ),
+      createTestCase([['midu']], ['******\n*midu*\n******'], 'should return a list of wrapped gifts (2)'),
+      createTestCase([['a']], ['***\n*a*\n***'], 'should return a list of wrapped gifts (3)'),
+      createTestCase([[]], [], 'should return en empty list if no gifts are given')
+    ];
+
+    it('#T should return an array', () => {
+      expect(wrapping([])).toBeInstanceOf(Array);
+    });
+
+    it.each(testCases)('#$# $description', ({ args, expected }) => {
+      expect(wrapping(...args)).toEqual(expected);
+    });
+  });
+});

2022/challenge-02/README.md

@@ -0,0 +1,28 @@
+# Nobody wants to do extra hours at work
+
+## 🔢 Instructions
+
+A millionaire has bought a social network and it doesn't bring good news. He has announced that **each time a working day is lost due to a holiday**, it will have to be compensated with **two extra hours another day of the same year**.
+
+Obviously the people who work in the company have not made the slightest joke and are **preparing a program that tells them the number of extra hours they would do** in the year if the new rule were applied.
+
+Since it is office work, their working hours are **from Monday to Friday**. So you only have to worry about the holidays that fall on those days.
+
+Given a year and an array with the dates of the holidays, return the number of extra hours that would be done that year:
+
+```javascript
+const year = 2022;
+const holidays = ['01/06', '04/01', '12/25']; // format MM/DD
+
+// 01/06 is January 6, Thursday. Count.
+// 04/01 is April 1, Friday. Count.
+// 12/25 is December 25, Sunday. Do not count.
+
+countHours(year, holidays); // 2 days -> 4 extra hours in the year
+```
+
+**Things to keep in mind**:
+
+- The year can be a leap year. Make the checks you need for it, if necessary.
+- Although the holiday is December 31, the extra hours will be done the same year.
+- `Date.getDay()` method returns the day of the week of a date. `0` is Sunday, `1` is Monday, etc.

2022/challenge-02/solution.js

@@ -0,0 +1,17 @@
+const countHours = (year, holidays) => {
+  return holidays.reduce((overtimeHours, holiday) => {
+    const dayOfWeek = new Date(`${holiday}/${year}`).getDay();
+    const isWorkDay = dayOfWeek !== 0 && dayOfWeek !== 6;
+    return isWorkDay ? overtimeHours + 2 : overtimeHours;
+  }, 0);
+};
+
+const countHoursAlt = (year, holidays) => {
+  return holidays.reduce((overtimeHours, holiday) => {
+    const dayOfWeek = new Date(`${holiday}/${year}`).getDay();
+    const isWorkDay = [1, 2, 3, 4, 5].includes(dayOfWeek);
+    return overtimeHours + isWorkDay * 2;
+  }, 0);
+};
+
+export { countHours, countHoursAlt };

2022/challenge-02/solution.spec.js

@@ -0,0 +1,26 @@
+import { countHours, countHoursAlt } from './solution';
+
+describe('Challenge 02: Nobody wants to do extra hours at work', () => {
+  describe('countHours(...)', () => {
+    const testCases = [
+      createTestCase([2023, ['01/06', '04/01', '12/25']], 4, 'should return 4 for 2023'),
+      createTestCase([2022, ['01/06', '04/01', '12/25']], 4, 'should return 4 for 2022'),
+      createTestCase(
+        [1985, ['01/01', '01/06', '02/02', '02/17', '02/28', '06/03', '12/06', '12/25']],
+        10,
+        'should return 10 for 1985'
+      ),
+      createTestCase([2000, ['01/01']], 0, 'should return 0 for 2000')
+    ];
+
+    it('#T should return a number', () => {
+      expect(typeof countHours(2022, ['01/01'])).toBe('number');
+      expect(typeof countHoursAlt(2022, ['01/01'])).toBe('number');
+    });
+
+    it.each(testCases)('#$# $description', ({ args, expected }) => {
+      expect(countHours(...args)).toEqual(expected);
+      expect(countHoursAlt(...args)).toEqual(expected);
+    });
+  });
+});

2022/challenge-03/README.md

@@ -0,0 +1,23 @@
+# How many packs of gifts can Santa carry?
+
+## 🔢 Instructions
+
+You receive a Christmas gifts pack that Santa Claus wants to deliver to the children. **Each gift inside the pack is represented by a string** and it has a weight equal to the number of letters in its name. Santa Claus's sleigh can only carry a **weight limit**.
+
+Santa Claus also has a list of reindeer able to help him to deliver the gifts. Each reindeer has a **maximum weight limit** that it can carry. The maximum weight limit of each reindeer is **equal to twice the number of letters in its name**.
+
+Your task is to implement a function `distributeGifts(packOfGifts, reindeers)` that receives a gifts pack and a list of reindeer and returns the maximum number of gifts packs that Santa Claus can deliver. **You can't split gifts packs**.
+
+```javascript
+const packOfGifts = ['book', 'doll', 'ball'];
+const reindeers = ['dasher', 'dancer'];
+
+// pack weights 4 + 4 + 4 = 12
+// reindeers can carry (2 * 6) + (2 * 6) = 24
+distributeGifts(packOfGifts, reindeers); // 2
+```
+
+**Things to keep in mind**:
+
+- The gifts pack can't be splitted.
+- Gifts and reindeers' names length will always be greater than 0.

2022/challenge-03/solution.js

@@ -0,0 +1,10 @@
+const distributeGifts = (packOfGifts, reindeers) => {
+  return Math.floor((reindeers.join``.length * 2) / packOfGifts.join``.length);
+};
+
+const distributeGiftsAlt = (packOfGifts, reindeers) => {
+  // Only valid for numbers between [−2147483648, 2147483647]
+  return ((reindeers.join``.length * 2) / packOfGifts.join``.length) | 0;
+};
+
+export { distributeGifts, distributeGiftsAlt };

2022/challenge-03/solution.spec.js

@@ -0,0 +1,43 @@
+import { distributeGifts, distributeGiftsAlt } from './solution';
+
+describe('Challenge 03: How many packs of gifts can Santa carry?', () => {
+  describe('distributeGifts(...)', () => {
+    const testCases = [
+      createTestCase(
+        [
+          ['a', 'b', 'c'],
+          ['d', 'e']
+        ],
+        1,
+        'should return 1 when Santa has 3 gifts with total weight of 3 and 2 reindeers whose weight limit is 4'
+      ),
+      createTestCase([['videogames', 'console'], ['midu']], 0, "should return 0 if reindeers can't carry any pack"),
+      createTestCase(
+        [
+          ['game', 'videoconsole', 'computer'],
+          ['midudev', 'pheralb', 'codingwithdani', 'carlosble', 'blasco', 'facundocapua', 'madeval', 'memxd']
+        ],
+        5,
+        'should return 5 when Santa has 3 gifts with total weight of 24 and 8 reindeers whose weight limit is 134'
+      ),
+      createTestCase(
+        [
+          ['music'],
+          ['midudev', 'pheralb', 'codingwithdani', 'carlosble', 'blasco', 'facundocapua', 'madeval', 'memxd']
+        ],
+        26,
+        'should return 26 when Santa has 1 gift with total weight of 5 and 8 reindeers whose weight limit is 134'
+      )
+    ];
+
+    it('#T should return a number', () => {
+      expect(typeof distributeGifts([], [])).toBe('number');
+      expect(typeof distributeGiftsAlt([], [])).toBe('number');
+    });
+
+    it.each(testCases)('#$# $description', ({ args, expected }) => {
+      expect(distributeGifts(...args)).toEqual(expected);
+      expect(distributeGiftsAlt(...args)).toEqual(expected);
+    });
+  });
+});

2022/challenge-04/README.md

@@ -0,0 +1,52 @@
+# Box inside a box and another...
+
+## 🔢 Instructions
+
+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**.
+
+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).
+
+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:
+
+```javascript
+fitsInOneBox([
+  { l: 1, w: 1, h: 1 },
+  { l: 2, w: 2, h: 2 }
+]); // true
+```
+
+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:
+
+```javascript
+const boxes = [
+  { l: 1, w: 1, h: 1 },
+  { l: 2, w: 2, h: 2 },
+  { l: 3, w: 1, h: 3 }
+];
+
+fitsInOneBox(boxes); // false
+```
+
+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.

2022/challenge-04/solution.js

@@ -0,0 +1,42 @@
+const fitsInOneBox = boxes => {
+  const sortedBoxes = [...boxes].sort((firstBox, secondBox) => {
+    return firstBox.l - secondBox.l;
+  });
+
+  return sortedBoxes.every(({ l: currentBoxL, w: currentBoxW, h: currentBoxH }, index, boxesList) => {
+    const { l: previousBoxL, w: previousBoxW, h: previousBoxH } = boxesList[index - 1] || {};
+
+    const isFirstBox = index === 0;
+    const canCurrentBoxContainPreviousOne =
+      currentBoxL > previousBoxL && currentBoxW > previousBoxW && currentBoxH > previousBoxH;
+
+    return isFirstBox || canCurrentBoxContainPreviousOne;
+  });
+};
+
+const fitsInOneBoxAlt = boxes => {
+  const sortedBoxes = [...boxes].sort((firstBox, secondBox) => {
+    return secondBox.l - firstBox.l;
+  });
+
+  return sortedBoxes.slice(1).every(({ l: currentBoxL, w: currentBoxW, h: currentBoxH }, index) => {
+    const { l: previousBoxL, w: previousBoxW, h: previousBoxH } = sortedBoxes[index] || {};
+    return currentBoxL < previousBoxL && currentBoxW < previousBoxW && currentBoxH < previousBoxH;
+  });
+};
+
+const fitsInOneBoxSome = boxes => {
+  const sortedBoxes = [...boxes].sort((firstBox, secondBox) => {
+    return firstBox.l - secondBox.l;
+  });
+
+  return !sortedBoxes.some((currentBox, index, sortedBoxesList) =>
+    sortedBoxesList
+      .slice(index + 1)
+      .some(remainBox =>
+        [remainBox.l > currentBox.l, remainBox.w > currentBox.w, remainBox.h > currentBox.h].includes(false)
+      )
+  );
+};
+
+export { fitsInOneBox, fitsInOneBoxAlt, fitsInOneBoxSome };

2022/challenge-04/solution.spec.js

@@ -0,0 +1,63 @@
+import { fitsInOneBox, fitsInOneBoxAlt, fitsInOneBoxSome } from './solution';
+
+describe('Challenge 04: Box inside a box and another...', () => {
+  describe('fitsInOneBox(...)', () => {
+    const testCases = [
+      createTestCase(
+        [
+          [
+            { l: 1, w: 1, h: 1 },
+            { l: 2, w: 2, h: 2 }
+          ]
+        ],
+        true,
+        'should fit in one box'
+      ),
+      createTestCase(
+        [
+          [
+            { l: 1, w: 1, h: 1 },
+            { l: 2, w: 2, h: 2 },
+            { l: 3, w: 1, h: 3 }
+          ]
+        ],
+        false,
+        'should not fit in one box'
+      ),
+      createTestCase(
+        [
+          [
+            { l: 1, w: 1, h: 1 },
+            { l: 2, w: 2, h: 2 },
+            { l: 2, w: 10, h: 2 }
+          ]
+        ],
+        false,
+        'should not fit in one box'
+      ),
+      createTestCase(
+        [
+          [
+            { l: 1, w: 1, h: 1 },
+            { l: 3, w: 3, h: 3 },
+            { l: 2, w: 2, h: 2 }
+          ]
+        ],
+        true,
+        'should fit in one box'
+      )
+    ];
+
+    it('#T should return a boolean', () => {
+      expect(typeof fitsInOneBox([{ l: 1, w: 1, h: 1 }])).toBe('boolean');
+      expect(typeof fitsInOneBoxAlt([{ l: 1, w: 1, h: 1 }])).toBe('boolean');
+      expect(typeof fitsInOneBoxSome([{ l: 1, w: 1, h: 1 }])).toBe('boolean');
+    });
+
+    it.each(testCases)('#$# $description', ({ args, expected }) => {
+      expect(fitsInOneBox(...args)).toEqual(expected);
+      expect(fitsInOneBoxAlt(...args)).toEqual(expected);
+      expect(fitsInOneBoxSome(...args)).toEqual(expected);
+    });
+  });
+});