AdventJS 2023: Reto del día 3
Tags: spanish, javascript, challenge, node
Published: 2023-12-04 16:15:21

Solución al [reto #3](https://adventjs.dev/es/challenges/2023/3) del [AdventJS 2023](https://adventjs.dev/es)

[Solución del reto anterior](https://dev.to/fenriuz/adventjs-2023-dia-1-2ncc)
[Solución del siguiente reto](https://dev.to/fenriuz/adventjs-2023-reto-del-dia-4-2h4g)

## Descripción del Reto

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.

```javascript
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

## Análisis

El objetivo es escribir una función que pueda identificar la primer diferencia entre dos strings, ya sea por un char extra en el string o un char faltante.

<aside>
💡 **Char:** En programación, el tipo de dato **char** es para caracteres (character en inglés). Es decir es un símbolo (letras, números, puntuación) como: a, +, 6, !, S. En JavaScript sigue siendo un string, no hay un tipo de dato para char, pero cuando hablamos de él nos referimos a un solo caracter.

Fuente: [Glosario de MDN](https://developer.mozilla.org/es/docs/Glossary/Character)

</aside>

**Entrada:**

1. Original(`original`): El string original, del que debemos partir para encontrar las diferencias. Vienen siendo los pasos originales.
2. Modified(`modified`): El string modificado al cuál debemos encontrarle el primer char extra o el primer char faltante. Son los pasos modificados por el elfo travieso.

**Salida:**

- Un string mostrando el char extra o faltante, de no ser encontrado retornar un string vacío `''`

**Consideraciones**

- El modificado no solo debe contener los chars del original, también debe tenerlos en el mismo orden

## Solución

Se puede usar un ciclo para ir comparando char por char en los strings y al encontrar la diferencia, evaluar si es un elementro exrta o un elemento faltante y retornarlo. De no cumplirse las condiciones retornamos en su defecto un string vacío `''`.

### Código

```javascript
/**
 * Encontrar el primer char diferente entre dos strings.
 *
 * @param {string} original - String original.
 * @param {string} modified - String modificado.
 * @return {string} La primera diferencia entre el string original y el modificado.
 */
function findNaughtyStep(original, modified) {
  // Empezamos declarando el índice que estaremos iterando
  let i = 0;

  // Mientras i sea menor que el tamaños de los dos strings
  // recorremos cada uno de ellos para irlos comparando
  while (i < original.length || i < modified.length) {
    // Si el char del string original es distinto al char del string modificado,
    // Si son iguales continuamos iterando y sumando 1 al indice

    if (original[i] !== modified[i]) {
      // Si el string original tiene más caracteres que el string modificado,
      // retornamos el char del string original.
      // sino retornamos el char del string modificado
      return original.length > modified.length ? original[i] : modified[i];
    }

    i += 1;
  }

  return '';
}
```

### Soluciones de la comunidad

Solución de [Achalogy](https://github.com/Achalogy/advent-js-2023/blob/main/retos/reto-3/main.ts):

```javascript
function findNaughtyStep(original, modified) {

  const [lessWords, mostWords] =
    [original, modified].sort((a, b) => a.length - b.length)

  return [...mostWords].find((x, i) => lessWords[i] != x) ?? "";
}
```

Solución de [iswilljr](https://github.com/iswilljr/adventjs-challenges/blob/master/2023/challenge-03/challenge-03.ts):

```javascript
function findNaughtyStep(original: string, modified: string) {
  const originalLen = original.length
  const modifiedLen = modified.length

  const sequences = {
    [originalLen]: [original, modified],
    [modifiedLen]: [modified, original],
  }

  const [steps, reference] = sequences[Math.max(originalLen, modifiedLen)]

  return [...steps].find((step, index) => step !== reference[index]) ?? ''
}
```

Y ese fue el reto para el 3 de diciembre y sus soluciones. ¿Tienes otra solución alternativa? ¡Déjala en los comentarios!