En el juego Pickomino , hay varias fichas situadas en el centro de la mesa, cada una con un número entero positivo diferente. Cada turno, los jugadores tiran dados de cierta manera y obtienen un puntaje, que es un número entero no negativo.

Ahora el jugador toma el mosaico con el número más alto que todavía es más bajo o igual a su puntaje, retira el mosaico del medio y lo agrega a su pila. Si esto no es posible porque todos los números en el medio son más altos que el puntaje del jugador, el jugador pierde la ficha más alta de su pila (que se agregó más tarde), que se devuelve al medio. Si al jugador no le quedan fichas, no pasa nada.

El reto

Simula a un jugador que juega contra ellos mismos. Obtiene una lista de las fichas en el medio y una lista de los puntajes que obtuvo el jugador. Devuelve una lista de las fichas del jugador después de que se hayan evaluado todos los turnos.

Reglas de desafío

• Puede suponer que la lista con los mosaicos está ordenada y no contiene ningún número entero dos veces.
• Puede tomar ambas listas de entrada en el orden que desee
• La salida debe mantener el orden de los mosaicos en la pila, pero puede decidir si la lista se ordena de arriba a abajo o de abajo hacia arriba.

Reglas generales

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Se recomienda agregar una explicación para su respuesta.

Ejemplo

(tomado del sexto caso de prueba)

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]

El primer puntaje es 22, así que toma la ficha más alta en el medio <= 22, que es 22 en sí.

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] 

El siguiente puntaje es 22, así que toma la ficha más alta en el medio <= 22. Como 22 ya está tomado, el jugador tiene que tomar 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]

El siguiente puntaje es 22, pero todos los números <= 22 ya están tomados. Por lo tanto, el jugador pierde la ficha superior de la pila (21), que se devuelve al medio.

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]

Los siguientes puntajes son 23, 21 y 24, por lo que el jugador toma estas fichas del medio.

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

El jugador revienta y anota cero. Por lo tanto, el mosaico con el número 24 (el más alto en la pila) se devuelve al medio.

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

El último puntaje es 22, pero todas las fichas <= 22 ya están tomadas, por lo que el jugador pierde la ficha superior en la pila (21).

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

Casos de prueba

(con el último mosaico superior en la lista de resultados)

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

Salvadera

Haskell , 119 111 104 103 bytes

1 byte guardado gracias a Ø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
([]%)

Pruébalo en línea!

Asume que los mosaicos están ordenados en orden descendente.

No hay mucha fantasía aquí. El primer argumento es la pila de jugadores, el segundo sus puntajes y el tercero es la pila en el medio.

Japt, 24 bytes

Oof! ¡Eso no funcionó tan bien como pensé!

Toma la entrada en orden inverso.

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

Pruébelo o ejecute todos los casos de prueba en 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 bytes

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

Pruébalo en línea!

Creo que hay algunos bytes más que se pueden sacar de esto ...

C # (compilador interactivo de Visual C #) , 159 158 154 bytes

Llamado 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 solo System.Voides realmente un tipo de retorno y no solo un marcador de posición para la reflexión. Podría reemplazar if(a<1)m.Add(s.Count<1?0:s.Pop());else s.Push(a);convar t=a>1?m.Add(s.Count<1?0:s.Pop()):s.Push(a); , ahorrando dos bytes.

Pruébalo en línea!

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

Ruby , 77 bytes

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

Pruébalo en línea!

JavaScript (Node.js) , 80 bytes

La misma lógica que la versión ES6, pero toma los mosaicos como una máscara de bits BigInt y las puntuaciones como una matriz 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

Pruébalo en línea!

JavaScript (ES6),  100 98 94  87 bytes

Toma entrada como (tiles)(scores). Las fichas se pueden pasar en cualquier orden.

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

Pruébalo en línea!

Comentado

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

Carbón , 35 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｆη«

Recorrer los puntajes.

≔⌈Φ講κιι

Busque el azulejo más alto disponible.

¿ι«

Si existe, entonces ...

≔Φθ⁻κιθ

... quitar el azulejo del medio ...

⊞υι

... y agrégalo a la pila.

»¿υ

De lo contrario, si la pila no está vacía ...

⊞θ⊟υ

Retire el último mosaico de la pila y vuelva a colocarlo en el medio.

»Ｉυ

Imprima la pila resultante de la más antigua a la más nueva.

Python 2 , 120 bytes

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

Pruébalo en línea!

05AB1E , 27 22 bytes

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

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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 bytes

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

Pruébelo en línea aquí , o verifique todos los casos de prueba a la vez aquí .

Debe haber margen de mejora aquí en alguna parte: cualquier sugerencia sería muy apreciada.

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 bytes

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

TIO

lee puntajes y mosaicos en la siguiente línea e imprime la salida.

Cómo

• -apl: -ppara recorrer las líneas e imprimir, -aauto dividir,-l para cambiar de entrada y agregar caracteres de nueva línea a la salida
• $_=$".<> : para leer la siguiente línea (mosaicos) y anteponer un espacio en la var predeterminada $_
• for$i(@F){... }bucle $imás @Fcampos de la línea actual (puntuaciones)
• (.. ?.. :.. ).=$&agregar una coincidencia anterior al valor l ternario
• ($m=max grep$_<=$i,/\d+/g)&&s/ $m\b//?$sen caso de que el valor máximo encontrado y eliminado de los mosaicos ( $_) el valor l sea puntajes ( $s)
• $s=~s/ \d+$//?$_ de lo contrario, si el último número se puede eliminar de las puntuaciones, son fichas
• :$G finalmente es basura porque no puede ocurrir
• $_=$s;s/ // para establecer las puntuaciones en var predeterminado y eliminar el espacio inicial