Merge pull request #6 from marcode24/2023-02

📦 update package

Author: marcode24

2023/02-ponemos-en-marcha-la-fabrica/README.md

@@ -0,0 +1,40 @@
+# Reto 02: Ponemos en marcha la fabrica
+
+## Problema
+
+En el taller de Santa, los elfos tienen una lista de regalos que desean fabricar y un conjunto limitado de materiales.
+
+Los regalos son cadenas de texto y los materiales son caracteres. Tu tarea es escribir una función que, dada una lista de regalos y los materiales disponibles, devuelva una lista de los regalos que se pueden fabricar.
+
+Un regalo se puede fabricar si contamos con todos los materiales necesarios para fabricarlo.
+
+```js
+const gifts = ['tren', 'oso', 'pelota']
+const materials = 'tronesa'
+
+manufacture(gifts, materials) // ["tren", "oso"]
+// 'tren' SÍ porque sus letras están en 'tronesa'
+// 'oso' SÍ porque sus letras están en 'tronesa'
+// 'pelota' NO porque sus letras NO están en 'tronesa'
+
+const gifts = ['juego', 'puzzle']
+const materials = 'jlepuz'
+
+manufacture(gifts, materials) // ["puzzle"]
+
+const gifts = ['libro', 'ps5']
+const materials = 'psli'
+
+manufacture(gifts, materials) // []
+```
+
+## Mi solución
+
+```js
+const manufacture = (gifts, materials) => gifts.filter((gift) => (
+  [...gift].every((letter) => materials.includes(letter))));
+```
+
+## Explicación de mi solución
+
+1. Utilizo el método `filter` para filtrar los regalos que se pueden fabricar. Para ello, utilizo el método `every` para comprobar que todas las letras del regalo están en los materiales disponibles. Para ello, convierto el regalo en un array de letras utilizando el operador de propagación `...` y compruebo que todas las letras están en los materiales utilizando el método `includes`.

2023/02-ponemos-en-marcha-la-fabrica/index.js

@@ -0,0 +1,4 @@
+const manufacture = (gifts, materials) => gifts.filter((gift) => (
+  [...gift].every((letter) => materials.includes(letter))));
+
+module.exports = manufacture;

2023/02-ponemos-en-marcha-la-fabrica/index.test.js

@@ -0,0 +1,34 @@
+const manufacture = require('./index');
+
+describe('02 => Ponemos en marcha la fabrica', () => {
+  const testCases = [
+    {
+      input: [['tren', 'oso', 'pelota'], 'tronesa'],
+      output: ['tren', 'oso'],
+    },
+    {
+      input: [['coche', 'muñeca', 'balon'], 'ocmuñalb'],
+      output: [],
+    },
+    {
+      input: [['patineta', 'robot', 'libro'], 'nopor'],
+      output: [],
+    },
+    {
+      input: [[], 'letras'],
+      output: [],
+    },
+    {
+      input: [['juego', 'puzzle'], 'jlepuz'],
+      output: ['puzzle'],
+    },
+  ];
+
+  it('should return an array type ', () => {
+    expect(Array.isArray(manufacture(['a'], ['a']))).toBe(true);
+  });
+
+  it.each(testCases)('should return $output', ({ input, output }) => {
+    expect(manufacture(...input)).toEqual(output);
+  });
+});

2023/03-el-elfo-travieso/README.md

@@ -0,0 +1,29 @@
+# Reto 03: El elfo travieso
+
+## Problema
+
+En el taller de Santa, **un elfo travieso** ha estado jugando en la cadena de fabricación de regalos, añadiendo o eliminando un paso no planificado.
+
+Tienes la secuencia original de pasos en la fabricación original y la secuencia modificada modified que puede incluir un paso extra o faltar un paso.
+
+Tu tarea **es escribir una función que identifique y devuelva el primer paso extra que se ha añadido o eliminado en la cadena de fabricación.** Si no hay ninguna diferencia entre las secuencias, devuelve una cadena vacía.
+
+```js
+const original = 'abcd'
+const modified = 'abcde'
+findNaughtyStep(original, modified) // 'e'
+
+const original = 'stepfor'
+const modified = 'stepor'
+findNaughtyStep(original, modified) // 'f'
+
+const original = 'abcde'
+const modified = 'abcde'
+findNaughtyStep(original, modified) // ''
+```
+
+A tener en cuenta:
+
+- **Siempre habrá un paso de diferencia o ninguno.**
+- **La modificación puede ocurrir en cualquier lugar de la cadena.**
+- **La secuencia original puede estar vacía**

