Étant donné un nombre> 0, sortez la somme avec tous les chiffres (1 .. n) concaténés et inversés et additionnez-les. Par exemple, avec n = 6:

Les numéros 1 à 6 concaténés:

123456

Renversé:

654321

Les additionner ensemble donnera: 777777. Un autre exemple est n = 11:

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

et

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

Les additionner ensemble se traduira par 2345555545332. Ceci est également connu comme A078262 .

Le code le plus court gagne!

05AB1E, 7 octets

LDRJsJ+

Essayez-le en ligne.

Explication

LDRJsJ+

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

Gelée, 9 octets

R,U$DF€ḌS

CJam, 15 14 octets

Merci à Martin d'avoir rasé un octet!

ri,:)_W%si\si+

Essayez-le en ligne!

Pyth, 12 10 octets

ssMjLk_BSQ

Merci à @FryAmTheEggman pour 2 octets!

Qest l'entrée, Sil se transforme en [1, 2, ..., input()], _Bbifurque il plus _(inverse) pour créer [rng, rev(rng)], jLkcartes au -dessus joinde k(qui est la variable « chaîne vide »), sMcartes intsur ce tableau résultant, et scalcule enfin la somme.

JavaScript (ES6), 70 67 64 octets

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

Corrigé pour répondre aux exigences, car l'ancien code a été créé en raison d'une mauvaise compréhension de l'entrée.

Python 3, 74

6 octets enregistrés grâce à DSM.

Rien de trop excitant, rejoignez les gammes puis convertissez-vous en pouces et ajoutez-les.

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

Rétine , 71

• 7 octets enregistrés grâce à @daavko.
• 3 octets économisés grâce aux fonctionnalités de la version 0.7.3

Parce que c'est manifestement le mauvais outil pour le travail.

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

Essayez-le en ligne.

Fonctionne pour des entrées jusqu'à 6, mais l'interpréteur en ligne expire après cela.

Jolf, 9 octets

Essayez-le ici! Remplacez ►par \x10.

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

Je peux être capable de jouer au golf en se déplaçant autour du casting de type.

JavaScript (ES6), 67 66 octets

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

Oui, c'est un espace. Pouah. Au moins @Downgoat m'a aidé à économiser un octet.

Sérieusement, 12 octets

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

Essayez-le en ligne!

Explication:

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

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

Convertit l'entrée en plages avec .., puis -joinles regroupe et les additionne.

Fonctionnera pour les numéros d'entrée jusqu'à 138, tandis que 139donnera Infinity, et au 140-dessus résoudra une erreur de casting incroyablement verbeuse:

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

Pyth - 8 octets

siRT_BSQ

Essayez-le en ligne ici .

JavaScript (ES6), 99

Cela ajoute chiffre par chiffre, de sorte qu'il peut gérer des nombres bien supérieurs aux 53 bits de précision de 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")

Tester

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 octets

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

MATL , 13 octets

:tP2:"wVXvU]+

EDIT (20 mai 2016) Le code dans le lien utilise à la Xzplace de Xv, en raison de récents changements dans la langue.

Essayez-le en ligne!

:                % 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 octets

LJDR+

Explication:

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

Essayez-le en ligne!

Bash + coreutils, 39

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

Ou:

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

Ideone.

Perl 6 , 25 octets

{([~] @_=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
}

Usage:

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

777777
2345555545332
244567776755433

R, 34 60 64 octets

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

Suppose que le pryrpackage est installé. cela donne fun raccourci pour créer des fonctions.

Edit ajouté 26 octets mais renvoie une fonction qui fonctionne, pas quelque chose de complètement faux.

Edit a ajouté encore 4 octets pour gérer les cas au-dessus de n = 10 où strtoi (précédemment utilisé) retournait NA

Lua, 57

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

Lua, 53 octets

Ce programme prend ncomme argument de ligne de commande.

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

J'ai supposé que la sortie d'un nombre avec une partie décimale de 0 était correcte (dans le formulaire 777777.0car c'est la façon par défaut de sortir un nombre en lua (il n'y a pas de distinction entre entier et flottant)

Perl 5, 37 octets

25 octets, plus 1 pour -pet 11 pour-MList::Gen

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

Solution précédente, 40 octets: 39, plus un pour -p

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

Perl, 36 octets

Comprend +1 pour -p

Courir avec sur STDIN

perl -p reverse.pl <<< 6

reverse.pl

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

Dyalog APL , 17 octets

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

⎕invite pour entrée
⍳'énumérer jusqu'à entrée
x←stocker la liste dans x
⌽inverser x
x(… )ajouter la liste inversée avec la liste d'origine
⍕¨¨convertir chaque numéro de chaque liste en chaîne de caractères
∊¨transformer chaque liste de chaînes de caractères en chaînes de caractères simples
⍎¨convertir chaque chaîne de caractères en un nombre
+/additionner les deux nombres .

Mathematica, 64 octets

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

Rétine, 80 octets (codage ISO 8859-1)

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

IO est en unaire avec 'comme caractère de comptage. En théorie, prend en charge tout entier que vous lui lancez, en pratique ... l'interprète en ligne refuse de traiter tout ce qui dépasse 6 (unaire '''''').

Essayez-le en ligne!
Essayez-le en ligne! (IO décimal - 91 octets)

𝔼𝕊𝕄𝕚𝕟, 12 caractères / 15 octets

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

Try it here (Firefox only).

Meh.

Explication

Prend une gamme [1,input], la rejoint; prend cette même plage, l'inverse, puis la rejoint; la somme des deux plages est le résultat.

Ruby, 40 caractères

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

Exemple d'exécution:

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 octets

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

Pourrait peut-être jouer au golf plus loin. Pas vraiment sûr.

Groovy, 42 39 caractères

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

Exemple d'exécution:

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

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