Die RTA-Sequenz (Reverse-Then-Add) ist eine Sequenz, die durch Hinzufügen einer Zahl zu ihrer Rückseite und Wiederholen des Prozesses für das Ergebnis erhalten wird. Zum Beispiel

Somit enthält die RTA-Sequenz von 5 10, 11, 22, 44, 88, 176 usw.

Die RTA-Wurzel einer Zahl ist die kleinste Zahl, die entweder gleich n ist oder in ihrer RTA-Sequenz n hervorruft.$n$$n$$n$

Zum Beispiel wird 44 in der RTA-Sequenz von 5, 10, 11, 13, 22, 31 usw. gefunden. Von diesen ist 5 die kleinste und daher ist RTAroot (44) = 5.

72 ist nicht Teil der RTA-Sequenz einer Zahl und wird daher als eigene RTA-Wurzel betrachtet.

Die Eingabe ist eine positive Ganzzahl in einem Bereich, den Ihre Sprache auf natürliche Weise verarbeiten kann.

Die Ausgabe ist die RTA-Wurzel der angegebenen Zahl, wie oben definiert.

Testfälle

Input
Output

44
5

72
72

132
3

143
49

1111
1

999
999

Verwandte OEIS: A067031 . Die Ausgabe ist eine Zahl aus dieser Sequenz.

Perl 6 , 45 44 Bytes

->\a{first {a∈($_,{$_+.flip}...*>a)},1..a}

Probieren Sie es online!

Erläuterung:

->\a{                                    }  # Anonymous code block
->\a     # That takes a number a
     first  # Find the first element
                                     1..a  # In the range 1 to a
           {                       },    # Where
            a∈       # a is an element of
              (             ...   )  # A sequence defined by
               $_,  # The first element is the number we're checking
                  {$_+.flip}  # Each element is the previous element plus its reverse
                               *>$a  # The last element is larger than a

Brachylog , 24 22 Bytes

{~{ℕ≤.&≜↔;?+}{|↰₁}|}ᶠ⌋

• 2 Bytes dank Sundar bemerkt, dass ich ein {{und hatte}}

