Votre tâche consiste à générer le nième terme de la séquence RATS, où n est l'entrée. La séquence RATS est également connue sous le nom de séquence Ajouter puis trier inversée. Cette séquence peut également être trouvée ici: http://oeis.org/A004000 .

cas de test:

0 > 1
1 > 2
2 > 4
3 > 8
4 > 16
5 > 77
6 > 145
7 > 668

Par exemple, la sortie pour 5 est 77 car 16 + 61 = 77. Après cela, le 77 est trié.

La soumission la plus courte gagne. C'est mon premier défi donc j'espère que ce n'est pas un doublon ou quelque chose.

MATL , 11 12 octets

1i"tVPU+VSU

L'entrée est une chaîne (avec des guillemets simples) représentant un entier en unaire . La saisie de chaîne est autorisée par le défi et unaire est un format valide .

Essayez-le en ligne!

Explication

1      % push number 1 to the stack
i      % input. Will be a string of "n" ones 
"      % for loop: repeat n times (consumes string)
  t    %   duplicate
  V    %   convert to string
  P    %   reverse
  U    %   convert to number
  +    %   add
  V    %   convert to string
  S    %   sort
  U    %   convert to number
       % loop is implicitly ended
       % stack content is implicitly displayed    

05AB1E , 6 octets

Code:

