La secuencia inversa-luego-sumar (RTA) es una secuencia obtenida agregando un número a su reverso y repitiendo el proceso en el resultado. Por ej.

Por lo tanto, la secuencia RTA de 5 contiene 10, 11, 22, 44, 88, 176, etc.

La raíz RTA de un número es el número más pequeño que es igual a o da aumento a en su secuencia RTA.$n$$n$$n$

Por ejemplo, 44 ​​se encuentra en la secuencia RTA de 5, 10, 11, 13, 22, 31, etc. De estos, 5 es el más pequeño y, por lo tanto, RTAroot (44) = 5.

72 no forma parte de la secuencia RTA de ningún número, por lo que se considera su propia raíz RTA.

La entrada es un número entero positivo en un rango que su idioma puede manejar naturalmente.

La salida es la raíz RTA del número dado, como se definió anteriormente.

Casos de prueba

Input
Output

44
5

72
72

132
3

143
49

1111
1

999
999

OEIS relacionados: A067031 . La salida será un número de esta secuencia.

Perl 6 , 45 44 bytes

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

Pruébalo en línea!

Explicación:

->\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 gracias a sundar notando que tenía un {{y}}

Explicación

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

perdón por la explicación inestable, esto es lo mejor que se me ocurrió

Pruébalo en línea!

Haskell , 59 57 bytes

^{-2 bytes gracias a user1472751 (¡usando un segundo en untillugar de comprensión de lista & head)!}

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

Pruébalo en línea!

Explicación

Esto evaluará Truepara cualquier raíz RTA:

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

El término (+)<*>read.reverse.showes una versión de golf de

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

que agrega un número a sí mismo invertido.

La función untilse aplica repetidamente (+)<*>read.reverse.showhasta que excede nuestro objetivo.

Envolviendo todo esto en otro untilcomienzo 1y agregando 1 con, (+1)se encontrará la primera raíz RTA.

Si no hay una raíz RTA adecuada n, eventualmente llegamos a ndonde untilno aplica la función desde entonces n<=n.

05AB1E , 7 bytes

Usando la nueva versión de 05AB1E (reescrita en Elixir).

Código

L.ΔλjÂ+

Pruébalo en línea!

Explicación

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.

Jalea , 12 11 bytes

ṚḌ+ƊС€œi¹Ḣ

$999$$1111$

¡Gracias a @JonathanAllan por jugar golf en 1 byte!

Pruébalo en línea!

Cómo funciona

ṚḌ+ƊС€œ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}

Pruébalo en línea!

Función recursiva que "deshace" repetidamente la operación RTA hasta llegar a un número que no puede producir, y luego devuelve el mínimo.

En lugar de usar filter, que es largo, simplemente mapsupero el rango del 1 al número. Para cada m en este rango, si m + rev (m) es el número, llama a la función recursivamente en m ; de lo contrario, devuelve n . Esto elimina la necesidad de a filtery nos da un caso base de f (n) = n gratis.

Los puntos destacados incluyen guardar un byte con Integer#digits:

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

El último sería un byte más corto, pero lamentablemente, Ruby analiza los números que comienzan con 0octal.

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])

Pruébalo en línea!

Pyth , 12 bytes

fqQ.W<HQ+s_`

¡Mira un paquete de prueba!

Sorprendentemente rápido y eficiente. Todos los casos de prueba ejecutados a la vez toman menos de 2 segundos.

Cómo funciona

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å}н

Pruébalo en línea!

Explicación

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 bytes

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

Pruébalo en línea!

Comentado

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 gracias a @Emigna .

Pruébalo en línea.

Explicación:

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

Carbón , 33 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｎθ

$q$

≔⊗θη

$2q$$h$

Ｗ›ηθ«

$h>q$

≔Ｌ⊞Ｏυωη

$u$$h$

Ｗ‹ηθ

$h<q$

≧⁺Ｉ⮌Ｉηη

$h$$h$

»ＩＬυ

$u$

MATL , 17 bytes

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

Pruébalo en línea!

Explicación

`         % 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;}

Pruébalo en línea.

Explicación:

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

Invertir aritméticamente el entero es 1 byte más largo ( 104 bytes ):

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;}}

Pruébalo en línea.

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;}

Pruébalo en línea!

Dada la entrada i, verifica cada número entero de i0 a una secuencia que contenga i.

• i es el valor de entrada
• o es el valor de salida (la raíz mínima encontrada hasta ahora)
• a ¿Se está comprobando el entero actual?
• bes el elemento actual de ala secuencia de
• cy dse usan para agregar ba su reverso

Japt , 16 15 11 bytes

@ÇX±swÃøU}a

Intentalo

@Ç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

El crédito por el método va a Doorknob .

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

Pruébalo en línea!

C (gcc) , 89 bytes

Ejecuto cada secuencia en [1, n ) hasta obtener una coincidencia; cero está en mayúsculas especiales porque no termina.

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;}

Pruébalo en línea!