Erläuterung

                --  f(n):
                --      g(x):
 {              --          h(y):
  ~             --              get z where k(z) = y
   {            --              k(z):
    ℕ≤.         --                  z>=0 and z<=k(z) (constrain so it doesn't keep looking)
    &≜          --                  label input (avoiding infinite stuff)
      ↔;?+      --                  return z+reverse(z)
   }            --
    {           --                  
     |↰₁        --              return z and h(z) (as in returning either)
    }           --                  
  |             --          return h(x) or x (as in returning either)
 }              --
ᶠ               --      get all possible answers for g(n)
  ⌋             --      return smallest of them

Entschuldigung für die wackelige Erklärung, das ist das Beste, was ich mir einfallen lassen konnte

Probieren Sie es online!

Haskell , 59-57 Bytes

^{-2 Bytes dank user1472751 (mit einer Sekunde untilanstelle von Listenverständnis & head)!}

f n=until((n==).until(>=n)((+)<*>read.reverse.show))(+1)1

Probieren Sie es online!

Erläuterung

Dies wird Truefür jede RTA-Wurzel ausgewertet :

(n==) . until (n<=) ((+)<*>read.reverse.show)

Der Begriff (+)<*>read.reverse.showist eine Golfversion von

\r-> r + read (reverse $ show r)

Das fügt eine Zahl zu sich selbst umgedreht.

Die Funktion wird untilwiederholt angewendet, (+)<*>read.reverse.showbis sie unser Ziel überschreitet.

Wenn Sie all dies in ein weiteres untilPaket packen, das mit 11 beginnt, (+1)finden Sie die erste RTA-Wurzel.

Wenn es keine richtige RTA-Wurzel von gibt n, gelangen wir irgendwann dahin, nwo untildie Funktion seitdem nicht mehr angewendet wird n<=n.

05AB1E , 7 Bytes

Verwendung der neuen Version von 05AB1E (in Elixir umgeschrieben).

Code

L.ΔλjÂ+

Probieren Sie es online!

Erläuterung

L           # Create the list [1, ..., input]
 .Δ         # Iterate over each value and return the first value that returns a truthy value for:
   λ        #   Where the base case is the current value, compute the following sequence:
     Â+     #   Pop a(n - 1) and bifurcate (duplicate and reverse duplicate) and sum them up.
            #   This gives us: a(0) = value, a(n) = a(n - 1) + reversed(a(n - 1))
    j       #   A λ-generator with the 'j' flag, which pops a value (in this case the input)
            #   and check whether the value exists in the sequence. Since these sequences will be 
            #   infinitely long, this will only work strictly non-decreasing lists.

Jelly , 12 11 Bytes

ṚḌ+ƊС€œi¹Ḣ

$999$$1111$

Vielen Dank an @JonathanAllan für das Abschlagen von 1 Byte!

Probieren Sie es online!

Wie es funktioniert

ṚḌ+ƊС€œi¹Ḣ  Main link. Argument: n

      €      Map the link to the left over [1, ..., n].
    С         For each k, call the link to the left n times. Return the array of k
               and the link's n return values.
   Ɗ           Combine the three links to the left into a monadic link. Argument: j
Ṛ                Promote j to its digit array and reverse it.
 Ḍ               Undecimal; convert the resulting digit array to integer.
  +              Add the result to j.
       œi¹   Find the first multindimensional index of n.
          Ḣ  Head; extract the first coordinate.

Ruby, 66 57 Bytes

f=->n{(1..n).map{|m|m+(m.digits*'').to_i==n ?f[m]:n}.min}

Probieren Sie es online!

Eine rekursive Funktion, die die RTA-Operation wiederholt "rückgängig macht", bis eine Zahl erreicht wird, die nicht von ihr erzeugt werden kann, gibt dann das Minimum zurück.

Anstatt zu verwenden filter, was lang ist, übersetze ich stattdessen einfach mapden Bereich von 1 bis zur Zahl. Wenn für jedes m in diesem Bereich m + rev (m) die Zahl ist, ruft es die Funktion rekursiv auf m auf ; Andernfalls wird n zurückgegeben . Dies beseitigt die Notwendigkeit für a filterund gibt uns einen Basisfall von f (n) = n kostenlos.

Highlights sind das Speichern eines Bytes mit Integer#digits:

m.to_s.reverse.to_i
(m.digits*'').to_i
eval(m.digits*'')

Das letzte wäre ein Byte kürzer, aber leider analysiert Ruby Zahlen, die mit einem 0Oktal beginnen.

Python 2 , 70 Bytes

f=lambda n,i=1,k=1:i*(k==n)or f(n,i+(k>n),[k+int(`k`[::-1]),i+1][k>n])

Probieren Sie es online!

Pyth , 12 Bytes

fqQ.W<HQ+s_`

Testen Sie eine Testsuite!

Überraschend schnell und effizient. Alle Testfälle liefen gleichzeitig und dauerten weniger als 2 Sekunden.

Wie es funktioniert

fqQ.W<HQ+s_` – Full program. Q is the variable that represents the input.
f            – Find the first positive integer T that satisfies a function.
   .W        – Functional while. This is an operator that takes two functions A(H)
               and B(Z) and while A(H) is truthy, H = B(Z). Initial value T.
     <HQ     – First function, A(H) – Condition: H is strictly less than Q.
        +s_` – Second function, B(Z) – Modifier.
         s_` – Reverse the string representation of Z and treat it as an integer.
        +    – Add it to Z.
             – It should be noted that .W, functional while, returns the ending
               value only. In other words ".W<HQ+s_`" can be interpreted as
               "Starting with T, while the current value is less than Q, add it
               to its reverse, and yield the final value after the loop ends".
 qQ          – Check if the result equals Q.

05AB1E , 13 Bytes

LʒIFDÂ+})Iå}н

Probieren Sie es online!

Erläuterung

L               # push range [1 ... input]
 ʒ         }    # filter, keep elements that are true under:
  IF   }        # input times do:
    D           # duplicate
     Â+         # add current number and its reverse
        )       # wrap in a list
         Iå     # check if input is in the list
            н   # get the first (smallest) one

JavaScript (ES6), 61 Byte

n=>(g=k=>k-n?g(k>n?++x:+[...k+''].reverse().join``+k):x)(x=1)

Probieren Sie es online!

Kommentiert

n =>                        // n = input
  (g = k =>                 // g() = recursive function taking k = current value
    k - n ?                 //   if k is not equal to n:
      g(                    //     do a recursive call:
        k > n ?             //       if k is greater than n:
          ++x               //         increment the RTA root x and restart from there
        :                   //       else (k is less than n):
          +[...k + '']      //         split k into a list of digit characters
          .reverse().join`` //         reverse, join and coerce it back to an integer
          + k               //         add k
      )                     //     end of recursive call
    :                       //   else (k = n):
      x                     //     success: return the RTA root
  )(x = 1)                  // initial call to g() with k = x = 1

05AB1E , 21 16 15 Bytes

G¼N¹FÂ+йQi¾q]¹

-1 Byte dank @Emigna .

Probieren Sie es online aus.

Erläuterung:

G               # Loop `N` in the range [1, input):
 ¼              #  Increase the global_counter by 1 first every iteration (0 by default)
 N              #  Push `N` to the stack as starting value for the inner-loop
  ¹F            #  Inner loop an input amount of times
    Â           #   Bifurcate (short for Duplicate & Reverse) the current value
                #    i.e. 10 → 10 and '01'
     +          #   Add them together
                #    i.e. 10 and '01' → 11
      Ð         #   Triplicate that value
                #   (one for the check below; one for the next iteration)
       ¹Qi      #   If it's equal to the input:
          ¾     #    Push the global_counter
           q    #    And terminate the program
                #    (after which the global_counter is implicitly printed to STDOUT)
]               # After all loops, if nothing was output yet:
 ¹              # Output the input

