Il tuo compito è generare l'ennesimo termine della sequenza RATS, dove n è l'input. La sequenza RATS è anche nota come sequenza Aggiungi quindi ordina inversa. Questa sequenza può essere trovata anche qui: http://oeis.org/A004000 .

casi test:

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

Ad esempio, l'output per 5 è 77 perché 16 + 61 = 77. Successivamente viene ordinato il 77.

Vince l'invio più breve. Questa è la mia prima sfida, quindi spero che questo non sia un duplicato o qualcosa del genere.

MATL , 11 12 byte

1i"tVPU+VSU

L'input è una stringa (con virgolette singole) che rappresenta un numero intero in unario . L'input di stringhe è consentito dalla sfida e unario è un formato valido .

Provalo online!

Spiegazione

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 byte

Codice:

$FDR+{

Spiegazione:

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

Questo funziona anche con un programma da 0 byte .

CJam, 15 byte

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

Provalo qui.

Spiegazione

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 byte

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

Provalo sull'interprete online .

Python 2, 72

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

La funzione ricorsiva, utilizza la scorciatoia di Python 2 per __repr__, che si interromperà quando la funzione raggiunge valori molto grandi ( Lverrà aggiunta alla stringa del numero), non sono sicuro dalle specifiche se c'è un posto dove possiamo fermarci , ma se non cambia instr() aggiungere solo 6 byte, ma diventa leggermente più breve per l'output come stringa, a 75 byte:

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

1 byte salvato grazie a trichoplax su questa versione

JavaScript ES6, 70 byte

Salvato 1 byte grazie a @ user81655

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

sospiro JavaScript è davvero dettagliato. Un sacco (> 50%) del codice è solo caso di funzione di stringa + array + unirsi + cast int. Ho provato a ridurre, valutare e ogni genere di cose, ma questa sembra essere la più breve.

Provalo online (tutti i browser funzionano)

Brachylog , 19 byte

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

Spiegazione

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 byte

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

Esempio di utilizzo: (g"1"!!) 7->"668" .

È un'implementazione diretta della definizione: a partire da "1", aggiungi ripetutamente il risultato reverse-add-sort dell'elemento corrente. La funzione principale (g"1"!!)seleziona l' ielemento th.

Julia, 77 byte

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

Questa è una funzione lambda che accetta un numero intero e restituisce un numero intero. Per chiamarlo, assegnarlo a una variabile.

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

Gelatina, 13 12 byte

Sono sicuro che questo può probabilmente essere giocato a golf, poiché questa è la mia prima risposta in Jelly / in un linguaggio tacito.

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: salvato 1 byte, grazie a Dennis

Java 1.8, 251 byte

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

allargato

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

Scherzi a parte, 17 byte

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

Provalo online!

Spiegazione:

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

Lua, 179 156 byte

Non riesco a vedere come potrei golf di più, ma sono sicuro che c'è un modo. Grazie a @LeakyNun ho avuto il tempo di scendere su questo e giocare a golf nel modo giusto, potrei forse ancora guadagnare qualche byte usando un altro approccio.

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

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 byte, sfida postdatati in lingua

;1{↔;?+o}ⁱ⁽

Provalo online!

Spiegazione

;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

Non sono del tutto chiaro su cosa faccia questo con zero cifre, ma la domanda non indica alcuna gestione particolare e probabilmente non compaiono comunque nella sequenza.

ES6, 79 byte

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

82 byte senza eval:

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

Tutte quelle conversioni sono dolorose.

@ edc65 Io in realtà salvato 4 byte passando da mapa reducequesto momento ... Non c'è dubbio che lo dimostrerò me sbagliato ancora una volta però.

Python 2, 91 byte

Immettere come intero, il risultato viene stampato sullo schermo.

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

Questo potrebbe essere molto più breve con un po 'di magia ricorsiva, immagino, ma non posso ancora avvolgere la testa. Daremo uno sguardo più tardi e spero di migliorarlo.

Python 2, 83 byte

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

Perl 6 , 40 byte

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

(Se vuoi che restituisca un Int, metti un +diritto prima [~])

Uso:

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

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

Abbastanza semplice.

PHP, 102 byte

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

Versione online

PHP, 95 byte

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 byte

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

Provalo online!

Non è la voce più lunga! \ O /

Python 2 , 70 byte

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

Provalo online!

Assioma, 146 byte

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 e risultati [sequenza 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 byte

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

Provalo online!