Nel gioco Pickomino , ci sono diverse tessere al centro del tavolo, ognuna con un intero positivo diverso su di esse. Ad ogni turno, i giocatori tirano i dadi in un certo modo e ottengono un punteggio, che è un numero intero non negativo.

Ora il giocatore prende la tessera con il numero più alto che è ancora inferiore o uguale al proprio punteggio, rimuovendo la tessera dal centro e aggiungendola al proprio stack. Se ciò non è possibile perché tutti i numeri nel mezzo sono più alti del punteggio del giocatore, il giocatore perde la tessera più in alto dal proprio stack (che è stato aggiunto per ultimo), che viene restituito al centro. Se al giocatore non sono rimaste tessere, non succede nulla.

La sfida

Simula un giocatore che gioca contro se stesso. Si ottiene un elenco delle tessere nel mezzo e un elenco dei punteggi ottenuti dal giocatore. Restituisce un elenco delle tessere del giocatore dopo che tutti i turni sono stati valutati.

Regole della sfida

• Puoi presumere che l'elenco con i riquadri sia ordinato e non contenga alcun numero intero due volte.
• Puoi prendere entrambi gli elenchi di input nell'ordine che desideri
• L'output deve mantenere l'ordine dei riquadri nello stack, ma è possibile decidere se l'elenco viene ordinato dall'alto verso il basso o dal basso verso l'alto.

Regole generali

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Le regole standard si applicano alla tua risposta con le regole I / O predefinite , quindi puoi utilizzare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi.
• Le scappatoie predefinite sono vietate.
• Se possibile, aggiungi un link con un test per il tuo codice (ad es. TIO ).
• Si consiglia di aggiungere una spiegazione per la risposta.

Esempio

(tratto dal sesto testcase)

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]

Il primo punteggio è 22, quindi prendi la tessera più alta nel mezzo <= 22, che è 22 stesso.

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] 

Il punteggio successivo è 22, quindi prendi la tessera più alta nel mezzo <= 22. Poiché 22 è già preso, il giocatore deve prendere 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]

Il prossimo punteggio è 22, ma tutti i numeri <= 22 sono già stati presi. Pertanto, il giocatore perde la tessera più in cima alla pila (21), che viene restituita nel mezzo.

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]

I prossimi punteggi sono 23, 21 e 24, quindi il giocatore prende queste tessere dal centro.

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

Il giocatore sballa e segna zero. Pertanto, la tessera con il numero 24 (in cima alla pila) viene restituita nel mezzo.

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

L'ultimo punteggio è 22, ma tutte le tessere <= 22 sono già state prese, quindi il giocatore perde la tessera più in cima alla pila (21).

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

Casi test

(con l'ultimo riquadro all'ultimo nella lista di output)

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

sandbox

Haskell , 119 111 104 103 byte

1 byte salvato grazie 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
([]%)

Provalo online!

Presuppone che le tessere siano ordinate in ordine decrescente.

Non c'è molta fantasia qui. Il primo argomento è la pila dei giocatori, la seconda i loro punteggi e la terza è la pila nel mezzo.

Japt, 24 byte

Oof! Non ha funzionato bene come pensavo!

Accetta l'ingresso in ordine inverso.

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

Provalo o esegui tutti i casi di test su 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 byte

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

Provalo online!

Penso che ci siano alcuni byte in più da cui giocare a golf ...

C # (compilatore interattivo Visual C #) , 159 158 154 byte

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

Se solo System.Voidfosse in realtà un tipo di ritorno e non solo un segnaposto per la riflessione. Sarei in grado di sostituire if(a<1)m.Add(s.Count<1?0:s.Pop());else s.Push(a);con var t=a>1?m.Add(s.Count<1?0:s.Pop()):s.Push(a);, salvando due byte.

Provalo online!

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

Rubino , 77 byte

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

Provalo online!

JavaScript (Node.js) , 80 byte

Stessa logica della versione ES6, ma accetta i riquadri come una maschera di bit BigInt e i punteggi come un array di 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

Provalo online!

JavaScript (ES6),  100 98 94  87 byte

Accetta input come (tiles)(scores). Le tessere possono essere passate in qualsiasi ordine.

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

Provalo online!

Commentate

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

Carbone , 35 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｆη«

Scorri i punteggi.

≔⌈Φ講κιι

Cerca la tessera più alta disponibile.

¿ι«

Se esiste allora ...

≔Φθ⁻κιθ

... rimuovi la piastrella dal centro ...

⊞υι

... e aggiungilo allo stack.

»¿υ

Altrimenti, se lo stack non è vuoto ...

⊞θ⊟υ

Rimuovi l'ultima tessera dalla pila e riportala al centro.

»Ｉυ

Stampa lo stack risultante dal più vecchio al più recente.

Python 2 , 120 byte

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

Provalo online!

05AB1E , 27 22 byte

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

Provalo online o verifica tutti i casi di test .

Spiegazione:

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 byte

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

Provalo online qui o verifica tutti i casi di test contemporaneamente qui .

Ci deve essere spazio per miglioramenti qui da qualche parte - qualsiasi suggerimento sarebbe molto apprezzato!

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 byte

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

TIO

legge spartiti e riquadri sulla riga successiva e stampa l'output.

Come

• -apl: -pper passare sopra le linee e stampare, -aautosplit, -ltagliare dall'input e aggiungere il carattere di nuova riga all'output
• $_=$".<> : per leggere la riga successiva (riquadri) e anteporre uno spazio alla var di default $_
• for$i(@F){... }passa $isopra i @Fcampi della riga corrente (punteggi)
• (.. ?.. :.. ).=$&aggiungi la corrispondenza precedente al valore l ternario
• ($m=max grep$_<=$i,/\d+/g)&&s/ $m\b//?$snel caso in cui il valore massimo sia stato trovato e rimosso dalle tessere ( $_) il valore l è score ( $s)
• $s=~s/ \d+$//?$_ altrimenti, se l'ultimo numero potesse essere rimosso dai punteggi, si tratta di tessere
• :$G infine è spazzatura perché non può accadere
• $_=$s;s/ // per impostare i punteggi sulla var predefinita e rimuovere lo spazio iniziale