Reduce Reloaded

Asi resolví el ejercicio:

const data = [
  {
    name: "Nicolas",
    level: "low",
  },
  {
    name: "Andrea",
    level: "medium",
  },
  {
    name: "Zulema",
    level: "hight",
  },
  {
    name: "Santiago",
    level: "low",
  },
  {
    name: "Valentina",
    level: "medium",
  },
  {
    name: "Lucia",
    level: "hight",
  },
];

mi solución 😊😊:

Devolver un solo objeto, aunque contenga “muchos elementos” sigue siendo un solo elemento de tipo objeto, y es por eso que se dice que reduce() solo devuelve un único valor.
.
Acá mi resolución al reto, seguramente se podría hacer muchísimo mejor:

const numbers = [1,2,3,3,4,5,2,1,1,3,4,5,6,7,5,5,4,7,8,9,8,7,5,4,5,8,9];
const ranges = ['1-5','6-7','8-9'];

const result = numbers.reduce((acum, item) => {
  if (item < 5) {
    !acum[ranges[0]] ? acum[ranges[0]] = 1 : acum[ranges[0]] += 1;
  } else if (item > 5 && item < 8) {
    !acum[ranges[1]] ? acum[ranges[1]] = 1 : acum[ranges[1]] += 1;
  } else {
    !acum[ranges[2]] ? acum[ranges[2]] = 1 : acum[ranges[2]] += 1;
  }
  return acum
},{})

console.log(result)

Aquí esta mi solución al problema:

Esta es mi solución al reto. Supongo que se puede limpiar más.

// reto
const arr = [3, 10, 9, 4, 3, 1, 8, 4, 7, 6];
const result = arr.reduce((obj, item) => {
  if (item <= 5) {
    obj['1-5']++
  } else if (item <= 8) {
    obj['6-8']++
  } else {
    obj['9-10']++
  }
  return obj
}, {
  '1-5': 0,
  '6-8': 0,
  '9-10': 0
})

console.log(result)

aqui mi solución

const a=[1,2,5,7,1,1,2,3,4,3,2,4,4,5,6,7,9,10,8,45,7,3,2]

const rst=a.reduce((obj,item)=>{
   //console.log(item)

   if(item>=1 && item<=5){
       obj.de1a5= obj.de1a5+1;
   }

   if(item>=6 && item<=8){
    obj.de6a8=obj.de6a8+1;
    }

if(item>=9 && item<=10){
  obj.de9a10=obj.de9a10+1;
    }

    return obj

},{de1a5:0,de6a8:0,de9a10:0})

console.log(rst);

Reduce

El método reduce() puede ser usado en cualquier array de elementos.
Cuando se llama, reduce() ejecuta una función reductora (proporcionada por ti) en cada elemento del array, resultando en un solo valor de salida, el acumulador.
_

Ejemplo de uso #1 (ES6+) - Sumar

Cuando quieres sumar todos los elementos que contiene un array.

La función reduce() recorrerá cada elemento del array y lo sumará al acumulador.
_

Ejemplo de uso # 2 - Para contar coincidencias

Si quieres saber cuántas veces se repite un elemento dentro de un array.

Para contar el número de veces que se repite un valor, nuestro valor inicial tiene que ser un objeto, de esta manera podemos retornar los pares key-value como el resultado.
reduce() en este ejemplo inicializa cada elemento encontrado con el valor 1, después, si lo encuentra de nuevo, ese valor se incrementa y el resultado se asigna al objeto key.
_

Ejemplo de uso #3 - Aplanamiento

Cuando quieres aplanar arrays del interior de un objeto.

Los datos a menudo se anidan de maneras complicadas. Lo que hace reduce en este ejemplo es recorrer cada instancia de colors desde la matriz y hace un push de cada valor encontrado al acumulador, lo que resultará en un array aplanado que contiene todos los colores que se encuentran dentro del objeto.
_

Tips Útiles ✅

Tip #1

Si no se le pasa un valor inicial a la función reduce(), automáticamente asumirá que el primer elemento en el array es el valor inicial. Esto funcionó en el ejemplo 1, porque solo sumamos una lista de números, pero en los otros dos ejemplos si lo necesitamos porque queremos recorrer el array con un valor inicial vacío e ir agregando los valores después, para construir el resultado.
_

Tip #2

No olvidar retornar el total (el acumulador). Siempre revisar que estás retornando el valor que necesitas.
_

Tip #3

Recuerda, la función reduce() puede tomar 2 parámetros:

1. El callback (función para recorrer cada elemento del array)
2. El valor inicial (valor a usar la primera vez que se ejecute el callback)
   _

Tip #4

El callback también requiere dos parámetros:

1. El acumulador.
2. El valor actual.

¡Espero les sirva! 😉

Mi solucion, claro que puede ser mejorada

const numbers=[1,2,3,4,5,6,7,8,9,10];
const ranges = ['1-3','4-7','8-10']
const result = ranges.reduce((obj,item)=>{
    const range=item.split('-')
    const suma = numbers.reduce((sum,dato) => {
         dato >=parseInt(range[0]) && dato <=parseInt(range[1])?sum = sum + 1:null
        return sum},0)
    obj[item]=suma
    return obj
},{})

Esta es mi solucion del reto 😄

Reto

const arr = [1,2,3,5,7,7,10,9,12,34];
// {1-5: 3, 6-8: 2, 9-10:1}

const result = arr.reduce((obj, item)=> {
    if(item > 0 && item < 11){
        if(item < 6){
            obj["1-5"] += 1
        }else if(item < 8){
            obj["6-8"] += 1
        }else{
            obj["9-10"] += 1
        }
    }
      return obj;
} , { '1-5': 0, '6-8': 0, '9-10': 0 });

console.log(result);

Mi solución al reto:

numbers = [9,6,5,8,7,4,1,2,3,6,5,2,1,4,7,8,9,6,6,2,5,4,9,6,6,5,5,6];
const numbersRangle = numbers.reduce((obj,item) =>{
    if(item >= 1 && item <= 5){
        if(!obj['1-5']){
            obj['1-5'] = 1;
        }else{
            obj['1-5'] += 1;
        }
    }else if(item >= 6 && item <= 8){
        if(!obj['6-8']){
            obj['6-8'] = 1;
        }else{
            obj['6-8'] += 1;
        }
    }else if(item >= 9 && item <= 10){
        if(!obj['9-10']){
            obj['9-10'] = 1;
        }else{
            obj['9-10'] += 1;
        }
    }

    return obj;
},{});

