故事

“ 2016年？好吧。”玩具销售商希尔伯特抱怨道。他睁开眼睛，擦干沙拉酱从耳朵里滴了出来，吃了早晨的起司奶油。典范假期。不过，他现在需要去上班，并完成年度会计。

圣诞节是一年中非常丰收的时期，尤其是对他的销售而言。希尔伯特（Hilbert）确切地知道它是如何工作的：一个人走进商店，购买了他们提供的第一份礼物。他们为此付费并跑到另一家商店。在实践中，礼物实际上是什么并没有真正改变。价格也不要紧，前提是价格不要太高。这完全取决于圣诞节前的剩余时间-时间越短，客户的悔恨就越大，他们愿意支付的价格就越高。

希尔伯特所需要做的就是看他的手表-他马上就知道他的顾客可以花多少钱。他可以轻松地利用这一事实：他只是找到可以出售给特定客户的最昂贵的礼物，并将其提供给他们。直到现在，他才意识到自己去年忘记采用这种狡猾的策略。那会改变的！

尽管如此，希尔伯特想知道如果他实际上使用了他的宏伟计划，他的生意将会蓬勃发展。他设法将来商店的人的名单汇总在一起，但是他不确定自己可以为他们赚多少钱。

您的任务（TL; DR）

输入包括可用礼物价格的升序列表和客户预算的列表。预算清单的顺序与客户到达商店的顺序相同-条件是每个客户都愿意至少支付与前者相同的费用，这意味着预算也在不断增加。

对于每个客户，找到他们愿意支付的最昂贵的礼物，然后输出价格。如果预算内没有可用的礼物，则输出0。

-40%如果算法的渐近时间复杂度为O(n+m)（而不是琐碎的O(n*m)），那么您将获得字符奖励，_{其中n, m输入列表的长度在哪里。}

这是代码高尔夫球，最短字节获胜。禁止出现标准漏洞。

例

输入：

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

_{这项任务是从本地编程比赛中提取的，由我翻译成英语。这是原始作业：https : //www.ksp.sk/ulohy/zadania/1131/}

Pyth，17 16字节

1字节归功于Pietu1998

VE=.-Q]
e|fgNTQ0

示范

说明：

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个字节

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

用法示例： [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]。

拆分价格分为两个部分：(h,t)其中h全部价格<=下一个客户的预算，t都是别人。取的最后一个价格，h然后递归地使用除最后一个h加号t和其余预算外的所有价格。last(0:h)评估0是否h为空。相似：向if init (h++[0|h==[]]) ++ t元素添加一个哑元素0，h如果它h为空，则要init删除一些东西（init在空列表上失败）。

Java，154 * 0.6 = 92.4字节

-13个字节，因为lambda可以实际使用int[]，而不是Integer[]（感谢BunjiquoBianco）

这应该花费O（n + m）时间和O（n + m）额外的空间_{^{（假设我理解大的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;}

缩进：（在线尝试！）

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

_{^{我在这里显示非lambda扩展，因为类型声明更简洁，并且逻辑完全相同。Lambda位于ideone链接上。}}

说明：

使用的变量：

• g是礼物价格b的清单，是预算的清单。
• gl是的长度g和bl是的长度b。
• a是负担得起的礼物的堆栈，s是出售礼物的输出数组。
• gp，bp和ap用于指针g，b和a分别。bp也是的指针s。

算法：

• 对于每个预算的预算期限
  • 虽然这个预算可以在 g[gp]
    • 将预算推入堆栈a并递增gp
  • 流行的顶部a进入s[bp]，如果它存在，否则放0。

Haskell，87 * 0.6 = 52.2字节

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[]

与我的其他答案完全不同，因为我要争取奖金。

最后一行（-> g[]）不是定义的一部分，而是调用开销。用例：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]。

基本上以与@ CAD97的答案相同的方式工作，即使用（最初为空）帮助程序堆栈来跟踪可购买的物品。详细信息：检查顺序：

• 如果第一个价格小于或等于第一个预算，则将价格移到堆栈中。重拨。
• 如果堆栈为空，则返回0，然后进行递归调用，同时放弃预算。
• 如果堆栈和预算列表都不为空，则返回堆栈顶部，然后递归调用并弹出堆栈和预算。
• 否则返回空列表。

这是m+n及时的，因为a）对帮助程序堆栈的操作使用恒定的时间，并且b）在每个递归调用中，列表之一缩短了一个元素。

果冻，15 个字节

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

在线尝试！

怎么运行的

ṀṄ;©®œ^  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字节

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)]:[]

@ CAD97的答案的另一个克隆。