Cerita

"2016? Al..baik," gerutu penjual mainan Hilbert. Dia membuka matanya, mengusap saus salad yang menetes dari telinganya dan makan cremeschnitte pagi yang baru dimulai. Teladan liburan. Dia perlu pergi bekerja sekarang, dan menyelesaikan akuntansi tahun ini.

Natal adalah periode yang sangat menguntungkan tahun ini, terutama untuk penjualannya. Hilbert tahu persis cara kerjanya: Seseorang datang ke toko dan membeli hadiah pertama yang mereka tawarkan. Mereka membayarnya dan lari ke toko lain. Dalam praktiknya, apa sebenarnya hadiah itu sebenarnya tidak membuat perbedaan. Harganya juga tidak relevan, asalkan tidak terlalu tinggi. Itu semua tergantung pada waktu yang tersisa sampai Natal - semakin pendek waktunya, semakin besar penyesalan pelanggan, semakin besar harga yang mereka bayarkan.

Yang diperlukan untuk Hilbert adalah melihat arlojinya - dan dia langsung tahu berapa banyak yang bisa dihabiskan pelanggannya. Dia dapat dengan mudah mengambil keuntungan dari fakta ini: Dia hanya menemukan hadiah paling mahal yang bisa dia jual kepada pelanggan tertentu, dan menawarkannya kepada mereka. Baru sekarang dia menyadari bahwa dia lupa menggunakan strategi licik ini tahun lalu. Itu akan berubah!

Namun demikian, Hilbert ingin tahu berapa banyak bisnisnya akan berkembang, jika dia benar-benar menggunakan skema besarnya. Dia berhasil mengumpulkan daftar orang-orang yang datang ke tokonya, tetapi dia tidak yakin berapa banyak uang yang dapat dia hasilkan dari mereka.

Tugas Anda (TL; DR)

Input terdiri dari ascending daftar harga hadiah yang tersedia, dan daftar anggaran pelanggan. Daftar anggaran berada dalam urutan yang sama seperti pelanggan datang ke toko - dengan syarat bahwa setiap pelanggan bersedia membayar setidaknya sebanyak yang sebelumnya, yang berarti juga naik.

Untuk setiap pelanggan, temukan hadiah termahal yang bersedia mereka bayar, dan berikan harga. Jika tidak ada hadiah dalam anggaran, output a 0.

Anda mendapatkan -40%bonus karakter, jika kompleksitas waktu asimptotik dari algoritma Anda O(n+m)(bukan sepele O(n*m)) _{Di mana n, mpanjang daftar input.}

Ini adalah kode-golf , byte terpendek menang. Celah standar dilarang.

Contoh

Memasukkan:

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

Keluaran:

1 0 2 2 5 2 10 20 7 0

_{Tugas ini diambil dari kompetisi pemrograman lokal, dan diterjemahkan ke dalam bahasa Inggris oleh saya. Inilah tugas aslinya: https://www.ksp.sk/ulohy/zadania/1131/}

Pyth, 17 16 byte

1 byte terima kasih kepada Pietu1998

VE=.-Q]
e|fgNTQ0

Demonstrasi

Penjelasan:

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

Contoh penggunaan: [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].

Membagi harga menjadi dua bagian: di (h,t)mana hsemua harga <= anggaran pelanggan berikutnya dan tyang lainnya. Ambil harga terakhir hdan lanjutkan secara rekursif dengan semua kecuali nilai htambah terakhir tdan sisa anggaran. last(0:h)mengevaluasi 0apakah hkosong. Mirip: init (h++[0|h==[]]) ++ tmenambahkan elemen dummy 0ke hjika hkosong, sehingga initmemiliki sesuatu untuk dijatuhkan ( initgagal pada daftar kosong).

Java, 154 * 0,6 = 92,4 byte

-13 byte karena lambda benar-benar dapat digunakan int[], bukan Integer[](terima kasih BunjiquoBianco )

Ini harus mengambil O (n + m) waktu dan O (n + m) ruang tambahan _{^{(dengan asumsi saya mengerti notasi O besar)}} .

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;}

Diindentasi: ( Coba 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})
        ));
}

_{^{Saya menunjukkan ekspansi non-lambda di sini karena deklarasi tipe lebih bersih dan logika yang persis sama. Lambda hadir di tautan ideone.}}

Penjelasan:

Variabel yang digunakan:

• gadalah daftar harga hadiah, badalah daftar anggaran.
• gladalah panjang gdan bladalah panjangnya b.
• aadalah tumpukan untuk hadiah yang terjangkau, sadalah rangkaian output dari hadiah yang dijual.
• gp, bp, Dan apadalah pointer untuk g, bdan amasing-masing. bpjuga merupakan penunjuk untuk s.

Algoritma:

• Untuk setiap anggaran dalam panjang anggaran
  • Sementara anggaran ini dapat membeli hadiah di g[gp]
    • Dorong anggaran ke Stack adan incrementgp
  • Pop bagian atas ake dalam s[bp]jika ada, taruh lagi 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[]

Sangat berbeda dari jawaban saya yang lain , karena saya akan mendapat bonus.

Baris terakhir (-> g[] ) bukan bagian dari definisi, tetapi memanggil overhead. Contoh penggunaan: 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].

Bekerja pada dasarnya dengan cara yang sama dengan jawaban @ CAD97 , yaitu menggunakan tumpukan pembantu (awalnya kosong) untuk melacak barang-barang yang dapat dibeli. Secara detail: check in order:

• jika harga pertama kurang atau sama dengan anggaran pertama, pindahkan harga ke tumpukan. Panggil lagi.
• jika tumpukan kosong, kembalikan 0 diikuti dengan panggilan rekursif dengan anggaran turun.
• jika kedua tumpukan dan daftar anggaran tidak kosong, kembalikan bagian atas tumpukan diikuti oleh panggilan rekursif dengan tumpukan & anggaran muncul.
• lain mengembalikan daftar kosong.

Ini bekerja m+ntepat waktu, karena a) operasi pada tumpukan pembantu menggunakan waktu konstan dan b) dalam setiap panggilan rekursif, salah satu daftar disingkat oleh satu elemen.

Jelly , 15 byte

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

Cobalah online!

Bagaimana itu bekerja

ṀṄ;©®œ^  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)]:[]

Klon lain dari jawaban @ CAD97.