Playground - encuentra el palindromo más grande

Cursos Empresas Blog Live Conf Precios

Contenido del curso

¡Te damos la bienvenida a este reto!

1
¡Bienvenido al mundo de JavaScript!
01:33 min

Día 1

Día 2

Día 3

Día 4

Día 5 - Checkpoint

20
Playground - encuentra el palindromo más grande
Viendo ahora

Día 6

Día 7

Día 8

Día 9

Día 10 - Checkpoint

Día 11

Día 12

Día 13

Día 14

Día 15 - Checkpoint

50
Playground - Sistema de reservaciones de un hotel

Día 16

Día 17

Día 18

Día 19

Día 20 - Checkpoint

65
Playground - Agenda de vuelos

Día 21

Día 22

Día 23

Día 24 - Checkpoint

77
Playground - Crea un task manager con patrones de diseño

Día 25

Día 26

Día 27

Día 28

Día 29

Día 30

93
¡Lo lograste!
01:41 min

Live Class

Tomar examen

Playground - encuentra el palindromo más grande

Comentarios

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)) 
}

Cristian Romero

student

Con un poco de ayuda de un compañero, esta fue mi solución:

export function findLargestPalindrome(words) {
  let palindromes = []
  let largestPalindrome = "";

  for (let i = 0; i < words.length; i++) {
    const word = words[i];
    const cleanWord = word.toLowerCase().replace(/[^a-z0-9]/g, '');
    const reversedWord = cleanWord.split('').reverse().join('');

    if (cleanWord === reversedWord) {
      palindromes.push(word)
    }
  }

  for (const wrd of palindromes) {
    if (wrd.length > largestPalindrome.length) {
      largestPalindrome = wrd;
    }
  }
  return palindromes.length === 0 ? null : largestPalindrome
}

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;

}

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 palindromes = []
  let largestPalindrome = "";

  for (let i = 0; i < words.length; i++) {
    const word = words[i];
    const cleanWord = word.toLowerCase().replace(/[^a-z0-9]/g, '');
    const reversedWord = cleanWord.split('').reverse().join('');

    if (cleanWord === reversedWord) {
      palindromes.push(word)
    }
  }

  for (const wrd of palindromes) {
    if (wrd.length > largestPalindrome.length) {
      largestPalindrome = wrd;
    }
  }
  return palindromes.length === 0 ? null : largestPalindrome
}

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];
}

¡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