AdventJS 2023: Reto del día 3

Solución al reto #3 del AdventJS 2023

Solución del reto anterior
Solución del siguiente reto

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.

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.

💡 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

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

/**
 * 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:

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:

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!

Comments

[Alejandro Jiménez Gracia]

He encontrado una solución que también está bastante bien:

function findNaughtyStep(original, modified) {
  // Comenzamos consiguiendo el string con más palabras.
  const longerString = original.length > modified.length ? original : modified

  // Iteramos sobre el string con más palabras.
  for (let i = 0; i < longerString.length; i++){
    // Cuando encontramos el carácter distinto, devolvemos de la palabra más larga el carácter faltante.
    if (original[i] != modified[i]){
      return longerString[i] 
    }
  }
  return ""
}

[Fenriuz]

Corta y limpia solución, gracias Alejandro, buen aporte.
Por cierto, cuando comentes y quieras mostrar código puedes poner javascript al crear un bloque de código para que haga el resaltado de la sintaxis

const myStr = 'Hello world!

[Alejandro Jiménez Gracia]

Corregido! Muchas gracias por el consejo!