console.log(numbersRangle); 

Les comparto mi solución

const itemsrange = [1, 3, 2, 3,5 ,7 ,6 ,9 ,9 ,10];

const rst = itemsrange
.reduce((obj, item) => {
    if(item <= 5){
        obj["1-5"] += 1;
    } else if (item <=8){
        obj["6-8"] += 1;
    } else if (item <=10){
        obj["9-10"] += 1;
    }
    return obj;
}, {
    "1-5": 0,
    "6-8": 0,
    "9-10": 0,

})

console.log(rst);

Muchachos les dejo esta solucion donde reduce tambien les toma el valor del indice del arreglo:

Mi solución:

const numbers = [1,2,3,3,4,5,2,1,1,3,4,5,6,7,5,5,4,7,8,9,8,7,5,4,5,8,9];

const groupedNumbers = numbers.reduce((prev, c) => ({
	...prev,
	[c]: !prev[c] ? 1 : prev[c] + 1
}), {});

console.log("groupedNumbers", groupedNumbers);

Saludos 0_o

Mi solución

Les dejo el objeto del ejercicio a mano 😃

const data = [
  {
    name: "Nicolas",
    level: "low",
  },
  {
    name: "Andrea",
    level: "medium",
  },
  {
    name: "Zulema",
    level: "hight",
  },
  {
    name: "Santiago",
    level: "low",
  },
  {
    name: "Valentina",
    level: "medium",
  },
  {
    name: "Lucia",
    level: "hight",
  },
];

Les comparto mi solución 🤘

const rnd= [3,4,6,9,1,2,4,9,5,1,3,4,10,4,2,5,6,7,8,2,1,10,2,6,3];

const range = rnd.reduce((obj, item) => {
    item > 0 && item <= 5 ? obj['1-5'] += 1 : obj['1-5'] += 0;
    item > 5 && item <= 8 ? obj['6-8'] += 1 : obj['6-8'] += 0;
    item > 8 && item <= 10 ? obj['9-10'] += 1 : obj['9-10'] += 0;
    return obj;
},{'1-5': 0, '6-8': 0, '9-10': 0});
console.log(range);

const numbers = [1,2,3,4,5,6,7,8,9,10,4,8,2,1,5,3,1]
const countedNumbers = numbers.reduce((obj,item) => {
  if(item<=5) obj["1-5"] += 1;
  else if(item>5 && item<=10) obj["6-10"] += 1;
  else obj["10-15"] += 1;
  return obj
},{
  "1-5":0,
  "6-10":0,
  "10-15":0
})
console.log(countedNumbers)

reduce reloaded 1ra práctica llevada a react

me costó bastante xq para renderizar el objeto que me devolvía el .reduce tuve que aprender los métodos Object (entries y value) y combinar estos con un map.
No me conformé con el console.log.
va mi codigo:

import { useState } from "react";
import "./App.css";

function App() {
  const [data, setData] = useState({});

  //   const myArray = [1, 2, 3, 4];

  const myArray = [
    {
      customerName: "Nicolas",
      total: 600,
      delivered: true,
    },
    {
      customerName: "Zulema",
      total: 120,
      delivered: false,
    },
    {
      customerName: "Santiago",
      total: 180,
      delivered: true,
    },
    {
      customerName: "Valentina",
      total: 600,
      delivered: true,
    },
  ];

  const myTotals = myArray.map((item) => item.total);

  const totalSales = myTotals.reduce((obj, item) => {
    if (!obj[item]) {
      obj[item] = 1;
    } else {
      obj[item] = obj[item] + 1;
    }
    return obj;
  }, {});

  const handleReduce = () => {
    console.log(totalSales);
    setData(totalSales);
  };

  return (
    <div className="App">
      <header className="App-header">
        <h1>veamos al método .reducePlus++</h1>
        <section className="data">
          <ul className="ul-key">
            {data &&
              Object.keys(data).map((item, index) => (
                <li className="li-keys" key={index}>{`${item} :`}</li>
              ))}
          </ul>
          <ul className="ul-value">
            {data &&
              Object.values(data).map((item, index) => (
                <li key={index}>{item}</li>
              ))}
          </ul>
        </section>
        <button onClick={handleReduce}>obtener total de ventas</button>
      </header>
    </div>
  );
}

export default App;

Reto con una pequeña modificación

//RETO: de un array de números de 1 - 20, acumular por rangos de 1-5, 6-10, 11-15 y 16-20
const numbers2 = [1,3,5,6,9,4,3,10,11,19,17,5,18,20,9,13,7,14];
const beetween = (min,max, x) => (min <= x && x <= max);

const rpta3 = numbers2.reduce((obj, number) => {
    if(beetween(1,5,number)){
        obj['1-5'] ++;
    }else if(beetween(6,10,number)){
        obj['6-10'] ++;
    }else if(beetween(11,15,number)){
        obj['11-15'] ++;
    }else{
        obj['16-20'] ++;
    }
    return obj;
},{'1-5': 0, '6-10': 0, '11-15': 0, '16-20': 0})

console.log(rpta3);

Mi forma de resolver el reto:

const array = [5, 8, 6, 9, 5, 8, 8, 2, 3, 2, 4, 6, 10, 3, 10, 2, 9, 9, 9, 10, 7, 4, 4, 5, 5, 4, 10, 3, 2, 3, 6, 2, 9, 8, 9, 10, 7, 2, 8, 4];

const challenge = array.reduce((obj, num) => {
  if (num <= 5 && !obj['1-5']) {
    obj['1-5'] = 1
  } else if (num <= 5 && obj['1-5']) {
    obj['1-5'] += 1
  } else if (num >= 6 && num <= 8 && !obj['6-8']) {
    obj['6-8'] = 1
  } else if (num >= 6 && num <= 8 && obj['6-8']) {
    obj['6-8'] += 1
  } else if (num >= 9 && num <= 10 && !obj['9-10']) {
    obj['9-10'] = 1
  } else if (num >= 9 && num <= 10 && obj['9-10']) {
    obj['9-10'] += 1
  }
  return obj
}, {})

