Dato un numero> 0, emetti la somma con tutte le cifre (1 .. n) concatenate e invertite e sommale. Ad esempio, con n = 6:

I numeri da 1 a 6 concatenati:

123456

invertito:

654321

Sommandoli insieme si otterrà: 777777. Un altro esempio è n = 11:

1 2 3 4 5 6 7 8 9 10 11 > 1234567891011

e

11 10 9 8 7 6 5 4 3 2 1 > 1110987654321

Sommarli insieme comporterà 2345555545332. Questo è anche noto come A078262 .

Vince il codice più corto!

05AB1E, 7 byte

LDRJsJ+

Provalo online.

Spiegazione

LDRJsJ+

L        range from 1 .. input
 D       duplicate
  R      reverse
   JsJ   convert both arrays to strings
      +  add (coerces both strings to ints)

Gelatina, 9 byte

R,U$DF€ḌS

CJam, 15 14 byte

Grazie a Martin per aver rasato un byte!

ri,:)_W%si\si+

Provalo online!

Pyth, 12 10 byte

ssMjLk_BSQ

Grazie a @FryAmTheEggman per 2 byte!

Qè l'input, lo Strasforma in [1, 2, ..., input()], lo _Bbiforcisce su _(inverso) per creare [rng, rev(rng)], lo jLkmappa jointramite k(che è la variabile "stringa vuota"), sMesegue intil mapping su questo array risultante e sinfine calcola la somma.

JavaScript (ES6), 70 67 64 byte

a=>(z=[...Array(a)].map((b,c)=>c+1)).join``- -z.reverse().join``

Risolto il problema per soddisfare i requisiti, dato che il vecchio codice era stato creato sotto incomprensione dell'input.

Python 3, 74

6 byte salvati grazie a DSM.

Niente di troppo eccitante, unisciti alle gamme e poi converti in ints e aggiungili.

lambda x:sum(int(''.join(list(map(str,range(1,x+1)))[::i]))for i in(1,-1))

Retina , 71

• 7 byte salvati grazie a @daavko.
• 3 byte salvati grazie alle funzionalità della versione 0.7.3

Perché è palesemente lo strumento sbagliato per il lavoro.