2023/03-el-elfo-travieso/index.js

@@ -0,0 +1,13 @@
+const findNaughtyStep = (original, modified) => {
+  const maxLength = Math.max(original.length, modified.length);
+
+  for (let i = 0; i < maxLength; i++) {
+    if (original[i] !== modified[i]) {
+      return original.length > modified.length ? original[i] : modified[i];
+    }
+  }
+
+  return '';
+};
+
+module.exports = findNaughtyStep;

2023/03-el-elfo-travieso/index.test.js

@@ -0,0 +1,34 @@
+const findNaughtyStep = require('./index');
+
+describe('03 => El elfo travieso', () => {
+  const testCases = [
+    {
+      input: ['abcd', 'abcde'],
+      output: 'e',
+    },
+    {
+      input: ['abcde', 'abcd'],
+      output: 'e',
+    },
+    {
+      input: ['xxxx', 'xxoxx'],
+      output: 'o',
+    },
+    {
+      input: ['stepfor', 'stepor'],
+      output: 'f',
+    },
+    {
+      input: ['iiiii', 'iiiii'],
+      output: '',
+    },
+  ];
+
+  it('should return a string type', () => {
+    expect(typeof findNaughtyStep('a', 'a')).toBe('string');
+  });
+
+  it.each(testCases)('should return $output', ({ input, output }) => {
+    expect(findNaughtyStep(...input)).toBe(output);
+  });
+});

2023/04-dale-la-vuelta-a-los-parentesis/README.md

@@ -0,0 +1,86 @@
+# Reto 04: Dale la vuelta a los parentesis
+
+## Problema
+
+En el taller de Santa 🎅, algunos mensajes navideños han sido escritos de manera peculiar: **las letras dentro de los paréntesis deben ser leídas al revés**
+
+**Santa necesita que estos mensajes estén correctamente formateados.** Tu tarea es escribir una función que tome una cadena de texto y revierta los caracteres dentro de cada par de paréntesis, eliminando los paréntesis en el mensaje final.
+
+Eso sí, ten en cuenta que **pueden existir paréntesis anidados**, por lo que debes invertir los caracteres en el orden correcto.
+
+```js
+const a = decode('hola (odnum)')
+console.log(a) // hola mundo
+
+const b = decode('(olleh) (dlrow)!')
+console.log(b) // hello world!
+
+const c = decode('sa(u(cla)atn)s')
+console.log(c) // santaclaus
+
+// Paso a paso:
+// 1. Invertimos el anidado -> sa(ualcatn)s
+// 2. Invertimos el que queda -> santaclaus
+```
+
+Notas:
+
+- Las cadenas de entrada siempre estarán bien formadas con paréntesis que coinciden correctamente, no necesitas validarlos.
+- En el mensaje final no deben quedar paréntesis.
+- El nivel máximo de anidamiento es 2.
+
+## Mi solución
+
+**Solucion 1:**
+
+```js
+const decode = (message) => {
+  let result = '';
+  const stack = [];
+
+  [...message].forEach((char) => {
+    if (char === '(') {
+      stack.push(result);
+      result = '';
+    } else if (char === ')') {
+      result = `${stack.pop()}${result.split('').reverse().join('')}`;
+    } else {
+      result += char;
+    }
+  });
+
+  return result;
+};
+```
+
+**Solucion 2:**
+
+```js
+const decode2 = (message) => {
+  const regex = /\(([^()]+)\)/;
+  let match = message.match(regex);
+  while (match) {
+    const reversed = match[1].split('').reverse().join('');
+    message = message.replace(match[0], reversed);
+    match = message.match(regex);
+  }
+  return message;
+};
+```
+
+## Explicación de mi solución
+
+**Solucion 1:**
+
+1. Inicializo la variable `result` a una cadena vacía y la variable `stack` a un array vacío.
+2. Convierto la cadena de entrada en un array de caracteres utilizando el operador de propagación `...` y recorro el array utilizando el método `forEach`.
+3. Si el caracter es un paréntesis de apertura, añado el valor de `result` al array `stack` y reinicio `result` a una cadena vacía.
+4. Si el caracter es un paréntesis de cierre, invierto el valor de `result` y lo concateno con el último valor del array `stack`.
+5. Si el caracter no es un paréntesis, lo añado a `result`.
+6. Devuelvo `result`.
+
+**Solucion 2:**
+
+1. Utilizo una expresión regular para buscar el primer paréntesis de apertura y cierre con cualquier caracter entre ellos.
+2. Mientras exista un paréntesis de apertura y cierre, invierto los caracteres entre los paréntesis y los reemplazo en la cadena de entrada.
+3. Devuelvo la cadena de entrada.