console.log(challenge)

(Para generar esos números aleatorios utilice esta pagina, no encontré ningún botón para copiar los números, los logre copiar utilizando el inspector de elementos y copiando el contenido, del contenedor (xd), que tenia los números)

Me parecio grandiosa idea de un estudiante que la hizo asi…

😊 Reto

const data = [1, 4, 2, 3, 3, 4, 4, 3, 1, 10, 3, 1, 4, 2, 3, 3, 4, 4, 3, 1, 10, 3, 2, 10, 10, 9, 9, 8, 7, 7, 6, 4, 9, 10, 5];

const rta = data.reduce((obj, item) => {
    if (item >= 1 && item <= 5) obj['1-5']++;
    if (item >= 6 && item <= 8) obj['6-8']++;
    if (item >= 9 && item <= 10) obj['9-10']++;

    return obj;
}, {
    '1-5': 0,
    '6-8': 0,
    '9-10': 0
});

console.table(rta);

Aporte del dejercicio
espero les sirva

const nums = [];
//Random numbers
for (let z = 0; z < 30; z++) {
  nums.push(Math.floor(Math.random() * 100));
}
//Reduce
const rta = nums.reduce(
  (acum, n) => {
    if (n <= 5) {
      acum["1-5"] += 1;
    } else if (n >= 6 && n <= 8) {
      acum["6-8"] += 1;
    } else {
      acum["9-10"] += 1;
    }
    return acum;
  },
  {
    "1-5": 0,
    "6-8": 0,
    "9-10": 0,
  }
);
console.log(rta);
console.log(nums);
//Output
//{ '1-5': 0, '6-8': 1, '9-10': 29 }
/*[
  85, 26, 88,  7, 71, 97, 77, 34, 12,
  70, 49, 13, 98,  9, 49, 68, 22, 10,
  15, 53, 35, 24, 88, 30, 30, 37, 13,
  25, 89, 45
]*/

Mi solucion:

nums.reduce((obj, num) => {
    if (num > 0 && num < 6) {
            obj['1-5'] = obj['1-5'] ? obj['1-5'] + 1 : 1  
    }else if (num <= 8 ) {
        obj['6-8'] = obj['6-8'] ? obj['6-8'] + 1 : 1 
    }else if (num <= 10) {
        obj['9-10'] = obj['9-10'] ? obj['9-10'] + 1 : 1 
    }
    return obj
}, {})

Creo que a este curso le vendrían fenomenal los QUIZ que hacen en otros cursos a lo largo del temario. Estoy viendo que al llegar al examen van a haber preguntas de esas que solo sabes si te memorizaste el detalle más mínimo de lo que dice el profe.
Ya verán.

//reto Agrupar numeros por rangos de un array y dar frecuencias de estos rangos.
const arr1 = ()=>{
    let arr= [];
    for(let i=0; i<100; i++){
        arr.push(parseInt(Math.random()*(100-1)+1))
    }
    return arr;
}

function getRangos(maxNumRanges , previoValue  , currentValue ){
    let elemento;
    let minOfRange ;
    let sizeOfRange =0;
    
    for(let i=0; i<=maxNumRanges; i++){
        minOfRange  = sizeOfRange+1;
        sizeOfRange += 10;
        
        if(minOfRange<=currentValue && currentValue <=sizeOfRange){
            elemento = `range_${minOfRange}_${sizeOfRange}`;
            if(!previoValue[elemento] ){
                previoValue[elemento] =1
            }   else{
                previoValue[elemento]++
            }
        }     
    }//for
    return previoValue;
}                

const rangosFrecuencia = (arr)=>{
    console.log("arr : ",arr.sort());
    return arr.reduce(
        (previoValue , currentValue , currentIndex,)=>{
           //>>>>>>>>>>>>>>>>>
           let sizeOfRange = 41
           previoValue = getRangos(10, previoValue , currentValue , sizeOfRange);
           //>>>>>>>>>>>>>>>>>
           return previoValue; 
        },{})
}

const miarr = arr1();
miarr.sort( (a,b)=>{a-b});
console.log("miarr ordenado" , miarr);
console.log("rangosFrecuencia :" ,rangosFrecuencia(miarr));

Esta es la solución por mi parte:

Hola, solucion al ejercicio:

const array=[1,2,3,4,3,4,3,2,3,4,3,3,4,3,5,3,5,6,8,9,7,6,8,7,6,7,6,5,5,5,6,4,3,2,1,2,2,3,4,5,7,8,7,9,8];

const rta=array.reduce((obj,item)=>{
    if(item<6&&item>0){
        obj.unocinco=obj.unocinco+1;
    }else if(item<9&&item>5){
        obj.cincoocho=obj.cincoocho+1;
    }else{
        obj.nuevediez=obj.nuevediez+1;
    }
    return obj;
},{
    unocinco:0,
    cincoocho:0,
    nuevediez:0
})
console.log(rta);

// Generamos un "array" con n elementos
let array = [];
const number = (() => {
    for (let i = 0; i <= 1000; i++) {
        array.push(i);
    }

})();
// Generamos un rango de agrupación
let range = array.filter(elem => elem % 500 == 0);

// Generamos un objeto que agrupa los valores del array

const arrayReloaded = array.reduce(function(obj, valueA) {


    for (let j = 0; j < range.length; j++) {
        let values = array.filter(element => element >= range[j] && element < range[j + 1]);

        obj[`${range[j]}-${range[j+1]}`] = values.length;

    }

    return obj;
}, {});
//Imprimimos en consola
console.log(arrayReloaded);

<
//RETO//
const numbers =[1,3,2,3,4,5,5,7,8,9,10,1,4,6,3,8,7,9,1];

const rta2 = numbers.reduce((obj, item)=>{
    if (item <=5) {
       obj["1-5"]+= 1;
    } else if (item<9){
        obj["6-8"] += 1;
    } else {
        obj["9-10"] += 1;
    }
    return obj;
},{
    "1-5": 0,
    "6-8":0,
    "9-10":0,
});

console.log(rta2);
>

Posible solución:

const randomNumber = [1, 1, 1, 2, 3, 4, 8, 6, 6, 8, 8, 8, 9, 10];

