L'histoire

"2016? Très bien", grommela le vendeur de jouets Hilbert. Il ouvrit les yeux, essuya la vinaigrette à salade s'écoulant de son oreille et mangea un cremeschnitte pour le coup d'envoi du matin. Des vacances exemplaires. Il doit cependant aller travailler maintenant et terminer la comptabilité de l'année.

Noël est une période très productive de l'année, notamment pour ses ventes. Hilbert sait exactement comment cela fonctionne: une personne entre dans un magasin et achète le premier cadeau qui lui est offert. Ils paient et s'enfuient dans un autre magasin. En pratique, ce qu'est réellement le cadeau ne fait pas vraiment de différence. Le prix n'est pas non plus pertinent, à condition qu'il ne soit pas trop élevé. Tout dépend du temps restant jusqu'à Noël - plus le temps est court, plus les remords des clients sont grands, plus le prix qu'ils sont prêts à payer est élevé.

Pour Hilbert, il suffit de regarder sa montre - et il sait tout de suite combien ses clients peuvent dépenser. Il peut facilement profiter de ce fait: il trouve simplement le cadeau le plus cher qu'il peut vendre à un client donné et le leur offrir. Ce n'est que maintenant qu'il a réalisé qu'il avait oublié d'employer cette stratégie astucieuse l'année dernière. Mais ça va changer!

Néanmoins, Hilbert aimerait savoir à quel point son entreprise aurait prospéré s'il avait effectivement utilisé son grand projet. Il a réussi à dresser une liste de personnes qui sont venues dans son magasin, il n'est cependant pas sûr de combien d'argent il aurait pu gagner.

Votre tâche (TL; DR)

L'entrée consiste en une liste ascendante des prix des cadeaux disponibles et une liste des budgets des clients. La liste des budgets est dans le même ordre que les clients sont arrivés au magasin - à condition que chaque client soit prêt à payer au moins autant que le précédent, ce qui signifie qu'il est également croissant.

Pour chaque client, trouvez le cadeau le plus cher qu'il est prêt à payer et affichez son prix. Si aucun cadeau dans le budget n'est disponible, affichez a 0.

Vous obtenez un -40%bonus de caractères, si la complexité temporelle asymptotique de votre algorithme est O(n+m)(plutôt que triviale O(n*m)) _{Où n, msont les longueurs des listes d'entrée.}

Il s'agit du code-golf , les octets les plus courts l'emportent. Les failles standard sont interdites.

Exemple

Contribution:

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

Production:

1 0 2 2 5 2 10 20 7 0

_{Cette tâche a été tirée d'un concours de programmation locale et traduite en anglais par mes soins. Voici la mission d'origine: https://www.ksp.sk/ulohy/zadania/1131/}

Pyth, 17 16 octets

1 octet grâce à Pietu1998

VE=.-Q]
e|fgNTQ0

Manifestation

Explication:

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 octets

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

Exemple d'utilisation: [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].

Divisez les prix en deux parties: (h,t)où hsont tous les prix <= le budget du prochain client et ttous les autres. Prenez le dernier prix de het continuez récursivement avec tout sauf le dernier de hplus tet les budgets restants. last(0:h)évalue 0si hest vide. Similaire: init (h++[0|h==[]]) ++ tajoute un élément factice 0à hif hest vide, de sorte qu'il inita quelque chose à supprimer ( initéchoue sur la liste vide).

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

-13 octets parce que le lambda peut réellement utiliser int[], non Integer[](merci BunjiquoBianco )

Cela devrait prendre du temps O (n + m) et de l'espace supplémentaire O (n + m) _{^{(en supposant que je comprends la notation 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;}

Indenté: ( Essayez-le en ligne! )

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

_{^{Je montre ici l'expansion non lambda car la déclaration de type est plus propre et c'est exactement la même logique. La lambda est présente au niveau du lien idéone.}}

Explication:

Variables utilisées:

• g est la liste des prix des cadeaux, b est la liste des budgets.
• glest la longueur de get blest la longueur deb .
• aest une pile de cadeaux abordables, sest la gamme de sortie des cadeaux vendus.
• gp, bpEt apsont des pointeurs pour g, bet arespectivement. bpest également le pointeur de s.

Algorithme:

• Pour chaque budget dans la longueur des budgets
  • Bien que ce budget puisse acheter le cadeau à g[gp]
    • Poussez le budget sur la pile aet augmentezgp
  • Insérez le dessus adans s[bp]s'il existe, sinon mettez 0.

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

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

Complètement différent de mon autre réponse , car je vais pour le bonus.

La dernière ligne (-> g[]) ne fait pas partie de la définition, mais appelle la surcharge. Exemple d'utilisation: 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] .

Fonctionne essentiellement de la même manière que la réponse de @ CAD97 , c'est-à-dire utilise une pile d'assistance (initialement vide) pour garder une trace des articles achetables. En détail: vérifiez dans l'ordre:

• si le premier prix est inférieur ou égal au premier budget, déplacez le prix vers la pile. Appelle encore une fois.
• si la pile est vide, retournez un 0 suivi d'un appel récursif avec le budget abandonné.
• si la liste de pile et de budget n'est pas vide, renvoyez le haut de la pile suivi d'un appel récursif avec pile et budget sautés.
• sinon retourne la liste vide.

Cela fonctionne dans le m+ntemps, car a) les opérations sur la pile d'assistance utilisent un temps constant et b) dans chacun des appels récursifs, l'une des listes est raccourcie d'un élément.

Gelée , 15 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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

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 autre clone de la réponse de @ CAD97.