Umkehren und subtrahieren

22

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 , also machen Sie Ihren Code so kurz wie möglich!
  • Relevante Reihenfolge: A072140
shooqie
quelle
Ein interessanter Hinweis: Es ist möglich, eine beliebig lange Ganzzahl mit einer Schleifenperiode von 2 zu konstruieren, wie in den Kommentaren zu A072141 beschrieben . Die Methode ist auch für andere Zeiträume wie 12, 14, 17 und 22
identisch

Antworten:

18

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
Undichte Nonne
quelle
Gute Verwendung der Auto-Fill-Variablen!
FryAmTheEggman
1
* Missbrauch - - - - -
Undichte Nonne
Wie funktioniert das für jemanden, der Pyth nicht kennt?
Fatalize
3
wie ist pyth so kurz und doch noch im ASCII-bereich ._.
Downgoat
3
@ Downgoat Weil es Pyth ist.
Undichte Nonne
11

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.

Martin Ender
quelle
10

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.
Dennis
quelle
11
Hat Pyth Jelly geschlagen?
Undichte Nonne
3
Nun, es ist ein Unentschieden.
Dennis
Das sind keine Bytes.
Mik
1
@mik Bitte klicken Sie auf den Byte- Link in der Kopfzeile.
Dennis
5

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
Jeto
quelle
5

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"?

lstefano
quelle
4

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 .

Dennis
quelle
4

CJam, 15 13 Bytes

ri_{_sW%i-z}*

Teste es hier.

Gleich wie meine Mathematica-Antwort.

Martin Ender
quelle
3

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

TuxCrafting
quelle
Das ist offiziell ein (netter) Missbrauch von unendlicher Rekursion.
Undichte Nonne
return a and rev(a)
Undichte Nonne
3
Ist es nicht möglich, einen RuntimeError zu erhalten, weil die Rekursion sehr lang ist, ohne dass sie notwendigerweise unendlich ist?
Fatalize
a=[n-x,x-n][n>x]
Undichte Nonne
Sie können es drastisch verkürzen: def rev(n):a=abs(n-int(str(n)[::-1]));return a and rev(a). rrev
Nennen Sie
3

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!

Undichte Nonne
quelle
3

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.

Atlasologe
quelle
1
Ich glaube, print n<1funktioniert (da nist immer nicht negativ) und es speichert ein Byte
NonlinearFruit
def f(n,L=[]):¶ if n<1or n in L:print n<1¶ else:f(abs(n-int(`n`[::-1])),L+[n])spart 5 Bytes
Leaky Nun
3

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Â-Ä
Emigna
quelle
Okay, das ist ein bisschen komisch Golf, aber DFÂ-Äfunktioniert in Version 7.9, aber nicht in der aktuellen Version. In der aktuellen Version müssen Sie es zuerst in ein int konvertieren (so DFÂï-Ä), aber Sie können Version 7.9 verwenden, um es zu 5 Bytes zu machen: p.
Adnan
@Adnan Ich kann nicht glauben, dass ich die Bifurkationsfunktion vergessen habe. Ich bleibe aber bei der aktuellen Version. Sie können die 7.9 als separate Antwort posten, wenn Sie möchten. Ansonsten werde ich es als Notiz setzen.
Emigna
Ich werde es wahrscheinlich nicht posten, da es nur 1 Byte von dieser Antwort entfernt ist: p.
Adnan
1

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;}
Sack
quelle
Beachten Sie, dass ich Importe und Funktionen bereits zuvor gesehen habe. Beispiel
Poke
Ist 1wahr?
Undichte Nonne
1
@LeakyNun 1 wird in Java nicht als wahr angesehen, aber die OP-Listen (True, 1) und (False, 0) gelten als akzeptable Ausgaben.
Poke
@LeakyNun Hat Java überhaupt ein Gefühl der Wahrheit oder der Falschheit?
Neil
@Neil Java hat das Gefühl, synergetische Möglichkeiten in vertikalen Marktkontexten zu nutzen - das war's
cat
1

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
Tödlich
quelle
0

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.

AdmBorkBork
quelle
0

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.

nimi
quelle
0

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.

Neil
quelle
0

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.

Histokrat
quelle
0

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)

Brad Gilbert b2gills
quelle
0

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.

mik
quelle
Schöne Antwort und willkommen bei PPCG! Beachten Sie, dass für Perl die Befehlszeilenoptionen in Ihrer Byteanzahl enthalten sein müssen , sodass dies nicht ganz 30 Bytes sind.
AdmBorkBork
@TimmyD ok, +1 für -pOption, -list für eine einzelne Eingabe nicht erforderlich
Mik
0

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)
pajonk
quelle