.+
$*a:$&$*
+`^(a+)a\b(.*)\b1(1+)$
$1 $& $3
 ?(\w)+ ?
$#1
\d+:?
$&$*c
c

Provalo online.

Funziona con input fino a 6, ma l'interprete online scade dopo.

Jolf, 9 byte

Provalo qui! Sostituisci ►con \x10.

+P►γzjP_γ
    zj    range 1...j
   γ      γ = ^
  ►        ^ .join("")
 P         as a number
+     P_γ  and γ reversed

Io possa essere in grado di golf spostando intorno al tipo di fusione.

JavaScript (ES6), 67 66 byte

n=>(a=[...Array(n+1).keys()].slice(1)).join``- -a.reverse().join``

Sì, quello è uno spazio. Ugh. Almeno @Downgoat mi ha aiutato a salvare un byte.

Scherzi a parte, 12 byte

,R;Rεj≈@εj≈+

Provalo online!

Spiegazione:

,R;Rεj≈@εj≈+
,R;           push two copies of range(1, input()+1)
   R          reverse one copy
    εj≈@εj≈   concatenate both and cast both to ints
           +  add

PowerShell, 35 byte

param($a)+-join(1..$a)+-join($a..1)

Converte l'input in intervalli con .., quindi -joinli unisce e li aggiunge.

Funzionerà per i numeri di input fino a 138, mentre 139darà Infinity, 140e soprattutto emetterà un errore di casting incredibilmente dettagliato:

Cannot convert value "12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413
5136137138139140" to type "System.Int32". Error: "Value was either too large or too small for an Int32."

Pyth - 8 byte

siRT_BSQ

Provalo online qui .

JavaScript (ES6), 99

Questo aggiunge cifra per cifra, quindi può gestire numeri ben al di sopra dei 53 bit di precisione di JavaScript

n=>eval("for(a=b=c=r='';n;a+=n--)b=n+b;for(i=a.length;i--;r=c%10+r)c=(c>9)-(-a[i]-b[i]);c>9?1+r:r")

Test

f=n=>eval("for(a=b=c=r='';n;a+=n--)b=n+b;for(i=a.length;i--;r=c%10+r)c=(c>9)-(-a[i]-b[i]);c>9?1+r:r")

// Less golfed
U=n=>{
  for(a=b=c=r=''; n; --n)
      b=n+b, a+=n;
  for(i=a.length; i--; r = c%10+r) 
      c=(c>9)-(-a[i]-b[i]);
  return c>9? 1+r : r;
}

function test() {
  var n=+I.value
  R.textContent=f(n)
}  

test()

N: <input id=I value=11 oninput="test()"> -> <span id=R></span>

Brachylog , 24 byte

:1fLrcC,Lc+C=.,{,.:1re?}

MATL , 13 byte

:tP2:"wVXvU]+

EDIT (20 maggio 2016) Il codice nel link utilizza Xzinvece di Xv, a causa di recenti cambiamenti nella lingua.

Provalo online!

:                % range [1,2,...,n], where n is input
 tP              % duplicate and flip
   2:"     ]     % do this twice
      w          % swap
       V         % convert array of numbers to string with numbers and spaces
        Xv       % remove spaces
          U      % convert to number
            +    % add the two numbers

05AB1E , 5 byte

LJDR+

Spiegazione:

L     # Pushes an array containing 1 .. [implicit] input
 J    # Join the array to a string (eg. [1, 2, 3] -> 123)
  D   # Duplicate the array
   R  # Reverse the duplicate
    + # Add them together

Provalo online!

Bash + coreutils, 39

eval echo {1..$1} + {$1..1}|tr -d \ |bc

O:

bc<<<`eval printf %s {1..$1} + {$1..1}`

Ideone.

Perl 6 , 25 byte

{([~] @_=1..$^n)+[R~] @_}

{
  (
    [~]           # reduce with the string concatenation infix op:
    @_ = 1 .. $^n # the range 1 to input ( also stored in @_ )
  )
  +               # add that to
  [R~] @_         # @_ reduced in reverse
}

Uso:

for 6, 11, 12 -> $n {
  say {([~] @_=1..$^n)+[R~] @_}( $n )
}

777777
2345555545332
244567776755433

R, 34 60 64 byte

f=pryr::f;g=f(as.numeric(paste(x,collapse='')));f(g(1:n)+g(n:1))

Presuppone che il pryrpacchetto sia installato. questo dà funa scorciatoia per la creazione di funzioni.

Modifica ha aggiunto 26 byte ma restituisce una funzione che funziona, non qualcosa di completamente sbagliato.

Modifica ha aggiunto altri 4 byte per gestire i casi sopra n = 10 in cui stava tornando strtoi (precedentemente utilizzato) NA

Lua, 57

a=''b=''for i=1,...do a=a..i b=b.. ...-i+1 end return a+b

Lua, 53 byte

Questo programma accetta ncome argomento della riga di comando.

s=""r=s for i=1,arg[1]do r,s=i..r,s..i end print(s+r)

Ho supposto che l'output di un numero con una parte decimale di 0 andasse bene (nella forma 777777.0perché questo è il modo predefinito per produrre un numero in lua (non c'è distinzione tra intero e float)

Perl 5, 37 byte

25 byte, più 1 per -pe 11 per-MList::Gen

$_=<[.]1..$_>+<[R.]1..$_>

Soluzione precedente, 40 byte: 39, più uno per -p

@a=reverse@_=1..$_;$"=$\;$_="@a"+"@_"

Perl, 36 byte

Include +1 per -p

Esegui con su STDIN

perl -p reverse.pl <<< 6

reverse.pl

$_=eval join"",map{abs||"+"}-$_..$_

Dyalog APL , 17 byte

+/⍎¨∊¨⍕¨¨x(⌽x←⍳⎕)

⎕richiesta di input
⍳'enumera fino a quando l'
x←elenco dell'archivio di input in x
⌽reverse x
x(... )antepone l'elenco invertito con l'elenco originale
⍕¨¨converte ogni numero di ogni elenco in stringa di caratteri,
∊¨trasformando ogni elenco di stringhe di caratteri in stringhe di caratteri singoli
⍎¨convertendo ogni stringa di caratteri in un numero
+/somma i due numeri .

Mathematica, 64 byte

Plus@@FromDigits/@#&[""<>ToString/@#&/@{#,Reverse@#}&[Range@#]]&

Retina, 80 byte (codifica ISO 8859-1)

'+
$0¶$0
+`^(('+)')
$2 $1
+`('('+))$
$1 $2
(')+( |$)?
$#1
(\d+)¶(\d+)
$1$*'$2$*'

IO è unario con 'il carattere di conteggio. In teoria supporta qualsiasi numero intero che ci passi, in pratica ... l'interprete online rifiuta di elaborare qualcosa di più grande di 6 (unario '''''').

Provalo online!
Provalo online! (IO decimale - 91 byte)

𝔼𝕊𝕄𝕚𝕟, 12 caratteri / 15 byte

⨭⟮⩤⁽1ï⟯⨝,Ⅰᴚ⨝

Try it here (Firefox only).

Meh.

Spiegazione

Prende un intervallo [1,input], lo unisce; prende lo stesso intervallo, lo inverte, quindi lo unisce; la somma di entrambi gli intervalli è il risultato.

Rubino, 40 caratteri

->n{eval (l=[*1..n])*''+?++l.reverse*''}

Esecuzione di esempio:

irb(main):001:0> ->n{eval (l=[*1..n])*''+?++l.reverse*''}[11]
=> 2345555545332

irb(main):002:0> ->n{eval (l=[*1..n])*''+?++l.reverse*''}[6]
=> 777777

C #, 126 byte

using System.Linq;a=>{var b=Enumerable.Range(1,a);return long.Parse(string.Concat(b))+long.Parse(string.Concat(b.Reverse()));}

Potrebbe essere possibile giocare a golf ulteriormente. Non sono proprio sicuro.

Groovy, 42 39 caratteri

{[1..it,it..1]*.join()*.toLong().sum()}

Esecuzione di esempio:

groovy:000> ({[1..it,it..1]*.join()*.toLong().sum()})(11)
===> 2345555545332

groovy:000> ({[1..it,it..1]*.join()*.toLong().sum()})(6)
===> 777777