Dans le jeu Pickomino , il y a plusieurs tuiles au milieu de la table, chacune avec un entier positif différent sur elles. Chaque tour, les joueurs lancent les dés d'une certaine manière et obtiennent un score, qui est un entier non négatif.

Maintenant, le joueur prend la tuile avec le nombre le plus élevé qui est toujours inférieur ou égal à son score, retirant la tuile du milieu et l'ajoutant à sa pile. Si cela n'est pas possible car tous les nombres au milieu sont supérieurs au score du joueur, le joueur perd la tuile la plus haute de sa pile (qui a été ajoutée en dernier), qui est retournée au milieu. Si le joueur n'a plus de tuiles, rien ne se passe.

Le défi

Simulez un joueur qui joue contre lui-même. Vous obtenez une liste des tuiles au milieu et une liste des scores obtenus par le joueur. Retourne une liste des tuiles du joueur après que tous les tours ont été évalués.

Règles du challenge

• Vous pouvez supposer que la liste avec les tuiles est ordonnée et ne contient aucun entier deux fois.
• Vous pouvez prendre les deux listes d'entrées dans l'ordre que vous souhaitez
• La sortie doit conserver l'ordre des tuiles sur la pile, mais vous pouvez décider si la liste est triée de haut en bas ou de bas en haut.

Règles générales

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues non-golfeur de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse avec des règles d'E / S par défaut , vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code (par exemple TIO ).
• Il est recommandé d'ajouter une explication pour votre réponse.

Exemple