const rsta = randomNumber.reduce((obj, item) => {
  switch (item) {
    case 1 || 2 || 3 || 4 || 5:
      obj['1-5'] += 1;
      break;
    case 6 || 7 || 8:
      obj['6-8'] += 1;
      break;
    case 9 || 10:
      obj['9-10'] += 1;
      break;
    default:
      break;
  }
  return obj
}, {'1-5': 0, '6-8': 0, '9-10': 0})

console.log(rsta)

Hola, les dejo mi solución al reto:

const numbersList = [1, 12, 8, 7, 5, 3, 9, 2, 10];

const numberListAns = numbersList.reduce(
  (obj, element) => {
    switch (true) {
      case element > 0 && element < 5:
        obj["1-4"] += 1;
        break;
      case element > 4 && element < 9:
        obj["5-8"] += 1;
        break;

      default:
        obj["9-12"] += 1;
        break;
    }
    return obj;
  },
  {
    "1-4": 0,
    "5-8": 0,
    "9-12": 0,
  }
);

console.log(numberListAns);

Mi versión al reto

Comparto mi solución del reto🎉

const arrayPractica2 = [9,6,8,7,2,1,10,6,5,7];
const matriz2 = arrayPractica2.reduce((objetoAcumulado, item) => {
    if(item >= 1 && item <= 5){
        objetoAcumulado["1-5"] += 1;
    } else if (item >= 6 && item <= 8){
            objetoAcumulado["6-8"] += 1;          
        } else {
                objetoAcumulado["9-10"] += 1;
            }
            return objetoAcumulado          
    }, {
        "1-5": 0,
        "6-8": 0,
        "9-10": 0
    });
    console.log(matriz2); // {'1-5': 3,'6-8': 5,'9-10': 2}

Una de las tantas soluciones …

// exercise
const dataEx = [1,2,3,4,5,6,7,8,9,9,10];
const resRange = dataEx.reduce((obj,item) => {
    if(item >= 1 && item <=5){
        obj['1-5']? obj['1-5'] += 1: obj['1-5']=1;
    }
    if(item >= 6 && item <=8){
        obj['6-8']? obj['6-8'] += 1: obj['6-8']=1;
    }
    if(item >= 9 && item <=10){
        obj['9-10']? obj['9-10'] += 1: obj['9-10']=1;
    }
    return obj
}, {});
console.log(resRange);

Alternativa, incluyendo el método Slice para recorrer la longitud que tiene cada rango. La cantidad es la sumatoria -1. ¡Espero sea de ayuda colegas!

Muy Interesante

Mi solución

Resultado

{ '1-4': 10, '5-7': 7, '8-10': 4 }

Basicamente es igual que otros aportes.
Pero funciona.

const rangos = [1, 3, 2, 5, 6, 7, 4, 6, 7, 9, 10, 1, 2, 4, 5, 7, 9, 8, 2, 3, 4];

const rta6 = rangos.reduce((obj, item) => {
    if (item >= 0 && item <= 4) {
        obj['1-4'] += 1;
    } else if (item >= 5 && item <= 7) {
        obj['5-7'] += 1;
    } else { obj['8-10'] += 1; }

    return obj;
}, { '1-4': 0, '5-7': 0, '8-10': 0 });

console.log(rta6);

Talvez alguien quiera intentarlo en TS

My solution:

Costó y quedó algo largo, pero lo conseguí! 😄

const items = [
    1, 4, 3, 5, 2, 6, 8, 8, 7, 7, 6, 5, 8, 8, 9, 10, 9, 9, 9, 9, 9, 5, 6, 8, 8,
    5, 8, 5,
];

const reto = items.reduce((obj, item) => {
    if (item <= 5) {
        let item = "1-5";
        if (!obj[item]) {
            obj["1-5"] = 1;
        } else {
            obj["1-5"] = obj[item] + 1;
        }
    }
    if (item <= 8 && item >= 6) {
        let item = "6-8";
        if (!obj[item]) {
            obj["6-8"] = 1;
        } else {
            obj["6-8"] = obj[item] + 1;
        }
    }
    if (item <= 10 && item >= 9) {
        let item = "9-10";
        if (!obj[item]) {
            obj["9-10"] = 1;
        } else {
            obj["9-10"] = obj[item] + 1;
        }
    }
    return obj;
}, {});

console.log(reto);

Las tablas con las iteraciones me recuerdan mis primeras clases de programación. Aun las sigo usando para entender código que de primera no entiendo.

Gracias por las memorias.

Les comparto mi código del reto. 😄

function betweenNumbers(object, number) {
    if (1 <= number && number <= 5) object['1-5']++;
    if (6 <= number && number <= 8) object['6-8']++;
    if (9 <= number && number <= 10) object['9-10']++;
    
    return object;
}

const ramdom = () => Math.floor(Math.random() * 10) + 1;

const numbers = [];
const numberRange = {
    '1-5': 0,
    '6-8': 0,
    '9-10': 0,
}

for (let index = 0; index <= 10; index++) {
    let ramdomNumber = ramdom();
    numbers.push(ramdomNumber);
}

const groupNumbers = numbers.reduce(betweenNumbers, numberRange);

console.log({numbers, groupNumbers});

mi solución al reto:

const items = [1, 2, 3, 2, 3, 3, 3, 2, 2, 1, 1, 10,5,5,6,4,7,8,9,7,9,9,9,8,8,7,7,4,6,6,6,5,10];

const nums = items.reduce((obj, item) => {
  if (item >= 1 && item <= 5) {
    obj['1-5']++;
  }
  if (item >= 6 && item <= 8) {
    obj['6-8']++;
  }
  if (item >= 9 && item <= 10) {
    obj['9-10']++;
  }
  return obj;
}, {
  '1-5': 0,
  '6-8': 0,
  '9-10': 0
});

console.log(nums);

let array =[];
for(i =0; i < 30; i++) {
    array.push(Math.floor(Math.random() * 11))
}
 
console.log(array);
 
const rta = array.reduce((obj, item) => {
    if (item <= 5) {
        obj['1-5']++
      } else if (item <= 8) {
        obj['6-8']++
      } else {
        obj['9-10']++
      }
      return obj
    }, {
 
      '1-5': 0,
      '6-8': 0,
      '9-10': 0
    })
   
    console.log(rta)
 
 
 

