Playground - Modifica una lista de compras

Esta es mi respuesta, cuidado con los spoilers!!
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  let total = 0;

  let newList = list.map(item => {
    if (item.name.includes("oferta")) {
      item.price = item.price * 0.8;
    }
    item.price = item.price * item.quantity;

    total += item.price;

    let { quantity, ...auxItem } = item;
    return auxItem;
  })

  Object.assign(list, newList);

  return total;
}

Solución… 😄
.
Para empezar, creamos una lista modificada donde al recorrer ‘list’ con map() verificamos si el elemento incluye la palabra “oferta”.
.
Entonces al precio se le aplicará el descuento del 20%, y retornamos los objetos con las propiedades ‘name’ y ‘price’; este último le asignamos el valor descontado previamente, ahora multiplicado por la cantidad.
.
En una variable total acumulamos el precio total. Finalmente pasamos los valores de la lista modificada a la lista original utilizando Object.assign(). Retornamos el total.
.

export function processShoppingList(list) {
  let modifiedList = list.map((element) => {
    if (element.name.includes("oferta")) {
      element.price *= 0.8;
    }

    return {
      name: element.name,
      price: element.price * element.quantity
    }
  });


  let total = modifiedList.reduce((acc, element) => acc + element.price, 0);

  Object.assign(list, modifiedList);

  return total;
}

Alerta de Spoilers

A mi parecer es una respuesta concisa y sencilla 😃

Acepto sugerencias
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

export function processShoppingList(list) {
  // Tu código aquí 👈
  let total = 0;
  list.forEach((element) => {
    console.log(element.name);
    if (element.name.includes("oferta")) {
      element.price *= 0.8
    }
    element.price = element.price * element.quantity
    total += element.price
    delete element.quantity
  });

  return total;
}

Mi respuesta 💚

.
.
.
.

export function processShoppingList(list) {
  let totalSum = 0;

  list.forEach((product) => {
    if (product.name.includes("oferta"))
      product.price -= product.price * 0.20

    product.price *= product.quantity
    delete product.quantity
    totalSum += product.price
    
  })

  return totalSum
}

SPOILER ALERT!

–

–

function processShoppingList(list) {
  // Tu código aquí 👈
  let sumaTotal = 0;

  for (let i = 0; i < list.length; i++) {
    if (list[i].name.includes('oferta')) {
      list[i].price = list[i].price * 0.8;
    }
    list[i].price = list[i].quantity * list[i].price;
    delete list[i].quantity;
    sumaTotal = sumaTotal + list[i].price;
  }

  return sumaTotal;
}

Usando funciones mutables

.

.
.
.
.
.
.

.
.
.
.
.

const shoppingList = [
  { name: "pan", price: 20, quantity: 2 },
  { name: "leche", price: 25, quantity: 1 },
  { name: "oferta manzanas", price: 10, quantity: 3 },
]
export function processShoppingList(list) {
  let listaPrecios = []
    for (let i = 0; i < list.length; i++){
      list[i].price *= list[i].quantity 
      delete list[i].quantity
      if (list[i].name.includes('oferta') === true){
        const restarValor = list[i].price * 0.20
        list[i].price -= restarValor
      }
      listaPrecios.push(list[i].price)
    }
  const cambio = listaPrecios.reduce((acc, elem) => {
    return acc += elem 
  },0)
   return cambio
}
processShoppingList(shoppingList)

Esta es mi solucion:

export function processShoppingList(list) {
  let total = 0

  for (let producto of list) {
    let precio = producto.price * producto.quantity

    if (producto.name.includes("oferta")) {
      precio = precio * .8
    }
    producto.price = precio
    delete producto.quantity
    total += producto.price
  }
  return total
}

Solución! 😄

Mi solución:

function processShoppingList(list) {
  // Tu código aquí 👈

  list.map(function (item) {
    if (item.name.includes("oferta")) {
      item.price *= 0.8;
    }
    item.price *= item.quantity;
    delete item.quantity;
  });

  const total = list.reduce((total, item) => total += item.price, 0);
  return total;
}

export function processShoppingList(list) {
  list = list.map((e) => {
    if (e.name.includes("oferta")) {
      e.price = (e.price - e.price * 0.2) * e.quantity;
    } else {
      e.price = e.price * e.quantity;
    }
    delete e.quantity;
    return {
      name: e.name,
      price: e.price,
    };
  });
  return list.reduce((sum, item) => sum + item.price, 0);
}

