Aquí mi humilde aporte
function solution(lines) {
return lines.flatMap((item) => item.split(" ")).length;
};
Introducción
Manipulación de Arrays en JavaScript para Desarrollo Full Stack
Fundamentos del manejo de arrays
Recorrido de Arrays con Foreach en JavaScript
Mutabilidad vs Inmutabilidad en Programación JavaScript
Uso de Map para Transformaciones en JavaScript y Renderizado HTML
Playground: multiplica todos los elementos por dos
Transformaciones avanzadas con map en JavaScript
Playground: calcula y agrega nuevas propiedades a un array
Filtrado de Arrays en JavaScript con el Método Filter
Playground: retorna solo palabras de 4 letras o más
Uso del método reduce en JavaScript para sumar elementos de un array
Contar elementos en un array con reduce y agrupar por rango
Playground: calcula la suma total de elementos en un array
Métodos en JavaScript
Uso de la función "sum" en JavaScript para evaluar condiciones
Playground: ¿al menos 1 de los números es par?
Uso del método `every` en JavaScript para validaciones de arrays
Playground: retorna un booleano si todos los elementos son pares
Uso de los métodos find y findIndex en JavaScript
Uso del método includes en JavaScript para arrays y strings
Playground: buscador de palabras con parámetros de búsqueda
Unificación y separación de arrays con join y split en JavaScript
Playground: construye URLs a partir de strings
Fusión de Arrays con Concat y Operador Spread en JavaScript
Aplanar Arrays en JavaScript con Flat y FlatMap
Uso de FlatMap para Extraer Fechas de Calendarios en JavaScript
Playground: calcula el total de palabras en un texto
Métodos Mutables e Inmutables en Arrays: Manipulación y Búsqueda
Ordenamiento de Arrays con el Método Sort en JavaScript
Despedida
Manipulación de Rides con JavaScript
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Aportes 130
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
}
Mi solución:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
export function countWords(array) {
return array.map(element => element.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;
};
mi solución:
export function countWords(array) {
return array.flatMap(item => item.split(' ')).length
}
esta es mi solución
function solution(lines) {
return lines.join(" ").split(" ").length;
};
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",
]))
aqui va mi respuesta
export function countWords(array) {
if (array.length > 0) {
return array.join(" ").split(" ").length
} else {
return 0
}
}
Solución sin flatMap
function solution(lines) {
let count = 0;
lines.map(item => count += item.split(' ').filter(a => a !== '').length);
return count;
}
Mi función debe devolver el resultado de aplicar reduce al array, ya que reduce retorna un solo valor iterando cada elemento y eso es lo que buscamos.
La sintaxis de reduce es array.reduce(function(accumulator, element, index, array), initialValue).
Solo voy a necesitar el accumulator, cada elemento y el valor inicial, que será cero.
Cada elemento del array es un string compuesto por palabras que se separan por espacios, así que, en cada iteración, aplicaré un split(’ ') que creará un nuevo array con cada palabra como su elemento, así, la longitud (length) de este array será el número de palabras.
Por último, sumaré al acumulador cada length de cada array.
export function countWords(array) {
return array.reduce(
(accumulator, element) =>
element.split(' ').length += accumulator,
0
)
}
Mi solución:
function solution(lines) {
return lines.flatMap(item => item.split(' ')).reduce((sum, _) => sum + 1, 0);
};
reto realizado
export function countWords(array) {
// Tu código aquí 👈
let numerodePalabras = 0
if (array.length === 0) {
numerodePalabras
} else {
let number = array.join(' ').split(' ').length
numerodePalabras = number
}
return numerodePalabras
}
Mi solución:
export function countWords(array) {
return array.reduce((acc, string) => {
const result = string.split(" ").length;
return acc + result;
}, 0)
}
export function countWords(array) {
return array.join(" ").split(" ").length
}
Ok, lo hice con ayuda, me perdí xd
array.flatMap(item => item.split(" ").length).reduce((sum, act) => sum + act, 0)```
Aquí va mi solución:
export function countWords(array) {
const separate = array.map(item => item.split(" "))
const total = separate.flatMap(obj => obj)
return total.length
}
<code>
export function countWords(array) {
// Tu código aquí 👈
return array.join(' ').split(' ').reduce((acu, item) => {
acu = !item.length == 0 ? acu + 1 : acu
return acu
}, 0)
}
Aún seguimos aprendiendo con este increíble curso, en mi caso mi solución al reto fue de la siguiente manera:
function countWords(array) {
if (array.join(' ').length === 0) {
return 0;
}
return array.join(' ').split(' ').length;
}
Solución:
function countWords(array) {
return array.length ? array.join(" ").split(" ").length : 0
}
"Si el array que se recibe si tiene elementos (o sea array.length es true), entonces ejecuta join() luego slipt() y devuelve cuánto es su length. Si el array no tiene ningún elemento (o sea array.length es false), se retorna 0, porque no tiene nada .
export function countWords(array) {
if (array.length === 0) {
return 0
} else {
let arr = array.join(’ ‘);
arr = arr.split(’ ');
return arr.length
}
}
otra forma de resolver el desafio es este
let totalWords = 0;
for (let i = 0; i < array.length; i++) {
let words = array[i].split(' ');
totalWords += words.length;
}
return totalWords;
Esta es mi solución usando el método ‘flatMap()’ y 'splt()'
Acá pueden probar el código:
export function countWords(array) {
return array.flatMap(sentence => sentence.split(' ')).length
}
lo pensé de esta manera
export function countWords(array) {
// Tu código aquí 👈
return array.length !=0 ? array.join(' ').split(' ').length : 0;
}
mi solucion
export function countWords(array) {
if (array.length === 0) {
return 0
} else {
return array.join(' ').split(' ').length
}
}
otro tipo de solución sin usar flatMap:
export function countWords(array) {
if (array.length === 0) {
return 0
} else {
let newArray = []
newArray = array.join(’ ‘).split(’ ')
return newArray.length
}
}
export function countWords(array) {
// Tu código aquí 👈
const words = array.length === 0 ? 0: array.join(' ').split(' ').length
return words;
}
return array
.map(phrase => phrase.split(' '))
.flat()
.length
export function countWords(array) {
// Tu código aquí 👈
let total = 0;
for (let index = 0; index < array.length; index++) {
const element = array[index].split(" ")
total += element.length
}
return total
}
Lo primero que se me pasó por la cabeza no incluia flatMap 😐
export function countWords(array) {
return array.reduce((acc, item) => acc + item.split(' ').length, 0)
}
Aquí mis soluciones
Con reduce
:
function countWords(phrasesList) {
return phrasesList.reduce((accumulator, phrase) => {
accumulator += phrase.trim().split(" ").length;
return accumulator;
}, 0);
}
Con flatMap
:
function countWordFlatMap(phrasesList) {
return phrasesList.flatMap((phrase) => phrase.trim().split(" ")).length;
}
function count_words(array) {
return array.join(' ').split(' ').length; //20
}
count_words([
"Beautiful is better than ugly",
"Explicit is better than implicit",
"Simple is better than complex",
"Complex is better than complicated"
]);
Aqui mi solución:
function countWords(array) {
return array.length === 0 ? 0 : array.join(" ").split(" ").length
}
Así lo hice:
if (array.length === 0) return 0;
return array.join(" ").split(" ").length;
export function countWords(array) {
return array.reduce((total, sentence) => {
total += sentence.split(" ").length;
return total;
}, 0);
}
Mi solución:
👇
👇
👇
👇
👇
👇
👇
👇
export function countWords(array) {
return array.flatMap(string => string.split(" ")).reduce((e, i) => e + 1, 0)
}
Mi solucion considerando que puedo tener varios elementos vacios " " , lo cual no implica tener una palabra y fallaria el _.length _
function countWords(array) {
if (array.join(' ').split(' ').includes('')) {
return 0
} else {
return array.join(' ').split(' ').length
}
}
export function countWords(array) {
var res = 0;
array.map(element => res = res + element.split(’ ').length)
return res
}
const ary1 = ["Beautiful is better than ugly","Explicit is better than implicit","Simple is better than complex","Complex is better than complicated",];
console.log(' ary1', ary1);
console.log('rslt1', ary1.join(' ').split(' ').length);
console.log('rslt2', ary1.map(item => item.split(' ')).flat().length);
Les dejo mi solución 😄
export function countWords(array) {
return array.length === 0 ? 0 : array.join(' ').split(' ').length
}
Mi solución:
||
||
||
||
||
||
||
||
||
||
v
export function countWords(array) {
return array.reduce((totalWords, item) => totalWords + item.split(" ").length, 0)
}
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)
}
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?