La historia

"2016? Muy bien", se quejó el vendedor de juguetes Hilbert. Abrió los ojos, se limpió el aderezo de ensalada que le goteaba de la oreja y se comió un cremoschnitte de arranque. Vacaciones ejemplares. Sin embargo, debe ir a trabajar ahora y terminar la contabilidad del año.

La Navidad es un período muy productivo del año, especialmente por sus ventas. Hilbert sabe exactamente cómo funciona: una persona entra en una tienda y compra el primer regalo que le ofrecen. Lo pagan y se van corriendo a otra tienda. En la práctica, lo que realmente es el regalo no hace la diferencia. El precio también es irrelevante, siempre que no sea demasiado alto. Todo depende del tiempo restante hasta Navidad: cuanto más corto es el tiempo, mayor es el remordimiento de los clientes, mayor es el precio que están dispuestos a pagar.

Todo lo que necesita Hilbert es mirar su reloj, y él sabe de inmediato cuánto pueden gastar sus clientes. Puede aprovechar fácilmente este hecho: encuentra el regalo más caro que puede vender a un cliente determinado y se lo ofrece. Solo ahora se ha dado cuenta de que olvidó emplear esta astuta estrategia el año pasado. ¡Eso va a cambiar sin embargo!

Sin embargo, a Hilbert le gustaría saber cuánto habría florecido su negocio si hubiera utilizado su gran esquema. Se las arregló para armar una lista de personas que vinieron a su tienda, sin embargo, no está seguro de cuánto dinero podría haber ganado con ellos.

Tu tarea (TL; DR)

La entrada consiste en una lista ascendente de precios de regalos disponibles y una lista de presupuestos de clientes. La lista de presupuestos está en el mismo orden en que los clientes llegaron a la tienda, con la condición de que cada cliente esté dispuesto a pagar al menos tanto como el anterior, lo que significa que también está ascendiendo.

Para cada cliente, encuentre el regalo más caro por el que está dispuesto a pagar y envíe su precio. Si no hay regalos disponibles dentro del presupuesto, salida a 0.

Obtiene una -40%bonificación de caracteres, si la complejidad de tiempo asintótica de su algoritmo es O(n+m)(en lugar de la trivial O(n*m)) _{¿Dónde n, mestán las longitudes de las listas de entrada?}

Este es el código de golf , gana los bytes más cortos. Las lagunas estándar están prohibidas.

Ejemplo

Entrada:

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

Salida:

1 0 2 2 5 2 10 20 7 0

_{Esta tarea fue tomada de una competencia de programación local y traducida al inglés por mí. Aquí está la tarea original: https://www.ksp.sk/ulohy/zadania/1131/}

Pyth, 17 16 bytes

1 byte gracias a Pietu1998

VE=.-Q]
e|fgNTQ0

Demostración

Explicación:

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

Ejemplo 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 los precios en dos partes: (h,t)donde hestán todos los precios <= el presupuesto del próximo cliente y tson todos los demás. Tome el último precio de hy continúe recursivamente con todos menos los últimos presupuestos y el hmás t. last(0:h)evalúa 0si hestá vacío. Similar: init (h++[0|h==[]]) ++ tagrega un elemento ficticio 0a hsi hestá vacío, por lo que inittiene algo que descartar ( initfalla en la lista vacía).

Java, 154 * 0.6 = 92.4 bytes

-13 bytes porque la lambda realmente puede usar int[], no Integer[](gracias BunjiquoBianco )

Esto debería tomar O (n + m) tiempo y O (n + m) espacio adicional _{^{(suponiendo que entiendo la notación O grande)}} .

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

Sangrado: (¡ Pruébelo en línea! )

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

_{^{Aquí muestro la expansión no lambda porque la declaración de tipo es más limpia y es exactamente la misma lógica. La lambda está presente en el enlace ideone.}}

Explicación:

Variables utilizadas:

• ges la lista de precios de regalos, bes la lista de presupuestos.
• gles la longitud de gy bles la longitud de b.
• aes una pila de regalos asequibles, ses la gama de salida de regalos vendidos.
• gp, bpY apson punteros para g, by arespectivamente. bpes también el puntero para s.

Algoritmo:

• Para cada presupuesto en la longitud de los presupuestos
  • Si bien este presupuesto puede comprar el regalo en g[gp]
    • Empuje el presupuesto en la pila ae incrementegp
  • Pop la parte superior de aen s[bp]si existe, de lo contrario poner 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 de mi otra respuesta , porque voy por la bonificación.

La última línea (-> g[]) no es parte de la definición, sino que llama a la sobrecarga. Ejemplo 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 básicamente de la misma manera que la respuesta de @ CAD97 , es decir, utiliza una pila auxiliar (inicialmente vacía) para realizar un seguimiento de los artículos que se pueden comprar. En detalle: verificar en orden:

• Si el primer precio es menor o igual que el primer presupuesto, mueva el precio a la pila. Llama de nuevo.
• Si la pila está vacía, devuelve un 0 seguido de una llamada recursiva con el presupuesto eliminado.
• Si tanto la lista de la pila como la del presupuesto no están vacías, devuelva la parte superior de la pila seguida de una llamada recursiva con la pila y el presupuesto aparecidos.
• De lo contrario, devuelva la lista vacía.

Esto funciona a m+ntiempo, porque a) las operaciones en la pila auxiliar usan tiempo constante yb) en cada una de las llamadas recursivas, una de las listas se acorta en un elemento.

Jalea , 15 bytes

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

Pruébalo en línea!

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

Otro clon de la respuesta de @ CAD97.