(extrait du 6ème cas d'essai)

Tiles: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Scores: [22, 22, 22, 23, 21, 24, 0, 22]

Le premier score est 22, alors prenez la tuile la plus haute au milieu <= 22, qui est 22 lui-même.

Middle: [21, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Stack: [22]
Remaining scores: [22, 22, 23, 21, 24, 0, 22] 

Le score suivant est de 22, alors prenez la tuile la plus haute au milieu <= 22. Parce que 22 est déjà pris, le joueur doit prendre 21.

Middle: [23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Stack: [22, 21]
Remaining scores: [22, 23, 21, 24, 0, 22]

Le score suivant est 22, mais tous les nombres <= 22 sont déjà pris. Par conséquent, le joueur perd la tuile la plus haute de la pile (21), qui est retournée au milieu.

Middle: [21, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Stack: [22]
Remaining scores: [23, 21, 24, 0, 22]

Les scores suivants sont 23, 21 et 24, donc le joueur prend ces tuiles du milieu.

Middle: [25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Stack: [22, 23, 21, 24]
Remaining scores: [0, 22]

Le joueur casse et marque zéro. Par conséquent, la tuile avec le numéro 24 (le plus haut sur la pile) est retournée au milieu.

Middle: [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Stack: [22, 23, 21]
Remaining scores: [22]

Le dernier score est de 22, mais toutes les tuiles <= 22 sont déjà prises, donc le joueur perd la tuile la plus haute de la pile (21).

Middle: [21, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Final Stack and Output: [22, 23]

Cas de test

(avec la tuile la plus haute en dernier dans la liste de sortie)

Tiles: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Scores: [26, 30, 21]
Output: [26, 30, 21]

Tiles: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Scores: [35, 35, 36, 36]
Output: [35, 34, 36, 33]

Tiles: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Scores: [22, 17, 23, 19, 23]
Output: [23]

Tiles: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Scores: []
Output: []

Tiles: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Scores: [22, 17, 23, 19, 23, 0]
Output: []

Tiles: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Scores: [22, 22, 22, 23, 21, 24, 0, 22]
Output: [22, 23]

Tiles: [1, 5, 9, 13, 17, 21, 26]
Scores: [6, 10, 23, 23, 23, 1, 0, 15]
Output: [5, 9, 21, 17, 13, 1]

Tiles: []
Scores: [4, 6, 1, 6]
Output: []

bac à sable

Haskell , 119 111 104 103 103 octets

1 octet économisé grâce à Ørjan Johansen

(#)=span.(<)
(a%(b:c))d|(g,e:h)<-b#d=(e:a)%c$g++h|g:h<-a,(i,j)<-g#d=h%c$i++g:j|1>0=a%c$d
(a%b)c=a
([]%)

Essayez-le en ligne!

Suppose que les tuiles sont triées par ordre décroissant.

Pas beaucoup de fantaisie ici. Le premier argument est la pile des joueurs, le second leurs scores et le troisième est la pile au milieu.

Japt, 24 octets

Oof! Cela n'a pas fonctionné aussi bien que je le pensais!

Prend la saisie dans l'ordre inverse.

®=Va§Z)Ì?NpVjZ:VpNo)nÃN¤

Essayez-le ou exécutez tous les cas de test sur TIO

®=Va§Z)Ì?NpVjZ:VpNo)nÃN¤     :Implicit input of N=[U=scores, V=tiles]
®                            :Map each Z in U
 =                           :  Reassign to Z
  Va                         :    0-based index of last element in V (-1 if not found)
    §Z                       :      Less than or equal to Z
      )                      :  End reassignment
       Ì                     :  Sign of difference with -1 (1 if found, 0 if not)
        ?                    :  If truthy (not zero)
         Np                  :    Push to N
           VjZ               :      Remove and return the element at index Z in V
              :              :  Else
               Vp            :    Push to V
                 No          :      Pop the last element of N
                   )         :    End Push
                    n        :    Sort V
                     Ã       :End map
                      N¤     :Slice the first 2 elements (the original inputs) off N

Perl 6 , 89 octets

{my@x;@^a;@^b>>.&{@x=|@x,|(keys(@a∖@x).grep($_>=*).sort(-*)[0]//(try ~@x.pop&&()))};@x}

Essayez-le en ligne!

Je pense qu'il y a encore quelques octets à jouer sur ce ...

C # (Visual C # compilateur interactif) , 159 158 154 octets

Appelé comme f(tiles)(scores)

n=>m=>{var s=new Stack<int>();m.Add(0);n.ForEach(k=>{var a=m.Except(s).Where(x=>x<=k).Max();if(a<1)m.Add(s.Count<1?0:s.Pop());else s.Push(a);});return s;}

Si seulement System.Voidest en fait un type de retour et pas seulement un espace réservé à la réflexion. Je serais en mesure de remplacer if(a<1)m.Add(s.Count<1?0:s.Pop());else s.Push(a);par var t=a>1?m.Add(s.Count<1?0:s.Pop()):s.Push(a);, en économisant deux octets.

Essayez-le en ligne!

//Function taking in a list and returning
//another function that takes in another list and returns a stack
n=>m=>{
//Initialize the stack
var s=new Stack<int>();
//Add a zero to the tiles, to ensure no exceptions appear due to accessing
//non-existent elements in an empty collection later
//when we try to filter it later and getting the biggest element
m.Add(0);
//Iterate through our scores
n.ForEach(k=>{
//Create a variable called a, which we will use later
var a=
//Get all the elements in the middle that haven't appeared in our stack
m.Except(s).
//And throw away all elements that are bigger than our current score
Where(x=>x<=k).
//And get the biggest element there, and that is now the value of a
//Without the m.Add(0), we would get an exception here
Max();
//Self-explanatory, if a is less than 1 aka if a equals 0
//Checks if all elements in the middle are bigger than our score 
//Except for our self added 0, of course
if(a<1)
//Add 0 to the middle if the stack is empty
//Remember, zeros don't affect the list
m.Add(s.Count<1?0:
//Else pop the stack and add that to the middle
s.Pop());
//If a isn't 0, add a to the stack
else s.Push(a);});
//Afterwards, return the stack
return s;}

Rubis , 77 octets

->t,s,r=[]{s.map{|i|(x=(t-[p]).reject{|j|j>i}.max)?(t-=[x];r<<x):t<<r.pop};r}

Essayez-le en ligne!

JavaScript (Node.js) , 80 octets

Même logique que la version ES6, mais prend les tuiles comme un masque de bits BigInt et les scores comme un tableau de BigInts.

m=>s=>s.map(g=x=>!x||m>>x&1n?m^=1n<<(x?r.push(x)&&x:r.pop()||~x):g(--x),r=[])&&r

Essayez-le en ligne!

JavaScript (ES6),  100 98 94  87 octets

Prend l'entrée comme (tiles)(scores). Les tuiles peuvent être passées dans n'importe quel ordre.

t=>s=>s.map(g=x=>m[x]?m[x?r.push(x)&&x:r.pop()]^=1:g(x-1),t.map(x=>m[x]=1,m=[r=[]]))&&r

Essayez-le en ligne!

Commenté

t => s =>                 // t[] = tiles; s[] = scores
  s.map(g = x =>          // for each score x in s[]:
    m[x] ?                //   if m[x] is set:
      m[                  //     update the 'middle':
        x ?               //       if x is not equal to 0:
          r.push(x) && x  //         push x in the stack r[] and yield x
        :                 //       else:
          r.pop()         //         pop the last value from the stack
                          //         (may be undefined if the stack is empty)
      ] ^= 1              //     toggle the corresponding flag in m[]
    :                     //   else:
      g(x - 1),           //     try again with x - 1
    t.map(x =>            //   initialization of the 'middle': for each value x in t[]:
      m[x] = 1,           //     set m[x]
      m = [r = []]        //     the stack r[] is stored as the first entry of m[],
                          //     which ensures that g will always stop when x = 0
    )                     //   end of initialization
  ) && r                  // end of main loop; return r[]

Fusain , 35 octets

Ｆη«≔⌈Φ講κιι¿ι«≔Φθ⁻κιθ⊞υι»¿υ⊞θ⊟υ»Ｉυ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｆη«

Faites une boucle sur les scores.

≔⌈Φ講κιι

Recherchez la tuile la plus haute disponible.

¿ι«

S'il existe, alors ...

≔Φθ⁻κιθ

... retirez la tuile du milieu ...

⊞υι

... et ajoutez-le à la pile.

»¿υ

Sinon, si la pile n'est pas vide ...

⊞θ⊟υ

Retirez la dernière tuile de la pile et remettez-la au milieu.

»Ｉυ

Imprimez la pile résultante du plus ancien au plus récent.

Python 2 , 120 octets

m,s=input()
t=[]
for n in s:
 i=[v for v in m if v<=n]
 if i:v=max(i);t+=[v];m.remove(v)
 else:m+=t and[t.pop()]
print t

Essayez-le en ligne!

05AB1E , 27 22 octets

vÐy>‹ÏDgĀià©K®së\sª])¨

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

v            # Loop `y` over the (implicit) input-list of scores:
 Ð           #  Triplicate the tiles list (takes it as implicit input in the first iteration)
  y>‹        #  Check for each if `y` <= the value in the tiles list
     Ï       #  Only leave the values at the truthy indices
 D           #  Duplicate the remaining tiles
  ¯Êi        #  If this list is not empty:
     à       #   Pop the list, and push its maximum
      ©      #   Store it in the register, without popping
       K     #   Remove it from the tiles list
        ®    #   Push the maximum again
         s   #   Swap the maximum and tiles-list on the stack
    ë        #  Else:
     \       #   Remove the duplicated empty tiles-list from the stack
      sª     #   Add the last tile to the tiles-list
]            # Close the if-else and loop
 )           # Wrap everything on the stack into a list
  ¨          # Remove the last item (the tiles-list)
             # (and output the result implicitly)

Pyth, 32 octets

VE ?JeS+0f!>TNQ=-QeaYJaQ.)|Y]0;Y

