Oyunda Pickomino , onlara farklı bir pozitif tamsayı olarak masaya, her ortasında yatan birçok fayans vardır. Her turda oyuncular zarları belirli bir şekilde yuvarlar ve negatif olmayan bir tam sayı olan bir puan alırlar.

Artık oyuncu, skorundan hala daha düşük veya eşit olan en yüksek numaraya sahip olan döşemeyi alır, döşemeyi ortadan kaldırır ve yığına ekler. Ortadaki tüm sayılar oyuncunun skorundan daha yüksek olduğu için bu mümkün değilse, oyuncu yığındaki en üstteki taşı kaybeder (en son eklenen), bu da ortasına döndürülür. Oyuncunun döşemesi kalmadıysa hiçbir şey olmaz.

Meydan okuma

Oyunu kendilerine karşı oynayan bir oyuncuyu simüle edin. Ortadaki fayansların bir listesini ve oyuncunun aldığı puanların bir listesini alırsınız. Tüm dönüşler değerlendirildikten sonra oynatıcının döşemelerinin bir listesini döndürün.

Zorluk kuralları

• Döşemeli listenin sıralandığını ve iki kez tamsayı içermediğini varsayabilirsiniz.
• Her iki girdi listesini istediğiniz sırada alabilirsiniz
• Çıktı, yığındaki döşemelerin sırasını korumak zorundadır, ancak listenin yukarıdan aşağıya mı yoksa aşağıdan yukarıya mı sıralanacağına karar verebilirsiniz.

Genel kurallar

• Bu kod golf , bayt en kısa cevap kazanır.
  Kod golf dillerinin, kod yazmayan dillerle yanıt göndermenizi engellemesine izin vermeyin. 'Herhangi bir' programlama dili için olabildiğince kısa bir cevap bulmaya çalışın.
• Varsayılan I / O kuralları ile cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT, fonksiyonlar / yöntem, uygun parametreler ve dönüş tipi, tam programlar ile kullanılabilir.
• Standart Boşluk Doldurma yasaktır.
• Mümkünse, lütfen kodunuz için bir test içeren bir bağlantı ekleyin (örn. TIO ).
• Cevabınız için bir açıklama eklemeniz önerilir.

Misal

(6. test çantasından alınmıştır)

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]

İlk puan 22'dir, bu yüzden ortadaki en yüksek karoyu al = 22, ki bu da 22'dir.

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] 

Bir sonraki skor 22, bu yüzden ortadaki en yüksek karoyu al <= 22.

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]

Bir sonraki puan 22'dir, ancak <= 22 olan tüm sayılar zaten alınmıştır. Bu nedenle, oyuncu yığının (21) ortasına döndürülen en üst döşemeyi kaybeder.

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]

Sonraki skorlar 23, 21 ve 24, bu yüzden oyuncu bu fayansları ortadan alıyor.

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

Oyuncu büst ve sıfır yapar. Bu nedenle, 24 numaralı (yığının en üstünde) karo ortaya geri döner.

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

Son skor 22, ancak tüm karolar <= 22 zaten alınmış, bu yüzden oyuncu destedeki en üstteki karoyu kaybediyor (21).

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

Test senaryoları

(en üstteki kutucuk çıktı listesinde en son olacak şekilde)

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

Kum havuzu

Haskell , 119 111 104 103 bayt

Ørjan Johansen sayesinde 1 bayt kurtardı

(#)=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
([]%)

Çevrimiçi deneyin!

Döşemelerin azalan sırada sıralandığını varsayar.

Burada çok fazla fantezi yok. İlk argüman oyuncular kazık, ikincisi puanları ve üçüncüsü ortadaki kazıktır.

Japt, 24 bayt

Oof! Düşündüğüm kadar da işe yaramadı!

Girişi ters sırada alır.

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

Deneyin veya TIO'daki tüm test senaryolarını çalıştırın

®=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 bayt

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

Çevrimiçi deneyin!

Bence bu golf için birkaç bayt var ...

C # (Visual C # Etkileşimli derleyicisi) , 159 158 154 bayt

Olarak adlandırılan 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;}

Sadece System.Voidbir dönüş türü ve sadece yansıma için bir yer tutucu ise. Ben yerine mümkün olacaktır if(a<1)m.Add(s.Count<1?0:s.Pop());else s.Push(a);ilevar t=a>1?m.Add(s.Count<1?0:s.Pop()):s.Push(a);İki bayt tasarrufu .

Çevrimiçi deneyin!

//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 bayt

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

Çevrimiçi deneyin!

JavaScript (Node.js) , 80 bayt

ES6 sürümü ile aynı mantık, ancak döşemeleri bir BigInt bitmask ve puanları bir BigInts dizisi olarak alır.

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

Çevrimiçi deneyin!

JavaScript (ES6),  100 98 94  87 bayt

Girişi alır (tiles)(scores). Fayanslar herhangi bir sırayla geçirilebilir.

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

Çevrimiçi deneyin!

Yorumlananlar

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

Odun kömürü , 35 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

Ｆη«

Puanları üzerinden döngü.

≔⌈Φ講κιι

Mevcut en yüksek kutucuğa bakın.

¿ι«

Varsa ...

≔Φθ⁻κιθ

... döşemeyi ortadan kaldır ...

⊞υι

... ve yığına ekleyin.

»¿υ

Aksi takdirde, yığın boş değilse ...

⊞θ⊟υ

En son döşemeyi yığından çıkarın ve ortasına döndürün.

»Ｉυ

Ortaya çıkan yığını en eskiden en yeniye doğru yazdırın.

Python 2 , 120 bayt

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

Çevrimiçi deneyin!

05AB1E , 27 22 bayt

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

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

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 bayt

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

Buradan çevrimiçi olarak deneyin veya tüm test senaryolarını burada bir kerede doğrulayın .

Burada bir yerde iyileştirme için yer olmalı - herhangi bir öneri çok takdir edilecektir!

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 bayt

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

TIO

sonraki satırda puanları ve çinileri okur ve çıktı yazdırır.

Nasıl

• -apl: -psatırlar arasında döngü yapmak ve otomatik olarak yazdırmak, -agirişten parçalamak -lve çıkışa yeni satır karakteri eklemek için
• $_=$".<> : sonraki satırı (kutucukları) okumak ve bir boşluğun önüne varsayılan var $_
• for$i(@F){... }döngü $iboyunca @Fgeçerli satırın alanlar (puanlar)
• (.. ?.. :.. ).=$&önceki maçı üçlü l-değerine ekle
• ($m=max grep$_<=$i,/\d+/g)&&s/ $m\b//?$sDöşemelerden ( $_) bulunan ve kaldırılan maksimum değerin ( ) l değerinin puanlar ( $s) olması durumunda
• $s=~s/ \d+$//?$_ aksi takdirde son sayı puanlardan kaldırılabilirse
• :$G nihayet çöp
• $_=$s;s/ // puanları varsayılan var değerine ayarlamak ve önde gelen alanı kaldırmak için