Playground: calcula el total de palabras en un texto

Clase 25 de 28 • Curso de Manipulación de Arrays en JavaScript

Fabrizio Heiner Ortiz Orellana

student•

Aquí mi humilde aporte

function solution(lines) {
	return lines.flatMap((item) => item.split(" ")).length;
};

Felix Torres Javier Antonio

student•

Me puedes explicar, en que momento se hace la suma?

Libardo Arturo Arroyave Bustos

student•

Faltaba sumar los resultados

function solution(lines) {
    return lines.flatMap(item => item.split(' ').length).reduce((sum, item) => sum += item, 0);
  }

Lucas Rojas

student•

function solution(lines) {
 	// Tu código aquí 👈 
	return lines.join(" ").split(" ").length
}; 
//20

Miguel Negron Garcia

student•

Me sale 3/4 pruebas pasadas, en la terecera se supone que devuelva 0 pero el codigo manda 1.

Alejandro Ramos

student•

Esta solución me gustó mucho, la solución para que pase todas las pruebas seria agregarle el operador ternario, quedaría así

array.length == 0 ? 0 : array.join(" ").split(" ").length

Williams Munguía

student•

si no existiera el metodo flatMap

function solution2 (array) {
return array.map(item  => item.split(' ')).flat().length

}

Javier Núñez

student•

Mi solución: . . . . . . . . . . . . . . .

export function countWords(array) {
  return array.map(element => element.split(" ")).flat().length;
}

Manuel Araujo

student•

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

Adan Saavedra

student•

mi solución:

export function countWords(array) {
  return array.flatMap(item => item.split(' ')).length
}

Yeferson Lasso España

student•

esta es mi solución

function solution(lines) {
	return lines.join(" ").split(" ").length; 
};

Joshep Ramiro Villalba Bejarano

student•

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",
]))

Jesus Anguiano Solano

student•

export function countWords(array) {
  // Tu código aquí 👈
  return array.flatMap(item => item.split(" ")).length
}

```Para cada `item` (cada oración), `item.split(" ")` divide la oración en un array de palabras utilizando el espacio (" ") como delimitador.

* Por ejemplo, `"Beautiful is better than ugly".split(" ")` se convierte en `["Beautiful", "is", "better", "than", "ugly"]`.

Después de aplicar `split(" ")` a cada oración, `flatMap` aplana el array de arrays resultante en un solo array de palabras.

`length` obtiene la longitud del array resultante, es decir, el número total de palabras en todas las oraciones combinadas.

OSCAR RICO

student•

Gracias, estaba un poco confundido!

Ruth Lovece

student•

Mi solución:

1) Con el .map paso cada string a un array de palabra.

2) Con el flat paso todo a un solo array, no necesito parametro en este caso

3). Con el .length obtengo la cantidad de elementos.

export function countWords(array) {
  return array.map(item => item.split(' ')).flat().length
}
```export function countWords(array) {  return array.map(item => item.split(' ')).flat().length}

Adrian Hassek Gonzalez Orobio

student•

// Mi solución: 
export function countWords(array) {
  return array.reduce((countWord, sentence) => countWord + sentence.split(' ').length, 0)
}

Luis Paredes

student•

aqui va mi respuesta

export function countWords(array) {
  if (array.length > 0) {
    return array.join(" ").split(" ").length
  } else {
    return 0
  }
}

Libardo Arturo Arroyave Bustos

student•

Solución sin flatMap

function solution(lines) {
	let count = 0;
	lines.map(item => count += item.split(' ').filter(a => a !== '').length);
	return count;
}

Byron Mesias Cueva Cabrera

student••

export function countWords(array) {

return array.map(frase => frase.split(" ").length).reduce((accumulator, item) => accumulator + item, 0);

}

Cristhian Mauricio Yara Pardo

student•

Mi solución:

export function countWords(array) {
  return array.reduce((total, frase) => total + frase.split(' ').length, 0);
}

Julio Manuel Nieto

student•

export function countWords(array) {
  if (!Array.isArray(array) || array.length === 0) return 0;

  const text = array.join(" ").trim();
  if (!text) return 0;

  return text.split(/\s+/).length;
}

Libia Perez

student•

my solution:

function countWords(array) {
  // Tu código aquí 👈
  if (array.length > 0) {    
  return array.join(' ').split(' ').length
  } else {
    return 0
  }
}

Hector Daniel Tapia

student•

Este ejercicio me gusto me tomo desprevenido y me quede un rato pensando de que forma poder hacerlo , al principio queria usar un reduce para ir contando cada indice y acumulandolo pero sentia que era muy rebuscado hasta que me di cuenta que debia tenerlos todo en un array pense en el join al instante pero el split me costo mas tiempo pero era lo que necesitaba para unir los espacios enblanco que dejaba el join , despues el .length para que me de de respuesta toda la longitud de lo que habia formado fue la cereza del pastel estuvo entretenido

function countWords(array) {
  if (array.length === 0) return 0
  return array.join(" ").split(" ").length
}
```function countWords(array) {

&#x20; if (array.length === 0) return 0

&#x20; return array.join(" ").split(" ").length

}

Jairo Alberto Mejía Ramírez

student•

Mi solución

export function countWords(array) { // Tu código aquí 👈 return array.map(item => item.split(" ")).flat().reduce((sum) => sum +1, 0);}

Ya luego leí otras respuestas y no me gustó tanto pero practiqué el resto de funciones.

Beder Danilo Casa Condori

student•

mi aporteexport function countWords(array) { // Tu código aquí 👈 return array.reduce((total, frase) => total + frase.split(' ').length, 0); }

export function countWords(array) {
  // Tu código aquí 👈
  return array.reduce((total, frase) => total + frase.split(' ').length, 0);

}

 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",
]))

export function countWords(array) {
  // Tu código aquí 👈
  return array.flatMap(item => item.split(" ")).length
}

```Para cada `item` (cada oración), `item.split(" ")` divide la oración en un array de palabras utilizando el espacio (" ") como delimitador.

* Por ejemplo, `"Beautiful is better than ugly".split(" ")` se convierte en `["Beautiful", "is", "better", "than", "ugly"]`.

Después de aplicar `split(" ")` a cada oración, `flatMap` aplana el array de arrays resultante en un solo array de palabras.

`length` obtiene la longitud del array resultante, es decir, el número total de palabras en todas las oraciones combinadas.

function countWords(array) {
  if (array.length === 0) return 0
  return array.join(" ").split(" ").length
}
```function countWords(array) {

&#x20; if (array.length === 0) return 0

&#x20; return array.join(" ").split(" ").length

}

Playground: calcula el total de palabras en un texto

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