Étant donné un entier positif n en entrée, sortez la somme de plage inversée de n.

Une somme de plage inversée est créée en créant une plage inclusive jusqu'à n, en commençant par 1 et en incluant n, en inversant chacun des nombres à l'intérieur et en le sommant.

Exemple:

Voici ce qui se passerait pour une entrée de 10:

Gamme: [1,2,3,4,5,6,7,8,9,10]

Inverse: [1,2,3,4,5,6,7,8,9,01](les nombres à 1 caractère inversés sont eux-mêmes, 10 inversés est 01 ou 1)

Somme: 46

Les nombres avec 3+ chiffres sont inversés de la même manière que les nombres avec 2 chiffres. Par exemple, 1234 deviendrait 4321.

Cas de test:

Input -> Output

10 -> 46
5 -> 15
21 -> 519
58 -> 2350
75 -> 3147
999 -> 454545

Les cas de texte complets à l'entrée de 999 peuvent être trouvés ici , merci beaucoup à @ fireflame241.

05AB1E , 3 octets

Code

LíO

Utilise l' encodage 05AB1E . Essayez-le en ligne!

Explication

L       # Range
 í      # Reverse
  O     # Sum

Utilitaires Bash + GNU, 24

seq $1|rev|paste -sd+|bc

Essayez-le en ligne .

Explication

seq $1                    # range
      |rev                # reverse (each line)
          |paste -sd+|bc  # sum

JavaScript (ES6), 42 octets

f=n=>n&&+[...n+""].reverse().join``+f(n-1)

Ma solution doublement récursive préférée est malheureusement 3 octets de plus:

f=n=>n&&+(g=x=>x?x%10+g(x/10|0):"")(n)+f(n-1)

Perl 6 , 20 octets

{(1..$_)».flip.sum}

Essaye-le

Étendu:

{
   ( 1 .. $_ )\  # Range
   ».flip        # flip each value in the Range (possibly in parallel)
   .sum          # sum up the list
}

Rétine , 41 36 35 octets

.+
$*
1
1$`¶
1+
$.&
%O^$`.

.+
$*
1

Essayez-le en ligne! Le lien inclut des cas de test. Edit: 5 octets enregistrés grâce à @FryAmTheEggman. 1 octet enregistré grâce à @ PunPun1000. Explication:

.+
$*

Convertissez en unaire.

1
1$`¶

Créez une plage de 1à n.

1+
$.&

Reconvertissez en décimal.

%O^$`.

Inversez chaque numéro.

.+
$*

Revenez à unaire.

1

Additionnez et reconvertissez en décimal.

Gelée , 4 octets

Ṛ€ḌS

Essayez-le en ligne!

Comment?

Ṛ€ḌS - Link: n
Ṛ€   - reverse for €ach (in implicit range)
  Ḍ  - convert from decimal list (vectorises)
   S - sum

Haskell, 34 octets

\n->sum$read.reverse.show<$>[1..n]

Simple et direct.

C (gcc) , 63 octets

f(n){int t=0,c=n;for(;c;c/=10)t=t*10+c%10;return n?t+f(n-1):0;}

Essayez-le en ligne!

cQuents , 4 octets

;\r$

Essayez-le en ligne!

Explication

       Implicit input n.
;      Series mode. Outputs the sum of the sequence from 1 to n.
 \r$   Each item in the sequence equals:
 \r    String reverse of
   $                     current index (1-based)

Python 2 , 38 octets

Impossible de calculer des termes supérieurs à la limite de récursivité:

f=lambda x:x and int(`x`[::-1])+f(x-1)

Essayez-le en ligne!

Brachylog , 4 octets

⟦↔ᵐ+

Essayez-le en ligne!

Explication

⟦↔ᵐ+
⟦        range from 0 to input
 ↔ᵐ      map reverse
   +     sum

Röda , 56 41 36 octets

15 octets économisés grâce à @fergusq

{seq 1,_|parseInteger`$_`[::-1]|sum}

Essayez-le en ligne!

Il s'agit d'une fonction anonyme qui prend un entier dans le flux d'entrée et génère un entier dans le flux de sortie.

Explication

{seq 1,_|parseInteger`$_`[::-1]|sum} Anonymous function
 seq 1,_                             Create a sequence 1 2 3 .. input and push each value to the stream
        |                            For each value in the stream:
                     `$_`             Cast it into a string
                         [::-1]       And reverse it
         parseInteger                 And parse the resulting string as an integer, while pushing the value to the stream
                               |sum  Sum all the values in the stream

C # (.NET Core) , 103 97 octets

