Herausforderungsbeschreibung

Nehmen wir eine positive ganze Zahl n, kehren Sie ihre Ziffern um, rev(n)um den absoluten Wert der Differenz dieser beiden Zahlen zu erhalten: |n - rev(n)|(oder abs(n - rev(n))).

Beispiel:

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

Nachdem Sie diesen Vorgang ausreichend oft wiederholt haben, werden die meisten Zahlen 0(wodurch die Schleife beendet wird) ...

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

... obwohl einige Zahlen (wie 1584) in einer Endlosschleife hängen bleiben:

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

Sie müssen feststellen, ob eine bestimmte Ganzzahl in einer Endlosschleife hängen bleibt.

Eingabebeschreibung

Eine positive ganze Zahl.

Ausgabebeschreibung

Ein wahrer Wert ( True, 1), wenn die Zahl in einer Endlosschleife stecken bleibt, ein falscher Wert ( False, 0), ansonsten.

Anmerkungen

• Nachgestellte Nullen sollten weggelassen werden. dh rev(5020) = 205.
• Denken Sie daran, dass dies Code-Golf ist , also machen Sie Ihren Code so kurz wie möglich!
• Relevante Reihenfolge: A072140

Pyth, 5 Bytes

4 Bytes dank FryAmTheEggman

uas_`

Testsuite.

Der Wahrheitswert ist eine der Zahlen in der Schleife.

Der falsche Wert ist 0.

Erläuterung

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 Bytes

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

Wendet einfach die Umkehr- / Subtraktionszeiten nauf den Eingang an nund prüft dann, ob das Ergebnis ist 0. Es kann nie mehr als 10nSchritte dauern , um eine Schleife zu erreichen, da die Transformation die Anzahl der Stellen nicht erhöhen kann und es weniger als 10nZahlen gibt, die nicht mehr Stellen haben als n. Sehen Sie sich Dennis 'Beweis an, wie Sie diese Grenze reduzieren können n.

Gelee , 6 5 Bytes

ṚḌạµ¡

Probieren Sie es online!

Hintergrund

Dies verwendet die obere Schranke von @ MartinEnder mit 10n Iterationen und die folgenden Beobachtungen.

1. Es gibt 9 × 10 ^{k - 1} positive ganze Zahlen n mit k Ziffern.

2. Die Differenz einer Zahl und ihrer Umkehrung ist immer ein Vielfaches von 9 , so dass nach der ersten Iteration nur 10 ^{k - 1} von ihnen auftreten können.

3. Von den Vielfachen mehr als 1/10 wird eine Ziffer in der nächsten Iteration (für den Anfang, alles , was und Ende mit den gleichen Ziffern beginnen, und doppelt so viele grob , wenn die erste Ziffer ist weder verlieren 1 noch ein 9 ), so Es dauert höchstens 9 × 10 ^{k - 2} , um eine Schleife zu betreten oder eine Ziffer zu verlieren.

4. Unter Anwendung der gleichen Überlegung auf die resultierende Ganzzahl von k - 1 Ziffern usw. dauert es höchstens 9 × 10 ^{k - 2} + 9 × 10 ^{k - 2} +… ≤ 10 ^{k - 1} ≤ n Iterationen erforderlich, um eine Schleife oder einzufügen 0 erreichen.

Wie es funktioniert

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

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;

Nicht golfen

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 Zeichen

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

Wir verwenden das linke Argument als Akkumulator der Werte, die wir bereits gesehen haben. Wir initialisieren es auf "0", was eine der beiden Beendigungsbedingungen ist. Die Wache ⍵∊⍺:×⍵lautet: "Ist das richtige Argument etwas, das wir bereits gesehen haben (und das beinhaltet Null)? Wenn ja, geben Sie das Vorzeichen der Zahl zurück, das ist 1 oder 0". Andernfalls rufen wir uns erneut mit dem absoluten Wert der Subtraktion auf, nachdem wir den aktuellen Wert mit dem linken Argument verknüpft haben.

Eine Neufassung der Mathematica-Lösung von Martin Ender würde mit 21 Zeichen aufwarten :

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

Es lautet: "Was ist das Zeichen des Ergebnisses nach dem Anwenden der gewünschten 10n-mal"?

Python 2, 50 Bytes

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

Teste es auf Ideone .

Hintergrund

Dies verwendet die obere Schranke von @ MartinEnder mit 10n Iterationen und die folgenden Beobachtungen.

1. Es gibt 9 × 10 ^{k - 1} positive ganze Zahlen n mit k Ziffern.

2. Die Differenz einer Zahl und ihrer Umkehrung ist immer ein Vielfaches von 9 , so dass nach der ersten Iteration nur 10 ^{k - 1} von ihnen auftreten können.

3. Von dem Multiples, mehr als ein Zehntel wird eine Ziffer in der nächsten Iteration (für den Anfang, alles , was und Ende mit den gleichen Ziffern beginnen, und doppelt so viele grob , wenn die erste Ziffer ist weder verlieren 1 noch ein 9 ), so Es dauert höchstens 9 × 10 ^{k - 2} , um eine Schleife zu betreten oder eine Ziffer zu verlieren.

4. Unter Anwendung der gleichen Überlegung auf die resultierende ganze Zahl von k - 1 Ziffern usw. sind höchstens 9 × 10 ^{k - 2} + 9 × 10 ^{k - 2} +… ≤ 10 ^{k - 1} ≤ n Iterationen erforderlich, um eine Schleife oder einzufügen 0 erreichen .

CJam, 15 13 Bytes

ri_{_sW%i-z}*

Teste es hier.

Gleich wie meine Mathematica-Antwort.

Python, 129 120 96 Bytes

Wenn eine Ausnahme abgefangen wird (normalerweise ist RuntimeError aufgrund der unendlichen Rekursion die einzige Ausnahme, die mit dieser Funktion ausgelöst werden kann), wird 1 ausgegeben. Andernfalls wird das Ergebnis 0 ausgegeben.

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

Vielen
Dank an @LeakyNun Vielen Dank an @shooqie

Python, 101 98 Bytes

Schildkröten- und Hasenalgorithmus.

Wahrheit ist jeder Wert in der Schleife, Falsch ist 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 es!

Python 2, 85 84 83 Bytes

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

Eine weitere Antwort von Python. Es fügt n für jede Iteration zu einer Liste hinzu, und wenn n bereits in der Liste enthalten ist, wird es ausgegebenFalse . Ansonsten funktioniert es bis auf 0.

Vielen Dank an @NonlinearFruit für ein Byte.

05AB1E, 11 8 6 Bytes

DFÂï-Ä

Erklärt

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

Der Wahrheitswert ist eine Zahl aus der Schleife.
Falscher Wert ist 0.

Probieren Sie es online aus

Verwendet die in Dennis 'Gelee-Antwort erklärt wurde

2 Bytes dank @Adnan gespart

In Version 7.9 von 05AB1E funktionieren die folgenden 5-Byte-Lösungen wie von @Adnan angegeben

DFÂ-Ä

Java 7, 161 Bytes

Dies erfordert einen Import, aber ich habe es als Funktion geschrieben. Schreien Sie mich in den Kommentaren an, wenn in diesem Szenario ein vollständiges Programm bevorzugt wird. Gibt 1 aus, wenn es eine Endlosschleife gibt, und 0, wenn der Wert 0 wird.

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 Bytes

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

Gibt truefür Endlosschleifen und zurückfalse sonstiges zurück.

Dies ist eine schamlose Anpassung von Martin Enders Algorithmus.

Vorherige Antwort 32 Bytes

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

Erläuterung der vorherigen Antwort

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 Byte

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

Übernimmt die Eingabe $nund startet eine forEndlosschleife mit $a=,0der Anfangsbedingung (dies verwendet den Komma-Operator, um $aein Array eines Elements festzulegen 0). Dies $aist unser Array von bereits gesehenen Werten.

Bei jeder Schleifeniteration prüfen wir eine if. Die Bedingung legt zunächst den nächsten Wert für die $nVerwendung der Zeichenfolgenumkehr und des [math]::Abs.NET-Aufrufs fest und überprüft, ob dieser Wert bereits vorhanden ist -in $a. Wenn ja, geben wir $nund ausexit . Andernfalls fügen wir diesen Wert zum Array hinzu und setzen die Schleife fort.

Ausgaben 0für Eingabewerte, bei denen keine Endlosschleife verwendet wird (was in PowerShell falsch ist), und Ausgaben für den Wert, bei dem die Schleife ansonsten angetroffen wurde (Ganzzahlen ungleich Null sind wahr). Zum Beispiel Ausgänge 2178für die Eingabe 1584.

Haskell, 65 Bytes

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

Gibt 0für False und 1für True zurück. Anwendungsbeispiel: ([]#) 1584->1 .

Der naheliegende Ansatz: Führen Sie eine Liste mit allen bisher gesehenen Ergebnissen. Berechnen Sie die nächste Zahl bis 0oder in der Liste.

JavaScript (ES6), 75 Byte

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

n<0?n=-n:nund n*=n>0||-1auch arbeiten. Der Algorithmus ähnelt etwas der PowerShell-Antwort, obwohl dies eine rekursive Formulierung ist.

Ruby, 57 Bytes

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

Das anfangs leere Array hverfolgt zuvor getroffene Werte. Wir iterieren die Zahl, bis wir einen vorherigen Wert erreicht haben, und überprüfen dann den Wert bei der letzten Iteration. Da 0 ein Zyklus von 1 ist, ist es nur dann 0, wenn es keinen größeren Zyklus gibt. Ich benötige zusätzliche 2 Bytes, um dies in einen Booleschen Wert umzuwandeln, da 0 in Ruby wahr ist.

Perl 6  58 53 33  30 Bytes

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

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

Erläuterung:

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

(stützt sich auf die vorherige Beobachtung, dass Sie diese Transformation höchstens neinmal durchführen müssen)

Perl 5, 31 29 Bytes

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

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

Es iteriert n=|n-rev(n)|n-mal, sodass die Ausgabe 0 ist, wenn keine Schleife vorhanden ist, andernfalls> 0. Dennis hat bereits bewiesen, dass das genug ist.

Neue Version verwendet evalund xWiederholungsoperator anstelle der forSchleife.

Matlab, 89 84 Bytes

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

Einfacher Ansatz - Stapelt alle Zahlen und prüft, ob zuvor eine Zahl aufgetaucht ist.

Erläuterung

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)