Merge pull request #7 from marcode24/2023

✨ add challenge-05 solution

Author: marcode24

2023/05-el-cybertruck-de-santa/README.md

@@ -0,0 +1,83 @@
+# Reto 05: El cybertruck de santa
+
+## Problema
+
+Santa 🎅 está probando su nuevo trineo eléctrico, el CyberReindeer, en una carretera del Polo Norte. La carretera se representa con una cadena de caracteres, donde:
+
+- **. = Carretera**
+- **S = Trineo de Santa**
+- **\* = Barrera abierta**
+- **| = Barrera cerrada**
+
+Ejemplo de carretera: `S...|....|.....`
+
+Cada unidad de tiempo, **el trineo avanza una posición a la derecha.** Si encuentra una barrera cerrada, se detiene hasta que la barrera se abra. Si está abierta, la atraviesa directamente.
+
+**Todas las barreras empiezan cerradas,** pero después de 5 unidades de tiempo, se abren todas **para siempre.**
+
+**Crea una función que simule el movimiento del trineo** durante un tiempo dado y **devuelva un array** de cadenas representando el estado de la carretera en cada unidad de tiempo:
+
+```js
+const road = 'S..|...|..'
+const time = 10 // unidades de tiempo
+const result = cyberReindeer(road, time)
+
+/* -> result:
+[
+  'S..|...|..', // estado inicial
+  '.S.|...|..', // avanza el trineo la carretera
+  '..S|...|..', // avanza el trineo la carretera
+  '..S|...|..', // el trineo para en la barrera
+  '..S|...|..', // el trineo para en la barrera
+  '...S...*..', // se abre la barrera, el trineo avanza
+  '...*S..*..', // avanza el trineo la carretera
+  '...*.S.*..', // avanza el trineo la carretera
+  '...*..S*..', // avanza el trineo la carretera
+  '...*...S..', // avanza por la barrera abierta
+]
+*/
+```
+
+El resultado es un **array donde cada elemento muestra la carretera en cada unidad de tiempo.**
+
+Ten en cuenta que **si el trineo está en la misma posición que una barrera,** entonces toma su lugar en el array.
+
+Los elfos **se inspiraron en este reto de Code Wars.**
+
+## Mi solución
+
+```js
+const cyberReindeer = (road, time) => {
+  const moves = [road];
+  let currentPosition = 0;
+  let b = '.';
+
+  for (let position = 1; position < time; position++) {
+    if (position === 5) road = road.replace(/\|/g, '*');
+    const newRoad = road.replace(/S[.*]/, `${b}S`);
+
+    if (newRoad !== road) {
+      currentPosition++;
+      b = road[currentPosition];
+    }
+
+    road = newRoad;
+    moves.push(road);
+  }
+
+  return moves;
+};
+```
+
+## Explicación de mi solución
+
+1. Creo un array `moves` donde voy a guardar el estado de la carretera en cada unidad de tiempo.
+2. Creo una variable `currentPosition` que me va a indicar la posición actual del trineo en la carretera.
+3. Creo una variable `b` que me va a indicar el estado de la barrera en la posición actual del trineo.
+4. Recorro la carretera `time` veces.
+5. Si la posición actual es igual a 5, entonces reemplazo todas las barreras `|` por barreras abiertas `*`.
+6. Creo una nueva carretera `newRoad` donde reemplazo la posición actual del trineo `S` por el estado de la barrera `b` y el trineo `S`.
+7. Si la nueva carretera es diferente a la carretera anterior, entonces incremento la posición actual del trineo y actualizo el estado de la barrera `b`.
+8. Actualizo la carretera `road` con la nueva carretera `newRoad`.
+9. Agrego la carretera `road` al array `moves`.
+10. Retorno el array `moves`.

2023/05-el-cybertruck-de-santa/index.js

