Torna alle sfide
Facile 0 risolte 0% di accettazione

Facade per il checkout

Nascondi i controlli di stock e i totali dei prezzi dietro una semplice chiamata di checkout.

Cosa imparerai

  • Nascondere più sottosistemi dietro una sola chiamata
  • Controllare le scorte prima di addebitare
  • Unire le righe ripetute del carrello per articolo

Problema

Il pattern facade offre un punto d'accesso semplice a un sottosistema complicato. La chiamata checkout di un negozio nasconde due sottosistemi: l'inventario e il listino prezzi.

Gli articoli sono numerati da 0 a n − 1. stock[i] indica quante unità dell'articolo i sono disponibili e prices[i] il suo prezzo. Il carrello è una lista di righe [item, quantity]; lo stesso articolo può comparire su più righe.

checkout(stock, prices, cart) deve:

  1. Controllare l'inventario: se la quantità totale di un articolo nel carrello supera la sua disponibilità, l'ordine fallisce.
  2. Altrimenti restituire il prezzo totale del carrello.

Implementa checkout_facade(stock, prices, cart).

Input

stock, prices: n valori ciascuno.

cart: righe [item, quantity].

Output

Restituisci il prezzo totale, oppure -1 se un articolo non ha abbastanza disponibilità.

Vincoli

1 ≤ n ≤ 1,000

0 ≤ stock[i], prices[i] ≤ 100,000; 0 ≤ righe del carrello ≤ 1,000; 1 ≤ quantity ≤ 1,000

Esempi

Esempio 1
Input:
cart = [
    [0, 2],
    [2, 4]
]
stock = [5, 2, 10]
prices = [3, 20, 1]

Output atteso:
expected = 10
Input:
std::vector<std::vector<long long>> cart = {
    {0, 2},
    {2, 4}
};
std::vector<long long> stock = {5, 2, 10};
std::vector<long long> prices = {3, 20, 1};

Output atteso:
long long expected = 10;
Input:
long[][] cart = new long[][] {
    new long[] {0, 2},
    new long[] {2, 4}
};
long[] stock = new long[] {5, 2, 10};
long[] prices = new long[] {3, 20, 1};

Output atteso:
long expected = 10;

Spiegazione

Entrambi gli articoli sono disponibili. 2 × 3 + 4 × 1 = 10.

Esempio 2
Input:
cart = [
    [1, 1],
    [1, 2]
]
stock = [5, 2]
prices = [3, 20]

Output atteso:
expected = -1
Input:
std::vector<std::vector<long long>> cart = {
    {1, 1},
    {1, 2}
};
std::vector<long long> stock = {5, 2};
std::vector<long long> prices = {3, 20};

Output atteso:
long long expected = -1;
Input:
long[][] cart = new long[][] {
    new long[] {1, 1},
    new long[] {1, 2}
};
long[] stock = new long[] {5, 2};
long[] prices = new long[] {3, 20};

Output atteso:
long expected = -1;

Spiegazione

L'articolo 1 compare due volte per un totale di 3 unità, ma ne sono disponibili solo 2, quindi l'ordine fallisce: -1.

Come affrontarlo

Prova prima da solo, poi apri un suggerimento alla volta.

Suggerimento 1

Somma prima la quantità di ogni articolo su tutte le righe del carrello.

Suggerimento 2

Confronta questi totali con le scorte prima di calcolare qualsiasi prezzo.

Suggerimento 3

Se manca un articolo, restituisci subito -1.

Complessità attesa

tempo O(n + righe del carrello), spazio aggiuntivo O(n)

Riferimenti

Questa sfida è adattata per CodeUtility. Segui la traccia e i vincoli sopra.

Impara dagli altri

Soluzioni della community

Nessuna soluzione pubblicata. Risolvi questa sfida per condividere la prima.