给定一个正整数n作为输入，输出n的反向范围和。

反向范围总和的产生方式是：使包含n的范围包括n（从1开始并包括n），将内部的每个数字取反，然后求和。

例：

这是输入10会发生的情况：

范围： [1,2,3,4,5,6,7,8,9,10]

反转：（反转的[1,2,3,4,5,6,7,8,9,01]1个字符本身就是数字，反转的10个数字是01或1）

和： 46

具有3位以上数字的数字与具有2位数字的数字相反。例如，1234变为4321。

测试用例：

Input -> Output

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

可以在这里找到输入999的完整文本案例，这非常感谢@ fireflame241。

05AB1E，3个字节

码

LíO

使用05AB1E编码。在线尝试！

说明

L       # Range
 í      # Reverse
  O     # Sum

Bash + GNU utils，24

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

在线尝试。

说明

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

JavaScript（ES6），42个字节

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

不幸的是，我最喜欢的双递归解决方案是3个字节长：

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

Perl 6，20个字节

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

测试一下

展开：

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

视网膜，41 36 35字节

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

.+
$*
1

在线尝试！链接包括测试用例。编辑：由于@FryAmTheEggman，节省了5个字节。感谢@ PunPun1000，节省了1个字节。说明：

.+
$*

转换为一元。

1
1$`¶

创建从1到的范围n。

1+
$.&

转换回十进制。

%O^$`.

反转每个数字。

.+
$*

转换回一元。

1

求和并转换回十进制。

果冻，4 字节

Ṛ€ḌS

在线尝试！

怎么样？

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

Haskell，34个字节

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

简单明了。

C（gcc），63个字节

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

在线尝试！

cQuents，4个字节

;\r$

在线尝试！

说明

       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个字节

无法计算比递归限制更高的条件：

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

在线尝试！

Brachylog，4个字节

⟦↔ᵐ+

在线尝试！

说明

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

Röda，56 41 36字节

@fergusq节省了15个字节

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

在线尝试！

这是一个匿名函数，该函数从输入流中获取一个整数并将一个整数输出到输出流。

说明

{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字节

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

在线尝试！

TIO链接输出从1到999的所有结果，因此随时检查我的工作。

我期望这会更短一些，但是结果是Reverse()返回一个IEnumerable<char>而不是另一个字符串，因此我不得不添加一些额外的内容以将其返回为字符串，这样我就可以将其解析为一个int了。也许有一种更短的方法可以IEnumerable<char>正确地从int转换为int。

轻微值得注意的是，这还采用了功能Range() Reverse()和Sum()一切为了。

-6个字节，感谢TheLethalCoder

红宝石， 56、52、41， 39个字节

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

Ruby，34个字节（如果lambda参数是一个字符串）

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

感谢@Unihedron提供第二种解决方案。

Mathematica，47个字节

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

在线尝试！ （为了进行数学研究，我们需要将“ Tr”替换为“ Total”）

木炭，14 13字节

-1字节感谢Carlos Alejo

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

在线尝试！链接是详细版本。

说明

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

Magneson，102字节

这不是很明显，所以这是一个放大的版本（注意：实际上不会运行，但仍然不是很漂亮）

Magneson通过解析图像并根据其读取的像素的颜色评估命令来进行操作。因此，逐步了解此挑战的图像，我们有：

• R: 0, G: 1, B: 1是一个整数分配命令，该命令使用一个字符串作为变量名和要分配的值。我们将用它来存储总数。
• R: 0, G: 1, B: 0是带有值的预构建字符串VAR_1（注意：仅在我们要求字符串时；颜色代码在其他地方使用时具有单独的功能）。
• R: 3, G: 0, B: 0是原始数字。Magneson通过要求Red分量正好为3来处理标准数字，然后通过直接使用蓝色值加上绿色值乘以256来形成数字。在这种情况下，我们只得到数字0。
• R: 0, G: 1, B: 1是另一个整数分配命令。这次，我们存储一个迭代变量，以跟踪我们所使用的数字
• R: 0, G: 1, B: 1是带有值的预构建字符串VAR_2（更多，仅在我们需要字符串时）
• R: 3, G: 0, B: 0是数字0，再一次。现在到有趣的地方。
• R: 1, G: 0, B: 0指示循环的开始。这需要一个数字，并循环多次以下代码片段。
• R: 2, G: 0, B: 0是STDIN函数，或者至少是在我们需要数字时。因为我们要求输入数字，所以这将从控制台读取一行输入并将其转换为数字。
• R: 0, G: 8, B: 0从循环代码开始，这是一个附加命令。这会在整数变量中添加一个数字，因此会使用一个字符串作为变量名称以及要添加的数字。
• R: 0, G: 1, B: 1 是用于的预构建字符串 VAR_2，这是我们的迭代变量。
• R: 3, G: 0, B: 1 是原始数字，但这次是数字1。
• R: 0, G: 8, B: 0 是另一个加法命令。
• R: 0, G: 1, B: 0 是的字符串 VAR_1，这是我们的总和。
• R: 0, G: 3, B: 0是一个反转字符串的函数。在询问数字的上下文中，然后将反向字符串转换为数字。
• R: 0, G: 2, B: 1是一个整数检索命令，它将检索存储在提供的变量中的数字。在询问字符串的上下文中（例如从反向命令），它将数字转换为字符串。
• R: 0, G: 1, B: 1是名字VAR_2; 我们的迭代变量。
• R: 1, G: 0, B: 1是结束循环的标记，如果不符合条件，则返回循环的开始（因此，如果我们需要继续循环）。否则，请继续。
• R: 0, G: 0, B: 1 是一个非常简单的println命令，并包含一个字符串。
• R: 0, G: 2, B: 1 从变量中检索整数

• R: 0, G: 1, B: 0 是总和变量的名称， VAR_1

  总而言之，该程序：

• 将值0分配给VAR_1和VAR_2
• 从0循环到STDIN中提供的数字
  • 加一 VAR_2
  • 将反转的整数值VAR_2加到VAR_1
• 打印内容 VAR_1

Python 2中，50 47个字节

-3字节，感谢Officialaimm！

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

在线尝试！

CJam，12个字节

ri){sW%i}%:+

在线尝试！

-1感谢Business Cat。

说明：

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字节

通过@Adám将3个字节打高尔夫球，将其从火车转换为tradfn

+/⍎⌽⍕⍳⎕

在线尝试！

⎕          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字节

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

编辑

根据的评论Kevin Cruijssen，我想改善我的回答。

Java 8，103字节

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

Japt，7 5字节

-2个字节，感谢@Shaggy。

õs xw

在线尝试！

说明

õ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.

旧解决方案，7个字节

保留这一点，因为它确实是的很酷的用法z2。

õs z2 x

在线尝试！

说明

õ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字节

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

稻壳， 7 6 3字节

ṁ↔ḣ

在线尝试！

取消高尔夫/解释

  ḣ  -- 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字节

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

在线尝试！

RProgN 2，8字节

{Ø.in}S+

讲解

{Ø.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.

在线尝试！

Pyth，8 6字节

^{-2个字节感谢FryAmTheEggman！}

sms_`h

在线尝试！

Tcl，66字节

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

在线尝试！

Neim，4个字节

Δ𝐫)𝐬

在线尝试！

说明

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

C（gcc），71个字节

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

在线尝试！