@@ -0,0 +1,22 @@
+const cyberReindeer = (road, time) => {
+  const moves = [road];
+  let currentPosition = 0;
+  let b = '.';
+
+  for (let position = 1; position < time; position++) {
+    if (position === 5) road = road.replace(/\|/g, '*');
+    const newRoad = road.replace(/S[.*]/, `${b}S`);
+
+    if (newRoad !== road) {
+      currentPosition++;
+      b = road[currentPosition];
+    }
+
+    road = newRoad;
+    moves.push(road);
+  }
+
+  return moves;
+};
+
+module.exports = cyberReindeer;

2023/05-el-cybertruck-de-santa/index.test.js

@@ -0,0 +1,74 @@
+const cyberReindeer = require('./index');
+
+describe('05 => El cybertruck de santa', () => {
+  const testCases = [
+    {
+      input: ['S..|...|..', 10],
+      output: [
+        'S..|...|..',
+        '.S.|...|..',
+        '..S|...|..',
+        '..S|...|..',
+        '..S|...|..',
+        '...S...*..',
+        '...*S..*..',
+        '...*.S.*..',
+        '...*..S*..',
+        '...*...S..',
+      ],
+    },
+    {
+      input: ['S.|.', 4],
+      output: [
+        'S.|.',
+        '.S|.',
+        '.S|.',
+        '.S|.',
+      ],
+    },
+    {
+      input: ['S.|.|.', 7],
+      output: [
+        'S.|.|.',
+        '.S|.|.',
+        '.S|.|.',
+        '.S|.|.',
+        '.S|.|.',
+        '..S.*.',
+        '..*S*.',
+      ],
+    },
+    {
+      input: ['S.|..', 6],
+      output: [
+        'S.|..',
+        '.S|..',
+        '.S|..',
+        '.S|..',
+        '.S|..',
+        '..S..',
+      ],
+    },
+    {
+      input: ['S.|.|.|......|.||.........', 8],
+      output: [
+        'S.|.|.|......|.||.........',
+        '.S|.|.|......|.||.........',
+        '.S|.|.|......|.||.........',
+        '.S|.|.|......|.||.........',
+        '.S|.|.|......|.||.........',
+        '..S.*.*......*.**.........',
+        '..*S*.*......*.**.........',
+        '..*.S.*......*.**.........',
+      ],
+    },
+  ];
+
+  it('should return an array type', () => {
+    expect(Array.isArray(cyberReindeer('S|.....', 5))).toBe(true);
+  });
+
+  it.each(testCases)('should return $output', ({ input, output }) => {
+    expect(cyberReindeer(...input)).toEqual(output);
+  });
+});

2023/06-los-renos-a-prueba/README.md

@@ -0,0 +1,58 @@
+# Reto 06: Los renos a prueba
+
+## Problema
+
+Los elfos están catalogando los renos de Santa 🦌 según la distancia que pueden recorrer.
+
+Para ello tienen una cadena de texto movements donde cada caracter representa la dirección del movimiento del reno:
+
+- **\> = Avanza a la derecha**
+- **< = Avanza a la izquierda**
+- **\* = Puede avanzar o retroceder**
+
+Por ejemplo, si el movimiento es >>*<, va hacia la derecha dos veces, luego puede ir a derecha o izquierda (lo que maximice la distancia recorrida final) y luego ir a la izquierda.
+
+Los elfos quieren saber cuál es la máxima distancia que recorre el reno **al finalizar todos los movimientos.**
+
+**En el ejemplo anterior, la máxima distancia que recorre el reno es 2.** Va a la derecha dos veces +2, luego con el * puede ir a la derecha otra vez para maximizar la distancia +1 y luego va a la izquierda -1.
+
+Crea una función `maxDistance` que reciba la cadena de texto `movements` y devuelva **la máxima distancia** que puede recorrer el reno **en cualquier dirección:**
+
+```js
+const movements = '>>*<'
+const result = maxDistance(movements)
+console.log(result) // -> 2
+
+const movements2 = '<<<>'
+const result2 = maxDistance(movements2)
+console.log(result2) // -> 2
+
+const movements3 = '>***>'
+const result3 = maxDistance(movements3)
+console.log(result3) // -> 5
+```
+
+Ten en cuenta que no importa si es a la izquierda o la derecha, la distancia es **el valor absoluto de la distancia recorrida máxima al finalizar los movimientos.**
+
+## Mi solucion
+
+```js
+const maxDistance1 = (movements) => {
+  const { move, stars } = movements.split('').reduce((acc, movement) => {
+    if (movement === '>') acc.move++;
+    else if (movement === '<') acc.move--;
+    else acc.stars++;
+    return acc;
+  }, { move: 0, stars: 0 });
+
+  return Math.abs(move) + stars;
+};
+```
+
+## Explicación de mi solución
+
+1. Primero separamos los movimientos en un array de caracteres con `split('')`.
+2. Luego con `reduce` vamos a ir sumando los movimientos a la derecha y a la izquierda y los asteriscos.
+3. Al finalizar el `reduce` tenemos un objeto con la cantidad de movimientos a la derecha, a la izquierda y los asteriscos.
+4. Para obtener la distancia máxima, sumamos los movimientos a la derecha y a la izquierda y le sumamos los asteriscos.
+5. Como la distancia puede ser negativa, usamos `Math.abs` para obtener el valor absoluto de la distancia.

