Playground - encuentra el palindromo más grande

Leonardo de los angeles Espinoza Hernandez

student•

🛡️🛡️Escudo anti spoilers🛡️🛡️

¡Bienvenido o bienvenida a tu primer checkpoint!

. Este desafío tiene un grado más alto de dificultad, combinando todo lo anteriormente aprendido en un solo ejercicio. Tómalo como un jefe final de la primer semana el cuál podrás resolver de multiples maneras y si logras pasarlo significa que tienes muy bien aprendidos los fundamentos de bucles, arrays, funciones, objetos y demás. ¿Y si no? ¡No pasa nada! puedes seguir adelante aprendiendo y cuando te sientes preparado o preparada puedes volver a este ejercicio y tratar de pasar este primer checkpoint ¡No te estanques! puedes comentar la parte que se te complicó y en comunidad te ayudaremos a resolverlo 💚 . Dicho todo esto, a continuación tendrás un gif randóm y JUSTO DESPUÉS LA EXPLICACIÓN CON EL CÓDIGO DE LA SOLUCIÓN por lo que haz scroll una vez sientas que necesites una explicación más a fondo acerca de la solución proporcionada. . Momento random del día !dancing bird .

Explicación

export function findLargestPalindrome(words) {
  // Primero definimos que la palabra más larga es null
  // Debido a que no se tiene un valor 
  let largest = null;
  // Después iteramos por cada una de las palabras
  for (const word of words) {
    // con split("") creamos un array donde cada elemento es una letra
    // Ejemplo "hola" => ["h","o","l","a"]
    // con reverse() "volteamos" el array
    // Ejemplo ["h","o","l","a"] => ["a"","l","o","h"]
    // y con .join("") volvemos a convertirlo en un string
    // Ejemplo  ["a"","l","o","h"] => "aloh"
    const reversedWord = word.split("").reverse().join("");
    // La primer validación que hacemos es para ver si efectivamente es un array
    if (reversedWord === word) {
      // Si si lo es, primero verificamos que se reemplace la variable largest
      // por el primer palindromo si es que no existe uno aún
      if (largest == null || word.length > largest.length) {
         // En caso de existir, se compara su longitud con el palindromo existente
        largest = word;
      }
    }
  }

  // Al final siempre retornamos la variable largest
  // Ya que si no existe ni uno solo en el array, su valor se mantiene como null
  return largest;
}

. ¿Que te pareció este primer checkpoint?¿Más difícil o más fácil de lo esperado? . Preparate porque aumentaremos la dificultad para el siguiente checkpoint 🔥

Raul Carrillo Garrido

student•

Jajajaj me acabo de dar cuenta viendo el ejeplo de que mi estrategia para detectar palíndromos es , cuando menosm """larga""" xDDDDD

Carlos Gutiérrez

student•

Otro reto puede ser este mismo ejercicio sin usar split, reverse y join para que uno mismo se cuestione si realmente estoy entendiendo que hacen esas tres instrucciones juntas o dicho de otra forma si no existieran esas funciones como las construyo por mi cuenta o en este caso particular como puedo comprobar si una palabra es palíndromo porque si encontramos una palabra con tilde seguro ese método no va a funcionar o por si queremos analizar no una palabra sino toda una frase.

Anita laba la tina Dábale arroz a la zorra el abad

PD. AL buscar ejemplos de frases que son palíndromos encontré una referencia al palíondromo más largo en español del venozolano Darío Lancini que tiene un poema de 74 palabras titulado Amor azul.

_ 'Amor azul' Ramera, de todo te di. Mariposa colosal, sí, yo de todo te di.

Poda la rosa, Venus. El átomo como tal es un evasor alado.

Pide, todo te doy: isla, sol, ocaso, pirámide. Todo te daré: mar, luz, aroma._

Por último una forma que implementé para ver si una palabra es palíndromo

// La función compara la primera letra (i) con la última (j)
// luego la segunda (i+1) con la penúltima (j-1) luego i+3 con j-3, etc
function palindromo(word){
// i para la primera letra y j para la última letra
  let j = word.length - 1; 
  for (let i= 0; i<=j; i++ ){
     if (word[i] != word[j]){ 
        return false; 
       // si encuentra una letra que no se igual sale inmediatamente y regresa false
     } 
     j--;
   }
   return true;
 
}

Santiago Palacio Vásquez

student•

Anti-Spoiler:

Solución:

/**
 * @param {string[]} words
 * @returns {string} null or the largest palindrome in the array.
 */
