Un supermercado vende yogurt en botellas de un litro a los precios dados en la siguiente tabla: Código Precio Marca 0 S/. 4.90 Gloria 1 S/. 4.80 Laive 2 S/. 5.20 Yoleit 3 S/. 4.60 Sbelt Como oferta, el supermercado ofrece un descuento del 10% del importe de la compra Como incentivo especial, la tienda obsequia caramelos de acuerdo a la siguiente tabla: Importe a Pagar Obsequio < 60 Cuaderno ≥ 60 Agenda Diseñe un algoritmo que determine el importe de la compra, el importe del descuento y el importe a pagar y el obsequio por la compra de cierta cantidad de botellas de un mismo código de yogurt.

Aquí te presento un algoritmo en JavaScript que resuelve el problema:

```javascript
class Yogur {
  constructor(codigo, precio, marca) {
    this.codigo = codigo;
    this.precio = precio;
    this.marca = marca;
  }
}

class Supermercado {
  constructor() {
    this.yogurts = [
      new Yogur(0, 4.90, "Gloria"),
      new Yogur(1, 4.80, "Laive"),
      new Yogur(2, 5.20, "Yoleit"),
      new Yogur(3, 4.60, "Sbelt")
    ];
  }

  calcularImporte(cantidad, codigo) {
    const yogurt = this.yogurts.find(yogur => yogur.codigo === codigo);
    if (!yogurt) {
      throw new Error(`Código de yogurt no encontrado: ${codigo}`);
    }
    return yogurt.precio * cantidad;
  }

  calcularDescuento(importe) {
    return importe * 0.10;
  }

  calcularObsequio(importe) {
    if (importe < 60) {
      return "Cuaderno";
    } else {
      return "Agenda";
    }
  }

  calcularCompra(cantidad, codigo) {
    const importe = this.calcularImporte(cantidad, codigo);
    const descuento = this.calcularDescuento(importe);
    const importeAPagar = importe - descuento;
    const obsequio = this.calcularObsequio(importeAPagar);
    return {
      importe,
      descuento,
      importeAPagar,
      obsequio
    };
  }
}

const supermercado = new Supermercado();
const cantidad = 2;
const codigo = 0;

const resultado = supermercado.calcularCompra(cantidad, codigo);
console.log(`Importe: $${resultado.importe.toFixed(2)}`);
console.log(`Descuento: $${resultado.descuento.toFixed(2)}`);
console.log(`Importe a pagar: $${resultado.importeAPagar.toFixed(2)}`);
console.log(`Obsequio: ${resultado.obsequio}`);
```

Este algoritmo define dos clases: `Yogur` y `Supermercado`. La clase `Yogur` representa un yogurt con código, precio y marca. La clase `Supermercado` representa el supermercado y tiene métodos para calcular el importe de la compra, el descuento y el obsequio.

El método `calcularImporte` calcula el importe de la compra para una cantidad determinada de yogurts con un código específico. El método `calcularDescuento` calcula el descuento del 10% del importe de la compra. El método `calcularObsequio` determina el obsequio según el importe a pagar. El método `calcularCompra` calcula todos los valores necesarios para una compra determinada.

Finalmente, se crea un objeto `Supermercado` y se calcula la compra para una cantidad de 2 yogurts con código 0. Los resultados se imprimen en la consola.