W grze Pickomino na środku stołu leży kilka płytek, każdy z inną dodatnią liczbą całkowitą. W każdej turze gracze rzucają kośćmi w określony sposób i otrzymują wynik, który jest nieujemną liczbą całkowitą.

Teraz gracz bierze żeton o najwyższym numerze, który jest nadal niższy lub równy jego punktowi, usuwając żeton ze środka i dodając go do swojego stosu. Jeśli nie jest to możliwe, ponieważ wszystkie liczby na środku są wyższe niż wynik gracza, gracz traci najwyższą płytkę ze stosu (który został dodany jako ostatni), który jest zwracany na środek. Jeśli graczowi nie pozostały żadne płytki, nic się nie dzieje.

Wyzwanie

Symuluj gracza grającego przeciwko sobie. Otrzymasz listę kafelków pośrodku i listę wyników uzyskanych przez gracza. Zwróć listę płytek gracza po ocenie wszystkich tur.

Zasady wyzwania

• Możesz założyć, że lista z kafelkami jest uporządkowana i nie zawiera żadnej liczby całkowitej dwa razy.
• Możesz wziąć obie listy danych wejściowych w dowolnej kolejności
• Dane wyjściowe muszą być utrzymywane w kolejności płytek na stosie, ale możesz zdecydować, czy lista jest sortowana od góry do dołu, czy od dołu do góry.

Główne zasady

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki kod-golfowe zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły z domyślnymi regułami We / Wy , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i typem zwracanych, pełnych programów.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem kodu (tj. TIO ).
• Zalecane jest wyjaśnienie swojej odpowiedzi.

Przykład

(wzięte z 6. próby)

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]

Pierwszy wynik to 22, więc weź najwyższy kafelek na środku <= 22, czyli sam 22.

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] 

Następny wynik to 22, więc weź najwyższy kafelek na środku <= 22. Ponieważ 22 jest już zajęty, gracz musi wziąć 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]

Następny wynik to 22, ale wszystkie liczby <= 22 są już zajęte. Dlatego gracz traci najwyższą płytkę na stosie (21), która jest zwracana na środek.

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]

Kolejne wyniki to 23, 21 i 24, więc gracz bierze te płytki ze środka.

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

Gracz psuje się i otrzymuje zero. Dlatego płytka z liczbą 24 (najwyższa pozycja na stosie) jest zwracana na środek.

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

Ostatni wynik to 22, ale wszystkie płytki <= 22 są już zajęte, więc gracz traci najwyższą płytkę na stosie (21).

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

Przypadki testowe

(z najwyższym kafelkiem na końcu listy wyników)

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

Piaskownica

Haskell , 119 111 104 103 bajtów

1 bajt zapisany dzięki Ø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
([]%)

Wypróbuj online!

Zakłada, że ​​kafelki są sortowane w kolejności malejącej.

Nie dzieje się tu zbytnio. Pierwszy argument to stos graczy, drugi ich wyniki, a trzeci to stos pośrodku.

Japt, 24 bajty

Oo! To nie wyszło tak dobrze, jak myślałem!

Pobiera dane wejściowe w odwrotnej kolejności.

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

Wypróbuj lub uruchom wszystkie przypadki testowe na 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 bajtów

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

Wypróbuj online!

Myślę, że jest jeszcze kilka bajtów do gry w golfa ...

C # (interaktywny kompilator Visual C #) , 159 158 154 bajtów

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

Jeśli tylko System.Voidjest faktycznie typem zwrotu, a nie tylko symbolem zastępczym do refleksji. Byłbym w stanie wymienić if(a<1)m.Add(s.Count<1?0:s.Pop());else s.Push(a);z var t=a>1?m.Add(s.Count<1?0:s.Pop()):s.Push(a);, oszczędzając dwa bajty.

Wypróbuj 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;}

Rubinowy , 77 bajtów

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

Wypróbuj online!

JavaScript (Node.js) , 80 bajtów

Ta sama logika co wersja ES6, ale przyjmuje kafelki jako maskę bitów BigInt, a wyniki jako tablicę 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

Wypróbuj online!

JavaScript (ES6),  100 98 94  87 bajtów

Pobiera dane wejściowe jako (tiles)(scores). Płytki można przekazywać w dowolnej kolejności.

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

Wypróbuj online!

Skomentował

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

Węgiel drzewny , 35 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

Ｆη«

Pętla nad wynikami.

≔⌈Φ講κιι

Poszukaj najwyższej dostępnej płytki.

¿ι«

Jeśli istnieje, to ...

≔Φθ⁻κιθ

... usuń płytkę ze środka ...

⊞υι

... i dodaj go do stosu.

»¿υ

W przeciwnym razie, jeśli stos nie będzie pusty ...

⊞θ⊟υ

Usuń najnowszą płytkę ze stosu i odłóż ją na środek.

»Ｉυ

Wydrukuj powstały stos od najstarszego do najnowszego.

Python 2 , 120 bajtów

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

Wypróbuj online!

05AB1E , 27 22 bajtów

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

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

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 bajty

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

Spróbuj go online tutaj , lub sprawdzić wszystkie przypadki testowe od razu tutaj .

Gdzieś tu musi być miejsce na ulepszenia - wszelkie sugestie byłyby mile widziane!

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 bajtów

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

TIO

odczytuje wyniki i kafelki w następnym wierszu i drukuje dane wyjściowe.

W jaki sposób

• -apl: -pdo -azapętlania linii i drukowania, autosplit, -lchomp od wejścia i dodawania znaku nowej linii do wyjścia
• $_=$".<> : aby odczytać następny wiersz (kafelki) i wstawić spację do domyślnego var $_
• for$i(@F){... }pętla $inad @Fpolami bieżącej linii (wyniki)
• (.. ?.. :.. ).=$&dołącz poprzednie dopasowanie do trójskładnikowej wartości L.
• ($m=max grep$_<=$i,/\d+/g)&&s/ $m\b//?$sw przypadku gdy maksymalna wartość znaleziona i usunięta z kafelków ( $_) wartość l to score ( $s)
• $s=~s/ \d+$//?$_ w przeciwnym razie, jeśli ostatnia liczba mogłaby zostać usunięta z wyników, są to kafelki
• :$G w końcu to śmieci, ponieważ nie mogą wystąpić
• $_=$s;s/ // ustawić wartości domyślne na var i usunąć wiodącą spację