Ihre Aufgabe ist es, den n-ten Term der RATS-Sequenz zu generieren, wobei n die Eingabe ist. Die RATS-Sequenz wird auch als umgekehrte Add-Then-Sort-Sequenz bezeichnet. Diese Sequenz finden Sie auch hier: http://oeis.org/A004000 .

Testfälle:

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

Beispielsweise ist die Ausgabe für 5 77, da 16 + 61 = 77. Danach wird die 77 sortiert.

Kürzeste Einreichung gewinnt. Dies ist meine erste Herausforderung, also hoffe ich, dass dies kein Duplikat oder so ist.

MATL , 11 12 Bytes

1i"tVPU+VSU

Die Eingabe ist eine Zeichenfolge (mit einfachen Anführungszeichen), die eine ganze Zahl in Unary darstellt . Die Eingabe von Zeichenfolgen ist für die Abfrage zulässig, und Unary ist ein gültiges Format .

Probieren Sie es online!

Erläuterung

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 Bytes

Code:

$FDR+{

Erläuterung:

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

Dies funktioniert auch mit einem 0-Byte- Programm.

CJam, 15 Bytes

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

Teste es hier.

Erläuterung

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 Bytes

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

Probieren Sie es mit dem Online-Dolmetscher aus .

Python 2, 72

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

Bei der rekursiven Funktion wird die Abkürzung für Python 2 verwendet __repr__, die abbricht, sobald die Funktion sehr große Werte erreicht ( Lund an die Zeichenfolge der Zahl angehängt wird). Ich bin mir aus der Spezifikation nicht sicher, ob es eine Stelle gibt, an der wir anhalten können Wenn Sie jedoch nicht ändern, um str()nur 6 Bytes hinzuzufügen, wird die Ausgabe als Zeichenfolge mit 75 Bytes etwas kürzer:

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

1 Byte gespart dank Trichoplax in dieser Version

JavaScript ES6, 70 Byte

1 Byte dank @ user81655 gespeichert

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

seufz JavaScript ist wirklich wortreich. Ein Großteil (> 50%) des Codes bezieht sich nur auf Zeichenfolge + Array-Funktion + Verknüpfung + Umwandlung in int. Ich habe versucht, zu reduzieren, auszuwerten und alle möglichen Dinge, aber dies scheint die kürzeste zu sein.

Probieren Sie es online aus (Alle Browser funktionieren)

Brachylog , 19 Bytes

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

Erläuterung

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 Bytes

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

Anwendungsbeispiel: (g"1"!!) 7-> "668".

Es handelt sich um eine direkte Implementierung der Definition: Beginnen Sie mit dem "1"wiederholten Anhängen des Umkehr-Add-Sort-Ergebnisses des aktuellen Elements. Die Hauptfunktion (g"1"!!)wählt das idritte Element aus.

Julia, 77 Bytes

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

Dies ist eine Lambda-Funktion, die eine Ganzzahl akzeptiert und eine Ganzzahl zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Ungolfed:

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

Gelee, 13-12 Bytes

Ich bin mir sicher, dass dies wahrscheinlich Golf sein kann, da dies meine erste Antwort in Jelly / in einer stillschweigenden Sprache ist.

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

BEARBEITEN: 1 Byte gespeichert, dank Dennis

Java 1.8, 251 Bytes

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

Erweitert

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

Im Ernst, 17 Bytes

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

Probieren Sie es online!

Erläuterung:

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

Lua, 179.156 Bytes

Ich kann nicht sehen, wie ich mehr Golf spielen kann, aber ich bin mir sicher, dass es einen Weg gibt. Dank @LeakyNun habe ich mir die Zeit genommen, mich damit zu befassen und richtig Golf zu spielen. Vielleicht könnte ich trotzdem ein paar Bytes gewinnen, wenn ich einen anderen Ansatz benutze.

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)

Ungolfed und Erklärungen

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 Bytes, Sprachnachstellung

;1{↔;?+o}ⁱ⁽

Probieren Sie es online!

Erläuterung

;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

Ich bin mir nicht ganz sicher, was dies mit Nullstellen macht, aber die Frage gibt keine besondere Behandlung an und sie erscheinen wahrscheinlich sowieso nicht in der Sequenz.

ES6, 79 Bytes

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

82 Bytes ohne eval:

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

All diese Umbauten sind schmerzhaft.

@ edc65 Ich habe tatsächlich 4 Bytes gespart, indem ich von mapzu reducedieser Zeit gewechselt bin .

Python 2, 91 Bytes

Eingabe als Ganzzahl, Ergebnis wird auf dem Bildschirm ausgegeben.

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

Das könnte mit ein bisschen Rekursionszauber viel kürzer sein, aber ich kann meinen Kopf noch nicht darum wickeln. Werde später einen neuen Look haben und diesen hoffentlich verbessern.

Python 2, 83 Bytes

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

Perl 6 , 40 Bytes

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

(Wenn Sie möchten, dass es ein Int zurückgibt, setzen Sie ein +Recht vor [~])

Verwendung:

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

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

Ziemlich einfach.

PHP, 102 Bytes

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

Online Version

PHP, 95 Bytes

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 Bytes

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

Probieren Sie es online!

Nicht der längste Eintrag! \O/

Python 2 , 70 Bytes

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

Probieren Sie es online!

Axiom 146 Bytes

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 und Ergebnisse [RATS-Sequenz]

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

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

Probieren Sie es online!