Giới thiệu

Trong thử thách này, nhiệm vụ của bạn là mô phỏng một loại trò chơi loại trừ nhất định. Trong trò chơi, những người tham gia đứng thành một vòng tròn và mọi người đều đang giữ một số nguyên. Trên mỗi vòng của trò chơi, mọi người tham gia chỉ vào người đó nbước đi, nếu đó nlà số họ đang giữ. Nếu nlà dương, họ đếm sang phải, nếu nâm, họ đếm sang trái và nếu nbằng 0, họ chỉ vào chính mình. Mọi người tham gia có ai đó chỉ vào họ đều bị loại và rời khỏi vòng tròn; Điều này kết thúc vòng. Các vòng đấu tiếp tục cho đến khi không còn người tham gia.

Đầu vào

Đầu vào của bạn là một danh sách các số nguyên không trống, ở bất kỳ định dạng hợp lý nào. Nó đại diện cho những con số mà những người tham gia trò chơi đang nắm giữ.

Đầu ra

Đầu ra của bạn là số vòng cần thiết cho đến khi trò chơi kết thúc.

Thí dụ

Hãy xem xét danh sách đầu vào [3,1,-2,0,8]. Ở vòng đầu tiên, những điều sau đây xảy ra:

• Người giữ 3điểm ngay tại người đang giữ 0.
• Người giữ 1điểm ngay tại người đang giữ -2.
• Người giữ -2điểm trái tại người đang giữ 3.
• Người giữ 0điểm tại chính họ.
• Người giữ 8điểm ngay tại người đang giữ -2(danh sách đại diện cho một vòng tròn, do đó, nó bao quanh ở cuối).

Điều này có nghĩa là 0, -2và 3được loại bỏ, vì vậy vòng thứ hai được thực hiện với danh sách [1,8]. Ở đây, 1chỉ vào 8và 8chỉ vào chính họ, vì vậy 8được loại bỏ. Vòng thứ ba được thực hiện với danh sách [1], trong đó 1chỉ đơn giản là chỉ vào chính họ và bị loại. Phải mất ba vòng để loại bỏ tất cả những người tham gia, vì vậy đầu ra chính xác là 3.

Quy tắc và tính điểm

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

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

[3] -> 1
[0,0,0] -> 1
[-2,-1,0,1,2,3,4,5,6,7] -> 2
[5,5,5,6,6,6] -> 2
[3,-7,-13,18,-10,8] -> 2
[-7,5,1,-5,-13,-10,9] -> 2
[4,20,19,16,8,-9,-14,-2,17,7,2,-2,10,0,18,-5,-5,20] -> 3
[11,2,7,-6,-15,-8,15,-12,-2,-8,-17,6,-6,-5,0,-20,-2,11,1] -> 4
[2,-12,-11,7,-16,9,15,-10,7,3,-17,18,6,6,13,0,18,10,-7,-1] -> 3
[18,-18,-16,-2,-19,1,-9,-18,2,1,6,-15,12,3,-10,8,-3,7,-4,-11,5,-15,17,17,-20,11,-13,9,15] -> 6

Bình thường, 15 byte

f!=.DQ.e%+bklQQ

Bộ thử nghiệm nhờ kirby

Sử dụng cơ chế lặp tương tự như @orlp, nhưng phát hiện số lần lặp sử dụng f, chức năng "Lặp lại cho đến khi giả mạo", để phát hiện []khi chúng ta hoàn thành.

Matlab, 91 77 byte

function k=f(a);k=0;while a*0+1;l=numel(a);a(mod((1:l)+a-1,l)+1)=[];k=k+1;end

Phiên bản cũ:

function k=f(a);for k=1:numel(a);a(mod((1:l)+a-1,l)+1)=[];l=numel(a);if l==0;break;end;end

Đây là một thách thức khi matlab tỏa sáng, trái tim của mã này là việc xóa các mục mảng: a(mod((1:l)+a-1,l)+1)=[]tôi nghĩ nó khá thanh lịch.

CJam, 21 byte

