소개

이 도전에서 당신의 임무는 특정 유형의 제거 게임을 시뮬레이션하는 것입니다. 게임에서 참가자는 원 안에 서 있으며 모두가 정수를 보유하고 있습니다. 게임의 각 라운드에서, 모든 참가자 는 자신이 보유하고있는 숫자 n인 경우 그 사람을 points니다 n. 경우 n양수이면, 그들은 자신의 오른쪽으로 계산 n부정적 그들은 자신의 왼쪽으로 계산하고, 경우, n제로, 그들은 그들 자신에 가리 킵니다. 누군가가 자신을 가리키고있는 모든 참가자는 제거되고 서클을 떠납니다. 이것으로 라운드가 끝납니다. 참가자가 없을 때까지 라운드가 계속됩니다.

입력

귀하의 입력은 임의의 합리적인 형식으로 비어 있지 않은 정수 목록입니다. 게임 참가자가 보유하고있는 숫자를 나타냅니다.

산출

당신의 결과는 게임이 끝날 때까지 걸리는 라운드 수입니다.

예

입력 목록을 고려하십시오 [3,1,-2,0,8]. 첫 번째 라운드에서 다음이 발생합니다.

• 들고 3있는 사람이 바로 들고있는 사람을 가리 킵니다 0.
• 들고 1있는 사람이 바로 들고있는 사람을 가리 킵니다 -2.
• 홀딩 -2포인트는 홀딩 한 사람에게 남았습니다 3.
• 0자신 을 가리키는 사람 .
• 홀딩 한 사람이 홀딩 한 사람을 8가리키고 있습니다 -2(목록은 원을 나타내므로 끝 부분을 감 쌉니다).

이 수단 0, -2및 3제거가 있으므로 두 번째 라운드를리스트로 이루어진다 [1,8]. 여기 1에서의 포인트 8와 8스스로가의 점 때문에 8제거된다. 세 번째 라운드는 단순히 자신을 가리키고 제거 [1]되는 list로 수행됩니다 1. 모든 참가자를 제거하는 데 3 라운드가 걸렸으므로 올바른 결과는 3입니다.

규칙과 득점

전체 프로그램 또는 함수를 작성할 수 있습니다. 가장 낮은 바이트 수가 이기고 표준 허점이 허용되지 않습니다.

테스트 사례

[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

Pyth, 15 바이트

f!=.DQ.e%+bklQQ

커비 덕분에 테스트 스위트

@orlp와 동일한 반복 메커니즘을 사용하지만 f"거짓까지 반복"기능을 사용하여 반복 횟수 를 감지하여 []완료된 것을 감지합니다 .

Matlab, 91 77 바이트

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

구 버전:

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

이것은 matlab이 빛나는 도전이며,이 코드의 핵심은 배열 항목을 삭제하는 a(mod((1:l)+a-1,l)+1)=[]것입니다.

CJam, 21 바이트

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

테스트 스위트.

입력을 CJam 스타일 목록으로 가져 오지만 테스트 스위트는 해당 형식의 변환을 처리합니다.

설명

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 바이트

가장 극복 할 수없는 비전 어적인 언어가 다시 발생합니다.

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

이 프로그램은 입력 순서를 명령 행 인수로 예상합니다. 예를 들어, list를 입력하려면 [5,5,5,6,6,6]명령 행 인수로이를 호출하십시오 5 5 5 6 6 6.

몇 가지 팁을 제공 한 Martin Büttner에게 감사합니다.

배열이 문자열 배열이지만 재사용 할 수 있음을 인식 하여 197 로 골프를 쳤습니다 args. 한곳에서 정수로 파싱하면됩니다.

보다 짧은 것을 실현 하여 193 으로 골프를 쳤다 ..Where(...==x).Any().Select(...).Contains(x)

언 골프

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

Pyth, 21 바이트

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

테스트 사례가 포함 된 라이브 데모.

R, 105 바이트

암호

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)

언 골프

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

Pyth, 17 바이트

tl.u.DN.e%+kblNNQ

우연히 kirbyfan의 답변과 매우 유사합니다.

Mathematica, 71 바이트

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

STATA, 146 바이트

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

유료 버전의 STATA를 사용합니다. 입력이이라는 개행으로 구분 된 파일에 있다고 가정합니다 a.. 허용되는 최대 변수 수로 인해 1023 회 이하의 라운드가 필요한 상황으로 제한됩니다 (10 바이트 비용으로 고정 가능). 더 이상 관측치가 없을 때까지 데이터를 읽고 루프를 실행합니다. 각 반복에서 가리키는 색인 값으로 변수를 작성하십시오. 각 관측치에 대해 다른 관측치가 가리키는 경우 변수를 삭제하도록 표시기를 설정하십시오. 그런 다음 해당 표시기로 모든 관측치를 삭제하고 카운터를 증가시킵니다. 루프 후 카운터를 인쇄하십시오.

루비, 78 74 바이트

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

awk, 66 바이트

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

단순히 mod length array배열 안에 보관하는 데 사용 합니다. 입력에서 숫자는 공백으로 분리해야합니다.

사용 예

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'

다음은 적절한 형식의 모든 입력 예입니다.

삼
0 0 0
-2-1012 34 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 -14 177 2 -2 10 0 18 -5 -5 20
11 2-6-6-15-8 15-12-2-2-8-17 6-6-5-20-20-2 11 1
2-12-11 7-16 9 15-1073 3-17 18 6 6 13 18 10-7-1
18-18-16-16-19 1-9-18 2 1 6-15 12 3-10 8-3 7-4-11 5-15 17 17-20 20 11-13 9 15

파이썬 2, 122 바이트

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