Dalam gim Pickomino , ada beberapa ubin yang terletak di tengah meja, masing-masing dengan bilangan bulat positif yang berbeda. Setiap belokan, pemain melempar dadu dengan cara tertentu dan mendapatkan skor, yang merupakan bilangan bulat negatif

Sekarang pemain mengambil ubin dengan angka tertinggi yang masih lebih rendah atau sama dengan skor mereka, menghapus ubin dari tengah dan menambahkannya ke tumpukan mereka. Jika ini tidak memungkinkan karena semua angka di tengah lebih tinggi dari skor pemain, pemain kehilangan ubin paling atas dari tumpukan mereka (yang ditambahkan terbaru), yang dikembalikan ke tengah. Jika pemain tidak memiliki ubin yang tersisa, tidak ada yang terjadi.

Tantangan

Simulasikan pemain yang memainkan permainan melawan diri mereka sendiri. Anda mendapatkan daftar ubin di tengah dan daftar skor yang didapat pemain. Kembalikan daftar ubin pemain setelah semua belokan dievaluasi.

Aturan tantangan

• Anda dapat mengasumsikan bahwa daftar dengan ubin disusun dan tidak mengandung bilangan bulat dua kali.
• Anda dapat mengambil kedua daftar input dalam urutan apa pun yang Anda inginkan
• Keluaran harus menjaga urutan ubin pada tumpukan, tetapi Anda dapat memutuskan apakah daftar diurutkan dari atas ke bawah atau dari bawah ke atas.

Aturan umum

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda dari memposting jawaban dengan bahasa yang bukan kode. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa pun'.
• Aturan standar berlaku untuk jawaban Anda dengan aturan I / O default , sehingga Anda diizinkan untuk menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program penuh.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda (yaitu TIO ).
• Dianjurkan menambahkan penjelasan untuk jawaban Anda.

Contoh

(diambil dari testcase ke-6)

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]

Skor pertama adalah 22, jadi ambil petak tertinggi di tengah <= 22, yaitu 22 itu sendiri.

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] 

Skor berikutnya adalah 22, jadi ambil ubin tertinggi di tengah <= 22. Karena 22 sudah diambil, pemain harus mengambil 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]

Skor berikutnya adalah 22, tetapi semua angka <= 22 sudah diambil. Oleh karena itu, pemain kehilangan ubin paling atas di tumpukan (21), yang dikembalikan ke tengah.

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]

Skor berikutnya adalah 23, 21 dan 24, sehingga pemain mengambil ubin ini dari tengah.

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

Pemain itu gagal dan skor nol. Oleh karena itu, ubin dengan nomor 24 (paling atas pada tumpukan) dikembalikan ke tengah.

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

Skor terakhir adalah 22, tetapi semua ubin <= 22 sudah diambil, sehingga pemain kehilangan ubin paling atas di tumpukan (21).

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

Uji kasus

(dengan ubin paling atas terakhir dalam daftar 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: []

Bak pasir

Haskell , 119 111 104 103 byte

1 byte disimpan berkat Ø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
([]%)

Cobalah online!

Asumsikan ubin diurutkan dalam urutan menurun.

Tidak banyak yang terjadi di sini. Argumen pertama adalah tumpukan pemain, yang kedua skor mereka dan yang ketiga adalah tumpukan di tengah.

Japt, 24 byte

Oh! Itu tidak berhasil sebaik yang saya kira!

Mengambil input dalam urutan terbalik.

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

Cobalah atau jalankan semua test case di 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}

Cobalah online!

Saya pikir ada beberapa byte lagi untuk bermain golf ini ...

C # (Visual C # Interactive Compiler) , 159 158 154 byte

Disebut sebagai 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;}

Kalau saja System.Voidsebenarnya tipe pengembalian dan bukan hanya pengganti untuk refleksi. Saya akan bisa mengganti if(a<1)m.Add(s.Count<1?0:s.Pop());else s.Push(a);dengan var t=a>1?m.Add(s.Count<1?0:s.Pop()):s.Push(a);, menghemat dua byte.

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

Ruby , 77 byte

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

Cobalah online!

JavaScript (Node.js) , 80 byte

Logika yang sama dengan versi ES6, tetapi menggunakan ubin sebagai bitmask BigInt dan skor sebagai array 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

Cobalah online!

JavaScript (ES6),  100 98 94  87 byte

Mengambil input sebagai (tiles)(scores). Ubin dapat dilewati dengan urutan apa pun.

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

Cobalah online!

Berkomentar

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

Arang , 35 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

Ｆη«

Ulangi skor.

≔⌈Φ講κιι

Cari ubin tertinggi yang tersedia.

¿ι«

Jika ada maka ...

≔Φθ⁻κιθ

... lepaskan ubin dari tengah ...

⊞υι

... dan tambahkan ke tumpukan.

»¿υ

Jika tidak, jika tumpukan tidak kosong ...

⊞θ⊟υ

Hapus ubin terbaru dari tumpukan dan kembalikan ke tengah.

»Ｉυ

Cetak tumpukan yang dihasilkan dari yang terlama ke yang terbaru.

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

Cobalah online!

05AB1E , 27 22 byte

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

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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

Coba online di sini , atau verifikasi semua uji sekaligus di sini .

Pasti ada ruang untuk perbaikan di sini di suatu tempat - saran apa pun akan sangat dihargai!

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

membaca skor dan ubin pada baris berikutnya dan mencetak output.

Bagaimana

• -apl: -puntuk mengulang garis dan mencetak, -aautosplit, -luntuk chomp dari input dan menambahkan karakter baris baru ke output
• $_=$".<> : untuk membaca baris berikutnya (petak) dan menambahkan spasi ke var default $_
• for$i(@F){... }loop di $iatas @Fbidang baris saat ini (skor)
• (... ?.. :.. ).=$&tambahkan pertandingan sebelumnya ke nilai ter ternary
• ($m=max grep$_<=$i,/\d+/g)&&s/ $m\b//?$sdalam hal nilai maks ditemukan dan dihapus dari ubin ( $_) nilai l adalah skor ( $s)
• $s=~s/ \d+$//?$_ jika tidak, jika nomor terakhir dapat dihapus dari skor itu ubin
• :$G akhirnya sampah karena tidak bisa terjadi
• $_=$s;s/ // untuk mengatur skor ke var default, dan menghapus ruang terdepan