using System.Linq;r=>new int[r+1].Select((_,n)=>int.Parse(string.Concat((n+"").Reverse()))).Sum()

Essayez-le en ligne!

Le lien TIO génère tous les résultats de 1 à 999, alors n'hésitez pas à vérifier mon travail.

Je m'attendais à ce que ce soit un peu plus court, mais il s'avère que Reverse()renvoie une IEnumerable<char>au lieu d'une autre chaîne, j'ai donc dû ajouter un peu plus pour la transformer en chaîne afin de pouvoir l'analyser en un int. Il y a peut-être un moyen plus court de passer de IEnumerable<char>à int correctement.

Il est à noter que cela utilise également les fonctions Range() Reverse() et Sum()tout dans l'ordre.

-6 octets grâce à TheLethalCoder

Rubis, 56, 52, 41, 39 octets

->n{(1..n).sum{|i|i.to_s.reverse.to_i}}

Ruby, 34 octets (si le paramètre lambda est une chaîne)

->n{(1..n).sum{|i|i.reverse.to_i}}

Merci à @Unihedron pour la deuxième solution.

Mathematica, 47 octets

Tr[FromDigits@*Reverse/@IntegerDigits@Range@#]&

Essayez-le en ligne! (afin de travailler sur les mathématiques, nous devons remplacer "Tr" par "Total")

Fusain , 14 13 octets

-1 octet grâce à Carlos Alejo

Ｉ∕…·⁰Ｎ«⁺ιＩ⮌Ｉκ

Essayez-le en ligne! Le lien est vers la version détaillée.

Explication

Ｉ                  Cast
  ∕     «           Reduce
   …·⁰Ｎ            Inclusive range from 0 to input as number
         ⁺          Plus
          ι         i
           Ｉ⮌Ｉκ   Cast(Reverse(Cast(k)))

Magneson , 102 octets

Ce n'est pas très visible, alors voici une version à plus grande échelle (Remarque: ne fonctionnera pas réellement et n'est toujours pas très jolie)

Magneson fonctionne en analysant une image et en évaluant les commandes à partir des couleurs des pixels qu'elle lit. Donc, en parcourant l'image de ce défi, nous avons:

• R: 0, G: 1, B: 1est une commande d'affectation d'entier, qui prend une chaîne pour le nom de variable et la valeur à affecter. Nous allons l'utiliser pour stocker la somme totale.
• R: 0, G: 1, B: 0est une chaîne précompilée avec la valeur VAR_1(Remarque: ce n'est que lorsque nous demandons une chaîne; le code de couleur a une fonction distincte lorsqu'il est utilisé ailleurs).
• R: 3, G: 0, B: 0est un nombre brut. Magneson gère les nombres standard en exigeant que le composant rouge soit exactement 3, puis forme un nombre en utilisant directement la valeur bleue plus la valeur verte multipliée par 256. Dans ce cas, nous obtenons simplement le nombre 0.
• R: 0, G: 1, B: 1est une autre commande d'affectation d'entiers. Cette fois, nous stockons une variable d'itération, pour garder une trace du nombre sur lequel nous sommes
• R: 0, G: 1, B: 1est une chaîne prédéfinie avec la valeur VAR_2(une fois de plus, uniquement lorsque nous avons besoin d'une chaîne)
• R: 3, G: 0, B: 0est le nombre 0, une fois de plus. Sur les morceaux intéressants maintenant.
• R: 1, G: 0, B: 0indique le début d'une boucle. Cela prend un certain nombre et boucle plusieurs fois l'extrait de code suivant.
• R: 2, G: 0, B: 0est la fonction STDIN, ou du moins c'est quand nous avons besoin d'un nombre. Cela lit une ligne d'entrée de la console et la transforme en nombre, puisque nous avons demandé un nombre.
• R: 0, G: 8, B: 0démarre notre code en boucle, et c'est une commande additive. Cela ajoute un nombre à une variable entière et prend donc une chaîne pour le nom de la variable et le nombre à ajouter.
• R: 0, G: 1, B: 1est la chaîne précompilée pour VAR_2, qui est notre variable d'itération.
• R: 3, G: 0, B: 1 est un nombre brut, mais cette fois c'est le numéro 1.
• R: 0, G: 8, B: 0 est une autre commande d'addition.
• R: 0, G: 1, B: 0est la chaîne pour VAR_1, qui est notre somme totale.
• R: 0, G: 3, B: 0est une fonction qui inverse une chaîne. Dans le contexte de la demande d'un nombre, il convertit ensuite la chaîne inversée en nombre.
• R: 0, G: 2, B: 1est une commande de récupération d'entier, et récupérera le nombre stocké dans une variable fournie. Dans le contexte de la demande d'une chaîne (comme à partir de la commande inverse), il convertit le nombre en chaîne.
• R: 0, G: 1, B: 1est le nom VAR_2; notre variable d'itération.
• R: 1, G: 0, B: 1est le marqueur pour terminer la boucle, et revenir au début de la boucle si les critères ne sont pas remplis (donc si nous devons continuer à boucler). Sinon, continuez.
• R: 0, G: 0, B: 1 est une commande println très simple et prend une chaîne.
• R: 0, G: 2, B: 1 récupère un entier à partir d'une variable

• R: 0, G: 1, B: 0 est le nom de notre variable somme totale, VAR_1

  Dans l'ensemble, le programme:

• Attribue la valeur 0 à VAR_1etVAR_2
• Boucles de 0 à un nombre fourni dans STDIN
  • Ajoute un à VAR_2
  • Ajoute la valeur entière de l'inversion VAR_2àVAR_1
• Imprime le contenu de VAR_1

Python 2 , 50 47 octets

-3 octets grâce à officialaimm!

lambda n:sum(int(`i+1`[::-1])for i in range(n))

Essayez-le en ligne!

CJam, 12 bytes

ri){sW%i}%:+

