Trong trò chơi Pickomino , có một vài viên gạch nằm ở giữa bàn, mỗi viên có một số nguyên dương khác nhau trên chúng. Mỗi lượt, người chơi tung xúc xắc theo một cách nhất định và nhận được điểm, đó là một số nguyên không âm.

Bây giờ người chơi lấy ô có số cao nhất vẫn thấp hơn hoặc bằng số điểm của họ, loại bỏ ô từ giữa và thêm nó vào ngăn xếp của họ. Nếu điều này là không thể bởi vì tất cả các số ở giữa cao hơn điểm của người chơi, thì người chơi sẽ mất ô trên cùng từ ngăn xếp của họ (được thêm mới nhất), được trả về giữa. Nếu người chơi không còn gạch, không có gì xảy ra.

Các thách thức

Mô phỏng một người chơi chơi trò chơi với chính họ. Bạn nhận được một danh sách các ô ở giữa và một danh sách các điểm số mà người chơi đạt được. Trả về một danh sách các ô của người chơi sau khi tất cả các lượt đã được đánh giá.

Quy tắc thử thách

• Bạn có thể giả sử rằng danh sách với các ô được sắp xếp và không chứa bất kỳ số nguyên nào hai lần.
• Bạn có thể lấy cả hai danh sách đầu vào theo bất kỳ thứ tự nào bạn muốn
• Đầu ra phải giữ thứ tự các ô trên ngăn xếp, nhưng bạn có thể quyết định danh sách được sắp xếp từ trên xuống dưới hoặc từ dưới lên trên.

Quy tắc chung

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Thêm một lời giải thích cho bạn câu trả lời được khuyến khích.

Thí dụ

(lấy từ mẫu thử thứ 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]

Điểm số đầu tiên là 22, vì vậy hãy lấy ô cao nhất ở giữa <= 22, chính là 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] 

Điểm tiếp theo là 22, vì vậy hãy lấy ô cao nhất ở giữa <= 22. Vì đã lấy 22, người chơi phải lấy 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]

Điểm tiếp theo là 22, nhưng tất cả các số <= 22 đã được sử dụng. Do đó, người chơi mất ô trên cùng trên ngăn xếp (21), được trả lại vào giữa.

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ểm tiếp theo là 23, 21 và 24, vì vậy người chơi sẽ lấy những ô này từ giữa.

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

Người chơi bán thân và điểm số không. Do đó, ô có số 24 (trên cùng trên ngăn xếp) được trả lại vào giữa.

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

Điểm cuối cùng là 22, nhưng tất cả các ô <= 22 đã được lấy, do đó người chơi sẽ mất ô trên cùng trên ngăn xếp (21).

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

Các trường hợp thử nghiệm

(với ô trên cùng cuối cùng trong danh sách đầu ra)

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

Hộp cát

Haskell , 119 111 104 103 byte

Lưu 1 byte nhờ Ø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
([]%)

Hãy thử trực tuyến!

Giả sử gạch được sắp xếp theo thứ tự giảm dần.

Không có nhiều ưa thích đang diễn ra ở đây. Đối số đầu tiên là người chơi đóng cọc, điểm thứ hai của họ và thứ ba là cọc ở giữa.

Japt, 24 byte

Ôi! Điều đó đã không diễn ra tốt như tôi nghĩ nó sẽ làm!

Đưa đầu vào theo thứ tự ngược lại.

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

Hãy thử hoặc chạy tất cả các trường hợp thử nghiệm trên 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}

Hãy thử trực tuyến!

Tôi nghĩ rằng có thêm một vài byte để được đánh gôn này ...

C # (Trình biên dịch tương tác Visual C #) , 159 158 154 byte

Gọi là 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;}

Nếu chỉ System.Voidthực sự là một loại trả lại và không chỉ là một giữ chỗ cho sự phản ánh. Tôi sẽ có thể thay thế if(a<1)m.Add(s.Count<1?0:s.Pop());else s.Push(a);bằng var t=a>1?m.Add(s.Count<1?0:s.Pop()):s.Push(a);, tiết kiệm hai byte.

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

JavaScript (Node.js) , 80 byte

Logic tương tự như phiên bản ES6, nhưng lấy các ô như một bitmask BigInt và điểm số là một mảng của 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

Hãy thử trực tuyến!

JavaScript (ES6),  100 98 94  87 byte

Đưa đầu vào là (tiles)(scores). Các gạch có thể được thông qua theo thứ tự bất kỳ.

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

Hãy thử trực tuyến!

Đã bình luận

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

Than , 35 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｆη«

Vòng qua điểm số.

≔⌈Φ講κιι

Tìm kiếm gạch có sẵn cao nhất.

¿ι«

Nếu nó tồn tại thì ...

≔Φθ⁻κιθ

... loại bỏ gạch từ giữa ...

⊞υι

... và thêm nó vào ngăn xếp.

»¿υ

Mặt khác, nếu ngăn xếp không trống ...

⊞θ⊟υ

Loại bỏ gạch mới nhất từ ​​ngăn xếp và đưa nó trở lại giữa.

»Ｉυ

In ngăn xếp kết quả từ cũ nhất đến mới nhất.

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

Hãy thử trực tuyến!

05AB1E , 27 22 byte

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

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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)

Bình thường, 32 byte

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

Dùng thử trực tuyến tại đây hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc tại đây .

Phải có chỗ để cải thiện ở đây ở đâu đó - bất kỳ đề xuất nào sẽ được đánh giá cao!

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

đọc điểm và gạch trên dòng tiếp theo và in đầu ra.

Làm sao

• -apl: -plặp qua các dòng và in, -aautosplit, -lđể chomp từ đầu vào và thêm ký tự dòng mới vào đầu ra
• $_=$".<> : để đọc dòng tiếp theo (gạch) và thêm một khoảng trắng vào var mặc định $_
• for$i(@F){... }vòng lặp $itrên @Fcác trường của dòng hiện tại (điểm số)
• (.. ?.. :.. ).=$&nối trận đấu trước vào giá trị lernary
• ($m=max grep$_<=$i,/\d+/g)&&s/ $m\b//?$strong trường hợp giá trị tối đa được tìm thấy và loại bỏ khỏi gạch ( $_) l-value là điểm ( $s)
• $s=~s/ \d+$//?$_ mặt khác, nếu số cuối cùng có thể bị xóa khỏi điểm số thì gạch đó
• :$G cuối cùng là rác vì không thể xảy ra
• $_=$s;s/ // để đặt điểm số thành var mặc định và xóa không gian hàng đầu