No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Playground: calcula el total de palabras en un texto

25/28

Aportes 111

Preguntas 0

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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",
]))
```js // Mi soluci贸n: export function countWords(array) { return array.reduce((countWord, sentence) => countWord + sentence.split(' ').length, 0) } ```

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;
}
Solucion: // Contador de palabras ```js // Contador de palabras function countWords(array) { return array.flatMap(item => item.split(' ').join('').length).reduce((sum, item) => sum + item, 0) } console.log("Palabras: ", countWords(palabras)); ```
2 solutions: `export function countWords(array) { ` `// first solution` `// return array.flatMap((item) => item.split(" ").length).reduce((a, b) => a + b, 0)` `// second solution` ` return array.length > 0 ? array.join(' ').split(' ').length : 0;}`
![](https://static.platzi.com/media/user_upload/image-1fc628c8-8503-4132-b57f-0be0ab3d0753.jpg)
Spoiler . . . . . . . . . . . . ```js export function countWords(array) { return array.length === 0 ? 0 : array.join(' ').split(' ').length } export function countWords(array) { return array.flatMap((element) => element.split(' ')).length } ```
Mi humilde soluci贸n, estos retos me gustan y mas ver todas las posibles soluciones que tienen todos :) ```js export function countWords(array) { // Tu c贸digo aqu铆 馃憟 return array.flatMap(item => item.split(' ')).reduce((count, item) => count += 1, 0); } ```

Mi soluci贸n:

function solution(lines) {
	return lines.flatMap(item => item.split(' ')).reduce((sum, _) => sum + 1, 0);	
}; 
```js export function countWords(array) { // Tu c贸digo aqu铆 馃憟 return array.reduce((sum, item) => sum + item.split(' ').length, 0); } ```export function countWords(array) {聽 // Tu c贸digo aqu铆 馃憟聽 return array.reduce((sum, item) => sum + item.split(' ').length, 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)
}
Mi solucion: ```js function countWords(array) { const arrayDividido = array.map(elemento => elemento.split(" ")) const flat = arrayDividido.flat() return flat.length } ```
```js function countWords(array) { return array.reduce((sum, item) => item.split(' ').length + sum,0) } ```聽function countWords(array) {聽 return array.reduce((sum, item) => item.split(' ').length + sum,0)} function countWords(array) {聽 return array.reduce((sum, item) => item.split(' ').length + sum,0)} ```js ```
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
}
Mi soluci贸n para que pase todas las pruebas `export function countWords(array) {聽 return array.length > 0 ? array.join(" ").split(" ").length : 0;}`
<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 鈥榝latMap()鈥 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)
}
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);
}
undefined