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

}

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

Solucionogra

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
}

Código JavaScript:

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