Contenido del curso
Playground - encuentra el palindromo más grande
Leonardo de los angeles Espinoza Hernandez
Estudiante
Raul Carrillo Garrido
Estudiante
Carlos Gutiérrez
Estudiante
Santiago Palacio Vásquez
Estudiante
Sebastian Camilo Guaqueta Melo
Estudiante
Miguel Angel Muñoz Pozos
EstudianteRaul Carrillo Garrido
Estudiante
Samuel Jaraba
Estudiante
Juan Vargas Mejía
Estudiante
Verónica Tamara Ezeta Medina
Estudiante
Aaron Alejandro Argot Palacios
Estudiante
Diana Loboa
Estudiante
david alvarez
Estudiante
Manuel Juarez
EstudianteAngel Ramírez
Estudiante
Jackeline Puruaya
Estudiante
Sebastian David Exeni Cazón
Estudiante
Edson Aguayo Choque
Estudiante
Cristian Romero
Estudiante
Santiago Tomatis
Estudiante
Isabelle de Souza
Estudiante
jorge vilchis
EstudianteJuan Felipe Zapata Moreno
Estudiante
Mayrelbis Fajardo
EstudianteLeonardo de los angeles Espinoza Hernandez
EstudianteLeonardo de los angeles Espinoza Hernandez
EstudianteMayrelbis Fajardo
Estudiante
Andrés Soret Chacin
Estudiante
David Galvan
Estudiante
Irving Daniel Reyes Elizondo
Estudiante🛡️🛡️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 🔥
Jajajaj me acabo de dar cuenta viendo el ejeplo de que mi estrategia para detectar palíndromos es , cuando menosm """larga""" xDDDDD
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; }
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.
La solución más eficiente que he visto
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"]))
Buen detalle el lower
function findLargestPalindrome(words) { let maxLengt = null; let reverse = []; words.map((word, index) => { reverse.push(word.split("").reverse().join("").toLowerCase()); if (word.toLowerCase() === reverse[index]) { if (maxLengt == null || word.length > reverse[index - 1].length) { maxLengt = word; } } }); return maxLengt; }
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 }
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;
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 }
Anti-Spoiler: I'm trying to do it with a few lines of code .
Mi solucion :
pro
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; }
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; }
. .. ... .... ..... ..... ...... ....... ........ .........
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; }
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)) }
otra forma
function findLargestPalindrome(words) { let palindromo = null for (const word of words) { if (esPalindromo(word)) { if (palindromo == null) { palindromo = word } else { if (word.length > palindromo.length) { palindromo = word } } } } return } function esPalindromo(word) { let palabraVolteada = "" let palindromo = false for (let i = word.length - 1; i >= 0; i--) { palabraVolteada += word[i] } if (word === palabraVolteada) { palindromo = true } return palindromo }
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 }
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(""); } }
En words[word] word es una palabra no un indice. Entonces word solamente es sufuciente. :)
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;
}
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; }
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.
¡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
¡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
Por qué Me toma el siguiente código como malo si está bueno?
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 ;
}
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; }
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]; }
🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️
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;
}
}
