도전 설명

양의 정수를 취하고 n숫자를 뒤집어 rev(n)두 숫자의 차이의 절대 값을 구합니다 : |n - rev(n)|(또는 abs(n - rev(n))).

예:

n = 5067 
rev(n) = 7605
|n - rev(n)| = |5067 - 7605| = |-2538| = 2538

이 작업을 충분히 여러 번 반복하면 대부분의 숫자가됩니다 0(따라서 루프 종료).

5067 -> 2538 -> 5814 -> 1629 -> 7632 -> 5265 -> 360 -> 297 -> 495 -> 99 -> 0

...와 같은 일부 숫자 1584는 무한 루프에 빠지지만 :

1584 -> 3267 -> 4356 -> 2178 -> 6534 -> 2178 -> 6534 -> 2178 -> 6534 -> ...
                        ^ infinite loop starts here

당신의 임무는 주어진 정수가 무한 루프에 걸리는지를 결정하는 것입니다.

입력 설명

양의 정수

출력 설명

truthy 값 ( True, 1) 수는 무한 루프에 찍히는 경우 falsy 값 ( False, 0) 그렇지.

노트

• 후행 0은 생략해야합니다. 즉 rev(5020) = 205.
• 이것은 code-golf 이므로 코드를 가능한 짧게 만드십시오!
• 관련 순서 : A072140

Pyth, 5 바이트

FryAmTheEggman 덕분에 4 바이트

uas_`

테스트 스위트.

진실한 가치는 루프의 숫자 중 하나입니다.

잘못된 값은 0입니다.

설명

uas_`      Input:Q
uas_`GGQ   Implicit filling of variables.

u      Q   Set G as Q: do this repeatedly until result seen before: Set G as
 a             the absolute difference of
     G             G
    `              convert to string
   _               reverse
  s                convert to integer
      G        and G

매스 매 티카, 39 37 바이트

