La storia

"2016? Bene ..." brontolò il venditore di giocattoli Hilbert. Aprì gli occhi, si asciugò il condimento per l'insalata che gli colava dall'orecchio e mangiò un cremeschnitte di kick-start al mattino. Vacanze esemplari. Ora ha bisogno di andare a lavorare e finire la contabilità dell'anno.

Il Natale è un periodo molto fruttuoso dell'anno, soprattutto per le sue vendite. Hilbert sa esattamente come funziona: una persona entra in un negozio e acquista il primo regalo che gli viene offerto. Lo pagano e scappano in un altro negozio. In pratica, ciò che il regalo è in realtà non fa davvero la differenza. Anche il prezzo è irrilevante, a condizione che non sia troppo elevato. Tutto dipende dal tempo rimanente fino a Natale: più breve è il tempo, maggiore è il rimorso dei clienti, maggiore è il prezzo che sono disposti a pagare.

Tutto ciò che serve a Hilbert è guardare l'orologio - e sa subito quanto i suoi clienti possono spendere. Può facilmente trarre vantaggio da questo fatto: trova il regalo più costoso che può vendere a un determinato cliente e lo offre a loro. Solo ora si è reso conto di aver dimenticato di usare questa astuzia strategia l'anno scorso. Ma cambierà!

Tuttavia, Hilbert vorrebbe sapere quanto i suoi affari sarebbero fioriti, se avesse effettivamente usato il suo grande schema. È riuscito a mettere insieme un elenco di persone che sono venute nel suo negozio, ma non è sicuro di quanti soldi avrebbe potuto guadagnare con loro.

Il tuo compito (TL; DR)

L'input è costituito da un elenco crescente di prezzi dei regali disponibili e da un elenco dei budget dei clienti. L'elenco dei budget è nello stesso ordine in cui i clienti sono arrivati ​​al negozio, a condizione che ogni cliente sia disposto a pagare almeno quanto il precedente, il che significa che è anche in aumento.

Per ogni cliente, trova il regalo più costoso che è disposto a pagare e genera il suo prezzo. Se non sono disponibili regali all'interno del budget, produrre a 0.

Ottieni un -40%bonus ai personaggi, se la complessità temporale asintotica del tuo algoritmo è O(n+m)(piuttosto che banale O(n*m)) _{Dove n, msono le lunghezze degli elenchi di input.}

Questo è code-golf , vince il byte più corto. Sono vietate le scappatoie standard.

Esempio

Ingresso:

1 2 2 2 5 7 10 20
1 1 2 3 6 6 15 21 21 22

Produzione:

1 0 2 2 5 2 10 20 7 0

_{Questo compito è stato preso da un concorso di programmazione locale e tradotto da me in inglese. Ecco l'incarico originale: https://www.ksp.sk/ulohy/zadania/1131/}

Pyth, 17 16 byte

1 byte grazie a Pietu1998

VE=.-Q]
e|fgNTQ0

Dimostrazione

Spiegazione:

VE=.-Q]<\n>e|fgNTQ0
                        Implicit: Q is the list of prices.
VE                      For N in the list of budgets
             f   Q      Filter the list of prices
              gNT       On the current person's budget being >= that price
            |     0     If there aren't any, use 0 instead.
          e             Take the last (most expensive) value.
      <\n>              Print it out.
  =.-Q                  Remove it from the list of prices.

Haskell, 67 byte

a#(b:c)|(h,t)<-span(<=b)a=last(0:h):(init(h++[0|h==[]])++t)#c
_#x=x

Esempio di utilizzo: [1,2,2,2,5,7,10,20] # [1,1,2,3,6,6,15,21,21,22]-> [1,0,2,2,5,2,10,20,7,0].