//RETO: CALCULAR EL RANGO DE LOS SIGUIENTES NÚMEROS    (beetwen)  Números intermedios
const items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

const rta = items.reduce((obj, item) => {
    if (item <= 5) {
        obj['1-5'] ++;
    } else if (item <= 8) {
        obj['6-8'] ++
    } else {
        obj['9-10'] ++;
    }
    return obj;
}, {  '1-5':0,
      '6-8':0,
      '9-10':0,
  });
console.log(rta);

Aquí está mi solución del reto, quedó muy largo pero con la lógica explicita; espero le sirva a alguien.

//acc == accumulator && curr == current value
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const range = ["1-5", "6-8", "9-10"];
const rank = numbers.reduce((acc, curr) => {
  if(curr <= 5 && !acc[range[0]]) {
    acc[range[0]] = 1;
  } else if(curr <= 5 && acc[range[0]]) {
    acc[range[0]] += 1;
  } else if(curr >=6 && curr <9 && !acc[range[1]]) {
    acc[range[1]] = 1;
  } else if (curr >=6 && curr <9 && acc[range[1]]) {
    acc[range[1]] += 1;
  } else if(curr >=9 && curr <=10 && !acc[range[2]]) {
    acc[range[2]] = 1;
  } else if (curr >=9 && curr <=10 && acc[range[2]]) {
    acc[range[2]] += 1;
  } 
  return acc;
}, {})
console.log(rank);

Algo muy importante por Pipeline son comunicación entre procesos.
la salida de uno es la entrada de información de otro

uff que clases mucho level

Mi solución dinámica, para construir los intervalos, como una tabla estadística.

//Lista de numeros
const numeros=[22,19,16,13,18,15,20,14,15,16,15,16,20,13,15,18,15,13,18,15];
//k-->interavlo, r-->Rango, a-->Amplitud
//Declaracion de variables
let max,min,r,k,a;
let li,ls;
let ranges =[];

//Calculos para generar intervalos en datos grupados
max=Math.max(...numeros);
min=Math.min(...numeros);
r=max-min;
k=intervalo(1+3.322*Math.log10(20));
a=Math.round(r/k);
li=min,ls=li+a;
console.log(`k: ${k} , r: ${r}, a=${a}`);

//Clase de los rangos de cada intervalo.
class Ran{
     constructor(ini,fin){
         this.ini=ini;
         this.fin=fin;
     }
}
//Cargar el Objeto con los intervalos
for(let i=1;i<=k;i++){
    ranges.push(new Ran(li,ls));
    li=ls;
    ls=(li)+a;
}
//Funcion para calcular K, en el caso que sea par
function intervalo(n){
    n=parseInt(n);
    if((n%2)==0) 
    {return n+1;}
    return n; 
}

numeros.map((itemNumber)=>{
    ranges.filter((itemRange,index)=>
    {
        if(itemNumber>=itemRange.ini && itemNumber<itemRange.fin){
        itemRange.xm=(itemRange.ini+itemRange.fin)/2;
            if(itemRange.f)
            {
                itemRange.f+=1;
            }else{
                itemRange.f=1;
            }
            return itemRange;
        }
    });
});
console.log('Count:',ranges);

Esta es mi solución al reto:

const totals = [1,2,3,4,5,6,7,8,9,10];

const ranges = [0,5,8,10]

const result = totals.reduce((histogram, number) => {
  if(number > ranges[0] && number <= ranges[1]) {
    if(!histogram[`${ranges[0]+1}-${ranges[1]}`]) {
      histogram[`${ranges[0]+1}-${ranges[1]}`] = 0;
    }
    histogram[`${ranges[0]+1}-${ranges[1]}`] += 1;
  }
  if(number > ranges[1] && number <= ranges[2]) {
    if(!histogram[`${ranges[1]+1}-${ranges[2]}`]) {
      histogram[`${ranges[1]+1}-${ranges[2]}`] = 0;
    }
    histogram[`${ranges[1]+1}-${ranges[2]}`] += 1;
  }
  if(number > ranges[2] && number <= ranges[3]) {
    if(!histogram[`${ranges[2]+1}-${ranges[3]}`]) {
      histogram[`${ranges[2]+1}-${ranges[3]}`] = 0;
    }
    histogram[`${ranges[2]+1}-${ranges[3]}`] += 1;
  }
  return histogram;
}, {});

console.log(result)

**Respeusta larga **
const rangeNumbers = [7, 6, 3, 4, 7, 5, 10, 1, 5, 6, 6, 1, 9, 10, 4];

const rta3 = rangeNumbers.reduce((obj, item) => {
if (item <= 5) {
if (!obj[“1-5”]) {
obj[“1-5”] = 1;
} else {
obj[“1-5”] = obj[“1-5”] + 1;
}
} else {
if (item >= 6 && item <= 8) {
if (!obj[“6-8”]) {
obj[“6-8”] = 1;
} else {
obj[“6-8”] = obj[“6-8”] + 1;
}
} else {
if (item >= 9) {
if (!obj[“9-10”]) {
obj[“9-10”] = 1;
} else {
obj[“9-10”] = obj[“9-10”] + 1;
}
}
}
}

return obj;
}, {});

console.log(rta3);
**Respuesta corta **
const rta4 = rangeNumbers.reduce(
(obj, item) => {
if (item <= 5) {
obj[“1-5”];
} else {
if (item >= 6 && item <= 8) {
obj[“6-8”];
} else {
obj[“9-10”]++;
}
}

return obj;

},
{
“1-5”: 0,
“6-8”: 0,
“9-10”: 0,
}
);

console.log(rta4);

Esta es la forma en la que resolví el reto, hice un array de rangos con el objetivo de poder agregar más rangos de forma dinámica, también añadí una función para generar los números de forma aleatoria.

Este es el resultado 👇

Cualquier sugerencia para mejorar es bienvenida y se agradece. 🙂

Aquí mi respuesta

const num = [1, 2, 3, 4, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 10, 10];