$FDR+{

Explication:

$       # Push 1 and input
 F      # For N in range(0, input)
  D     # Duplicate top of the stack
   R    # Reverse top of the stack
    +   # Add top two items
     {  # Sort top of the stack
        # Implicitly print top of the stack

Cela fonctionne également avec un programme de 0 octet .

CJam, 15 octets

1ri{_sW%i+s$i}*

Testez-le ici.

Explication

1     e# Push 1 as the start of the sequence.
ri    e# Read input and convert to integer N.
{     e# Run this block N times...
  _s  e#   Duplicate and convert to string.
  W%  e#   Reverse string.
  i+  e#   Convert back to integer and add to previous value.
  s$  e#   Convert to string and sort.
  i   e#   Convert back to integer for the next iteration.
}*

Pyth, 17 13 12 octets

uS`+vGv_GQ\1

u        Q\1    reduce range(input()) on base case of "1" (string)
   +vG          eval the string (to get a number), and add...
      v_G       the same number, reversed first and then eval'd
 S`             convert back to string and sort

Essayez-le sur l'interprète en ligne .

Python 2, 72

f=lambda x,n=1:x and f(x-1,int(''.join(sorted(`n+int(`n`[::-1])`))))or n

Fonction récursive, utilise le raccourci Python 2 pour __repr__, qui se brisera une fois que la fonction atteindra de très grandes valeurs (un Lsera ajouté à la chaîne du numéro), je ne suis pas certain de la spécification s'il y a un endroit où nous pouvons nous arrêter , mais s'il ne change pas en str()ajoute seulement 6 octets, mais il devient alors légèrement plus court pour sortir sous forme de chaîne, à 75 octets:

f=lambda x,n='1':x and f(x-1,''.join(sorted(str(int(n)+int(n[::-1])))))or n

1 octet économisé grâce à trichoplax sur cette version

JavaScript ES6, 70 octets

1 octet enregistré grâce à @ user81655

f=n=>n?+[...+[...''+(b=f(n-1))].reverse().join``+b+''].sort().join``:1

soupir JavaScript est vraiment verbeux. Une grande partie (> 50%) du code est juste cas pour chaîne + fonction de tableau + jointure + transtypage en int. J'ai essayé de réduire, d'évaluer et toutes sortes de choses, mais cela semble être le plus court.

Essayez-le en ligne (tous les navigateurs fonctionnent)

Brachylog , 19 octets

0,1 .|-1=:0&Rr+R=o.

Explication

0,1 .               § If Input is 0, unify the Output with 1
     |              § Else
      -1=:0&R       § unify R with the output of this main predicate, with input = Input - 1
             r+R=o. § Reverse R, add it to itself and order it, then unify with the Output.

Haskell, 67 octets

import Data.List
g i=i:g(sort$show$read i+read(reverse i))
(g"1"!!)

Exemple d'utilisation: (g"1"!!) 7-> "668".

C'est une implémentation directe de la définition: en commençant par "1", ajoutez à plusieurs reprises le résultat inverse-ajoutez-trier de l'élément actuel. La fonction principale (g"1"!!)sélectionne le ie élément.

Julia, 77 octets

n->(x=1;for _=1:n x=(p=parse)(join(sort(["$(x+p(reverse("$x")))"...])))end;x)

Il s'agit d'une fonction lambda qui accepte un entier et renvoie un entier. Pour l'appeler, affectez-le à une variable.

Non golfé:

function f(n::Int)
    # Begin x at 1
    x = 1

    # Repeat this process n times
    for _ = 1:n
        # Add x to itself with reversed digits
        s = x + parse(reverse("$x"))

        # Refine x as this number with the digits sorted
        x = parse(join(sort(["$s"...])))
    end

    # Return x after the process (will be 1 if n was 0)
    return x
end

Gelée, 13 12 octets

Je suis sûr que cela peut probablement être joué au golf, car c'est ma première réponse en Jelly / dans une langue tacite.

DUḌ+ðDṢḌ Performs RATS
1Ç¡      Loops

D        Converts integer to decimal
 U       Reverses
  Ḍ      Converts back to integer
   +     Adds original and reversed
    ð    Starts new chain
     D   Converts back to decimal
      Ṣ  Sorts
       Ḍ Back to integer again

1        Uses 1 instead of input
 Ḍ       Uses line above
  ¡      For loop

EDIT: enregistré 1 octet, grâce à Dennis

Java 1,8, 251 octets

interface R{static void main(String[]a){int i,r,n=1,c=0,t=Byte.valueOf(a[0]);while(++c<=t){i=n;for(r=0;i!=0;i/=10){r=r*10+i%10;}n+=r;a[0]=n+"";char[]f=a[0].toCharArray();java.util.Arrays.sort(f);n=Integer.valueOf(new String(f));}System.out.print(n);}}

Étendu

interface R{
static void main(String[]args){
    int input,reversed,nextValue=1,count=0,target=Byte.valueOf(args[0]);
    while(++count<=target){
        input=nextValue;
        for(reversed=0;input!=0;input/=10){reversed=reversed*10+input%10;}
        nextValue+=reversed;
        args[0]=nextValue+"";
        char[]sortMe=args[0].toCharArray();
        java.util.Arrays.sort(sortMe);
        nextValue=Integer.valueOf(new String(sortMe));
    }
    System.out.print(nextValue);
}
}

Sérieusement, 17 octets

1,`;$R≈+$S≈`n

Essayez-le en ligne!

Explication:

1,`;$R≈+$S≈`n
1              push 1
 ,`       `n   do the following n times:
   ;$R≈        reverse
       +       add
        $S≈    sort

Lua, 179156 octets

Je ne vois pas comment je pourrais jouer au golf plus, mais je suis sûr qu'il y a un moyen. Grâce à @LeakyNun, j'ai pris le temps de revenir sur ce sujet et de le jouer correctement, je pourrais peut-être encore gagner quelques octets en utilisant une autre approche.

k=0z=table
for i=0,io.read()do
t={}(""..k+(""..k):reverse()):gsub("%d",function(d)t[#t+1]=d
end)z.sort(t)k=k<1 and 1or tonumber(z.concat(t,""))
end
print(k)

Non golfé et explications

k=0                                  
z=table                              -- z is a pointer on the table named table
                                     -- it allows me to use its functions
                                     -- while saving 4 bytes/use

for i=0,io.read()                    -- Iterate n times for the nth element
do
  t={}
  (""..a+(""..a):reverse())          -- we add k with its "reversed" value
                                     -- and convert the whole thing to a string
    :gsub(".",function(d)            -- for each character in it, use an anonymous fucntion
       t[#t+1]=d end)                -- which insert them in the array t
  z.sort(t)                          
  a=a<1 and 1 or                     -- if i==0, k=1
     tonumber(z.concat(t,""))        -- else we concat t in a string and convert it to number
end
print(k)

Brachylog 2, 11 octets, défi de postdates de langue

;1{↔;?+o}ⁱ⁽

Essayez-le en ligne!

Explication

;1{↔;?+o}ⁱ⁽
  {     }ⁱ  Repeatedly apply the following,
 1            starting at 1,
;         ⁽   a number of times equal to the input:
   ↔            reverse,
    ;?+         add the original input,
       o        then sort the resulting number

Je ne suis pas tout à fait clair sur ce que cela fait avec zéro chiffre, mais la question n'indique aucun traitement particulier, et ils n'apparaissent probablement pas dans la séquence de toute façon.

ES6, 79 octets

n=>eval("r=1;while(n--)r=+[...+[...r+''].reverse().join``+r+''].sort().join``")

82 octets sans eval:

n=>[...Array(n)].reduce(r=>+[...+[...r+''].reverse().join``+r+''].sort().join``,1)

Toutes ces conversions sont douloureuses.

@ edc65 J'ai en fait économisé 4 octets en passant de mapà reducecette époque ... sans aucun doute, vous me prouverez encore une fois.

Python 2, 91 octets

Saisie en entier, le résultat est imprimé à l'écran.

def f(n):
 t=1
 for i in range(n):t=int("".join(sorted(str(int(str(t)[::-1])+t))))
 print t

Cela pourrait être beaucoup plus court avec de la magie de récursivité, je suppose, mais je ne peux pas encore m'en occuper. J'aurai un nouveau look plus tard et j'espère améliorer celui-ci.

Python 2, 83 octets

def f(n):
 v='1'
 for _ in v*n:v=''.join(sorted(str(int(v)+int(v[::-1]))))
 print v

Perl 6 , 40 octets

{(1,{[~] ($_+.flip).comb.sort}...*)[$_]} # 40

(Si vous voulez qu'il retourne un Int, mettez un +droit avant [~])

Usage:

# give it a lexical name
my &RATS = {…}

say RATS 5; # 77

# This implementation also accepts a list of indexes

# the first 10 of the sequence
say RATS ^10; # (1 2 4 8 16 77 145 668 1345 6677)

Mathematica 10.3, 66 61 octets

Nest[FromDigits@Sort@IntegerDigits[#+IntegerReverse@#]&,1,#]&

Assez facile.

PHP, 102 octets

$r=[1];$i++<$argn;sort($v),$r[]=join($v))$v=str_split(bcadd(strrev($e=end($r)),$e));echo$r[$argn];

Version en ligne

PHP, 95 octets

n <= 39

for($r=[1];$i++<$argn;sort($v),$r[]=join($v))$v=str_split(strrev($e=end($r))+$e);echo$r[$argn];

Java , 171 167 163 160 160 octets

int f(int n){int a=n>0?f(n-1):0,x=10,b[]=new int[x],c=a,d=0;for(;c>0;c/=x)d=d*x+c%x;for(a+=d;a>0;a/=x)b[a%x]++;for(;a<x;c=b[a++]-->0?c*x+--a:c);return n>0?c:1;}

Essayez-le en ligne!

Pas l'entrée la plus longue! \ o /

Python 2 , 70 octets

f=lambda n,a=1:n and int(''.join(sorted(`f(n-1)+f(n-1,-1)`))[::a])or 1

Essayez-le en ligne!

Axiome, 146 octets

c(r:String):NNI==reduce(+,[(ord(r.i)-48)*10^(#r-i) for i in 1..#r]);f(n:INT):NNI==(n<1=>1;v:=f(n-1);v:=v+c(reverse(v::String));c(sort(v::String)))

test et résultats [séquence RATS]

(3) -> [[i, f(i)] for i in 0..20]
   (3)
   [[0,1], [1,2], [2,4], [3,8], [4,16], [5,77], [6,145], [7,668], [8,1345],
    [9,6677], [10,13444], [11,55778], [12,133345], [13,666677], [14,1333444],
    [15,5567777], [16,12333445], [17,66666677], [18,133333444], [19,556667777],
    [20,1233334444]]

Tcl , 91 octets

proc R n {join [lsort [split [expr {$n?[set v [R [expr $n-1]]]+[string rev $v]:1}] ""]] ""}

Essayez-le en ligne!