export function processShoppingList(list){
  const DISCOUNT = ['oferta', 0.80];

  for (let product of list) {

    const nameDivision = 
      product.name.split(' ');

    let totalPrice = 
      product.price * product.quantity;

    let totalDiscountPrice = 
      totalPrice * DISCOUNT[1];

    let containsDiscount = 
      nameDivision.includes(DISCOUNT[0]);

    product.price = containsDiscount ? 
      totalDiscountPrice : totalPrice;

    delete product.quantity;
  }

  const prices = list.map(
    product => product.price
  );

  return prices.reduce(
    (total, value) => total += value
  );

}

Vamoooooooooooooooosss!!!
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  let price = 0
  list.forEach(item => {
    item.price = item.price * item.quantity

    if (item.name.includes('oferta')) {
      item.price *= 0.75
    }
     price += item.price
  })
  return price
}

Mi solución:
|
|
|
|
|
|
|
|
|
|

export function processShoppingList(list) {
  // Tu código aquí 👈
  let modifiedList = list.map(product => {
    if (product.name.includes('oferta')) {
      product.price = product.price * 0.80;
    }
    return {
      name: product.name,
      price: product.price * product.quantity
    };
  });

  Object.assign(list, modifiedList);

  let totalPrices = modifiedList.reduce((sum, currentElement) => sum + currentElement.price, 0);

  return totalPrices;
}

export const processShoppingList = (list) => {
  let total = 0;
  for (let item of list) {
    item.price = item.name.includes('oferta') ? item.price - (item.price * 0.20) : item.price;
    item.price = item.price * item.quantity;
    delete item.quantity;
    total = total + item.price;
  }
  return total;
}

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
…

export function processShoppingList(list) {
    let suma = 0
    for (let item in list) {
      console.log(list[item])

      if (list[item].name.includes('oferta')) {
        list[item].price *= 0.8
      }

      list[item].price *= list[item].quantity

     delete list[item].quantity

      suma += list[item].price
    }
    return suma
  }

Una solución en pocas lineas:

export function processShoppingList(list) {
  let precioTotal = 0
  list.forEach(item => {
    item.price = item.quantity * (item.name.includes("oferta") ? item.price * 0.8 : item.price)
    precioTotal += item.price
    delete item.quantity
  })
  return precioTotal
}

.
.
.
.
.
.

export function processShoppingList(list) {
    let finalPrice = 0;
    list.forEach(product => {
        if (product.name.includes("oferta")) {
            product.price = (product.price * (100 - 20)) / 100; 
        }
        product.price *= product.quantity;
        delete product.quantity;
        finalPrice += product.price;
    })
    return finalPrice;
}

Mi solución:

const OFFER_NAME_KEYWORD = 'oferta';
const DISCOUNT = 0.20;

export function processShoppingList(list) {
  return list.reduce((total, product, index) => {
    if (product.name.includes(OFFER_NAME_KEYWORD)) {
      product.price *= (1 - DISCOUNT);
    }

    product.price *= product.quantity;
    delete product.quantity;

    list[index] = product;

    return total + product.price
  }, 0);
}

export function processShoppingList(list) {
  let totalAllProducts = 0;
  list.forEach(product => {
    const total = (product.price * product.quantity)
    if (product.name.includes('oferta')) {
      const discount = total * 0.2;
      product.price = total - discount
    } else {
      product.price = total;
    }
    totalAllProducts += product.price;
    delete product.quantity;
  });
  return totalAllProducts;
}

ALERTA SPOILER
Mi solución:
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  let total=0;
  list.forEach(function (item) {
    let indice = item.name.indexOf("oferta");
    if (indice != -1) { item.price *= 0.8; }
    item.price *= item.quantity;
    delete item.quantity;
    total += item.price;
  })
  return total;
}