const responseFinal = num.reduce((obj, num) => {
    if (num >= 1 && num <= 5) { //5
        obj['1-5'] ++;
    } else if (num >= 6 && num <= 8) { //13
        obj['6-8'] ++;
    }
     else if (num >= 9 && num <= 10) { //5
        obj['9-10'] ++;
    }
    return obj;
}, {
    ['1-5']: 0, 
    ['6-8']: 0, 
    ['9-10']: 0
});

console.log(responseFinal);

Esta es mi solución al pequeño challenge.

Debo mencionar que hace una semana, tuve una entrevista donde me hicieron solucionar dos escenarios y uno de ellos era bastante similar al challenge de esta lección. Yo hice mi solución utilizando map, pero si hubiera visto este video a tiempo, con reduce() era mas elegante.

Saludos buen contenido, bien explicado todo.

YO LA VERDAD lo hice mas simple
!

Comparto mi solución del ejercicio:

Method chaining

Funciones de orden mayor combinadas de forma elegante para lograr un resultado.

<// Method chaining
// Funciones de orden mayor
let employes = [
  { name: "Jhonson", salary: 95000, hireDate: "July 2, 1858" },
  { name: "Hansel", salary: 75000, hireDate: "Agust 25, 2009" },
  { name: "Devora", salary: 83000, hireDate: "November 12, 1985" },
];

// Combinadas de forma elegante
const totalHightier = employes
  .map((employes) => employes.salary)
  .filter((salary) => salary > 75000)
  .reduce((total, current) => total + current);

console.log(totalHightier);> 

const array = [1,2,5,6,8,10,13,2,14,15,28,20,18,24]
const r = ['1-5','6-10','11-15']

const rta = array.reduce((obj,e)=> {
    if (e <= 5){
        !obj[r[0]] ? obj[r[0]] = 1 : obj[r[0]] += 1 
    } else if (e > 5 && e <= 10) {
        !obj[r[1]] ? obj[r[1]] = 1 : obj[r[1]] += 1 
    } else if (e > 10 && e <= 15){
        !obj[r[2]] ? obj[r[2]] = 1 : obj[r[0]] += 1
    } else {
        !obj['otros'] ? obj['otros'] = 1 : obj['otros'] += 1
    }

    return obj
},{})

console.log(rta)

Output:
{ ‘1-5’: 6, ‘6-10’: 3, ‘11-15’: 1, otros: 4 }

también hice varias pruebas y lo realice retornando un objeto que tiene almacenado arrays con los números pares, impares y el conteo o cantidad de cada uno.

let array = [1,2,3,4,5,6,7,8,9,10]

let rta = array.reduce((obj,e)=>{
    if (e % 2 === 0){
        obj.pares.push(e)
        obj['countPar'] += 1  
    } else  {
        obj.impares.push(e)
        obj['countImpar'] += 1 
    }

    return obj
}, { countPar: 0, pares: [], countImpar: 0, impares: [],} )

console.log(rta)

Output:
{
countPar: 5,
pares: [ 2, 4, 6, 8, 10 ],
countImpar: 5,
impares: [ 1, 3, 5, 7, 9 ]
}

Mi solución:

const nums = [1, 6, 7, 10]

const rta = nums.reduce(
    (obj, num) => {
        if (num >= 1 && num <= 5) obj['1-5']++
        else if (num >= 6 && num <= 8) obj['6-8']++
        else if (num >= 9 && num <= 10) obj['9-10']++
        else obj['other']++

        return obj
    },
    { '1-5': 0, '6-8': 0, '9-10': 0, other: 0 }
)

console.log(rta)
// output
// {
//     '1-5': 1,
//     '6-8': 2,
//     9-10: 1
// }

Así lo resolvi yo…

const groupItems = items.reduce((objeto, item) => {
    objeto.forEach(element => {
        if (item >= element.min && item <= element.max) {
            element.cant++;
        }
    });
    return objeto;
}, [{min: 0, max: 3, cant: 0},
    {min: 4, max: 7, cant: 0},
    {min: 8, max: 1000000, cant: 0},
]);

Mi solución:

const objectByRanks = nums.reduce((obj, item) => {
    if(item >= 1 && item <= 5){
        obj['1-5']++;
    }else if(item > 5 && item <= 8){
        obj['6-8']++;
    }else if(item > 8 && item <= 10){
        obj['9-10']++;
    }else{
        if(obj['out of range']){
            obj['out of range']++;
        }else{
            obj['out of range'] = 1;
        }
    }
    return obj;
}, { '1-5':0, '6-8':0, '9-10':0});

Así lo solucioné yo:

const numbers = [1,2,2,2,6,7,7,7,7,7,9,9,9];

let range1_5 = 0;
let range6_8 = 0;
let range9_10 = 0;

const result = numbers.reduce((obj, number) => {
	if(number <= 5){
		range1_5 += 1;
	} else if(number >= 6 && number <= 8){
		range6_8 += 1;
	} else {
		range9_10 += 1;
	}

	obj['range1_5'] = range1_5;
	obj['range6_8'] = range6_8;
	obj['range9_10'] = range9_10;
	return obj;
}, {})

console.log(result)

Hola les comparto mi solucion.
Mi aproach fue crear una lista con los intervalos, asi considero que es mucho mas fácil de escalar y mantener ya que puedo configurar los rangos de manera muy rapida y fácil

Esta es mi solución 🙂

  const arr = [1, 3, 1, 2, 3, 3, 4, 3, 3, 6, 4]
  const result = arr.reduce((acc, item) => {
    acc[item] = -~acc[item]
    return acc
  }, {})

El operador bitwise (operador bit a bit) es interesante, cuando aplicamos este operador a un número obtenemos una operación así: -(x + 1), esto significa que al número que tenemos le sumamos 1 y multiplicamos por -1 el resultado.

Si alguien necesita lo puedo explicar para que sea más claro

Aquí esta mi solución al reto.

const numbers = [4, 2, 1, 7, 3, 3, 2, 8, 4, 9, 10]

const rta = numbers.reduce((obj, item) => {
  if (item <= 5) obj["1 - 5"] += 1
  else if (item <= 8) obj["6 - 8"] += 1
  else obj["9 - 10"] += 1

  return obj
}, {
  "1 - 5": 0,
  "6 - 8": 0,
  "9 - 10": 0
})

Bueno excelente curso, un poco tarde pero he aquí mi solución.

