[Question]
  [
Given a positive integer n as input, output the reversed range sum of n.
A reversed range sum is created by making an inclusive range up to n, starting with 1 and including n, reversing each of the numbers inside, and summing it.
**Example:**
Here is what would happen for an input of 10:
Range: `[1,2,3,4,5,6,7,8,9,10]`
Reverse: `[1,2,3,4,5,6,7,8,9,01]` (1-char numbers reversed are themselves, 10 reversed is 01 or 1)
Sum: `46`
Numbers with 3+ digits are reversed the same way numbers with 2 digits are. For example, 1234 would become 4321.
**Test cases:**
```
Input -> Output
10 -> 46
5 -> 15
21 -> 519
58 -> 2350
75 -> 3147
999 -> 454545
```
Complete text cases to input of 999 can be found [here](https://pastebin.com/2TdCfeS4), thanks very much to @fireflame241.
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 3 bytes
### Code
```
LíO
```
Uses the **05AB1E** encoding. [Try it online!](https://tio.run/##MzBNTDJM/f/f5/Ba////zU0B "05AB1E – Try It Online")
### Explanation
```
L       # Range
 í      # Reverse
  O     # Sum
```
[Answer]
# Bash + GNU utils, 24
```
seq $1|rev|paste -sd+|bc
```
[Try it online](https://tio.run/##Nco7DoAgEAXAnlO8ws6QiAlR4mn4rNEGlN1YcXe0ceoJno@@lwohluiZcGaYCRazgV2xWDjnsCEVhQ@TQGsMf1ed6cZgWqWnXZ6FoDmNLcSeSqb@Ag).
### Explanation
```
seq $1                    # range
      |rev                # reverse (each line)
          |paste -sd+|bc  # sum
```
[Answer]
## JavaScript (ES6), 42 bytes
```
f=n=>n&&+[...n+""].reverse().join``+f(n-1)
```
My favorite doubly-recursive solution is unfortunately 3 bytes longer:
```
f=n=>n&&+(g=x=>x?x%10+g(x/10|0):"")(n)+f(n-1)
```
[Answer]
# [Perl 6](https://perl6.org), 20 bytes
```
{(1..$_)».flip.sum}
```
[Test it](https://tio.run/##TY7dCoJAEIXv5ykGkVjR1lZbTaToIboMonQDwZ@l1SiiJ@oRuvPFrLGImIsZzvnOYbQ6ldHQGYXniGcpVFecZE2ucDncmODc3jn9kx/LQnPTVfdhJNatMi0u0e0fZVErw4jJmurA/G3u@k4KVLh5Qynocl@jOyZSODanb3i6QoZ2Ueuu9dBWF62yVuXo4A0QC4P0A/v4zh/gofURqeCnWnAfxIykeQSStpAQCDqkSEAu6ApCOYN4dEMxjyFJkjEhaV4 "Perl 6 – Try It Online")
## Expanded:
```
{
   ( 1 .. $_ )\  # Range
   ».flip        # flip each value in the Range (possibly in parallel)
   .sum          # sum up the list
}
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 63 bytes
```
f(n){int t=0,c=n;for(;c;c/=10)t=t*10+c%10;return n?t+f(n-1):0;}
```
[Try it online!](https://tio.run/##FYxNDoIwEIXXcAqCIWkt6NSlQ/UibshAdRIdTC0rwtkr3by8n3yPuidROrDQexmnqv/FkefT65a8Er2yxCo6aMkJ@jkoJKSzs6Cji0cLhhoLGKa4BKnkHs0OdVZfAbeU0c/AorIZ9FoW@SAHdoDcW9jVmDwU37D3XtXN@JC69Yq1xrLYyi2li/0D "C (gcc) – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~41~~ ~~36~~ 35 bytes
```
.+
$*
1
1$`¶
1+
$.&
%O^$`.
.+
$*
1
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wX0@bS0WLy5DLUCXh0DYuQyBPT41L1T9OJUGPiwsq@f@/oQGXKZeRIZepBZe5KZelpSUA "Retina – Try It Online") Link includes test cases. Edit: Saved 5 bytes thanks to @FryAmTheEggman. Saved 1 byte thanks to @PunPun1000. Explanation:
```
.+
$*
```
Convert to unary.
```
1
1$`¶
```
Create a range from `1` to `n`.
```
1+
$.&
```
Convert back to decimal.
```
%O^$`.
```
Reverse each number.
```
.+
$*
```
Convert back to unary.
```
1
```
Sum and convert back to decimal.
[Answer]
# [Python 2](https://docs.python.org/2/), 38 bytes
Can't compute higher terms than the recursion limit:
```
f=lambda x:x and int(`x`[::-1])+f(x-1)
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P802JzE3KSVRocKqQiExL0UhM69EI6EiIdrKStcwVlM7TaNC11Dzf0ERUFwhTcPcVPM/AA "Python 2 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Ṛ€ḌS
```
**[Try it online!](https://tio.run/##y0rNyan8///hzlmPmtY83NET/P//f3NTAA "Jelly – Try It Online")**
### How?
```
Ṛ€ḌS - Link: n
Ṛ€   - reverse for €ach (in implicit range)
  Ḍ  - convert from decimal list (vectorises)
   S - sum
```
[Answer]
# Haskell, 34 bytes
```
\n->sum$read.reverse.show<$>[1..n]
```
Simple and straightforward.
[Answer]
# [cQuents](https://github.com/stestoltz/cQuents), 4 bytes
```
;\r$
```
[Try it online!](https://tio.run/##Sy4sTc0rKf7/3zqmSOX/f0tLSwA "cQuents – Try It Online")
## Explanation
```
       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)
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog/), 4 bytes
```
⟦↔ᵐ+
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//9H8ZY/apjzcOkH7/39Dg//@AA "Brachylog – Try It Online")
### Explanation
```
⟦↔ᵐ+
⟦        range from 0 to input
 ↔ᵐ      map reverse
   +     sum
```
[Answer]
# [Python 2](https://docs.python.org/2/), 50 47 bytes
 -3 bytes thanks to [officialaimm!](https://codegolf.stackexchange.com/users/59523/officialaimm)
```
lambda n:sum(int(`i+1`[::-1])for i in range(n))
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSHPqrg0VyMzr0QjIVPbMCHaykrXMFYzLb9IIVMhM0@hKDEvPVUjT1Pzf0ERUJFCmoahgeZ/AA "Python 2 – Try It Online")
[Answer]
# [Röda](https://github.com/fergusq/roda), ~~56~~ ~~41~~ 36 bytes
*15 bytes saved thanks to @fergusq*
```
{seq 1,_|parseInteger`$_`[::-1]|sum}
```
[Try it online!](https://tio.run/##K8pPSfyfFvO/uji1UMFQJ76mILGoONUzryQ1PbUoQSU@IdrKStcwtqa4NLf2f25iZl51tKWlZWxNWu1/AA "Röda – Try It Online")
This is an anonymous function that takes an integer from the input stream and outputs an integer to the output stream.
### Explanation
```
{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
```
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), ~~103~~ 97 bytes
```
using System.Linq;r=>new int[r+1].Select((_,n)=>int.Parse(string.Concat((n+"").Reverse()))).Sum()
```
[Try it online!](https://tio.run/##XU/BSsRADL3PV4Q9Zdg6sMdS24voSUG2Bw8iEse4DrTpOpmuSPHba1APYkIOeS95eYl6FqfM66xJDtB/aOGxcX@7cJ3krXFCI@uRIoMsLg6kCsfFaaGSIpym9Aw3lAT94q5miedJSmXVwZ7kwHs@cVbu5xHaNbed8DsYe5@3u4fQ88CxID5W4tvO4HBLNoxasrkIF5NEMlq2m40Pv0roLYLpoV8b92IfUHxF24VkwnAp88iZngYO3/dxV9V17c2cqelk8F1Ohe0zxn8GMXnfuM@fXL8A "C# (.NET Core) – Try It Online")
TIO link outputs all the results from 1 to 999, so feel free to check my work.
I expected this to be a bit shorter, but it turns out `Reverse()` returns an `IEnumerable<char>` instead of another string so I had to add some extra to turn it back into a string so I could parse it to an int. Maybe there's a shorter way to go from `IEnumerable<char>` to int correctly.
~~Of minor note, this also uses the functions `Range()` `Reverse()` and `Sum()` all in order.~~
-6 bytes thanks to TheLethalCoder
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~10~~ 7 bytes
*3 bytes golfed thanks to @Adám by converting to a tradfn from a train*
```
+/⍎⌽⍕⍳⎕
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKPd8b@2/qPevkc9ex/1Tn3Uu/lR31SQ8H8FMHDkMjTggjFN4SwjQ4SgBZxpjlBgaWkJAA "APL (Dyalog Unicode) – 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
```
[Answer]
# Ruby, ~~56, 52, 41,~~ 39 bytes
```
->n{(1..n).sum{|i|i.to_s.reverse.to_i}}
```
# Ruby, 34 bytes (if lambda param is a string)
```
->n{(1..n).sum{|i|i.reverse.to_i}}
```
Thanks to @Unihedron for the second solution. 
[Answer]
# [Vim](https://www.vim.org/), ~~39~~ ~~37~~ 28 bytes
```
D@"O<C-V><C-A>0<ESC>V{g<C-A>:%!rev
v}gJS0<ESC>@"
```
[Try it online!](https://tio.run/##K/v/38VByV@M0UA6rDqd0UpVsSi1jKusNt0r2EDaQen/f0tLy/@6ZQA "V (vim) – Try It Online")
Tons of bytes saved thanks to some [great advice by user41805](https://chat.stackexchange.com/transcript/message/57622507#57622507)
### Explanation
Step 1: build the range (with summing commands included)
```
D@"O<C-V><C-A>0<ESC>V{g<C-A>
D                               Delete the input number
 @"            <ESC>            Do that many times:
   O                              Insert a new line above
    <C-V><C-A>                    Write a <C-A> byte (\x01)
              0                   Followed by a 0
                    V{          Select all the lines just written
                      g<C-A>    Turn the numbers into an increasing range            
```
Step 2: reverse each number
`:%!rev` (that's it)
This will produce a sequence of lines with the reversed number followed by `<C-A>`, which is the command to increase a value by the reversed number. Leading 0s actually move the pointer to the beginning of the line, so they are effectively ignored.
Step 3: sum them all up
```
v}gJS0<ESC>@"
v}               Select all the lines to the end of the file
  gJ             Join them
    S            Replace this line
     0<ESC>         with a 0
           @"    Execute the replaced line as commands
```
[Answer]
# Mathematica, 47 bytes
```
Tr[FromDigits@*Reverse/@IntegerDigits@Range@#]&
```
[Try it online!](https://tio.run/##y00sychMLv6fZvs/JL8kMSfarSg/1yUzPbOk2EErKLUstag4Vd/BM68kNT21CCoelJiXnuqgHKv2P6AoM69EwSFNwcHS0vI/AA "Mathics – Try It Online") (in order to work on mathics we need to replace "Tr" with "Total")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~14~~ 13 bytes
-1 byte thanks to [Carlos Alejo](https://codegolf.stackexchange.com/users/70347/carlos-alejo)
```
Ｉ∕…·⁰Ｎ«⁺ιＩ⮌Ｉκ
```
[Try it online!](https://tio.run/##JYy7CoQwEAB/JeUGI1wbLLWxOQ7/IMZFF3NR8mrEb1/vdGDKGbuYYDfjmD@BfILWxAQdFZoQem9djlRwMH5GeCnR@z2nd/6OGEBKJY4nqoCUuMsBC4aIz2aVf86fDbPWmuvCdXQX "Charcoal – Try It Online") Link is to verbose version.
## Explanation
```
Ｉ                  Cast
  ∕     «           Reduce
   …·⁰Ｎ            Inclusive range from 0 to input as number
         ⁺          Plus
          ι         i
           Ｉ⮌Ｉκ   Cast(Reverse(Cast(k)))
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 12 bytes
```
ri){sW%i}%:+
```
[Try it online!](https://tio.run/##S85KzP3/vyhTs7o4XDWzVtVK@/9/QwMA "CJam – Try It Online")
-1 thanks to [Business Cat](https://codegolf.stackexchange.com/users/53880/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
```
[Answer]
# 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`](https://codegolf.stackexchange.com/users/52210/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()
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~7~~ 5 bytes
*-2 bytes thanks to @Shaggy.* 
```
õs xw
```
[Try it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=9XMgeHc=&input=NzU=)
## 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!](http://ethproductions.github.io/japt/?v=1.4.4&code=9XMgejIgeA==&input=NzU=)
## 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
```
[Answer]
## 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;}
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~7 6~~ 3 bytes
```
ṁ↔ḣ
```
[Try it online!](https://tio.run/##yygtzv7//@HOxkdtUx7uWPz//39LS0sA "Husk – Try It Online")
### Ungolfed/Explanation
```
  ḣ  -- With the list [1..N] ..
ṁ    -- .. do the following with each element and sum the values:
 ↔   --    reverse it
```
[Answer]
# [Perl 5](https://www.perl.org/), ~~29 27~~ 22 + 1 (`-p`) = 23 bytes
```
map$\+=reverse,1..$_}{
```
[Try it online!](https://tio.run/##K0gtyjH9/z83sUAlRtu2KLUstag4VcdQT08lvrb6/39Dg3/5BSWZ@XnF/3V9TfUMDA3@6xYAAA "Perl 5 – Try It Online")
[Answer]
# [Gol><>](https://github.com/Sp3000/Golfish), 26 bytes
```
&IFLPWaSD$|~rlMFa*+|&+&|&h
```
[Try it online!](https://tio.run/##S8/PScsszvj/X83TzScgPDHYRaWmrijH1y1RS7tGTVutRg0oZ2gAAA "Gol><> – Try It Online")
## Explanation
```
&I                      &h < register init, read "n"; print register (h = n;)
  FLP                  |   < For loop, do "n" times for each x in [1] to [n]
     WaSD$|                < modpow "x" to digits: [123] [3 12] [3 2 1] [3 2 1 0]
           ~rlMFa*+|       < Ditch zero, reverse stack, build the number back
                    &+&    < register += final x
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), `s`, 2 bytes
```
ƛṘ
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=s&code=%C6%9B%E1%B9%98&inputs=10&header=&footer=)
[Answer]
# vim, 49 46 bytes
```
A@q<ESC>0"bDa1<ESC>qqYp<C-a>q@bdk:%s/$/+
:%!rev
xVGJ:%!bc
```
`<ESC>` is 0x1b,
`<C-a>` is 0x01,
`<NL>` is 0x0a.
## Annotated
```
A@q<ESC>0"bD  # put {N}@q (run macro q N times) in register b
a1<ESC>       # buffer now contains "1"
qqYp<C-a>q    # store macro that copies and increments the last line in register q
@bd1k         # run {N} times, then delete the extra lines
              # (can't just run {N-1} times, or it won't handle N=1 correctly)
:%s/$/+<NL>   # append + to each line
:%!rev<NL>    # reverse each line
x             # delete leading +
VGJ           # join lines
:%!bc<NL>     # sum
```
[Try it online!](https://tio.run/##K/v/39GhUNpAKckl0VC6sDCygLHQISkl20q1WF9FX5vLSlWxKLWMqyLM3QvITErm@v/f0AAA "V (vim) – Try It Online")
[Answer]
# Excel, 59 bytes
```
=LET(y,COLUMN(A:O),SUM((0&MID(SEQUENCE(A1),y,1))*10^(y-1)))                                               
```
Explanation
```
=LET(
y,COLUMN(A:O)                           'y = [1..15] horz.; Excel is accurate to 15 places
SUM((0&MID(SEQUENCE(A1),y,1))*10^(y-1)) 'final result
           SEQUENCE(A1)                 '[1..A1] vertical
    (0&MID(            ,y,1))           'array of individual digits; 0& is to avoid errors on blank cells 
                             *10^(y-1)  'multiply 2nd column by 10, 3rd 100, etc.
SUM(                                  ) 'sum the array
```
[Answer]
## [Magneson](https://github.com/UnderMybrella/Magneson), 102 bytes
[![Source](https://i.stack.imgur.com/QgOlF.png)](https://i.stack.imgur.com/QgOlF.png)
That's not very visible, so here's a scaled up version (Note: Won't actually run, and still isn't very pretty)
[![Display Purposes Only](https://i.stack.imgur.com/q0xa2.png)](https://i.stack.imgur.com/q0xa2.png)  
(source: [googleapis.com](https://storage.googleapis.com/brella-archives/Code%20Golf/Magneson/range_reverse_sum_visible.png))
Magneson operates by parsing an image and evaluating commands from the colours of the pixels it reads. So stepping through the image for this challenge, we have:
* `R: 0, G: 1, B: 1` is an integer assignment command, which takes a string for the variable name and the value to assign. We'll use this to store the sum total.
* `R: 0, G: 1, B: 0` is a prebuilt string with the value `VAR_1` (Note: This is only while we're asking for a string; the colour code has a separate function when used elsewhere).
* `R: 3, G: 0, B: 0` is a raw number. Magneson handles standard numbers by requiring the Red component to be exactly 3, and then forms a number by using the blue value directly *plus* the green value multiplied by 256. In this case, we're just getting the number 0.
* `R: 0, G: 1, B: 1` is another integer assignment command. This time, we're storing an iteration variable, to keep track of which number we're on
* `R: 0, G: 1, B: 1` is a prebuilt string with the value `VAR_2` (Once more, only when we need a string)
* `R: 3, G: 0, B: 0` is the number 0, once more. Onto the interesting bits now.
* `R: 1, G: 0, B: 0` indicates the start of a loop. This takes a number and loops the following snippet of code that many times.
* `R: 2, G: 0, B: 0` is the STDIN function, or at least it is when we need a number. This reads a line of input from the console and turns it into a number, since we asked for a number.
* `R: 0, G: 8, B: 0` starts off our looping code, and it is an additive command. This adds a number to an integer variable, and so takes a string for the variable name, and the number to add.
* `R: 0, G: 1, B: 1` is the prebuilt string for `VAR_2`, which is our iteration variable.
* `R: 3, G: 0, B: 1` is a raw number, but this time it's the number 1.
* `R: 0, G: 8, B: 0` is another addition command.
* `R: 0, G: 1, B: 0` is the string for `VAR_1`, which is our sum total.
* `R: 0, G: 3, B: 0` is a function that reverses a string. In the context of asking for a number, it then converts the reversed string to a number.
* `R: 0, G: 2, B: 1` is an integer retrieval command, and will retrieve the number stored in a provided variable. In the context of asking for a string (such as from the reverse command), it converts the number to a string.
* `R: 0, G: 1, B: 1` is the name `VAR_2`; our iteration variable.
* `R: 1, G: 0, B: 1` is the marker to end the loop, and go back to the start of the loop if the criteria isn't met (so if we need to keep looping). Otherwise, proceed onwards.
* `R: 0, G: 0, B: 1` is a very simple println command, and takes a string.
* `R: 0, G: 2, B: 1` retrieves an integer from a variable
* `R: 0, G: 1, B: 0` is the name of our sum total variable, `VAR_1`
All in all, the program:
* Assigns the value 0 to `VAR_1` and `VAR_2`
* Loops from 0 to a number provided in STDIN
	+ Adds one to `VAR_2`
	+ Adds the integer value of reversing `VAR_2` to `VAR_1`
* Prints the contents of `VAR_1`
]