q~{__ee{~+0t}/0-}h],(

Bộ thử nghiệm.

Đưa đầu vào dưới dạng danh sách kiểu CJam, nhưng bộ thử nghiệm đảm nhiệm việc chuyển đổi từ định dạng trong thử thách.

Giải trình

q~     e# Read and evaluate the input.
{      e# While the array is non-empty...
  _    e#   Copy the array. The original is left on the stack so that we can use the
       e#   stack depth to count the number of iterations later.
  _ee  e#   Make another copy and enumerate it, which means that each element is replaced
       e#   by a pair containing the element and its index in the array.
  {    e#   For each such pair...
    ~+ e#     Add the value to the index, giving the index it points at.
    0t e#     Set the value in the original array at the pointed-at index to 0.
       e#     This works without giving false positives because all 0s point to themselves.
  }/
  0-   e#   Remove all 0s from the array.
}h
],(    e# Wrap the stack in an array, get its length and decrement it to determine how
       e# many iterations this process took.

C #, 251 219 211 197 193 byte

Ngôn ngữ phi bí truyền vô đạo đức nhất lại xuất hiện.

using System.Linq;class X{static void Main(string[]a){int i=0,c;for(;(c=a.Length)>0;i++)a=a.Where((e,x)=>!a.Where((f,y)=>((int.Parse(f)+y)%c+c)%c==x).Any()).ToArray();System.Console.Write(i);}}

Chương trình này dự kiến ​​chuỗi đầu vào là đối số dòng lệnh. Ví dụ, để nhập danh sách [5,5,5,6,6,6], hãy gọi nó bằng các đối số dòng lệnh 5 5 5 6 6 6.

Cảm ơn Martin Büttner cho một số lời khuyên.

Đánh gôn đến 197 bằng cách nhận ra rằng tôi có thể sử dụng lại argsmảng mặc dù đó là một chuỗi các chuỗi. Tôi chỉ cần phân tích chúng thành một số nguyên ở một nơi.

Chơi gôn đến 193 bằng cách nhận ra rằng .Where(...==x).Any()nó ngắn hơn .Select(...).Contains(x).

Ung dung

using System.Linq;
class X
{
    static void Main(string[] args)
    {
        var iterations = 0, count;

        // In the golfed version, this is a `for` loop instead.
        while ((count = args.Length) > 0)
        {
            // Create a new args array containing the items to be kept.
            args = args.Where((item, index) =>
            {
                // Should the item at index `index` be deleted?
                var deleteThisIndex = args.Where((item2, index2) =>
                    // Modulo that works with negative numbers...
                    ((int.Parse(item2) + index2) % count + count) % count
                        == index);

                return !deleteThisIndex.Any();

            }).ToArray();

            iterations++;
        }

        System.Console.Write(iterations);
    }
}

Bình thường, 21 byte

lt.u@LN-UlN.e%+kblNNQ

Bản demo trực tiếp với các trường hợp thử nghiệm.

R, 105 byte

mã

l=scan();o=c();z=0;while((n=length(l))>0){for(i in 1:n)o=c(o,(i+l[i]-1)%%n+1);l=l[-o];o=c();z=z+1};cat(z)

vô dụng

l <- scan()                  # get input as a 'l' vector from user
o <- c()                     # create a empty vector
z=0                          # create a counter starting at 0   
while((n=length(l))>0){      # while the length of the input is more than 0
  for(i in 1:n){             # iterate through the vector
    o=c(o,(i+l[i]-1)%%n+1)   # add the index that will be deleted to the 'o' vector
  }
  l=l[-o]                    # remove the 'o' vector indexes from 'l'
  o=c()                      # empty 'o'
  z=z+1                      # add 1 to counter
}
cat(z)                       # print the counter

Bình thường, 17 byte

tl.u.DN.e%+kblNNQ

Thật trùng hợp rất giống với câu trả lời của kirbyfan.

Toán học, 71 byte

Length@FixedPointList[#~Delete~Mod[Plus~MapIndexed~#,Length@#,1]&,#]-2&

STATA, 146 byte

inf a using a.
gl b=0
qui while _N>0{
g q$b=0
g c$b=mod(_n+a-1,_N)+1
forv y=1/`=_N'{
replace q$b=1 if _n==c$b[`y']
}
drop if q$b
gl b=$b+1
}
di $b

Sử dụng phiên bản trả phí của STATA. Giả sử đầu vào là trong một tệp mới được phân tách được gọi là a.. Giới hạn trong các tình huống không yêu cầu quá 1023 vòng do số lượng biến tối đa được phép (có thể được sửa với chi phí 10 byte). Nó đọc dữ liệu và chạy một vòng lặp cho đến khi không còn quan sát nữa. Trong mỗi lần lặp, tạo một biến có giá trị của chỉ mục mà nó trỏ tới. Đối với mỗi quan sát, nếu một quan sát khác chỉ vào nó, đặt một chỉ báo để thả biến. Sau đó thả tất cả các quan sát với chỉ báo đó và tăng bộ đếm. Sau vòng lặp, in bộ đếm.

Ruby, 78 74 byte

f=->a{b,i=[],0;(a.map{|e|b<<a[(e+i)%a.size]};a-=b;i+=1)while a.size>0;p i}

ôi, 66 byte

{for(;n=split($0=$0,a);++r)for(i in a)$((i+a[i]%n+n-1)%n+1)=X}$0=r

Đơn giản chỉ cần sử dụng mod length array để giữ nó bên trong mảng. Trong đầu vào, các số cần được phân tách bằng dấu cách.

Ví dụ sử dụng

echo "-2 -1 0 1 2 3 4 5 6 7" | awk '{for(;n=split($0=$0,a);++r)for(i in a)$((i+a[i]%n+n-1)%n+1)=X}$0=r'

Đây là tất cả các ví dụ đầu vào ở định dạng thích hợp

3
0 0 0
-2 -1 0 1 2 3 4 5 6 7
5 5 5 6 6 6
3 -7 -13 18 -10 8
-7 5 1 -5 -13 -10 9
4 20 19 16 8 -9 -14 -2 17 7 2 -2 10 0 18 -5 -5 20
11 2 7 -6 -15 -8 15 -12 -2 -8 -17 6 -6 -5 0 -20 -2 11 1
2 -12 -11 7 -16 9 15 -10 7 3 -17 18 6 6 13 0 18 10 -7 -1
18 -18 -16 -2 -19 1 -9 -18 2 1 6 -15 12 3 -10 8 -3 7 -4 -11 5 -15 17 17 -20 11 -13 9 15

Python 2, 122 byte

def f(l):
 if not l:return 0
 L=len(l);x=[1]*L
 for i in range(L):x[(i+l[i])%L]=0
 return 1+e([v for i,v in zip(x,l)if i])