La séquence inversée puis ajoutée (RTA) est une séquence obtenue en ajoutant un nombre à son inverse et en répétant le processus sur le résultat. Par exemple.,

Ainsi, la séquence RTA de 5 contient 10, 11, 22, 44, 88, 176, etc.

La racine RTA d'un nombre est le plus petit nombre égal à ou donnant lieu à dans sa séquence RTA.n $n$$n$$n$

Par exemple, 44 se trouve dans la séquence RTA de 5, 10, 11, 13, 22, 31, etc. Parmi ceux-ci, 5 est le plus petit, et donc RTAroot (44) = 5.

72 ne fait partie d'aucune séquence RTA d'aucun nombre, et est donc considéré comme sa propre racine RTA.

L'entrée est un entier positif dans une plage que votre langue peut naturellement gérer.

La sortie est la racine RTA du nombre donné, comme défini ci-dessus.

Cas de test

Input
Output

44
5

72
72

132
3

143
49

1111
1

999
999

OEIS connexe: A067031 . La sortie sera un nombre de cette séquence.

Perl 6 , 45 44 octets

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

Essayez-le en ligne!

Explication:

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

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

• 2 octets grâce à Sundar remarquant que j'avais un {{et}}

Explication

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

désolé pour l'explication bancale, c'est le meilleur que j'ai pu trouver

Essayez-le en ligne!

Haskell , 59 57 octets

^{-2 octets grâce à user1472751 (en utilisant une seconde untilau lieu de la liste-compréhension & head)!}

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

Essayez-le en ligne!

Explication

Cela évaluera Truepour n'importe quelle racine RTA:

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

Le terme (+)<*>read.reverse.showest une version golfée de

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

ce qui ajoute un nombre à lui-même inversé.

La fonction untils'applique à plusieurs reprises (+)<*>read.reverse.showjusqu'à ce qu'elle dépasse notre objectif.

Enveloppant tout cela dans un autre untildébut avec 1et en ajoutant 1 avec (+1), vous trouverez la première racine RTA.

S'il n'y a pas de racine RTA appropriée n, nous arrivons finalement à l' nendroit où untiln'applique pas la fonction depuis n<=n.

05AB1E , 7 octets

Utilisation de la nouvelle version de 05AB1E (réécrite dans Elixir).

Code

L.ΔλjÂ+

Essayez-le en ligne!

Explication

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.

Gelée , 12 11 octets

ṚḌ+ƊС€œi¹Ḣ

$999$$1111$

Merci à @JonathanAllan d'avoir joué au golf sur 1 octet!

Essayez-le en ligne!

Comment ça marche

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

Rubis, 66 57 octets

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

Essayez-le en ligne!

Fonction récursive qui "annule" à plusieurs reprises l'opération RTA jusqu'à arriver à un nombre qui ne peut pas être produit par elle, puis retourne le minimum.

Au lieu d'utiliser filter, ce qui est long, je préfère simplement mappasser de 1 au nombre. Pour chaque m de cette plage, si m + rev (m) est le nombre, il appelle la fonction récursivement sur m ; sinon, il renvoie n . Cela supprime à la fois le besoin de a filteret nous donne un cas de base de f (n) = n gratuitement.

Les points forts incluent l'enregistrement d'un octet avec Integer#digits:

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

Le dernier serait un octet plus court, mais malheureusement, Ruby analyse les nombres commençant par 0octal.

Python 2 , 70 octets

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

Essayez-le en ligne!

Pyth , 12 octets

fqQ.W<HQ+s_`

Découvrez une suite de tests!

Étonnamment rapide et efficace. Tous les cas de test exécutés simultanément prennent moins de 2 secondes.

Comment ça marche

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 octets

LʒIFDÂ+})Iå}н

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Commenté

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 octets

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

-1 octet grâce à @Emigna .

Essayez-le en ligne.

Explication:

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

Fusain , 33 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｎθ

$q$

≔⊗θη

$2q$$h$

Ｗ›ηθ«

$h>q$

≔Ｌ⊞Ｏυωη

$u$$h$

Ｗ‹ηθ

$h<q$

≧⁺Ｉ⮌Ｉηη

$h$$h$

»ＩＬυ

$u$

MATL , 17 octets

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

Essayez-le en ligne!

Explication

`         % 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 octets

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

Essayez-le en ligne.

Explication:

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

L'inversion arithmétique de l'entier est de 1 octet de plus ( 104 octets ):

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

Essayez-le en ligne.

C (gcc) , 120 100 99 octets

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

Essayez-le en ligne!

Étant donné l'entrée i, vérifie chaque entier de ià 0 pour une séquence contenant i.

• i est la valeur d'entrée
• o est la valeur de sortie (la racine minimale trouvée jusqu'à présent)
• a est l'entier en cours de vérification
• best l'élément courant de ala séquence de
• cet dsont utilisés pour ajouter bà son revers

Japt , 16 15 11 octets

@ÇX±swÃøU}a

Essayez-le

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

Le mérite de la méthode revient à Doorknob .

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

Essayez-le en ligne!

C (gcc) , 89 octets

J'exécute chaque séquence en [1, n ) jusqu'à ce que j'obtienne une correspondance; zéro est placé dans un boîtier spécial car il ne se termine pas.

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

Essayez-le en ligne!