최근에 나는 답이없는 Diffy games에 관한 질문을 게시 했습니다 . 괜찮습니다. 질문은 정말 어렵지만 Diffy 게임에 대해 더 쉬운 질문을해서 볼을 굴릴 수있게하고 싶습니다.

Diffy의 작동 방식

Diffy 게임 찾기 에서 복사

Diffy 게임은 다음과 같이 작동합니다 : 음이 아닌 정수 목록으로 시작합니다.이 예에서는

3 4 5 8

그런 다음 인접한 숫자 사이의 절대 차이를 취합니다.

 (8)  3   4   5   8
    5   1   1   3

그런 다음 반복합니다. 루프가 시작될 때까지 반복합니다. 그리고 일반적으로 게임은 처음부터 다시 시작됩니다.

3 4 5 8
5 1 1 3
2 4 0 2
0 2 4 2
2 2 2 2
0 0 0 0
0 0 0 0

대부분의 게임은 잃어버린 상태로 간주되는 모든 0의 문자열로 끝나지 만 드문 게임은 더 큰 루프에 빠집니다.

태스크

Diffy 게임의 시작 상태가 주어지면 게임이 결국 0의 상태에 도달하는지 여부를 결정하십시오. 두 상태 각각에 대해 Truthy 또는 Falsy 값을 출력해야합니다. 어느 것이 중요하지 않습니다.

목표는 소스의 바이트 수를 최소화하는 것입니다.

Pyth, 6 바이트

suaV+e

테스트 스위트

이 프로그램은 매우 무섭습니다. 0 (거짓)은 모두 0을 의미하고 다른 것 (거짓)은 모두 0을 의미하지 않습니다.

작동 방식 :

suaV+e
suaV+eGGGQ    Variable introduction.
 u       Q    Apply the following function repeatedly to its previous result,
              starting with the input. Stop when a value occurs which has
              occurred before.
  aV          Take the absolute differences between elements at the same indices of
        G     The previous list and
    +eGG      The previous list with its last element prepended.
s             The repeated value is returned. Sum its entries. This is zero (falsy)
              if and only if the entries are all zero.

매스 매 티카, 52 바이트

