Playground: calcula el total de palabras en un texto

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