Racine RTA (Reverse-Then-Add) d'un nombre

22

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

5+5=1010+01=1111+11=2222+22=44 ...

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 nnnn

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.

Sundar - Rétablir Monica
la source

Réponses:

13

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
Jo King
la source
5
La syntaxe des ellipses de Perl 6 devient plus magique à chaque fois que je la rencontre. Cette spécification de séquence basée sur lambda est une bonne idée!
sundar
@sundar, cette syntaxe était en fait l'une des principales raisons pour lesquelles je suis venu à Perl 6. (et pourquoi, après un certain temps, c'est devenu ma langue préférée)
Ramillies
7

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!

Kroppeb
la source
1
Son utilisation {|↰₁}est simple mais brillante. Bon travail!
sundar
5

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.

ბიმო
la source
1
Vous pouvez également économiser 2 octets en utilisant untilla boucle externe: TIO
user1472751
5

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.
Adnan
la source
Attendez .. ja une signification particulière dans un environnement récursif? Je ne connaissais que le travers et le λsoi dans l'environnement récursif. Y en a-t-il d'autres en plus j? EDIT: Ah, je vois aussi quelque chose £dans le code source . Où est-il utilisé?
Kevin Cruijssen
1
@KevinCruijssen Oui, ce sont des drapeaux utilisés dans l'environnement récursif. jvérifie essentiellement si la valeur d'entrée est dans la séquence. £s'assure qu'il retourne les n premières valeurs de la séquence (les mêmes que λ<...>}¹£).
Adnan
3

Gelée , 12 11 octets

ṚḌ+ƊС€œi¹Ḣ

9991111

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.
Dennis
la source
3

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.

Poignée de porte
la source
2

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.
M. Xcoder
la source
2

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
Emigna
la source
Intelligent! Je sais que ma version de 21 octets était déjà beaucoup trop longue (que j'ai joué à 16 avec la même approche), mais je ne pouvais pas vraiment trouver un moyen de le faire plus court. Je ne peux pas croire que je n'ai pas pensé à utiliser la tête après le filtre .. J'ai continué à essayer d'utiliser l'index de boucle + 1, ou le global_counter..>.>
Kevin Cruijssen
2

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
Arnauld
la source
2

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
Kevin Cruijssen
la source
Vous n'avez pas besoin de l'impression en raison d'une impression implicite.
Emigna
1

Fusain , 33 octets

Nθ≔⊗θηW›ηθ«≔L⊞OυωηW‹ηθ≧⁺I⮌Iηη»ILυ

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

Nθ

q

≔⊗θη

2qh

W›ηθ«

h>q

≔L⊞Oυωη

uh

W‹ηθ

h<q

≧⁺I⮌Iηη

hh

»ILυ

u

Neil
la source
1

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)
Luis Mendo
la source
1
Juste comme note latérale, j'ai utilisé MATL pour générer les sorties de cas de test, en utilisant cette version de 31 octets: :!`tG=~yV2&PU*+tG>~*tXzG=A~]f1) Essayez-le en ligne!
Sundar
1

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.

Kevin Cruijssen
la source
1

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
Curtis Bechtel
la source
Compiler avec -DL=forvous économiserait 2 octets.
Grattez ça; mal faire les mathématiques.
Cependant, vous pouvez renvoyer la valeur de sortie avec i=o;si vous utilisez -O0, vous économisant 5 octets.
1

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?
Hirsute
la source
0

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!

ErikF
la source