Essayez-le en ligne ici ou vérifiez tous les cas de test en même temps ici .

Il doit y avoir place à amélioration quelque part - toutes les suggestions seraient très appréciées!

VE ?JeS+0f!>TNQ=-QeaYJaQ.)|Y]0;Y   Implicit: Q=input 1 (middle), E=input 2 (scores), Y=[]
VE                            ;    For each score, as N, in the second input:
         f    Q                      Filter Q, keeping elements T where:
          !>TN                         T is not greater than N 
                                       (less than or equal is the only standard inequality without a token in Pyth, grrr)
       +0                            Prepend 0 to the filtered list
     eS                              Take the largest of the above (_e_nd of _S_orted list)
    J                                Store the above in J
   ?                                 If the above is truthy:
                   aYJ                 Append J to Y
                  e                    Take last element of Y (i.e. J)
               =-Q                     Remove that element from Q and assign the result back to Q
                                     Else:
                          |Y]0         Yield Y, or [0] if Y is empty
                        .)             Pop the last element from the above (mutates Y)
                      aQ               Append the popped value to Q
                               Y   Print Y

Perl 5 -apl -MList:Util=max, 97 octets

$_=$".<>;for$i(@F){(($m=max grep$_<=$i,/\d+/g)&&s/ $m\b//?$s:$s=~s/ \d+$//?$_:$G).=$&}$_=$s;s/ //

TIO

lit les partitions et les tuiles sur la ligne suivante et imprime la sortie.

Comment

• -apl: -ppour boucler sur les lignes et imprimer, -aautosplit, -lpour couper à partir de l'entrée et ajouter un caractère de nouvelle ligne à la sortie
• $_=$".<> : pour lire la ligne suivante (tuiles) et ajouter un espace dans la var par défaut $_
• for$i(@F){... }boucle $isur les @Fchamps de la ligne courante (scores)
• (.. ?.. :.. ).=$&ajouter la correspondance précédente à la valeur l ternaire
• ($m=max grep$_<=$i,/\d+/g)&&s/ $m\b//?$sdans le cas où la valeur maximale trouvée et supprimée des tuiles ( $_) la valeur l est les scores ( $s)
• $s=~s/ \d+$//?$_ sinon, si le dernier numéro peut être retiré des scores, ce sont des tuiles
• :$G enfin c'est des ordures parce que ça ne peut pas arriver
• $_=$s;s/ // pour définir les scores sur var par défaut et supprimer l'espace de tête