Dividi i prezzi in due parti: (h,t)dove hsono tutti i prezzi <= il budget del prossimo cliente e tsono tutti gli altri. Prendete l'ultimo prezzo di he continuare in modo ricorsivo con tutti, ma l'ultimo dei hpiù te le restanti budget. last(0:h)valuta 0se hè vuoto. Simile: init (h++[0|h==[]]) ++ taggiunge un elemento fittizio 0a hse hè vuoto, in modo che initabbia qualcosa da eliminare ( initfallisce nell'elenco vuoto).

Java, 154 * 0.6 = 92.4 byte

-13 byte perché la lambda può effettivamente utilizzare int[], non Integer[](grazie BunjiquoBianco )

Questo dovrebbe richiedere O (n + m) tempo e O (n + m) spazio aggiuntivo _{^{(supponendo che comprendo la grande notazione O)}} .

g->b->{int l=g.length,L=b.length,G=0,B=0,A=0;int[]a=new int[l],s=new int[L];for(;B<L;){while(G<l&&g[G]<=b[B])a[A++]=g[G++];s[B++]=A>0?a[--A]:0;}return s;}

Rientrato: ( provalo online! )

static int[] toyStore(int[]g,int[]b) {
    int gl=g.length,bl=b.length,gp=0,bp=0,ap=0;
    int[] a=new int[gl],s=new int[bl];
    for (;bp<bl;) {
        while(gp<gl&&g[gp]<=b[bp])a[ap++]=g[gp++];
        s[bp++]=ap>0?a[--ap]:0;
    }
    return s;
}

public static void main(String[] args)
{
    System.out.println(Arrays.toString(
        toyStore(new int[] {1,2,2,2,5,7,10,20},
                 new int[] {1,1,2,3,6,6,15,21,21,22})
        ));
}

_{^{Qui mostro l'espansione non lambda perché la dichiarazione del tipo è più pulita ed è esattamente la stessa logica. La lambda è presente sul collegamento ideone.}}

Spiegazione:

Variabili utilizzate:

• gè l'elenco dei prezzi dei regali, bè l'elenco dei budget.
• glè la lunghezza di ged blè la lunghezza di b.
• aè una pila di regali convenienti, sè la gamma di output di regali venduti.
• gp, bpE apsono puntatori per g, be arispettivamente. bpè anche il puntatore di s.

Algoritmo:

• Per ciascun budget nella lunghezza dei budget
  • Mentre questo budget può acquistare il regalo a g[gp]
    • Spingi il budget nello stack ae incrementalogp
  • Pop cima ain s[bp]se esiste, mettere il resto 0.

Haskell, 87 * 0,6 = 52,2 byte

g s(p:q)d@(b:c)|p<=b=g(p:s)q d
g[]p(b:c)=0:g[]p c
g(s:t)p(b:c)=s:g t p c
g _ _ _=[]
g[]

Completamente diverso dall'altra mia risposta , perché sto andando per il bonus.

L'ultima riga (-> g[]) non fa parte della definizione, ma chiama l'overhead. Esempio di utilizzo: g [] [1,2,2,2,5,7,10,20] [1,1,2,3,6,6,15,21,21,22]-> [1,0,2,2,5,2,10,20,7,0].

Funziona sostanzialmente allo stesso modo della risposta di @ CAD97 , ovvero utilizza uno stack di supporto (inizialmente vuoto) per tenere traccia degli articoli acquistabili. Nel dettaglio: controlla nell'ordine:

• se il primo prezzo è inferiore o uguale al primo budget, sposta il prezzo nello stack. Richiamare.
• se lo stack è vuoto, restituisce uno 0 seguito da una chiamata ricorsiva con il budget sceso.
• se sia lo stack che l'elenco budget non sono vuoti, restituire la parte superiore dello stack seguita da una chiamata ricorsiva con stack e budget spuntati.
• altrimenti restituisce l'elenco vuoto.

Funziona nel m+ntempo, perché a) le operazioni sullo stack di helper usano un tempo costante eb) in ciascuna delle chiamate ricorsive una delle liste è accorciata di un elemento.

Gelatina , 15 byte

ṀṄ;©®œ^
Rf@€ç/Ṁ

Provalo online!

Come funziona

ṀṄ;©®œ^  Helper link. Arguments: G, H (lists of affordable gifts)

Ṁ        Compute the maximum of G (0 if the list is empty).
 Ṅ       Print it.
  ; ®    Concatenate it with the register (initially 0).
   ©     Save the result in the register.
     œ^  Compute the multiset symmetric difference of the updated register and H.

Rf@€ç/Ṁ  Main link. Arguments: B (budgets), P (prices)

R        Range; replace each t in B with [1, ..., t].
 f@€     Intersect the list of prices with each budget range, obtaining, for each
         customer, the list of all gifts he's willing to pay for.
    ç/   Reduce the array of lists by the helper link.
         In each iteration, this computes and prints the most expensive gift for
         a customer, than removes the selected gift (and all previously
         selected gifts) from the next list.
      Ṁ  Compute the maximum of the resulting list, which corresponds to the last
         customer.

JavaScript, 85 * 0.6 = 51 byte

f=(a,b,s=[],[t,...u]=a,[v,...w]=b)=>v?t<=v?f(u,b,[...s,t]):[s.pop()|0,...f(a),w,s)]:[]

Un altro clone della risposta di @ CAD97.