function findLargestPalindrome(words) {
    return words.reduce((prevWord, word) => (word && word.toLowerCase() === word.toLowerCase().split('').reverse().join('') && word.length > prevWord.length) ? word : prevWord, '') || null
}

Lo importante para que una palabra sea palíndroma es que se lea igual de izquierda a derecha que de derecha a izquierda, independientemente de si contiene letras mayúsculas o minúsculas.

Sebastian Camilo Guaqueta Melo

student•

La solución más eficiente que he visto

Miguel Angel Muñoz Pozos

student•

este es mi solucion cheque que faltaba convertir las palabras en mayusculas o en minusculas

function firstLargestPalindrome(words) {
    let largest = null;
    words.map(word => {
        let wordReverse = word.split("").reverse().join("").toLowerCase()

        if (word.toLowerCase() === wordReverse) {
            if (largest == null || word.length > largest.length) {
                largest = word;
            }
        }
    });

    return largest;
}

console.log(firstLargestPalindrome(["Ana", "Oso", "html", "css"]))

Raul Carrillo Garrido

student•

Buen detalle el lower

Samuel Jaraba

student•

Juan Vargas Mejía

student•

Logrado :)

function findLargestPalindrome(words){
    let palindromos = []
    let sizeInicial = 0
    let respuesta

    words.forEach((word)=>{
        let compar = word.split('').reverse().join('')

        if(word === compar){
            palindromos.push(word)
        }
    })

    palindromos.forEach((palindromo)=>{
        let size = palindromo.length

        if(size > sizeInicial){
            respuesta = palindromo
            sizeInicial += size
        }
    })

    if(palindromos.length === 0){
        return null
    }

    return respuesta
}

Verónica Tamara Ezeta Medina

student•

Mi solución a este playground...

let result = null;
  let maxLength = 0;

  words.forEach(item => {

    // we reverse each string
    let reverseString = item.split("").reverse().join("");

    // we compare the current string with their reverse also
    // we verify if the item length is grater than the current max length
    if (item === reverseString && item.length > maxLength) {

      maxLength = item.length;
      result = item;
    }
  });

  return result;

Aaron Alejandro Argot Palacios

student•

Llegue prácticamente a la misma solución

export function findLargestPalindrome(words) {
 
  let maxLength = 0
  let masLargo = null

  words.forEach(word => {
    if (word === word.split("").reverse().join("") && word.length > maxLength) {
      maxLength = word.length
      masLargo = word
    }
  });

  return masLargo
}

Diana Loboa

student•

Anti-Spoiler: I'm trying to do it with a few lines of code .

Mi solucion :

david alvarez

student•

pro

Manuel Juarez

student•

export function findLargestPalindrome(words) {
  // Tu código aquí 👈
  let maxLength = 0;
  let chosenPalindrome = null;

  for (let word of words) {
    if (isPalindrome(word) === true) {
      if (word.length > maxLength) {
        maxLength = word.length;
        chosenPalindrome = word;
      }
    }
  }
  return chosenPalindrome;
}

function isPalindrome(word) {
  let halfWord = Math.floor(word.length / 2);
  let i = 1;
  let truePalindrome = true;
  while (i <= halfWord) {
    let firstLetter = word.charAt(i - 1);
    let lastLetter = word.charAt(word.length - i);
    if (firstLetter !== lastLetter) {
      truePalindrome = false;
      break;
    }
    i++;
  }
  return truePalindrome;
}

Angel Ramírez

student•

Mi solución:

function findLargestPalindrome(words) {
  let maxNumber = 0;
  const palindromes = []
  words.forEach(word => {
    let word2 = '';
    let extension = word.length - 1;
    while (extension > -1) {
      word2 += word[extension];
      extension--;
    }
    if (word === word2) {
      palindromes.push({
        name: word,
        length: word.length
      });
    } 
  })
  if (palindromes.length < 1) {
    return null;
  }
  palindromes.forEach(number => {
    if (number.length > maxNumber) {
      maxNumber = number.length;
    }
  })
  const palindrome = palindromes.filter(palindrome => palindrome.length === maxNumber);
  return palindrome[0].name;
}

Jackeline Puruaya

student•

. .. ... .... ..... ..... ...... ....... ........ .........

