Clase 20 de 99 • 30 días de JavaScript
Contenido del curso
Leonardo de los angeles Espinoza Hernandez
Raul Carrillo Garrido
Carlos Gutiérrez
Santiago Palacio Vásquez
Sebastian Camilo Guaqueta Melo
Miguel Angel Muñoz Pozos
Raul Carrillo Garrido
Samuel Jaraba
Juan Vargas Mejía
Verónica Tamara Ezeta Medina
Aaron Alejandro Argot Palacios
Diana Loboa
david alvarez
Manuel Juarez
Angel Ramírez
Jackeline Puruaya
Sebastian David Exeni Cazón
Cristian Romero
Santiago Tomatis
Isabelle de Souza
Edson Aguayo Choque
jorge vilchis
Juan Felipe Zapata Moreno
Mayrelbis Fajardo
Leonardo de los angeles Espinoza Hernandez
Leonardo de los angeles Espinoza Hernandez
Mayrelbis Fajardo
Andrés Soret Chacin
David Galvan
Irving Daniel Reyes Elizondo
🛡️🛡️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)) }
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. :)
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 }
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;
}
}
