A história

"2016? Tudo bem", resmungou Hilbert, vendedor de brinquedos. Ele abriu os olhos, limpou o molho de salada que escorria do ouvido e comeu um cremeschnitte de manhã. Férias exemplares. No entanto, ele precisa ir trabalhar agora e terminar a contabilidade do ano.

O Natal é um período muito produtivo do ano, especialmente para suas vendas. Hilbert sabe exatamente como funciona: uma pessoa entra em uma loja e compra o primeiro presente que lhe é oferecido. Eles pagam e correm para outra loja. Na prática, o que realmente é o presente realmente não faz diferença. O preço também é irrelevante, desde que não seja muito alto. Tudo depende do tempo restante até o Natal - quanto menor o tempo, maior o remorso dos clientes, maior o preço que eles estão dispostos a pagar.

Tudo o que é preciso para Hilbert é olhar para o relógio - e ele sabe imediatamente quanto seus clientes podem gastar. Ele pode facilmente tirar proveito desse fato: ele encontra o presente mais caro que pode vender para um determinado cliente e oferece a ele. Só agora ele percebeu que se esqueceu de empregar essa estratégia astuta no ano passado. Isso vai mudar!

No entanto, Hilbert gostaria de saber quanto seus negócios teriam florescido, se ele realmente tivesse usado seu grande esquema. Ele conseguiu reunir uma lista de pessoas que vieram à sua loja, mas não sabe ao certo quanto dinheiro poderia ter ganho com elas.

Sua tarefa (TL; DR)

A entrada consiste em uma lista crescente de preços de presentes disponíveis e uma lista dos orçamentos dos clientes. A lista de orçamentos está na mesma ordem em que os clientes chegaram à loja - com a condição de que todo cliente esteja disposto a pagar pelo menos o mesmo valor que o anterior, o que significa que também está em ascensão.

Para cada cliente, encontre o presente mais caro pelo qual está disposto a pagar e produza o preço. Se não houver presentes no orçamento disponíveis, produza a 0.

Você recebe um -40%bônus de caracteres, se a complexidade assintótica do seu algoritmo for O(n+m)(em vez de trivial O(n*m)) _{Onde n, mestão os comprimentos das listas de entrada.}

Isso é código-golfe , o menor número de bytes vence. As brechas padrão são proibidas.

Exemplo

Entrada:

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

Resultado:

1 0 2 2 5 2 10 20 7 0

_{Essa tarefa foi tirada de uma competição de programação local e traduzida para inglês por mim. Aqui está a tarefa original: https://www.ksp.sk/ulohy/zadania/1131/}

Pitão, 17 16 bytes

1 byte graças a Pietu1998

VE=.-Q]
e|fgNTQ0

Demonstração

Explicação:

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 bytes

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

Exemplo de uso: [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].

Divida os preços em duas partes: (h,t)onde hestão todos os preços <= o orçamento do próximo cliente e ttodos os outros. Pegue o último preço de he continue recursivamente com todos, exceto o último de hmais te os demais orçamentos. last(0:h)avalia 0se hestá vazio. Similar: init (h++[0|h==[]]) ++ tadiciona um elemento fictício 0a hse hestiver vazio, para que inithaja algo a ser descartado ( initfalha na lista vazia).

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

-13 bytes porque o lambda pode realmente usar int[], não Integer[](obrigado BunjiquoBianco )

Isso deve levar tempo O (n + m) e espaço adicional O (n + m) _{^{(supondo que eu entenda grande notação 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;}

Recuado: ( Experimente 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})
        ));
}

_{^{Eu mostro a expansão não lambda aqui porque a declaração de tipo é mais limpa e é exatamente a mesma lógica. O lambda está presente no link ideone.}}

Explicação:

Variáveis ​​utilizadas:

• gé a lista de preços de presentes, bé a lista de orçamentos.
• glé o comprimento de ge blé o comprimento de b.
• aé uma pilha de presentes acessíveis, sé a matriz de saída de presentes vendidos.
• gp, bpE apsão ponteiros para g, be, arespectivamente. bptambém é o ponteiro para s.

Algoritmo:

• Para cada orçamento na duração dos orçamentos
  • Embora esse orçamento possa comprar o presente em g[gp]
    • Empurre o orçamento para a pilha ae aumentegp
  • Coloque o topo de aem s[bp]se ele existir, ou então coloque 0.

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

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 diferente da minha outra resposta , porque eu estou indo para o bônus.

A última linha (-> g[]) não faz parte da definição, mas chama a sobrecarga. Exemplo de uso: 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] .

Funciona basicamente da mesma maneira que a resposta do @ CAD97 , ou seja, usa uma pilha auxiliar (inicialmente vazia) para rastrear os itens compráveis. Em detalhes: verifique em ordem:

• se o primeiro preço for menor ou igual ao primeiro orçamento, mova o preço para a pilha. Ligue novamente.
• se a pilha estiver vazia, retorne um 0 seguido de uma chamada recursiva com o orçamento reduzido.
• se a pilha e a lista de orçamento não estiverem vazias, retorne o topo da pilha seguido de uma chamada recursiva com a pilha e o orçamento acionados.
• caso contrário, retorne a lista vazia.

Isso funciona com o m+ntempo, porque a) as operações na pilha auxiliar usam tempo constante eb) em cada uma das chamadas recursivas, uma das listas é encurtada por um elemento.

Gelatina , 15 bytes

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

Experimente online!

Como funciona

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

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

Outro clone da resposta do @ CAD97.