Meydan açıklaması

Olumlu bir tamsayı alalım , bu iki sayının farkının mutlak değerini nalmak rev(n)ve elde etmek için rakamlarını tersine çevirelim: |n - rev(n)|(veya abs(n - rev(n))).

Örnek:

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

Bu işlemi yeterince defalarca tekrarladıktan sonra çoğu sayı olacak 0(böylece döngüyü sonlandıracak) ...

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

... bazı rakamlar (gibi 1584) sonsuz bir döngüde sıkışıp kalsa da:

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

İşiniz, verilen bir tamsayı sonsuz bir döngüde sıkışıp kalmayacağını belirlemek.

Giriş açıklaması

Olumlu bir tamsayı.

Çıktı açıklaması

Bir truthy değeri ( True, 1) sayısı sonsuz bir döngüde saplandığında, bir falsy değeri ( False, 0) olarak belirtilmiştir.

notlar

• Sondaki sıfırlar kullanılmamalıdır. yani rev(5020) = 205.
• Bunun kod golf olduğunu unutmayın, bu yüzden kodunuzu mümkün olduğunca kısa tutun!
• İlgili dizi: A072140

Pyth, 5 bayt

FryAmTheEggman sayesinde 4 bayt

uas_`

Test odası.

Gerçek değer, döngüdeki sayılardan biridir.

Falsey değeri 0.

açıklama

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

Mathematica, 39 37 bayt

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

Tersine / çıkarma dönüşüm nzamanlarını girişe uygular nve sonucun olup olmadığını kontrol eder 0. 10nBir döngüye ulaşmak için hiçbir zaman daha fazla adım alamaz , çünkü dönüşüm basamak sayısını artıramaz ve 10nrakamdan daha fazla basamak olmaz n. Bu sınırın nasıl azaltılacağı konusunda Dennis'in kanıtına bakın n.

Jöle , 6 5 bayt

ṚḌạµ¡

Çevrimiçi deneyin!

Arka fon

Bu kullanımlar MartinEnder @ üst kaçınılmazdır ait 10n tekrarlamalar ve aşağıdaki gözlemler.

1. Orada 9 × 10 ^{1 - k} pozitif tamsayılar n ile k basamak.

2. Bir sayının ve tersinin farkı daima 9'un katıdır , bu nedenle ilk yinelemeden sonra yalnızca 10 ^{k - 1} tanesi oluşabilir.

3. Katların 1 / 10'dan fazlası bir sonraki yinelemede bir basamağı kaybedecektir (başlangıçlar için, aynı basamaklarla başlayıp bitenler ve ilk basamak ne 1 ya da 9 değilse, kabaca iki katı ) bir döngüye girmesi veya bir basamağı kaybetmesi en çok 9 × 10 ^{k - 2} sürer .

4. Aynı mantığı, sonuçta elde edilen k - 1 hane tamsayılarına uygulayarak, bir döngüye girmek için en fazla 9 × 10 ^{k - 2} + 9 × 10 ^{k - 2} +… ≤ 10 ^{k - 1} ten yineleme alır. 0'a ulaş .

Nasıl çalışır

ṚḌạµ¡  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 bayt

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;

Un-golfed

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 karakter

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

Sol argümanı, daha önce gördüğümüz değerlerin akümülatörü olarak kullanıyoruz. Bunu iki sonlandırma koşulundan biri olan "0" olarak başlatıyoruz. Koruma ⍵∊⍺:×⍵okunur: "daha önce gördüğümüz bir şey (ve sıfır dahil) doğru argüman mı? Eğer öyleyse, sayının işaretini döndür, bu 1 veya 0'dır". Aksi halde, şimdiki değeri soldaki argümana yönlendirdikten sonra çıkarmanın mutlak değeri ile kendimizi arayarak tekrarlanalım.

Martin Ender'in Mathematica çözümünün tekrarı 21 karakterde gerçekleşecek :

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

Okur: "İstenen 10n kez uyguladıktan sonra sonucun işareti nedir?"

Python 2,50 bayt

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

İdeone üzerinde test et .

Arka fon

Bu kullanımlar MartinEnder @ üst kaçınılmazdır ait 10n tekrarlamalar ve aşağıdaki gözlemler.

1. Orada 9 × 10 ^{1 - k} pozitif tamsayılar n ile k basamak.

2. Bir sayının ve tersinin farkı daima 9'un katıdır , bu nedenle ilk yinelemeden sonra yalnızca 10 ^{k - 1} tanesi oluşabilir.

3. Katların 1 / 10'dan fazlası bir sonraki yinelemede bir basamağı kaybedecektir (başlangıçlar için, aynı basamaklarla başlayıp bitenler ve ilk basamak ne 1 ya da 9 değilse, kabaca iki katı ) bir döngüye girmesi veya bir basamağı kaybetmesi en çok 9 × 10 ^{k - 2} sürer .

4. Aynı mantığı, sonuçta elde edilen k - 1 hane tamsayılarına uygulayarak, bir döngüye girmek için en fazla 9 × 10 ^{k - 2} + 9 × 10 ^{k - 2} +… ≤ 10 ^{k - 1} ten yineleme alır. 0'a ulaş .

CJam, 15 13 bayt

ri_{_sW%i-z}*

Burada test et.

Mathematica cevabımla aynı.

Python, 129 120 96 bayt

Bir istisna yakalanırsa (normalde bu işlevle atılabilecek tek istisna, sonsuz özyineleme nedeniyle bir RuntimeError'dır), 1 yazdırabilirsiniz. Aksi takdirde, sonucu yazdırın, 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
teşekkürler @shooqie için teşekkürler

Python, 101 98 bayt

Kaplumbağa ve tavşan algoritması.

Truthy döngüdeki herhangi bir değerdir, falsey 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

Ideone!

Python 2, 85 84 83 bayt

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

Başka bir Python cevabı. Her yineleme için bir listeye n ekler ve listede zaten n varsa, çıktılar False. Aksi takdirde, 0'a kadar çalışır.

Bir bayt için @NonlinearFruit teşekkürler.

05AB1E, 11 8 6 bayt

DFÂï-Ä

Açıklaması

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

Gerçek değeri, döngüden bir sayıdır.
Sahte değer 0'dır.

Çevrimiçi deneyin

Dennis'in Jelly cevabında açıklanan üst sınırı kullanır.

@Adnan sayesinde 2 bayt kaydedildi

Gelen sürümü 7.9 @Adnan tarafından belirtildiği gibi 05AB1E 5 bayt çözümleri çalışmalarını takip

DFÂ-Ä

Java 7, 161 bayt

Bu bir içe aktarma gerektiriyor ancak bir işlev olarak yazdım. Bu senaryoda tam bir program tercih edilirse yorumlarda bana bağır. Sonsuz bir döngü varsa 1, değer 0 ise 0 çıktı.

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 bayt

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

trueSonsuz döngüler ve falsebaşka türlü döndürür .

Bu Martin Ender'in algoritmasının utanmaz bir uyarlaması.

Önceki cevap, 32 bayt

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

Önceki cevabın açıklaması

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 bayt

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

Girdiyi alır $n, başlangıç ​​koşulu olarak sonsuz bir fordöngü başlatır $a=,0(bu $a, bir eleman dizisine ayarlamak için virgül operatörünü kullanır 0). Bu $abizim önceden görülmüş değerler dizimizdir.

Her döngü yineleme bir kontrol edin if. Koşul ilk önce $nstring reversing ve [math]::Abs.NET çağrısını kullanmanın bir sonraki değerini ayarlar ve bu değerin önceden olup olmadığını kontrol eder -in $a. Eğer öyleyse, biz çıktı $nve exit. Aksi takdirde, bu değeri diziye ekler ve döngüye devam ederiz.

Çıkışlar 0(PowerShell Falsey olan) ve döngü (sıfır olmayan tamsayılardır truthy olan) olarak karşılaşıldı değerini verir sonsuz bir döngü gitmez giriş değerleri için. Örneğin, giriş 2178için çıkışlar 1584.

Haskell, 65 bayt

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

0False ve 1True için döndürür . Kullanım örneği: ([]#) 1584-> 1.

Belirgin yaklaşım: şu ana kadar görülen tüm sonuçların bir listesini tutun. Bir sonraki sayıyı 0listeye gelinceye kadar hesaplayın .

JavaScript (ES6), 75 bayt

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

n<0?n=-n:nve n*=n>0||-1ayrıca iş. Algoritma, biraz özyinelemeli bir formülasyon olmasına rağmen, PowerShell cevabını biraz andırıyor.

Ruby, 57 bayt

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

Başlangıçta boş olan dizi hönceden isabet değerleri izler. Önceki bir değere ulaşana kadar sayıyı yineleriz, sonra son yinelemedeki değeri kontrol ederiz. 0, 1'lik bir döngü olduğundan, yalnızca büyük bir döngü yoksa, 0 olur. Bunu bir Boole'ye dönüştürmek için fazladan 2 bayt alıyorum, çünkü Ruby'de 0 truthy.

Perl 6  58 53 33  30 bayt

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

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

Açıklama:

{ # 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
  )[ $_ ]
}

(bu dönüşümü yalnızca çoğu nzaman yapmanız gereken önceki gözlemlere dayanır )

Perl 5, 31 29 bayt

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

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

n=|n-rev(n)|N kez yinelenir , bu nedenle herhangi bir döngü yoksa çıkış 0, aksi halde> 0 olur. Dennis bunun yeterli olduğunu kanıtladı.

Yeni sürüm döngü yerine operatörü kullanır evalve xtekrarlar for.

Matlab, 89 84 bayt

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

Basit yaklaşım - tüm sayıları istifler ve daha önce bir sayının görünüp görünmediğini kontrol eder.

açıklama

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)