function findLargestPalindrome(words) {

    let largestPalindrome = "";

    for (let i = 0; i <= words.length - 1; i++) {
      let word = words[i];
      let arrWord = [...word];
      let palindrome = false;
      let normalLetters = "";
      let reverseLetters = "";

      for (let j = 0; j <= arrWord.length - 1; j++) {
        let normalLetterOfWord = arrWord[j];
        normalLetters = normalLetterOfWord;
      }
      
      for (let k = [arrWord.length - 1]; k >= 0; k--) {
        let letterOfWordReverse = arrWord[k];
        reverseLetters = letterOfWordReverse;
      }

      if (normalLetters === reverseLetters) {
        palindrome = true;
        let palindromeWord = "";
        palindromeWord = word;
        if (palindrome && palindromeWord.length > largestPalindrome.length) {
          largestPalindrome = palindromeWord;
        }
      }
    }

    if (largestPalindrome.length === 0) {
      largestPalindrome = null;
    }
    return largestPalindrome;
  
}

Sebastian David Exeni Cazón

student•

El mio xd:

export function findLargestPalindrome(words) {
  // Tu código aquí 👈
  return (words.filter(word => word.split("").reverse().join("") === word)).length <= 0 ? null : ((words.filter(word => word.split("").reverse().join("") === word)).reduce((a,b) => b.length > a.length ? b : a)) 
}

Santiago Tomatis

student•

esta era mi solucion, pero pro algun motivo en "vista" devuelve {} y si corro las pruebas dice "Cannot read properties of undefined (reading 'split')"

export function findLargestPalindrome(words) {
  let largest_palindrome = " ";
  for (let word of words) {
    let backward_word = reverseString(words[word]);
    if (words[word] == backward_word && words[word].length > largest_palindrome.length) {
      largest_palindrome = word;
      // return word;
    }
  }
  
  return (largest_palindrome == " " ? null : largest_palindrome);

  function reverseString(str) {
    return str.split("").reverse().join("");
  }
}

Isabelle de Souza

student•

En words[word] word es una palabra no un indice. Entonces word solamente es sufuciente. :)

Edson Aguayo Choque

student•

dejo mi solucion quizas les ayuda a comprender de mejor forma la logica aunque con los metodos de split reverse y join simplifican bastante

function findLargestPalindrome(words) {
  let palabraPalindromo = null
  let palabraVolteada = ""
  let longitud = 0
  for (let palabra of words) {
    palabraVolteada = voltearPalabra(palabra)
    if (palabra === palabraVolteada && longitud < palabra.length) {
      palabraPalindromo = palabra
      longitud=palabra.length
    }
  }
return palabraPalindromo  
}

function voltearPalabra(palabra) {
  let palabraVolteada = ""
  for (let i = palabra.length - 1; i >= 0; i--){
    palabraVolteada+=palabra[i]
  }
  return palabraVolteada
}

jorge vilchis

student•

aqui mi aporte