Hola comunidad les comparto mi solución.

  list.forEach(element => {

    // suma += element.price * element.quantity;
    if (element.name.includes('oferta')) {
      console.log('El objeto tiene el valor oferta ');
      let descuento = (element.price * element.quantity) * 20 / 100;
      let priceTo = element.price * element.quantity;
      let preciofinal = priceTo - descuento;
      element.price = preciofinal
      total += preciofinal
      // console.log(preciofinal)
    } else {

      let priceTo = element.price * element.quantity;
      total += element.price * element.quantity;
      element.price = priceTo;
      //console.log('El objeto no tiene el valor oferta');
    }
    delete element.quantity


  });

  return total ```

dejo mi solucion por aqui
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu código aquí 👈
  let totalPrice = 0

  list.forEach(el => {
    if (el.name.includes('oferta')) {
      el.price -= el.price * 20 / 100
    }
    el.price = el.price * el.quantity
    totalPrice += el.price;
    delete el.quantity;
  });
  return totalPrice;
  
}

export function processShoppingList(list) {

  let totalProductos = 0;

  list.map(shopping => {
    if (shopping.name.includes("oferta")) {

      shopping.price = (shopping.price - ((20 * shopping.price) / 100)) * shopping.quantity;
      delete shopping.quantity;
      totalProductos += shopping.price;
    } else {
      shopping.price = shopping.price * shopping.quantity;
      delete shopping.quantity;
      totalProductos += shopping.price;
    }



  });

  return totalProductos;


}

export function processShoppingList(list) {
  // Tu código aquí 👈
  let precio = 0
  list.forEach((item) => {

    if (item.name.includes('oferta') === false) {
      precio += item.price * item.quantity
      item.price = item.price * item.quantity
    }
    else {
      precio += item.price * item.quantity * 0.8
      item.price = item.price * item.quantity * 0.8
    }
    delete item.quantity;

  })
  return precio
}

Aun sigo resistiendo en usar funciones anónimas o flecha

export function processShoppingList(list) {
  // Tu código aquí 👈
  let total = 0
  for (const [key, item] of Object.entries(list)) {
    if (item.name.includes("oferta")) item.price *= 0.8
    item.price *= item.quantity
    total += item.price
    delete item.quantity
  }
  return total
}

Mi solucion:
😉
😉
😉
😉
😉
😉
😉
😉
😉
😉
😉
😉
😉
😉
😉
😉

export function processShoppingList(list) {
  let total = 0;
  for (let i = 0; i < list.length; i++) {
    if (list[i].name.includes("oferta")) {
      list[i].price *= 0.8;
    }
    list[i].price = list[i].price * list[i].quantity;
    total += list[i].price;
    delete list[i].quantity;
  }
  return total;
}

🛡️🛡️Escudo anti-spoilers🛡️🛡️

Mi solución al reto:

export function processShoppingList(list) {
    let modifiedList = list.map((item) => {
      if (item.name.includes('oferta'))
        item.price *= .80;
  
      return {
        name: item.name,
        price: item.price * item.quantity
      }
    }, 0)
    Object.assign(list, modifiedList);
    return list.reduce((sum, item) => sum += item.price, 0);
  }
 

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

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list){
    const rePricedList=list.map(product=>{
        if(product.name.includes("oferta")){
            return{
                name: product.name,
                price: (product.price-product.price*0.2)*product.quantity
            }
        }else{
            return{
                name: product.name,
                price: product.price*product.quantity
            }
        }
    })
    Object.assign(list,rePricedList);
    const solution= list.reduce((acc,product)=>{
        return acc+product.price;
    },0)
    return solution;
};

Hola, Comparto la solución del reto:

💚
💚💚
💚💚💚
💚💚💚💚
💚💚💚💚💚
💚💚💚💚💚💚
💚💚💚💚💚💚💚
💚💚💚💚💚💚💚💚
💚💚💚💚💚💚💚💚💚
💚💚💚💚💚💚💚💚
💚💚💚💚💚💚💚
💚💚💚💚💚💚
💚💚💚💚💚
💚💚💚💚
💚💚💚
💚💚
💚

export function processShoppingList(list) {
  const OFERTA = "oferta";
  let total = 0;
  list.forEach((product) => {
    product.price *= product.quantity;
    delete product.quantity;

    const nameProduct = product.name.toLowerCase();
    if (nameProduct.search(OFERTA) > -1) {
      product.price *= 0.8;
    }
    total += product.price;
  });

  return total;
}

Mi aporte:
Antes solía usar antes mucho el for of para casi todas las soluciones del reto. Ahora con el paso de actividades aprendí que el .map() puede sustituirlo.

SPOILER

.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu código aquí 👈
  let totalSum = 0;
  list.map((element, index, array) => {
    if (element.name.includes("oferta")) {
      array[index].price = element.price * 0.8 * element.quantity;
    } else {
      array[index].price = element.price * element.quantity;
    }
    delete array[index].quantity;
    totalSum += element.price;
  })
  return totalSum;
}

¡Aquí va mi manera de hacerlo!

V
V
V
V
V
V
V
V
V
V
V
V
V

export function processShoppingList(list) {
  let totalAmount = 0;
  list.forEach((product) => {
    if (product.name.indexOf('oferta') !== -1) {
      let discounted = product.price - (product.price * 0.2);
      product.price = discounted * product.quantity;
    }
    else {
      product.price *=  product.quantity;
    }
    totalAmount += product.price
    delete product.quantity;
  })
  return totalAmount
}

export function processShoppingList(list) {
  // Tu código aquí 👈
  let total = 0;
  list.map(item => {
    if (item.name.includes('oferta')) {
      item.price *= 0.8;
    }
    item.price *= item.quantity;
    delete item.quantity;
    total += item.price; 
    return item
  })
  return total;
}

Solucion

function processShoppingList(list) {
  // Tu código aquí 👈
  list.forEach(obj => {
    
    // Apply 20% discount if "offer" apears in name
    obj.name.includes("oferta") ? 
      obj.price = obj.price * 0.8 :
      ""
    
    // Multiply price * qty
    obj.price = obj.price * obj.quantity
    
    // Delete "quantity" attribute
    delete obj.quantity
  })

  // Return total
  const total = list
    .map(obj => obj.price)
    .reduce((acc, cur) => acc + cur)

  console.log(total)
  return total
}

SPOILERT ALERT!!!
Acepto sugerencias
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  let discount = 0.8
  let totalPrice = 0
  list.map(product => {
    if (product.name.includes('oferta')) {
      product.price *= discount
    }
    product.price *= product.quantity
    totalPrice += product.price
    delete product.quantity
  })
  return totalPrice
}

Comparto mi solucion implementada

function processShoppingList(list) {
  
  for (const iterator of list) {
    if (iterator.name.includes('oferta')) {
      iterator.price -=  (iterator.price * (20/100))
    }
    iterator.price *= iterator.quantity
    delete iterator.quantity
  }
  return list.reduce((acc, current)=>(acc+current.price),0)
}

#My solution
…
a
.

export function processShoppingList(list) {
  let result = [...list]
    .map(prod => {
      return {
        name: prod.name,
        price: prod.price * prod.quantity
          * (prod.name.includes('oferta') ? 0.8 : 1)
      }
    })
  Object.assign(list, result);
  return result.reduce((sum, {price}) => sum += price ,0)
}

Use un forEach por velocidad y doble calculo al precio porque no afecta el resultado y castin a los números para no obtener float

export function processShoppingList(list) {
let total = 0
list.forEach(function (element, index, array) {
if (element?.name.indexOf(‘oferta’) !== -1) {
array[index].price = parseInt(element.price * 0.8)
}
array[index].price = parseInt(element.price * element.quantity)
delete array[index].quantity
total += array[index].price
})
return total
}

Mi solucion, espero alguna devolucion gracias.

  let rta = 0;
  if (shoppingList.some(sol => sol.name.split(' ').find(x => x === 'oferta'))) {
    for (let index = 0; index < shoppingList.length; index++) {
      const element = shoppingList[index];
      if (element.name.split(' ').find(x => x === 'oferta')) {
        element.price = element.price * element.quantity * 0.8;
        delete element.quantity;
        rta += element.price;
      } else {
        element.price = element.price * element.quantity;
        delete element.quantity;
        rta += element.price;
      }
    }
  }
  console.log(shoppingList);
  return rta;
}

⚠ Cuidado Spoiler ⚠

*
*
*
*

Mi solución

export function processShoppingList(list) {
  for (let item of list) {
    if (item.name.includes("oferta")) {
      item.price *= 0.8
    }
    item.price *= item.quantity
    delete item.quantity
  }
  return list.reduce((total, item) => total += item.price, 0)
}

Esta es mi respuesta

function processShoppingList(list) 
{
    let total = 0;
    list.forEach(element => {
      let itemTotal = 0;
     if(element.name.includes('oferta'))
     {
      itemTotal = (element.price * 0.8) * element.quantity;
     }
     else
     {
      itemTotal = element.price * element.quantity;
     }

     element.price = itemTotal;
     delete element.quantity;
     
     total += itemTotal;

    });

    return total;
}

.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  let item = {};
  for (let i = 0; i < list.length; i++) {
    item = list[i];
    if (item.name.includes("oferta")) {
      item.price = item.price * 0.8;
    }
    item.price = item.price * item.quantity;
    list[i] = {
      name: item.name,
      price: item.price,
    }
  }
  return list.reduce((total, item) => total + item.price,0);
}

🛡️Escudo anti-spoilers🛡️

Aqui está mi código

export function processShoppingList(list) {
  return  list.map(obj => {
    if (obj.name.includes("oferta")) {
      obj.price *= 0.80;
    }
    obj.price *= obj.quantity;
    delete obj.quantity;
    return obj.price;
  }).reduce((acc,cur)=>acc + cur,0);
 
}

Este es mi aporte
Este es mi aporte
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu código aquí 👈
  let total = 0;
  list = list.map(product => {
    if (product.name.includes('oferta')) {
      product.price -= (product.price * 20 / 100);
    }
    product.price *= product.quantity;
    total += product.price;
    delete product.quantity;
  });
  return total;
}

Mi aporte

export function processShoppingList(list) {
  let total = 0;
  list.forEach(el => {
    if (el.name.includes("oferta")) {
      let descount = el.price * 0.2;
      el.price = el.price - descount;

    }
    el.price = el.price * el.quantity;
    total += el.price;
    delete el["quantity"]
  })

  return total
}

Esta es mi solución
.
.
.
.
.
.
.
.
.
.
…

.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  return list.reduce((acc, curr) => {
    let price;
    if (curr.name.includes('oferta')) {
      price = (curr.price * 0.8) * curr.quantity;
    }
    else {
      price = curr.price * curr.quantity;
    }
    curr.price = price;
    delete curr.quantity;
    return acc + price;
  }, 0);
}

Solución:

• Inicializar una variable total en cero para ir acumulando el total de la lista procesada.
• Recorrer cada objeto de la lista con un ciclo for o un método de array como map.
• Multiplicar el precio del producto por su cantidad y asignar este valor a la propiedad price del objeto.
• Verificar si el nombre del producto incluye la palabra “oferta” utilizando el método includes() de strings y aplicar un descuento del 20% al precio del producto en caso de ser necesario.
• Eliminar la propiedad quantity del objeto utilizando el operador delete.
• Acumular el valor del precio del objeto a la variable total.
• Devolver el valor de la variable total.

export function processShoppingList(list) {
  let total = 0;
  list.map((product) => {
    const totalPrice = product.price * product.quantity;
    if (product.name.includes("oferta")) {
      product.price = totalPrice * 0.8; // aplicar descuento del 20%
    } else {
      product.price = totalPrice;
    }
    delete product.quantity;
    total += product.price;
    return product;
  });
  return total;
}

el primero que hago en menos de hora… jajajaja

  let total = 0;
  for (let i = 0; i < list.length; i++) {
    if (list[i].name.includes("oferta") === true) {
        list[i].price = list[i].price - ((list[i].price * 20) / 100);
    }
    
    list[i].price = (list[i].price * list[i].quantity)
    total += list[i].price;
    delete list[i].quantity;
  };
  return total; 

Mi solucion

export function processShoppingList(list) {
  let total = 0;
  list.map(function (element) { 
    if (element.name.includes("oferta")){ 
      element.price = element.price * 0.8;
    }
    element.price=element.price*element.quantity
    total = total + element.price;
    delete element.quantity;
  })
  return total;
}

Que belleza, me gusta esto… 😃

 function processShoppingList(list) {
  // Tu código aquí 👈   

  let findlist = list.find(prod => prod.name.includes("oferta"));
  if (findlist) {
    findlist.price -= findlist.price * 0.2;
    for (let prod of list) {
      prod.price *= prod.quantity;
      delete prod.quantity;
    }

    return list.reduce((acc, prod) => acc + prod.price, 0);
  }
}

ez solution bb

export function processShoppingList(list) {
  for (const item of list) {
    const isOnOffert = item.name.split(' ').some(value => value === 'oferta')
    item.price = item.price * item.quantity
    if (isOnOffert) item.price -= item.price * 0.20
    delete item.quantity
  }
  const total = list.reduce((a, b) => a += b.price, 0)
  return total
}

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

export function processShoppingList(list) {
  // Tu código aquí 👈
  list.forEach(item => {
    if (item.name.includes("oferta")) item.price *= 0.8;

    item.price *= item.quantity;
    delete item.quantity;
  })

  const total = list.map(item => item.price).reduce((acumulador, numero) => acumulador + numero);

  return total;
}

Mi solución:

export function processShoppingList(list) {
  let total = 0
  for (let product of list) {
    product.price = product.name.includes("oferta") ? product.price * 0.8 : product.price
    product.price *= product.quantity
    delete product.quantity
    total += product.price
  }
  return total
}

MI SOLUCION 💪
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  list.forEach(product => {
    product.price *= product.quantity;
    if (product.name.includes("oferta")) {
      product.price -= product.price*.2;
    }
    delete product.quantity;
  });
  return list.reduce((total, product) => total + product.price, 0);
}

Mi humilde solución:

export function processShoppingList(list) {
  let total = 0;
  for (const prop in list) {
    if (list[prop].name.includes("oferta")) {
      list[prop].price -= (list[prop].price * .20);
    }
    list[prop].price *= list[prop].quantity;
    delete list[prop].quantity;
    total += list[prop].price;
  }
  return total;
}

Aquí mi soluccion:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

function processShoppingList(list) {
  let total = 0;
  let newlist = list.map(function(elem) {
    if (elem.name.includes("oferta")){
      elem.price = elem.price * 0.8;      
    }
    elem.price = elem.price * elem.quantity;
    total += elem.price
    let { quantity, ... newElem } = elem;
    return newElem;
  });
  Object.assign(list, newlist);
  return total;
}

the sol mmm

export function processShoppingList(list) {
  let acumulator = 0;
  list.forEach(item => {
    if (item.name.includes('oferta')) {
      item.price = item.price - 0.2 * item.price;
    }
    item.total = item.price * item.quantity;
    delete item.quantity;
    acumulator += item.total   
  })
  return acumulator;
}

Mi solucion:

• Utilicé los metodos ‘split’ e ‘includes’ para descubrir productos en oferta
• Usé ‘Object.hasOwn’ para modificar el precio dependiendo de la propiedad quantity para luego eliminarla.
  .
  .
  .

function processShoppingList(list) {
  let totalPrice = 0
  list.map((product) => {
    const isThereProm = product.name.split(" ")

    if (isThereProm.includes("oferta")) {
      product.price *= 0.8
    }

    if (Object.hasOwn(product, "quantity")) {
      product.price *= product.quantity
      delete product.quantity
    }
    totalPrice += product.price
  })
  return totalPrice
}

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

export function processShoppingList(list) {
  // Tu código aquí 👈
  list.forEach((product, index) => {
    if (product.name.includes('oferta')) product.price *= 0.8;
    product.price *= product.quantity;
    const { quantity, ...productDetails } = product;
    list[index] = productDetails;
  });

  return list
    .reduce((total, product) => total += product.price, 0)
}

😎 Mi solución por acá:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu código aquí 👈
  for (let item of list) {
    const discount = item.name.includes('oferta');
    item.price = discount
      ? item.price * (1 - 0.2) * item.quantity
      : item.price * item.quantity;
    delete item.quantity;
  }
  return list.reduce((acum, item) => acum + item.price, 0);
}

🛡️Escudo anti-spoilers🛡️

Mi solucion:

export function processShoppingList(list) {
  for (let product of list) {
    //Almacena un multiplicador para el descuento
    const offer = product.name.includes("oferta") ? 0.8 : 1

    //Calcular precio
    product.price = product.price * product.quantity * offer

    //Eliminar la propiedad quantity
    delete product.quantity;
  }

  //Regresar la suma de los costos
  return list.reduce((acum, product) => acum + product.price, 0)
}

Solución …
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu código aquí 👈
  let total = 0
  for (let item of list) {
    
    if (item.name.includes("oferta")) {
      let priceAux = item.price
      item.price = priceAux - priceAux * 0.2;
    }

    item.price = item.price * item.quantity
    delete item.quantity
    total += item.price
  }

  return total;
}

.
.
.
.
.

function processShoppingList(list) {
    // Tu código aquí 👈
    list.forEach(product => {
        if(product.name.includes("oferta")){
            product.price *= 0.8;
        }
        product.price *= product.quantity;
        delete product.quantity;
  })
  return list.map(product => product.price).reduce((acum, priceItem) => acum + priceItem, 0);
}

¡Hola, Desafío cumplido 😃!
Objetivo

Mi solución,
Se detalla hasta abajo.⬇
⬇
⬇
⬇
⬇
⬇
⬇
⬇
⬇
⬇
⬇

export function processShoppingList(list) {
  let indexFind = list.findIndex(item => item.name.includes("oferta"));
  if (indexFind >= 0)
    list[indexFind].price = list[indexFind].price - (list[indexFind].price * (20 / 100));

  let total = 0;

  list = list.map(item => {

    item.price *= item.quantity;
    delete item['quantity'];
    total += item.price;
  })

  return (total);
}

Mi respuesta
Recorriendo cada elemento de la lista, verifico si en el nombre tiene la palabra **oferta ** mediante la función includes(), si es así. multiplico directamente el objeto en su precio por el .80 y así obtener el 20% de descuento.
Finalmente multiplico el precio por la cantidad y lo guardo en precio.
Borro el atributo de cantidad y hago la suma total de los precios para retornarlo afuera del forEach()

export function processShoppingList(list) {
  let total = 0;
  list.forEach(product => {
    if (product.name.includes('oferta')) {
      product.price *= .80;
    }
    product.price *= product.quantity;
    delete product.quantity;
    total += product.price;
  });
  return total;
}

.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu código aquí 👈
  let total = 0;
  const DISCOUNT = 20;
  const KEY_WORD_DISCOUNT = "oferta"; 
  list = list.map(product => {
    if (product.name.includes(KEY_WORD_DISCOUNT)) {
      product.price = Math.trunc(product.price - (product.price * (DISCOUNT / 100))); 
    }
    product.price *= product.quantity;
    delete product['quantity'];
    total += product.price;
  })
  return total
}

Hola, dejo mi solucion
Caminito anti spoilers
🛴✨
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Llegamos 📍

export function processShoppingList(list) {
  // Tu código aquí 👈
  let total = 0;
  list.forEach((element, index) => {
    const priceWithDiscount = element.name.includes('oferta') ? element.price * 0.8 : element.price;
    const priceQuantity = priceWithDiscount * element.quantity;
    list[index].price = priceQuantity;
    total += priceQuantity;
    delete element.quantity;
  });
  return total;
}

Mi solución :

function processShoppingList(list){
  const price = [];
  list.forEach((a) => {
    a.name.toLowerCase().includes("oferta")
      ? Object.assign(a, { price: a.price * a.quantity - a.price * a.quantity * 0.2, })
      : Object.assign(a, { price: a.price * a.quantity });
    delete a.quantity;
    price.push(a.price);
  });

  return price.reduce((a, b) => a + b);
}

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

let total = 0;
  list = list.map((elemt) => {
    (elemt.name.includes('oferta')) ? elemt.price = (elemt.price * 0.8) : "";
    elemt.price *= elemt.quantity;
    delete elemt.quantity;
    total += elemt.price
    return elemt;
  })
  return total;

.

.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.

export function processShoppingList(list) {
  const DESCUENTO = 0.8;
  let total = 0;
  list.forEach((element) => {
    element.price = element.name.split(' ').includes("oferta") ?
      ((element.price * DESCUENTO) * element.quantity) :
      (element.price * element.quantity)

    total += element.price
    delete element.quantity
  });

  return total;
}

Solución

export function processShoppingList(list) {
  // Tu código aquí 👈
  let total = 0;
  list.forEach(product => {
    if (product.name.includes("oferta")) {
      product.price *= 0.8;
    }
    product.price *= product.quantity;
    total += product.price;
    delete product.quantity;
  })
  return total;
}

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

export function processShoppingList(list) {
  let totalPrice = 0;

  for (let i = 0; i < list.length; i++) {
    let product = list[i];
    product.price *= product.quantity;

    if (product.name.includes("oferta")) {
      product.price -= (product.price * 20) / 100;
    }

    let { quantity, ...newProduct } = product;
    list[i] = newProduct;

    totalPrice += product.price;
  }

  return totalPrice;
}

No se porque pero me siento orgulloso de mi solución xD

Solución:

.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  return list.reduce((sum, element) => {
    let totalPerProduct
    let total
    if (element.name.includes('oferta')) {
      totalPerProduct = (element.price * 0.8) * element.quantity
    }
    else {
      totalPerProduct = element.price * element.quantity
    }
    total = totalPerProduct + sum
    element.price = totalPerProduct
    delete element.quantity
    return total
  }, 0)
}

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

export function processShoppingList(list) {
  let total = 0
  list.forEach(product => {
    product.price *= product.quantity
    if (product.name.includes('oferta'))
      product.price *= 0.8
    total += product.price
    delete product.quantity
  })
  return total
}

Spoiler:
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu código aquí 👈
  const discount = 20;
  let total = 0;
  for (let i = 0; i < list.length; i++) {
    const product = list[i];
    if (contains_oferta(product.name)) {
      product.price *= (100 - discount)/100;
    }
    product.price *= product.quantity;
    delete product.quantity;
    total += product.price;
  }
  return total;
}

export function contains_oferta(string) {
  const re = /oferta/g;
  const str = string;
  return re.test(str);
}

Hola. Comparto mi solución
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  /* acumulador de total */
  let sum = 0
  /* recorrido del arreglo */
  list.forEach(p => {
    /* evalua si tiene la cadena oferta y ajecuta el descuento */
    if (p.name.includes("oferta")) p.price = p.price * 0.8
    /* actualiza el valor de price */
    p.price = p.price * p.quantity
    /* acumula el total */
    sum += p.price
    /* elimina la propiedad quantity */
    delete p.quantity
  })
  return sum
}

  export function processShoppingList(list) {
    let response = 0;
    list.forEach(element => {
      if (element.name.includes("oferta")) {
        element.price = element.price * 0.8 * element.quantity;
        response += element.price;
      }
      else {
        element.price = element.price * element.quantity;
        response += element.price;
      }
      delete element.quantity;
    });
    return response;
  }

Les dejo mi solución
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Inicializo la variable que controla el total de la suma de los productos
  let total = 0

  // Creo la función que procesa producto por producto
  const procesarProducto = (producto) => {
    chequearYAplicarDescuento(producto)
    precioPorCantidad(producto)
    eliminarCantidad(producto)
  }

  //Chequeo si el nombre incluye la palabra oferta y le aplico el descuento
  const chequearYAplicarDescuento = (producto) => {
    if (producto['name'].includes('oferta')) {
      aplicarDescuento(producto)
    }
  }

  //Multiplico el precio por 0.8 para generar un descuento del 20%
  const aplicarDescuento = (producto) => {
    producto['price']*=0.8
  }

  //Multiplico el precio por la cantidad
  const precioPorCantidad = (producto) => {
    producto['price']*=producto['quantity']
  }

  //Elimino ['quantity']
  const eliminarCantidad = (producto) => {
    delete producto['quantity']
  }

  //Proceso producto por producto con un map, y al procesar el producto agrego el total del producto al total general
  list = list.map(producto => {
    procesarProducto(producto)
    total+=producto['price']
  })

  //Retorno la suma de todos los productos
  return total
}

Spoiler:
.
.
.
.
.
.
.
.
.
.

function processShoppingList(list) {
    list.map((ele) => {
        return ele.name.includes('oferta') ? 
        ele.price = (ele.price * ele.quantity) * .8  : 
        ele.price = ele.price * ele.quantity,
        delete ele.quantity  
    });

    return list.map((ele) => {return ele.price})
    .reduce((a,b) => a + b);
};

Aquí mi solución, cualquier retroalimentación es bienvenida

export function processShoppingList(list) {
// Mutar el objeto list para colocar el precio según la cantidad de productos y aplicar descuento del 20% a los elementos que tengan oferta.
  list.filter(item => item.name.includes('oferta')).map((item) => {
    item.price = (item.price - item.price * 0.2);
    item.price = item.price * item.quantity;
    delete item.quantity;
    return item;
  });
  // Mutar el objeto list para colocar el precio a los productos sin oferta según la cantidad de productos.
  list.filter(item => !item.name.includes('oferta')).map((item) => {
    item.price = item.price * item.quantity;
    delete item.quantity;
    return item;
  });
  // Se crea nuevo objeto para concatenar los productos modificados.
  const prods = [];
  prods.push(...list);
  // Se suman los precios 
  const out = prods.map(prod => prod.price).reduce((sum, curr) => curr + sum);

  return out;
}