Nest[Abs[#-IntegerReverse@#]&,#,#]<1&

반전 / 빼기 변환 n시간을 입력에 적용한 n다음 결과가되는지 확인하면됩니다 0. 10n변환은 자릿수를 늘릴 수없고 자릿수가 더 적은 10n자릿수보다 작 으므로 루프에 도달하는 단계 이상을 수행 할 수 없습니다 n. 이 한계를로 줄이는 방법에 대한 Dennis의 증거를 참조하십시오 n.

젤리 , 6 5 바이트

ṚḌạµ¡

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

배경

이 사용 MartinEnder @이 상한 것 으로 10N의 반복과 같은 관찰.

1. 있다 9 × 10 ^{일 - K} 양의 정수 N 과 K의 자리.

2. 숫자 및 역방향 차이는 항상의 배수 9 때문에 단지 10 ^{1 - K} 그 중 첫 번째 반복 후에 발생할 수있다.

3. 배수 중 1/10 이상 은 다음 반복에서 숫자를 잃게됩니다 (첫 번째 숫자는 같은 숫자로 시작하고 끝나는 모든 숫자, 첫 번째 숫자가 1 도 아니고 9 도 아닌 경우 대략 두 배 ) 루프를 입력하거나 숫자를 잃는 데 최대 9 × 10 ^k-2 가 걸립니다 .

4. 결과 추론 결과 정수 k-1 등에 동일한 추론을 적용하면 루프에 들어가기 위해 최대 9 × 10 ^k-2 + 9 × 10 ^k-2 +… ≤ 10 ^k-1 ≤ n 반복 이 걸리 거나 0에 도달하십시오 .

작동 원리

ṚḌạµ¡  Main link. Argument: n

   µ¡  Iteratively apply the chain to the left n times.
Ṛ      Reverse n (casts to digits).
 Ḍ     Undecimal; convert from base 10 to integer.
  ạ    Take the absolute difference of the result and the argument.

Oracle SQL 11.2, 136 바이트

WITH v(n)AS(SELECT :1 FROM DUAL UNION ALL SELECT ABS(n-REVERSE(n||''))FROM v WHERE n>0)CYCLE n SET c TO 0 DEFAULT 1 SELECT MIN(c)FROM v;

언 골프

WITH v(n) AS
(
  SELECT :1 FROM DUAL
  UNION ALL
  SELECT ABS(n-REVERSE(n||''))FROM v WHERE n>0 
) CYCLE n SET c TO 0 DEFAULT 1
SELECT MIN(c)FROM v

APL, 26 자

0∘{⍵∊⍺:×⍵⋄(⍺,⍵)∇|⍵-⍎⌽⍕⍵}

왼쪽 인수를 이미 본 값의 누산기로 사용합니다. 두 가지 종료 조건 중 하나 인 "0"으로 초기화합니다. 경비원 ⍵∊⍺:×⍵은 다음과 같이 읽습니다. "우리가 이미 봤던 (그리고 0을 포함하는) 올바른 주장입니까? 그렇다면 숫자의 부호를 반환하면 1 또는 0입니다." 그렇지 않으면 현재 값을 왼쪽 인수로 범주화 한 후 빼기의 절대 값으로 자신을 호출하여 재귀합시다.

Martin Ender의 Mathematica 솔루션의 개편은 21 자 정도입니다 .

 {×{|⍵-⍎⌽⍕⍵}⍣(10×⍵)⊣⍵}

"원하는 10n 회 적용 후 결과의 부호는 무엇입니까?"라고 읽습니다.

파이썬 2, 50 바이트

n=input()
exec'n=abs(n-int(`n`[::-1]));'*n
print n

Ideone에서 테스트하십시오 .

배경

이 사용 MartinEnder @이 상한 것 으로 10N의 반복과 같은 관찰.

1. 있다 9 × 10 ^{일 - K} 양의 정수 N 과 K의 자리.

2. 숫자 및 역방향 차이는 항상의 배수 9 때문에 단지 10 ^{1 - K} 그 중 첫 번째 반복 후에 발생할 수있다.

3. 배수 중 1/10 이상 은 다음 반복에서 숫자를 잃게됩니다 (첫 번째 숫자는 같은 숫자로 시작하고 끝나는 모든 숫자, 첫 번째 숫자가 1 도 아니고 9 도 아닌 경우 대략 두 배 ) 루프를 입력하거나 숫자를 잃는 데 최대 9 × 10 ^k-2 가 걸립니다 .

4. 결과 추론 결과 정수 k-1 등에 동일한 추론을 적용하면 루프에 들어가기 위해 최대 9 × 10 ^k-2 + 9 × 10 ^k-2 +… ≤ 10 ^k-1 ≤ n 반복 이 걸리 거나 0에 도달하십시오 .

CJam, 15 13 바이트

ri_{_sW%i-z}*

여기에서 테스트하십시오.

내 Mathematica 답변과 동일합니다.

파이썬, 129 (120) 96 바이트

예외가 발생하면 (일반적으로이 함수로 발생 가능한 유일한 예외는 무한 재귀로 인해 RuntimeError입니다), 1을 인쇄하십시오. 그렇지 않으면 결과를 0으로 인쇄하십시오.

def r(n):a=abs(n-int(str(n)[::-1]));return a and r(a)
try:print(r(int(input())))
except:print(1)

@LeakyNun
에게 감사합니다 @shooqie 에게 감사합니다

파이썬, 101 98 바이트

거북이와 토끼 알고리즘.

Truthy는 루프의 값이며 false는 0입니다.

g=lambda n:abs(n-int(str(n)[::-1]))
def r(n):
    t=g(n);h=g(t)
    while t-h:h=g(g(h));t=g(t)
    return h

무시 했어!

파이썬 2, 85 84 83 바이트

L=[]
def f(n,L=L):
    if n<1or n in L:print n<1
    else:L+=[n];f(abs(n-int(`n`[::-1])))

또 다른 파이썬 답변. 반복 할 때마다 n을 목록에 추가하고 n이 이미 목록에 있으면를 출력 False합니다. 그렇지 않으면 0으로 작동합니다.

1 바이트에 대해 @NonlinearFruit에게 감사드립니다.

05AB1E, 11 8 6 바이트

DFÂï-Ä

설명

DF          # input number of times do
  Â         # push current number and its reverse
   ï-       # convert reverse to int and subtract
     Ä      # absolute value
            # implicitly print after loop ends

Truthy 값은 루프의 숫자입니다.
거짓 값은 0입니다.

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

에 설명 된 상한을 사용합니다 Dennis 'Jelly 답변에

@Adnan 덕분에 2 바이트 절약

05AB1E 버전 7.9 에서는 다음 5 바이트 솔루션이 @Adnan에서 언급 한대로 작동합니다.

DFÂ-Ä

자바 7, 161 바이트

가져 오기가 필요하지만 함수로 작성했습니다. 이 시나리오에서 전체 프로그램이 선호된다면 의견을 말하십시오. 무한 루프가 있으면 1을, 값이 0에 도달하면 0을 출력합니다.

import java.util.*;int z(int a){int o,r,c=a;Set s=new HashSet();while(c!=0){for(r=0,o=c;o!=0;r=r*10+o%10,o/=10);c=Math.abs(c-r);if(!s.add(c))return 1;}return 0;}

Brachylog , 49 32 23 바이트

:10*N,?:N:{r:?-+.}itT'0

반환 true무한 루프 및 false그렇지.

이것은 Martin Ender의 알고리즘을 수치스럽게 적용한 것입니다.

이전 답변, 32 바이트

g{tTr:T-+U(0!\;?:ImU;?:[U]c:1&)}

이전 답변에 대한 설명

g{                             } Call predicate with [Input] as input
  tT                             T is the last element of Input
    r:T-                         Subtract T from the reverse of T
        +U                       U is the absolute value of T
          (0!\                   If U is 0, return false
              ;                  Or
               ?:ImU             If U is in Input, return true
                    ;            Or
                     ?:[U]c:1&)  Recursive call with U concatenated to the Input

PowerShell v2 +, 94 바이트

param($n)for($a=,0;){if(($n=[math]::Abs($n-(-join"$n"["$n".length..0])))-in$a){$n;exit}$a+=$n}

input을 취하고 초기 조건으로 $n무한 for루프를 시작합니다 $a=,0(쉼표 연산자를 사용하여 $a한 요소의 배열 로 설정 0). 이$a 이미 본 값들의 배열입니다.

우리는 각 루프 반복을 검사합니다 if. 조건은 먼저 $n문자열 역전 및 [math]::Abs.NET 호출 사용 의 다음 값을 설정하고 해당 값이 이미 있는지 확인합니다 -in $a. 그렇다면, 우리의 출력 $n과 exit. 그렇지 않으면 해당 값을 배열에 추가하고 루프를 계속합니다.

출력 0(PowerShell에서 falsey이다) 및 루프 (비 - 제로 truthy 정수이다), 그렇지 않으면 검출 된 값을 출력은 무한 루프 가지 않는 입력 값. 예를 들어, 2178입력 출력1584 .

하스켈, 65 바이트

_#0=0
a#n|elem n a=1|1<2=(n:a)#abs(n-(read$reverse$show n))
([]#)

0False에 대한 반품 및1 True를 . 사용 예 : ([]#) 1584-> 1.

확실한 접근 방법 : 지금까지 본 모든 결과가있는 목록을 유지하십시오. 다음 숫자 0가 목록에 올 때까지 계산하십시오 .

자바 스크립트 (ES6), 75 바이트

f=(n,...a)=>a.includes(n=n<0?-n:n)?n:f([...n+``].reverse().join``-n,n,...a)

n<0?n=-n:n와 n*=n>0||-1도 작동합니다. 알고리즘은 재귀 공식이지만 PowerShell 답변과 다소 유사합니다.

루비, 57 바이트

->n,*h{h[n]=n=(n-"#{n}".reverse.to_i).abs until h[n];n>0}

초기에 비어있는 배열 h은 이전에 적중 된 값을 추적합니다. 이전 값에 도달 할 때까지 숫자를 반복 한 다음 마지막 반복에서 값을 확인합니다. 0은 1의주기이므로 더 큰주기가없는 경우에만 0이됩니다. Ruby에서 0은 진실이기 때문에 이것을 2 부울로 변환하여 부울로 변환합니다.

Perl 6  58 53 33  30 바이트

sub {$/=%;$^a,{return ?1 if $/{$_}++;abs $_-.flip}...0;?0}
{$/=%;?($_,{last if $/{$_}++;abs $_-.flip}...0)[*-1]}
{?($_,{abs $_-.flip}...0)[10**$_]}

{?($_,{abs $_-.flip}...0)[$_]}

설명:

{ # block lambda with implicit parameter $_

  # coerce the following to Bool
  # ( False for Nil or 0, True otherwise )
  ?

  (

    $_, # start a sequence with the input

    # block lambda with implicit parameter $_
    # subtracts the previous value in the sequence and its reverse
    # ( .flip is short for $_.flip where a term is expected )
    { abs $_ - .flip } 

    ... # repeat that lambda
    0   # until you get 0

  # get the element indexed with the block's input
  # may be 0, Nil, or a number that is part of a repeating sequence
  )[ $_ ]
}

(이 변환은 대부분의 경우에만 수행하면된다는 이전의 관찰에 의존합니다 n)

펄 5, 31 29 바이트

perl -pe'for$x(1..$_){$_=abs$_-reverse}'

perl -pe'eval"\$_=abs\$_-reverse;"x$_'

n=|n-rev(n)|n 번 반복 되므로 루프가 없으면 출력은 0이고 그렇지 않으면> 0입니다. 데니스는 이미 이것으로 충분하다는 것을 증명했습니다.

새 버전은 루프 대신 연산자를 사용 eval하고 x반복 for합니다.

Matlab, 89 84 바이트

n=input('');z=n;while n
z=abs(z-str2num(fliplr(num2str(z))));n=[n z]*all(n~=z);end
z

간단한 접근 방식-모든 숫자를 누적하고 숫자가 이전에 나타 났는지 확인합니다.

설명

n=input('');z=n;  -- take input, initiate z
while n           -- n is said to be positive
z=abs(z-str2num(fliplr(num2str(z)))) -- calculate the "reverse and substract"
n=[n z]           -- put the value at the end of the vector
       *all(n~=z) -- make the n all zeroes if z is previously in the vector (break the loop)
end
z                 -- print z (0 when not entered loop, >0 otherwise)