2023/04-dale-la-vuelta-a-los-parentesis/index.js

@@ -0,0 +1,35 @@
+// complejidad: 3
+const decode = (message) => {
+  let result = '';
+  const stack = [];
+
+  [...message].forEach((char) => {
+    if (char === '(') {
+      stack.push(result);
+      result = '';
+    } else if (char === ')') {
+      result = `${stack.pop()}${result.split('').reverse().join('')}`;
+    } else {
+      result += char;
+    }
+  });
+
+  return result;
+};
+
+// complejidad: 2
+const decode2 = (message) => {
+  const regex = /\(([^()]+)\)/;
+  let match = message.match(regex);
+  while (match) {
+    const reversed = match[1].split('').reverse().join('');
+    message = message.replace(match[0], reversed);
+    match = message.match(regex);
+  }
+  return message;
+};
+
+module.exports = {
+  decode,
+  decode2,
+};

2023/04-dale-la-vuelta-a-los-parentesis/index.test.js

@@ -0,0 +1,32 @@
+const { decode, decode2 } = require('./index');
+
+describe('04 => Dale la vuelta a los parentesis', () => {
+  const testCases = [
+    {
+      input: 'hola (odnum)',
+      output: 'hola mundo',
+    },
+    {
+      input: '(olleh) (dlrow)!',
+      output: 'hello world!',
+    },
+    {
+      input: 'sa(u(cla)atn)s',
+      output: 'santaclaus',
+    },
+    {
+      input: '((nta)(sa))',
+      output: 'santa',
+    },
+  ];
+
+  it('should return a string type', () => {
+    expect(typeof decode('a')).toBe('string');
+    expect(typeof decode2('a')).toBe('string');
+  });
+
+  it.each(testCases)('should return $output', ({ input, output }) => {
+    expect(decode(input)).toBe(output);
+    expect(decode2(input)).toBe(output);
+  });
+});

README.md

@@ -8,12 +8,15 @@ Built by [@midudev](https://twitter.com/midudev)
 
 ## 🎯 2023 Challenges
 
-<details>
-<summary show>Show / Hide</summary>
+<details open>
+<summary>Show / Hide</summary>
 
-|  #  | Challenge                                                                                   | Difficulty |                                            My Solution                                             |
-| :-: | ------------------------------------------------------------------------------------------- | :--------: | :------------------------------------------------------------------------------------------------: |
-| 01  | [¡Primer regalo repetido!](https://adventjs.dev/es/challenges/2023/1)                       |     🟢     |  [here](https://github.com/marcode24/adventjs-solutions/tree/main/2023/01-primer-regalo-repetido)  |
+|  #  | Challenge                                                                                   | Difficulty |                                           My Solution                                                           |
+| :-: | ------------------------------------------------------------------------------------------- | :--------: | :------------------------------------------------------------------------------------------------------------:  |
+| 01  | [¡Primer regalo repetido!](https://adventjs.dev/es/challenges/2023/1)                       |     🟢     |        [here](https://github.com/marcode24/adventjs-solutions/tree/main/2023/01-primer-regalo-repetido)         |
+| 02  | [Ponemos en marcha la fábrica](https://adventjs.dev/es/challenges/2023/2)                   |     🟢     |       [here](https://github.com/marcode24/adventjs-solutions/tree/main/2023/02-ponemos-en-marcha-la-fabrica)    |
+| 03  | [El elfo travieso](https://adventjs.dev/es/challenges/2023/3)                               |     🟢     |               [here](https://github.com/marcode24/adventjs-solutions/tree/main/2023/03-el-elfo-travieso)        |
+| 04  | [Dale la vuelta a los paréntesis](https://adventjs.dev/es/challenges/2023/4)                |     🟡     |   [here](https://github.com/marcode24/adventjs-solutions/tree/main/2023/04-dale-la-vuelta-a-los-parentesis)     |
 
 Difficulties legend:
 🟢 Easy 🟡 Medium 🔴 Hard