2023/06-los-renos-a-prueba/index.js

@@ -0,0 +1,54 @@
+/* eslint-disable no-restricted-syntax */
+
+// complejidad: 4
+const maxDistance1 = (movements) => {
+  const { move, stars } = movements.split('').reduce((acc, movement) => {
+    if (movement === '>') acc.move++;
+    else if (movement === '<') acc.move--;
+    else acc.stars++;
+    return acc;
+  }, { move: 0, stars: 0 });
+
+  return Math.abs(move) + stars;
+};
+
+// complejidad: 3
+// para el problema es la que mas da puntos
+const maxDistance2 = (movements) => {
+  let move = 0;
+  let stars = 0;
+
+  for (const movement of movements) {
+    if (movement === '>') move++;
+    else if (movement === '<') move--;
+    else stars++;
+  }
+
+  return Math.abs(move) + stars;
+};
+
+// complejidad: 1
+const maxDistance3 = (movements) => {
+  const left = movements.match(/</g)?.length ?? 0;
+  const right = movements.match(/>/g)?.length ?? 0;
+  const stars = movements.match(/\*/g)?.length ?? 0;
+  return Math.abs(left - right) + stars;
+};
+
+// complejidad: 1
+const maxDistance4 = (movements) => {
+  const counts = { '<': 0, '>': 0, '*': 0 };
+
+  for (const movement of movements) {
+    counts[movement]++;
+  }
+
+  return Math.abs(counts['<'] - counts['>']) + counts['*'];
+};
+
+module.exports = {
+  maxDistance1,
+  maxDistance2,
+  maxDistance3,
+  maxDistance4,
+};

2023/06-los-renos-a-prueba/index.test.js

@@ -0,0 +1,38 @@
+const {
+  maxDistance1, maxDistance2, maxDistance3, maxDistance4,
+} = require('./index');
+
+describe('06 => Los renos a prueba', () => {
+  const testCases = [
+    {
+      input: '>>*<',
+      output: 2,
+    },
+    {
+      input: '<<<<<',
+      output: 5,
+    },
+    {
+      input: '>***>',
+      output: 5,
+    },
+    {
+      input: '**********',
+      output: 10,
+    },
+  ];
+
+  it('should return a number type', () => {
+    expect(typeof maxDistance1('')).toBe('number');
+    expect(typeof maxDistance2('')).toBe('number');
+    expect(typeof maxDistance3('')).toBe('number');
+    expect(typeof maxDistance4('')).toBe('number');
+  });
+
+  it.each(testCases)('should return $output', ({ input, output }) => {
+    expect(maxDistance1(input)).toBe(output);
+    expect(maxDistance2(input)).toBe(output);
+    expect(maxDistance3(input)).toBe(output);
+    expect(maxDistance4(input)).toBe(output);
+  });
+});