Try it online!

-1 thanks to Business Cat.

Explanation:

ri){sW%i}%:+
r            Get token
 i           To integer
  )          Increment
   {sW%i}    Push {sW%i}
    s         To string
     W        Push -1
      %       Step
       i      To integer
         %   Map
          :+ Map/reduce by Add

APL (Dyalog), 10 7 bytes

3 bytes golfed thanks to @Adám by converting to a tradfn from a train

+/⍎⌽⍕⍳⎕

Try it online!

⎕          Input (example input: 10)
⍳          Range; 1 2 3 4 5 6 7 8 9 10
⍕          Stringify; '1 2 3 4 5 6 7 8 9 10'
⌽          Reverse; '01 9 8 7 6 5 4 3 2 1'
⍎          Evaluate; 1 9 8 7 6 5 4 3 2 1
+/         Sum; 46

Java 8, 97 bytes

IntStream.range(1,n+1).map(i->Integer.valueOf(new StringBuffer(""+i).reverse().toString())).sum()

EDIT

As per the comment of Kevin Cruijssen, I would like to improve my answer.

Java 8, 103 bytes

n->java.util.stream.LongStream.range(1,n+1).map(i->new Long(new StringBuffer(""+i).reverse()+"")).sum()

Japt, 7 5 bytes

-2 bytes thanks to @Shaggy.

õs xw

Try it online!

Explanation

õs xw  Implicit input of integer U
õs     Create range [1,U] and map to strings
    w  Reverse each string
   x   Sum the array, implicitly converting to numbers.

Old solution, 7 bytes

Keeping this since it's a really cool use of z2.

õs z2 x

Try it online!

Explanation

õs z2 x  Implicit input of integer U
õs       Create range [1,U] and map to strings
   z2    Rotate the array 180°, reversing strings
      x  Sum the array, implicitly converting back to integers

C++, 146 bytes

#include<string>
using namespace std;int r(int i){int v=0,j=0;for(;j<=i;++j){auto t=to_string(j);reverse(t.begin(),t.end());v+=stoi(t);}return v;}

Husk, 7 6 3 bytes

ṁ↔ḣ

Try it online!

Ungolfed/Explanation

  ḣ  -- With the list [1..N] ..
ṁ    -- .. do the following with each element and sum the values:
 ↔   --    reverse it

Perl 5, 29 27 22 + 1 (-p) = 23 bytes

map$\+=reverse,1..$_}{

Try it online!

RProgN 2, 8 bytes

{Ø.in}S+

Explained

{Ø.in}S+
{    }S # Create a stack in range 0 through the implicit input, using the function defined
 Ø.     # Append nothing, stringifying the number
   i    # Reverse the string
    n   # Convert back to a number
       +# Get the sum of the stack, and output implicitly.

Try it online!

Pyth, 8 6 bytes

^{-2 bytes thanks to FryAmTheEggman!}

sms_`h

Try it online!

Tcl, 66 bytes

time {incr s [regsub ^0+ [string rev $n] ""];incr n -1} $n
puts $s

Try it online!

Neim, 4 bytes

Δ𝐫)𝐬

Try it online!

Explanation

Δ )              for each element 1 to n (outputs list)
 𝐫               reverse 
   𝐬             sum 

C (gcc), 71 bytes

q(n,x,p){p=n?q(n/10,x*10+n%10):x;}f(w,a,e){for(a=0;w;)a+=q(w--,0);e=a;}

Try it online!