Aquà mi humilde aporte
function solution(lines) {
return lines.flatMap((item) => item.split(" ")).length;
};
Introducción
Tu AS bajo la manga
Fundamentos del manejo de arrays
ForEach
Mutable o Inmutable
Qué es el método map
Playground: multiplica todos los elementos por dos
Map Reloaded
Playground: calcula y agrega nuevas propiedades a un array
Filter
Playground: retorna solo palabras de 4 letras o más
Reduce
Reduce Reloaded
Playground: calcula la suma total de elementos en un array
Métodos en JavaScript
Some
Playground: ¿al menos 1 de los números es par?
Every
Playground: retorna un booleano si todos los elementos son pares
Find y FindIndex
Includes
Playground: buscador de palabras con parámetros de búsqueda
Join
Playground: construye URLs a partir de strings
Concat
Flat
FlatMap
Playground: calcula el total de palabras en un texto
Mutable functions
Sort
Despedida
Despedida
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Aportes 68
Preguntas 0
Aquà mi humilde aporte
function solution(lines) {
return lines.flatMap((item) => item.split(" ")).length;
};
function solution(lines) {
// Tu código aquà 👈
return lines.join(" ").split(" ").length
};
//20
si no existiera el metodo flatMap
function solution2 (array) {
return array.map(item => item.split(' ')).flat().length
}
Aplico .map() al array para recorrerlo y que a cada elemento le aplique .split() con respecto a espacios, creando asà un array con 4 arrays dentro, conformados estos por las palabras de cada Zen. Luego a ese resultado le aplico .flat() para crear un solo array que contenga todas las palabras que conformaban los 4 Zens. Finalmente aplico .length para saber la cantidad de elementos del array definitivo.
function solution(lines) {
const rta = lines.map(item => item.split(' ')).flat().length;
return rta;
};
Recuerden que siempre se puede llegar a la solución de diferentes formas.
function solution(lines) {
// Tu código aquà 👈
const rta = lines.map(item => item.split(' ')).flat().length
return rta;
};
console.log(solution([
"Beautiful is better than ugly",
"Explicit is better than implicit",
"Simple is better than complex",
"Complex is better than complicated",
]))
Mi solución:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
export function countWords(array) {
return array.map(element => element.split(" ")).flat().length;
}
Solución sin flatMap
function solution(lines) {
let count = 0;
lines.map(item => count += item.split(' ').filter(a => a !== '').length);
return count;
}
Esta solución contempla casos extremos, en donde pueden haber strings con espacios al inicio y al final, dobles espacios o incluso strings con solamente espacios:
function countWords(array) {
return array.flatMap(line =>
line.trim().match(/\b\w+\b/g) ?? []
).length;
}
Comparto mi solución, no se me ocurrió utilizar 😔.
export function countWords(array) {
return (array.length != 0) ? (array.join(" ").split(" ")).length: 0;
}
Mi solucion:
export function countWords(array) {
let suma = 0
array.flatMap(element => suma += element.split(" ").length)
return suma
}
export function countWords(array) {
return array.flatMap(item => {
return item.toString().split(’ ')
}).length
}
Este es mi aporte, tambien lo hice con reduce porque creo que es mas facil de entender el codigo
const conutWordOneLine = (array) => array.reduce((num, phrase)=> num += phrase.split(' ').length, 0);
const conutWorsFM = (array) => array.flatMap(element => element.split(' ')).length;
export function countWords(array) {
return array.flatMap((element) => element.split(' ')).length;
}
Lo hice sin usar map o flatMap y pasa todos los test,
export function countWords(array) {
// Tu código aquà 👈
return array.length > 0 ? array.join(' ').split(' ').length : 0;
}
Solución
export function countWords(array) {
// Tu código aquà 👈
return array.flatMap(elem => elem.split(" ")).length;
}
function countWords(array) {
return array.reduce((acc,item) => item.split(' ').length + acc, 0)
}
Mi solución
export function countWords(array) {
return array.length === 0 ? 0 : array.join(' ').split(' ').length;
}
This is my solution for the challenge. Hope you like it1
function countWords(array) {
// Tu código aquà 👈
if (array.length != 0) {
return array.join(" ").split(" ").length
} else {
return array.length
}
}
Mi aporte, pero recuerden que deben intentarlo.
const strings = [
"Beautiful is better than ugly",
"Explicit is better than implicit",
"Simple is better than complex",
"Complex is better than complicated",
]
export function countWords(array) {
// Tu código aquà 👈
const rta = array.flatMap(item => {
const strSplit= item.split(' ')
console.log(strSplit);
return strSplit.length
})
console.log(rta)
const rta2 = rta.reduce((count, item) =>{
return count +=item
}, 0)
console.log(rta2)
return rta2
}
countWords(strings);
export function countWords(array) {
// Tu código aquà 👈
const result = array.reduce((newArr, item) => {
return newArr.concat(item.split(" "))
}, [])
return result.length;
}
Mi solución:
export function countWords(array) {
return array.flatMap(item => item.split(' ')).length;
}
No sólo se puede lograr con flatMap:
export function countWords(array) {
return (array.length > 0) ? array.join(' ').split(' ').length : 0;
}
aqui mi colucion, primero paso un map que convierte cada item en un nuevo array, en donde cada elemento depende de los espacion, para eso uso el split, y luego simplemente aplano ese array nuevo, y retorno su longitud con length
export function countWords(array) {
const array2 = array.map(item => item.split(' '))
return array2.flat().length
}
const conteo = (array) => {
if(array.length > 0){
return array.join(' ').split(' ').length;
}
else{
return 0;
}
};
export function countWords(array) {
return array != 0 ? array.join(' ').split(' ').length : 0
}
export function countWords(array) {
// Tu código aquà 👈
const resp = array.map(string => string.split(" ")).flat(Infinity).length;
console.log(resp)
return resp
}
Aquà mi código.
Estuve tentado hacer el reduce ya en otra arrayFunctión para ser más sencillo de leer pero por ahora lo deje asÃ.
export function countWords(array) {
return array.map( words => words.split(' ').length)
.reduce((acumulador, item) => acumulador + item, 0);
}
Mi solucion:
export function countWords(array) {
return array.reduce((sum, num) => sum + num.split(' ').length, 0)
}
//Mi solución!
export function countWords(array) {
let sumar = array.flatMap(line => {
return line.split(" ");
});
return sumar.length;
}
export function countWords(array) {
return array.flatMap((item) => item.split(" ")).length;
}
Input.join(' ').split(' ').length
Es raro la solucion del ejecicio solo suma una sola palabra, Esta es mi solución y sumo todas las palabras de mi array.
function countWord(array){
const newArray = array.flatMap(item => item.length)
return newArray.reduce((obj,suma) => obj + suma, 0)
}
eeeezzzz
export function countWords(array) {
return array.reduce((total, element) => total + element.split(' ').length, 0)
}
a que se refieren este ejercicio con el Zen de Python
? y con cada lÃnea
? se refiere a cada Ãndice dentro del array? es algo confusa la instrucción.
Solucion
export function countWords(array) {
// Tu código aquà 👈
let words = 0
array.forEach(astr => {
let newArr = astr.split(' ')
words += newArr.length
})
return words
}
Utilizando reduce() y split()
function countWords(array) {
return array.reduce((acum, el) => acum + el.split(' ').length, 0)
}
function countWords(array){
let count = 0;
array.map(item => {
count += item.split(" ").length
})
return count;
}
export function countWords(array) {
return array.map(item => { return item.split(' ') }).flat().length;
}
Una alternativa sin utilizar el flatmap
export function countWords(array) {
return array.map(string=>string.split(" ").length).reduce((a,b)=>a+b,0)
}
**Aunque la idea es usarlo, jeje.
return array.map(item => item.split(" ")).flat().length;
Mi solucion, funciona con arrays vacios 😄
function countWords(array) {
if (array.length === 0) {
return 0;
} else {
let arrayWords = array.join(' ').split(' ')
return arrayWords.length;
}
}
Usando RegEx
function solution(lines) {
return lines.join(" ").match(/\w+/g).length
}
Solución:
function solution(lines) {
return lines.flatMap(line => line.split(" ")).length;
};
Mi solución
function solution(lines) {
const frase = lines.flatMap(word => word.split(' '));
return frase.length
};
function solution(lines) {
// Tu código aquà 👈
let i = 0;
let sum = 0;
while (i < lines.length) {
sum += lines[i].split(" ").length
++i;
}
return sum
};
function solution(lines) {
const allTheWordsInArray = lines.join(" ").split(" ");
const lengthWords = allTheWordsInArray.length;
return lengthWords;
};
const wordCount = array => (array.flatMap(item => item.split(’ ')).length);
solución sin flatMap
function solution(lines) {
return lines.map(item => item.split(" ").length).reduce((sum, item) => sum + item, 0);
};
function solution(lines) {
return lines.reduce((accum, item) => accum + item.split(" ").length, 0);
};
Esta fue mi soluciñon,
function solution(lines) {
return lines.flatMap(element => element.split(" ")).length;
};
Lo solucioné asÃ, aunque supongo que le profe querÃa que lo solucionáramos con flat() o flatmap()
function solution(lines) {
const palabras = [];
lines.forEach((element) => {
palabras.push(element.split(" ").length)
});
return palabras.reduce((b, a) => b + a)
};
function solution(lines){
let counter = 0
lines.forEach(item => {
counter += item.split(' ').length
})
return counter;
};
function solution(lines) {
return lines.join(’ ‘).toString().split(’ ').length
};
Una manera usando varios métodos a la vez:
const solution = (arr) => {
console.log(arr.flat().join(' ').split(' ').length);
}
function solution(lines) {
return lines.join(' ').split(' ').length;
};
Respuesta:
function solution(lines) {
// Tu código aquà 👈
const rta = lines.flatMap(item => item.split(" "));
return rta.length;
};
function solution(lines) {
const internalArray = [];
lines.forEach(element => internalArray.push(element.split(' ')))
return internalArray.flat().length;
};
Mi solución:
function solution(lines) {
return lines.flatMap(item => item.split(' ')).reduce((sum, _) => sum + 1, 0);
};
comparto mi respuesta
function solution(lines) {
const array = lines.map(line => line.split(" "))
return array.flat().length;
};
Mi solución:
function solution(lines) {
const value = lines
.reduce((acum, item) => {
const itemArray = item.split(' ');
return acum + itemArray.length;
}, 0);
return value;
};
Mi aporte de la solución:
let sum = 0;
lines.map((l) => {
sum += l.split(" ").length;
});
return sum;
Ja ja ja, yo lo hice super complejo en comparación con los demás que lo hicieron prácticamente todo en unas pocas lÃneas, 😅.
function solution(lines) {
let total_words = [];
for (let line of lines) {
let words = line.split(' ');
total_words = total_words.concat(words);
}
return total_words.length;
};
Acá mi solución 😄
function solution(lines) {
// Tu código aquà 👈
return lines.flatMap(item =>item.split(' ')).length
};
Este código de ejemplo de la mdn web es genial para comprender este Playground. Lo comparto para que lo ejecuten y comprendan mejor cómo funciona:
function splitString(stringToSplit, separator) {
const arrayOfStrings = stringToSplit.split(separator)
console.log('The original string is: ', stringToSplit)
console.log('The separator is: ', separator)
console.log('The array has ', arrayOfStrings.length, ' elements: ', arrayOfStrings.join(' / '))
}
const tempestString = 'Oh brave new world that has such people in it.'
const monthString = 'Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec'
const space = ' '
const comma = ','
splitString(tempestString, space)
splitString(tempestString)
splitString(monthString, comma)
esta es mi solución
function solution(lines) {
return lines.join(" ").split(" ").length;
};
function solution(lines) {
return lines.reduce( (sumarLineas,linea)=>sumarLineas + linea.split(' ').length,0)
};
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?
o inicia sesión.