Holzkohle , 33 Bytes

Ｎθ≔⊗θηＷ›ηθ«≔Ｌ⊞ＯυωηＷ‹ηθ≧⁺Ｉ⮌Ｉηη»ＩＬυ

Probieren Sie es online!Link ist eine ausführliche Version des Codes. Erläuterung:

Ｎθ

Eingang $q$.

≔⊗θη

Zuordnen $2q$ zu $h$ damit die Schleife startet.

Ｗ›ηθ«

Wiederholen Sie dies während $h>q$:

≔Ｌ⊞Ｏυωη

Schieben Sie einen Dummy-Null-String auf $u$ Erhöhen Sie damit seine Länge und weisen Sie die resultierende Länge zu $h$;

Ｗ‹ηθ

wiederholen während $h<q$:

≧⁺Ｉ⮌Ｉηη

fügen Sie die Rückseite von hinzu $h$ zu $h$.

»ＩＬυ

Drucken Sie die endgültige Länge von $u$ Welches ist die gewünschte Wurzel.

MATL , 17 Bytes

`@G:"ttVPU+]vG-}@

Probieren Sie es online!

Erläuterung

`         % Do...while loop
  @       %   Push iteration index, k (starting at 1)
  G:"     %   Do as many times as the input
    tt    %     Duplicate twice
    VPU   %     To string, reverse, to number
    +     %     Add
  ]       %   End
  v       %   Concatenate all stack into a column vector. This vector contains
          %   a sufficient number of terms of k's RTA sequence
  G-      %   Subtract input. This is used as loop condition, which is falsy
          %   if some entry is zero, indicating that we have found the input
          %   in k's RTA sequence
}         % Finally (execute on loop exit)
  @       %   Push current k
          % End (implicit). Display (implicit)

Java 8, 103 Bytes

n->{for(int i=0,j;;)for(j=++i;j<=n;j+=n.valueOf(new StringBuffer(j+"").reverse()+""))if(n==j)return i;}

Probieren Sie es online aus.

Erläuterung:

n->{                // Method with Integer as both parameter and return-type
  for(int i=0,j;;)  //  Infinite loop `i`, starting at 0
    for(j=++i;      //  Increase `i` by 1 first, and then set `j` to this new `i`
        j<=n        //  Inner loop as long as `j` is smaller than or equal to the input
        ;           //    After every iteration:
         j+=        //     Increase `j` by:
            n.valueOf(new StringBuffer(j+"").reverse()+""))
                    //     `j` reversed
     if(n==j)       //   If the input and `j` are equal:
       return i;}   //    Return `i` as result

Das arithmetische Umkehren der Ganzzahl ist 1 Byte länger ( 104 Byte ):

n->{for(int i=0,j,t,r;;)for(j=++i;j<=n;){for(t=j,r=0;t>0;t/=10)r=r*10+t%10;if((j+=r)==n|i==n)return i;}}

Probieren Sie es online aus.

C (gcc) , 120 100 99 Bytes

f(i,o,a,b,c,d){for(a=o=i;b=a;o=i/b?a:o,a--)for(;b<i;b+=c)for(c=0,d=b;d;d/=10)c=c*10+d%10;return o;}

Probieren Sie es online!

iÜberprüft bei gegebener Eingabe jede Ganzzahl von ibis 0 auf eine Sequenz, die Folgendes enthält i.

• i ist der Eingabewert
• o ist der Ausgabewert (die bisher gefundene Mindestwurzel)
• a ist die aktuelle Ganzzahl, die geprüft wird
• bist das aktuelle Element der aSequenz
• cund dwerden verwendet, um bzu seiner Rückseite hinzuzufügen

Japt , 16 15 11 Bytes

@ÇX±swÃøU}a

Versuch es

@ÇX±swÃøU}a     :Implicit input of integer U
@        }a     :Loop over the positive integers as X & output the first that returns true
 Ç              :  Map the range [0,U)
  X±            :    Increment X by
    sw          :    Its reverse
      Ã         :  End map
       øU       :  Contains U?

Physica , 57 Bytes

Gutschrift für die Methode geht an Doorknob .

F=>N:Min@Map[->m:N==m+Int[Str[m]{%%-1}]&&F@m||N;…[1;N]]

Probieren Sie es online!

C (gcc) , 89 Bytes

Ich führe jede Sequenz in [1, n ) aus, bis ich eine Übereinstimmung erhalte. Null ist ein Sonderfall, weil sie nicht beendet wird.

j,k,l,m;r(i){for(j=k=0;k-i&&++j<i;)for(k=j;k<i;k+=m)for(l=k,m=0;l;l/=10)m=m*10+l%10;j=j;}

Probieren Sie es online!