1>Max@Nest[Abs[#-RotateLeft@#]&,#,Max[1+#]^Tr[1^#]]&

입력 및 반환 등의 음이 아닌 정수의 목록 복용 순수 기능 True또는 False.

Abs[#-RotateLeft@#]&diffy 게임의 한 라운드를 실행하는 기능입니다. (기술적으로이어야 RotateRight하지만 궁극적 인 대답은 영향을받지 않으며, 여유 바이트입니다.) 따라서 diffy 게임 라운드를 Nest[...,#,R]실행 R한 다음 1>Max@결과가 모두 0인지 여부 를 감지합니다.

얼마나 많은 diffy-game 라운드 R를 해야하는지 어떻게 알 수 있습니까? m입력에서 가장 큰 값 이면 m라운드 수에 관계없이 더 큰 정수를 생성 하지 않습니다. l음이 아닌 정수 길이 의 총 목록 수는 모두로 묶 m입니다 (m+1)^l. 그래서 (m+1)^l우리가 diffy 게임 라운드를 수행한다면 , 우리는 그때까지 두 번 목록을 보았으므로 게임의 주기적 부분에있을 것입니다. 특히 게임 (m+1)^l라운드 결과가 모두 0 인 경우에만 게임은 모두 0으로 끝납니다 . 그 표현은 Max[1+#]^Tr[1^#]계산하는 것입니다.

젤리 , 13 바이트

Ṁ‘*L
ṙ1ạ
ÇÑ¡Ṁ

모두 0 상태에 도달하면 0 (거짓)을 출력하고 그렇지 않으면 정확한 값 (양의 정수)을 반환합니다.

온라인으로 사용해보십시오!

배열 내 숫자가 도메인 [0, m]을 떠나지 않을 수 있다는 Greg Martin의 첫 번째 관찰을 사용합니다 . 여기서 m 은 입력의 최대 요소이므로 (m + 1) ^l 반올림을 수행합니다. 여기서 l 은 입력 길이입니다. 충분하다.

방법?

Ṁ‘*L - Link 1, number of rounds to perform: list a
Ṁ    - maximum of a
 ‘   - incremented
   L - length of a
  *  - exponentiate

ṙ1ạ - Link 2, perform a round: list x
ṙ1  - rotate x left by 1
  ạ - absolute difference (vectorises) with x

ÇÑ¡Ṁ - Main link: list a
  ¡  - repeat:
Ç    -     the last link (2) as a monad
 Ñ   -     the next link (1) as a monad times
   Ṁ - return the maximum of the resulting list

PHP, 144 바이트

모든 0에 대해 0을 인쇄하고 true에 대한 양의 정수 값

<?for($r[]=$_GET[0];!$t;){$e=end($r);$e[]=$e[$c=0];for($n=[];++$c<count($e);)$n[]=abs($e[$c-1]-$e[$c]);$t=in_array($n,$r);$r[]=$n;}echo max($n);

온라인 버전

넓히는

for($r[]=$_GET;!$t;){
    $e=end($r);  # copy last array
    $e[]=$e[$c=0]; # add the first item as last item
    for($n=[];++$c<count($e);)$n[]=abs($e[$c-1]-$e[$c]); # make new array
    $t=in_array($n,$r); # is new array in result array
    $r[]=$n; # add the new array
}
echo max($n); # Output max of last array

R (3.3.1), 87 바이트

0으로 끝나는 게임의 경우 0을, 그렇지 않으면 양수를 반환합니다.

z=scan();sum(Reduce(function(x,y)abs(diff(c(x,x[1]))),rep(list(z),max(z+1)^length(z))))

Greg Martin의 동일한 사실을 활용하고 내장 diff를 사용하여 diffy-ing을 수행합니다.

로다 , 80 바이트

f l...{x=[{peek a;[_];[a]}()|slide 2|abs _-_];[sum(x)=0]if[x in l]else{x|f*l+x}}

온라인으로 사용해보십시오!

언 골프 드 :

function f(l...) { /* function f, variadic arguments */
    x := [ /* x is a list of */
        { /* duplicate the first element of the stream to the last position */
            peek a /* read the first element of the stream */
            [_]    /* pull all values and push them */
            [a]    /* push a */
        }() |
        slide(2) | /* duplicate every element except first and last */
        abs(_-_)   /* calculate the difference of every pair */
    ]
    /* If we have already encountered x */
    if [ x in l ] do
        return sum(x) = 0 /* Check if x contains only zeroes */
    else
        x | f(*l+x) /* Call f again, with x appended to l */
    done
}

05AB1E , 13 바이트

반환 1 은 0과 1로 끝나는 경우 0 , 그렇지 않으면.

Z¹g*F¤¸ì¥Ä}_P

온라인으로 사용해보십시오!

설명

라운드의 상한을 사용합니다 : 주석 섹션에서 xnor 에 max(input)*len(input)의해 설명됩니다 .

Z              # get max(input)
 ¹g            # get length of input
   *           # multiply
    F          # that many times do:
     ¤         # get the last value of the current list (originally input)
      ¸        # wrap it
       ì       # prepend to the list
        ¥      # calculate deltas
         Ä     # calculate absolute values
          }    # end loop
           _   # negate each (turns 0 into 1 and everything else to 0)
            P  # calculate product

J, 22 바이트

모든 0으로 끝나는 퇴행성 게임에 대한 리턴 값 0( falseJ에 효과적으로 있음). n 번째 반복에 0이 아닌 숫자가 포함 된 경우 1( true)를 반환합니다 . 여기서 n은 원래 시퀀스에서 가장 큰 정수와 목록의 길이를 곱한 값과 같습니다. 이것이 사실 인 이유를 설명하는 Greg Martin의 답변을 참조하십시오 .

*>./|&(-1&|.)^:(#*>./)

번역:

• 사인은 무엇인가 *
• 가장 큰 가치 >./
• 다음을 여러 번 반복하면 ^:( )
• 리스트의 길이에리스트 에서 가장 큰 값을 #곱한 *값 >./:
  • 의 절대 가치 |&를 가지고
  • 목록 (- )과 의 차이점
  • 1 씩 회전 한 목록 1&|.

예 :

   *>./|&(-1&|.)^:(#*>./) 1 1 0
1
   *>./|&(-1&|.)^:(#*>./) 42 42 41
1
   *>./|&(-1&|.)^:(#*>./) 3 4 5 8
0
   *>./|&(-1&|.)^:(#*>./) 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 1
0

자바 스크립트 (ES6), 95 92 90 바이트

f=(a,b=(Math.max(...a)+1)**(c=a.length))=>b?f(a.map((v,i)=>v-a[++i%c]),b-1):a.every(v=>!v)

설명

카운터 (목록의 최대 값에 1을 더한 목록 [ = (max + 1)**length] 의 1의 배수로 시작 함 )가 0이 아닌 한 자체 호출하는 재귀 함수입니다 . 모든 호출에서 카운터가 감소하고 0에 도달하면 목록의 모든 요소가 0과 비교하여 검사됩니다. 모두 0과 같으면 프로그램에서을 반환 true하고 false그렇지 않으면을 반환합니다 .

PHP, 123 115

for($a=$_GET,$b=[];!in_array($a,$b);){$b[]=$c=$a;$c[]=$c[0];foreach($a as$d=>&$e)$e=abs($e-$c[$d+1]);}echo!max($a);

HTTP get을 통해 입력을 받으면 ?3&4&5&8몇 바이트를 절약 할 수 있습니다.

모두 0에 도달하거나 그렇지 않으면 1을 인쇄합니다.

for($e=$argv,$r=[];!in_array($e,$r);$q=$e[0]){$e[0]=end($e);$r[]=$e;foreach($e as$k=>&$q)$q=abs($q-$e[$k+1]);}echo!max($e);

명령 행을 통해 인수 목록을 가져옵니다. 나는 이것이 @Titus를보고 더 골프를 칠 수 있다는 느낌을 얻었습니다.

파이썬 3.6, 101 바이트

def f(t):
 x={}
 while x.get(t,1):x[t]=0;t=(*(abs(a-b)for a,b in zip(t,t[1:]+t[:1])),)
 return any(t)

숫자의 튜플을 가져 와서 0으로 끝나는 경우 False를 반환하고 반복되면 True를 반환합니다.

자바 스크립트 (ES6), 84 83 바이트

그렇지 않으면 true0으로 끝나는 게임을 반환 합니다 false.

f=(a,k=a)=>k[b=a.map((n,i)=>Math.abs(n-a[(i||a.length)-1]))]?!+b.join``:f(k[b]=b,k)

테스트

f=(a,k=a)=>k[b=a.map((n,i)=>Math.abs(n-a[(i||a.length)-1]))]?!+b.join``:f(k[b]=b,k)

console.log(f([3,4,5,8])); // ends in zeros
console.log(f([1,0,1]));   // does not end in zeros
console.log(f([7]));       // ends in zeros