export function findLargestPalindrome(words) {

let longestPalindrome = null;

let maxLength = 0;

for (const word of words) {

const reversed = word.split('').reverse().join('');

if (word === reversed) { // Es palíndromo

if (word.length > maxLength) {

longestPalindrome = word;

maxLength = word.length;

}

return longestPalindrome;

}

Juan Felipe Zapata Moreno

student•

function findLargestPalindrome(words){
  
var largest = null;

  for(let i = 0; i < words.length; i++){
    palin = words[i];
    var newWord = ""
    for (var j = palin.length -1; j >= 0 ;j--){
      newWord += palin[j]
    }
    if (palin === newWord && palin.length > largest.length){
       largest = palin;
    }
  }
  return largest;
}

Mayrelbis Fajardo

student•

Quisiera saber por qué toma el código como malo?

var mayor=0 , pos=0;
for(i=0 ; i<words.length ; i++)
{
    var re = /[\W_]/g;
    var lowRegStr = words[i].toLowerCase().replace(re, '');
    var reverseStr = lowRegStr.split('').reverse().join(''); 
    reverseStr === lowRegStr;
  if(reverseStr === lowRegStr)
  { 
    if(words[i].length > mayor)
    {
      mayor = words[i].length;
      pos = i;  
    }  
  }
}
if(mayor != 0){
  return words[pos];
}else{
  return null ;
}

me sale esto como error

Should return racecar

i is not defined Should return null

i is not defined Should return madam

i is not defined Should return repaper

i is not defined Algo salió mal, revisa tu código e intentalo de nuevo.

Leonardo de los angeles Espinoza Hernandez

student•

¡Hola @mayrelbisfajardo!

Recuerda que en los bucles es necesario que declares e inicialices la variable con la cual se va a iterar, solo debes agregar la keyword let y debería funcionar sin problema alguno 🙌

Cambiar esto

for(i=0 ; i<words.length ; i++)

a esto

for(let i=0 ; i<words.length ; i++)

Espero mi comentario te sea de ayuda :D

Leonardo de los angeles Espinoza Hernandez

student•

¡Hola @mayrelbisfajardo!

Recuerda que en los bucles es necesario que declares e inicialices la variable con la cual se va a iterar, solo debes agregar la keyword let y debería funcionar sin problema alguno 🙌

Cambiar esto

for(i=0 ; i<words.length ; i++)

a esto

for(let i=0 ; i<words.length ; i++)

Espero mi comentario te sea de ayuda :D

Mayrelbis Fajardo

student•

Por qué Me toma el siguiente código como malo si está bueno?

Andrés Soret Chacin

student•

My solution 👇

function findLargestPalindrome(words) {
  const palindromesFound = words.filter(word => {
    const invertedWord = word.split("").reverse().join("");
    return word === invertedWord;
  });

  if (palindromesFound.length === 0) {
    return null;
  }

  const largestPalindrome = palindromesFound.reduce((acc, val) => val.length > acc.length ? val : acc, "");

  return largestPalindrome;
}

David Galvan

student•

Mi solución:

export function findLargestPalindrome(words) {
  const palindromes = words.filter((word) => {
    const reverseWord = word.split("").reverse().join("");
    return word === reverseWord;
  });

  if (palindromes.length === 0) return null;

  return palindromes.sort((a, b) => b.length - a.length)[0];
}

Irving Daniel Reyes Elizondo

student•

🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️

function findLargestPalindrome(words) {

let largestPalindrome = "";

for (let word of words) {

if (word == word.split("").reverse().join("") && largestPalindrome.length < word.length ) {

largestPalindrome = word;

}

if (largestPalindrome) {

return largestPalindrome;

} else {

return null;

}

Joan Alexander Valerio Rodríguez

student•

Saludos a todos. Pude programar esta función en varios ejemplos y aun con la prueba, nunca quede satisfecho porque a la hora de leer el código, otros developer se les complicaría entender la lógica. Sin embargo, hice este código que se que a muchos les puede ayudar, especialmente a aquellos que están conociendo el mundo de JavaScript.

Y si el discurso fue para no hacer spoilers a los que no lo han intentado XD Suerte!!

export function findLargestPalindrome(words) {
  // Primero definimos que la palabra más larga es null
  // Debido a que no se tiene un valor 
  let largest = null;
  // Después iteramos por cada una de las palabras
  for (const word of words) {
    // con split("") creamos un array donde cada elemento es una letra
    // Ejemplo "hola" => ["h","o","l","a"]
    // con reverse() "volteamos" el array
    // Ejemplo ["h","o","l","a"] => ["a"","l","o","h"]
    // y con .join("") volvemos a convertirlo en un string
    // Ejemplo  ["a"","l","o","h"] => "aloh"
    const reversedWord = word.split("").reverse().join("");
    // La primer validación que hacemos es para ver si efectivamente es un array
    if (reversedWord === word) {
      // Si si lo es, primero verificamos que se reemplace la variable largest
      // por el primer palindromo si es que no existe uno aún
      if (largest == null || word.length > largest.length) {
         // En caso de existir, se compara su longitud con el palindromo existente
        largest = word;
      }
    }
  }

  // Al final siempre retornamos la variable largest
  // Ya que si no existe ni uno solo en el array, su valor se mantiene como null
  return largest;
}

// La función compara la primera letra (i) con la última (j)
// luego la segunda (i+1) con la penúltima (j-1) luego i+3 con j-3, etc
function palindromo(word){
// i para la primera letra y j para la última letra
  let j = word.length - 1; 
  for (let i= 0; i<=j; i++ ){
     if (word[i] != word[j]){ 
        return false; 
       // si encuentra una letra que no se igual sale inmediatamente y regresa false
     } 
     j--;
   }
   return true;
 
}

/**
 * @param {string[]} words
 * @returns {string} null or the largest palindrome in the array.
 */
function findLargestPalindrome(words) {
    return words.reduce((prevWord, word) => (word && word.toLowerCase() === word.toLowerCase().split('').reverse().join('') && word.length > prevWord.length) ? word : prevWord, '') || null
}

function firstLargestPalindrome(words) {
    let largest = null;
    words.map(word => {
        let wordReverse = word.split("").reverse().join("").toLowerCase()

        if (word.toLowerCase() === wordReverse) {
            if (largest == null || word.length > largest.length) {
                largest = word;
            }
        }
    });

    return largest;
}

console.log(firstLargestPalindrome(["Ana", "Oso", "html", "css"]))

function findLargestPalindrome(words){
    let palindromos = []
    let sizeInicial = 0
    let respuesta

    words.forEach((word)=>{
        let compar = word.split('').reverse().join('')

        if(word === compar){
            palindromos.push(word)
        }
    })

    palindromos.forEach((palindromo)=>{
        let size = palindromo.length

        if(size > sizeInicial){
            respuesta = palindromo
            sizeInicial += size
        }
    })

    if(palindromos.length === 0){
        return null
    }

    return respuesta
} 

let result = null;
  let maxLength = 0;

  words.forEach(item => {

    // we reverse each string
    let reverseString = item.split("").reverse().join("");

    // we compare the current string with their reverse also
    // we verify if the item length is grater than the current max length
    if (item === reverseString && item.length > maxLength) {

      maxLength = item.length;
      result = item;
    }
  });

  return result;

export function findLargestPalindrome(words) {
 
  let maxLength = 0
  let masLargo = null

  words.forEach(word => {
    if (word === word.split("").reverse().join("") && word.length > maxLength) {
      maxLength = word.length
      masLargo = word
    }
  });

  return masLargo
}

export function findLargestPalindrome(words) {
  // Tu código aquí 👈
  let maxLength = 0;
  let chosenPalindrome = null;

  for (let word of words) {
    if (isPalindrome(word) === true) {
      if (word.length > maxLength) {
        maxLength = word.length;
        chosenPalindrome = word;
      }
    }
  }
  return chosenPalindrome;
}

function isPalindrome(word) {
  let halfWord = Math.floor(word.length / 2);
  let i = 1;
  let truePalindrome = true;
  while (i <= halfWord) {
    let firstLetter = word.charAt(i - 1);
    let lastLetter = word.charAt(word.length - i);
    if (firstLetter !== lastLetter) {
      truePalindrome = false;
      break;
    }
    i++;
  }
  return truePalindrome;
}

function findLargestPalindrome(words) {
  let maxNumber = 0;
  const palindromes = []
  words.forEach(word => {
    let word2 = '';
    let extension = word.length - 1;
    while (extension > -1) {
      word2 += word[extension];
      extension--;
    }
    if (word === word2) {
      palindromes.push({
        name: word,
        length: word.length
      });
    } 
  })
  if (palindromes.length < 1) {
    return null;
  }
  palindromes.forEach(number => {
    if (number.length > maxNumber) {
      maxNumber = number.length;
    }
  })
  const palindrome = palindromes.filter(palindrome => palindrome.length === maxNumber);
  return palindrome[0].name;
}

function findLargestPalindrome(words) {

    let largestPalindrome = "";

    for (let i = 0; i <= words.length - 1; i++) {
      let word = words[i];
      let arrWord = [...word];
      let palindrome = false;
      let normalLetters = "";
      let reverseLetters = "";

      for (let j = 0; j <= arrWord.length - 1; j++) {
        let normalLetterOfWord = arrWord[j];
        normalLetters = normalLetterOfWord;
      }
      
      for (let k = [arrWord.length - 1]; k >= 0; k--) {
        let letterOfWordReverse = arrWord[k];
        reverseLetters = letterOfWordReverse;
      }

      if (normalLetters === reverseLetters) {
        palindrome = true;
        let palindromeWord = "";
        palindromeWord = word;
        if (palindrome && palindromeWord.length > largestPalindrome.length) {
          largestPalindrome = palindromeWord;
        }
      }
    }

    if (largestPalindrome.length === 0) {
      largestPalindrome = null;
    }
    return largestPalindrome;
  
}

export function findLargestPalindrome(words) {
  // Tu código aquí 👈
  return (words.filter(word => word.split("").reverse().join("") === word)).length <= 0 ? null : ((words.filter(word => word.split("").reverse().join("") === word)).reduce((a,b) => b.length > a.length ? b : a)) 
}

export function findLargestPalindrome(words) {
  let largest_palindrome = " ";
  for (let word of words) {
    let backward_word = reverseString(words[word]);
    if (words[word] == backward_word && words[word].length > largest_palindrome.length) {
      largest_palindrome = word;
      // return word;
    }
  }
  
  return (largest_palindrome == " " ? null : largest_palindrome);

  function reverseString(str) {
    return str.split("").reverse().join("");
  }
}

function findLargestPalindrome(words) {
  let palabraPalindromo = null
  let palabraVolteada = ""
  let longitud = 0
  for (let palabra of words) {
    palabraVolteada = voltearPalabra(palabra)
    if (palabra === palabraVolteada && longitud < palabra.length) {
      palabraPalindromo = palabra
      longitud=palabra.length
    }
  }
return palabraPalindromo  
}

function voltearPalabra(palabra) {
  let palabraVolteada = ""
  for (let i = palabra.length - 1; i >= 0; i--){
    palabraVolteada+=palabra[i]
  }
  return palabraVolteada
}

function findLargestPalindrome(words){
  
var largest = null;

  for(let i = 0; i < words.length; i++){
    palin = words[i];
    var newWord = ""
    for (var j = palin.length -1; j >= 0 ;j--){
      newWord += palin[j]
    }
    if (palin === newWord && palin.length > largest.length){
       largest = palin;
    }
  }
  return largest;
}

var mayor=0 , pos=0;
for(i=0 ; i<words.length ; i++)
{
    var re = /[\W_]/g;
    var lowRegStr = words[i].toLowerCase().replace(re, '');
    var reverseStr = lowRegStr.split('').reverse().join(''); 
    reverseStr === lowRegStr;
  if(reverseStr === lowRegStr)
  { 
    if(words[i].length > mayor)
    {
      mayor = words[i].length;
      pos = i;  
    }  
  }
}
if(mayor != 0){
  return words[pos];
}else{
  return null ;
}

function findLargestPalindrome(words) {
  const palindromesFound = words.filter(word => {
    const invertedWord = word.split("").reverse().join("");
    return word === invertedWord;
  });

  if (palindromesFound.length === 0) {
    return null;
  }

  const largestPalindrome = palindromesFound.reduce((acc, val) => val.length > acc.length ? val : acc, "");

  return largestPalindrome;
}

export function findLargestPalindrome(words) {
  const palindromes = words.filter((word) => {
    const reverseWord = word.split("").reverse().join("");
    return word === reverseWord;
  });

  if (palindromes.length === 0) return null;

  return palindromes.sort((a, b) => b.length - a.length)[0];
}

Playground - encuentra el palindromo más grande

¡Te damos la bienvenida a este reto!

¡Bienvenido al mundo de JavaScript!

Día 1

Variables, funciones y sintaxis básica

Tipos de datos

Playground - Retorna el tipo

Tipos de datos - pt 2

Día 2

Operadores

Hoisting y coerción

Playground - Calcula la propina

Alcance de las variables

Día 3

Condicionales

Playground - Calcula años bisiestos

Switch

Playground - Obten información de mascotas según su tipo

Ciclos

Playground - Dibuja un triangulo

Día 4

Arrays

Playground - Encuentra al michi mas famoso

Objetos

Playground - Obten el promedio de los estudiantes

Día 5 - Checkpoint

Playground - encuentra el palindromo más grande

Día 6

Reasignación y redeclaración

Modo estricto

Día 7

Debugging y manejo de errores

Programación funcional

Día 8

Closures

Playground - Crea una calculadora con closures

Higher order functions

Playground - Crea tu propio método map

Día 9

ECMAScript

TC39

Día 10 - Checkpoint

ES6

ES7

Playground - Task planner

Día 11

Asincronismo

Playground - Promesas

Manejando el asincronismo

Playground - Resuelve el callback hell usando promesas

Playground - Resuelve el callback hell usando async/await

Día 12

Arrays a profundidad

Métodos de arrays: Every, Find y findIndex

Playground - Válida el formulario

Día 13

Métodos de arrays: Includes, Join y concat

Playground - agrupa los productos

Métodos de arrays: Flat y FlatMap

Playground - Encuentra la ubicación del valor buscado

Día 14

Mutable functions

Playground - Modifica una lista de compras

Métodos de arrays: sort

Playground - Ordena los productos

Día 15 - Checkpoint

Playground - Sistema de reservaciones de un hotel

Día 16

Programación orientada a objetos en JavaScript

Objetos literales

Playground - Congela el objeto recursivamente

Día 17

Prototipos en JavaScript

Playground - Modifica el prototype de los arrays

Playground - Crea un auto usando clases

Día 18

Abstracción en JavaScript

Playground - Sistema de carrito de compras

Encapsulamiento en JavaScript

Playground - Encapsula datos de los usuarios