let data = [0, 2, 8, 5, 1, 8, 8, 6, 1, 9];
var res = data.reduce((prev, curr) => {
  if (curr > 0 && curr <= 5) prev['1-5'] = prev['1-5'] ? prev['1-5'] + 1 : 1;
  if (curr > 5 && curr <= 8) prev['6-8'] = prev['6-8'] ? prev['6-8'] + 1 : 1;
  if (curr > 8 && curr <= 10) prev['9-10'] = prev['9-10'] ? prev['9-10'] + 1 : 1;
  return prev;
}, {});

console.log(res);

mi solución:

const rta= array.reduce((obj,item)=>{
    if (item>=1 && item<=5) {
        obj["1-5"]++
    }else if (item>=6 && item<=8) {
        obj["6-8"]++       
    }else if (item>=9 && item<=10){
        obj["9-10"]++       
    }  
    return obj;
},{
    "1-5":0,
    "6-8": 0,
    "9-10": 0,
})

Así hice el ejercicio:

const rta = items.reduce((obj, item) => {
  switch (item) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      if (!obj["1 - 5"]) {
        obj["1 - 5"] = 1;
        return obj;
      } else {
        obj["1 - 5"] = obj["1 - 5"] + 1;
        return obj;
      }
    case 6:
    case 7:
    case 8:
      if (!obj["6 - 8"]) {
        obj["6 - 8"] = 1;
        return obj;
      } else {
        obj["6 - 8"] = obj["6 - 8"] + 1;
        return obj;
      }
    case 9:
    case 10:
      if (!obj["9 - 10"]) {
        obj["9 - 10"] = 1;
        return obj;
      } else {
        obj["9 - 10"] = obj["9 - 10"] + 1;
        return obj;
      }
  }
}, {});

Lo hice con Switch pero creo que lo aploqué mal, además de que podria haber hecho una función entre cada caso ya sino repito el mismo código. (DRY)

const numeros = [1,2,6,4,3,8,9,7,5,4,22,1,0,3,8,4,3,2];

const rangeNumber = numeros.reduce((range, item)=>{
    if(item>1 && item<=5){
        range['1-5']++;

    }else if(item>5 && item<=8){
        range['6-8']++;
    }else if(item>8 && item<=10){
        range['9-10']++;
    }
    return range;
},{'1-5':0,'6-8':0,'9-10':0})

console.log(rangeNumber);

Yo probe resolverlo usando el reduce + forEach. Les adjunto la respuesta por si a alguien le sirve:

// Inventamos una cantidad de numeros a agrupar por rangos
const numbers = [0, 8, 9, 4, 8, 5, 2, 7, 4, 3, 1, 2];

//Inentamos los rangos a nuestro antojo
let rangosOriginal = [
{inicio:0,
final: 3,
cantidad:0},  // Deberia dar 5

{inicio:4,
final:7,
cantidad:0},  // Deberia dar 4

{inicio: 8,
final: 9,
cantidad:0}   //Deberia dar 3
];

//Analizamos el array numbers
let respuesta = numbers.reduce(function(rangosAcumulado, elementoActual){
    rangosAcumulado.forEach(function(rangosAcumulado){
        if (rangosAcumulado.inicio <= elementoActual && elementoActual <= rangosAcumulado.final) {
            rangosAcumulado.cantidad++;
        }
    });
return rangosAcumulado;
}, rangosOriginal);

console.log(respuesta);

😮 Reduce es muy poderoso, algo que me sirvio para entenderlo mejor como funciona el reduce fue poner el debugger y verlo en el navegador el codigo 😃

const numbers = [1, 3, 2, 3, 10,20,10];

const resultado = numbers.reduce((obj, numbers) =>{
   //estado inicial
   //si dentro del objeto ya existe ese numero,
   if(!obj[numbers]){
      //si no existe inicializalo en 1
      obj[numbers] = 1;
   } else {
       //obtenemos ese elemento en el contador que este + 1
       obj[numbers] = obj[numbers] + 1;
   }
   debugger;
   return obj;
},{});
// De todo un array lo redujimos a un solo objeto
console.log('Resultado', resultado);

Mi solución al reto

 const numbers = [1, 2, 3, 4, 5, 1, 6, 7, 2, 3, 8, 7, 9, 4, 10, 6, 4, 3, 7, 9, 1, 5]
  
  const numbersSimplified = numbers.reduce((obj, element)=>{
    if(element == 1 || element == 2 || element == 3 || element == 4 || element ==5){
        obj["1-5"] = obj["1-5"] + 1;
    }
    else if(element == 6 || element == 7 || element == 8){
        obj["6-8"] = obj["6-8"] + 1;
    }
    else if (element == 9 || element == 10) {
        obj["9-10"] = obj["9-10"] + 1;
    } 
    return obj
  }, {"1-5": 0, "6-8":0, "9-10": 0})

Mi solución:

const num = [1,1,1,1,1,2,2,3,3,3,4,5,6,7,7,7,8,8,9,9,10];

const red = num.reduce((obj, item) => {
    if (item > 0 && item < 11) {
        if (item < 6) {
            obj["1-5"] += 1;
        }
        if (item > 5 && item < 9) {
            obj["6-8"] += 1; 
        }
        if (item > 8) {
            obj["9-10"] += 1;
        }
    }
    return obj;
}, {"1-5" : 0, "6-8" : 0, "9-10" : 0});

console.log(red);

Mi solución:
const items = [1,2,3,4,5,6,7,8,9,10];
const rta = items.reduce((obj, item) => {
if(item >= 1 && item <= 5){
obj[“1-10”] = obj[“1-10”] + 1
}
else if(item >= 6 && item <= 8){
obj[“6-8”] = obj[“6-8”] + 1
}
else if(item >= 9 && item <= 10){
obj[“9-10”] = obj[“9-10”]+ 1
}
return obj;
}, {
“1-10”: 0,
“6-8”: 0,
“9-10”: 0
});

console.log(rta);

Map, Filter y Reduce son los metodos mas importantes y usados en el manejo de arrays

Reduce es el metodo que se hace un poco complejo de entender, pero con el profesor nicolas se entiende como funciona reduce

Mi solución:

const challenge = [1,3,2,3,7,7,10,6,5,3,8,9,6,8,7,2,3,10,1,9,10]
const rta3 = challenge.reduce((obj, item) => {
  if (item<=5) {
    obj["1-5"]++
  } else if (item<=8) {
    obj["6-8"]++
  } else {
    obj["9-10"]++
  }
  return obj
}, {
  "1-5":0,
  "6-8":0,
  "9-10":0
})

console.log('challenge', rta3);

Esta fue mi solución

const numbers = [1, 2, 5, 6, 2, 9, 7, 6, 3, 5, 9, 1, 6, 8, 4, 7, 3];
const ranges = {
                 "1-4":0,
                 "5-6":0,
                 "7-9":0
                };

const numbersRanges = numbers.reduce( (obj, item) => {
    if(item <= 4){
        obj["1-4"] += 1
    }
    else if(item >= 5 && item <=6){
        obj["5-6"] += 1; 
    }
    else if(item >= 7 && item <=9){
        obj["7-9"] += 1;
    }
    return obj;
}, ranges);

console.log(numbersRanges);

aca mi aporte usando filter a lo pro 😃

const clases = [[0,10],[11,20],[21,30]]

const A = [1,1,5,6,9,8,5,6,16,25];


const R = clases.reduce((obj,item)=>{

    const b = A.filter(item2 => item2>= item[0] &&  item2<= item[1]);
    // console.log(b);
    obj[item] = b.length;
    return obj;
},{});

console.log(R)

este es mi solución al reto

const rta = lista.reduce((obj, item) => {
    if(item <= 3){obj['1-3'] += 1}
    else if(item >= 4 && item <= 6){obj['4-6'] += 1}
    else{obj['7-9'] += 1};
    return obj;
},{
    '1-3' : 0,
    '4-6' : 0,
    '7-9' : 0,
});

console.log(rta);

const values = [];

for (let i = 0; i <= 100; i++) {
  values.push(Math.floor(Math.random() * 10 + 1));
}

const initialState = {
  '1-5': 0,
  '6-8': 0,
  '9-10': 0,
};

const frequency = values.reduce((acc, curr) => {
  if (curr < 6) {
    acc['1-5'] = acc['1-5'] + 1;
  } else if (curr < 9) {
    acc['6-8'] = acc['6-8'] + 1;
  } else {
    acc['9-10'] = acc['9-10'] + 1;
  }

  return acc;
}, initialState);

console.log(values);
console.log(frequency);

Lo hice para que en base a la nota que tenga (del 1 al 10) se lo clasifique en bajo nivel, nivel, nivel mas y sobrenivel.

Aquí esta mi respuesta 😄

const array = [1,5,4,6,8,9,1,2,3,1,9,7,5,6]

const result = array.reduce((resObj, element)=>{
    if(element >=9)
        resObj["9-10"]+=1;
    else if(element>=6) 
        resObj["6-8"]+=1;
    else
        resObj["1-5"]+=1;

    return resObj;
},{
    '9-10':0,
    '6-8': 0,
    '1-5': 0,
})

console.log(result);

Solución al Reto

const numbers = [1,1,2,6,8,9,4,2,10,5,10,9,8,7,5,2,3,6,5,4,7,8,62]; //Dejé este último valor a propósito

const count = numbers.reduce((acum, value) => {

    
    if(value>=1 && value<=5)
    {
        acum["1-5"] += 1;
        

    }
    else
    {
        if(value>=6 && value<=8)
        {
            acum["6-8"] +=1;
            
        }
        else
        {
            if(value>=9 && value>=10)
            {
                acum["9-10"] +=1;
                
            }
        }
    }

    return acum;

}, {

    ["1-5"]:0,
    ["6-8"]:0,
    ["9-10"]:0,

})

console.log(count);

Tuve que inicializar los atributos del objeto acum porque con solo decirle a recude() que el parámetro acumulador es un objeto, no es suficiente; ya que cuando vamos a asignar valores a un atributo este se encuentra con el valor undefined y no es posible operar con él, los resultados serían NaN.

En el arreglo dejé un valor que no estaba en ningún rango para verificar que funcione solo con los rangos establecidos y que si en el arreglo hay números superiores y/o inferiores a los rangos, que sean omitidos gracias a las condiciones específicas del if else.

const numbers= []

while (numbers.length < 50) {
    numbers.push(Math.floor(Math.random()* (1, 10)) + 1);
};
const numberRanks = numbers.reduce((obj, item) => {
    if (item < 6 ) {obj['1-5'] = obj['1-5'] + 1; }
    else if (item >= 6 & item < 9 ) {obj['6-8'] = obj['6-8'] + 1; }
    else { obj['9-10'] = obj['9-10'] + 1; }
    return obj;
},{
    '1-5': 0,
    '6-8':0,
    '9-10': 0 
})
console.log(numberRanks); 

Mi solución 😁

const data = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]

const intervals = [ [1,5], [6,10], [11,15] ]

const result = data.reduce((obj, item) => {
    intervals.map(interval => {
        const min = Math.min(...interval)
        const max = Math.max(...interval)

        if (item >= min && item <= max) {
            if(!obj[`${min}:${max}`]) {
                obj[`${min}:${max}`] = 1
            } else {
                obj[`${min}:${max}`]++
            }
        }
    })
    return obj
},{})

Iteraciones de ejemplo

Esta es mi solución.

const numbers = [1, 2, 3, 5, 6, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10, 1, 3, 2, 2, 10, 8, 9, 9];

const numbersPerRank = numbers
.reduce((acum, item) => {
    if(item <= 5) {
        if(!acum["1-5"]) {
            acum["1-5"] = 1;
        } else {
            acum["1-5"] = acum["1-5"] + 1;
        }
    }
    else if(item >= 6 && item <= 8) {
        if(!acum["6-8"]) {
            acum["6-8"] = 1;
        } else {
            acum["6-8"] = acum["6-8"] + 1;
        }
    }
    else if(item === 9 || item === 10) {
        if(!acum["9-10"]) {
            acum["9-10"] = 1;
        } else {
            acum["9-10"] = acum["9-10"] + 1;
        }
    }
    return acum
}, {})

console.log(numbersPerRank) // { '1-5': 12, '6-8': 6, '9-10': 5 }