挑战在于编写一个程序或脚本，该程序将对从1到给定数字（包括给定数字）的整数内的所有数字的总和进行计数。

输入，一个正整数。输出该数字和所有较小数字的数字总和。

例子：

Input: 5 
Integer Sequence: 1, 2, 3, 4, 5
Sum of Digits: 1 + 2 + 3 +4 + 5 = 15

Input: 12
Integer Sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 
Sum of Digits: 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 1 + 0 + 1 + 1 + 1 + 2 = 51

要明确的是，这是为了计算数字的总和-而不是整数。对于一位数字输入，这将是相同的。但是，大于10的输入将具有不同的响应。这将是错误的响应：

Input: 12
Output: 78

另一个示例，以显示差异：

Input: 10

Integer Sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Sum of Integers (INCORRECT RESPONSE): 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55

Digit Sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 0
Sum of Digits (CORRECT RESPONSE): 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 1 + 0 = 46

更大的测试用例（正确响应）：

Input: 1000000
Output: 27000001

规则与准则：

• 提交的代码必须是完整的程序或脚本，而不仅仅是函数。如果代码要求包含，导入等，则必须将其包含在发布的代码中。
• 该数字必须由用户输入-不得进行硬编码。输入可以作为命令行参数，文件，stdin或您的语言可以接受用户输入的任何其他方式来接收。
• 该代码必须至少能够正确处理输入(2^64)-1。
• 该代码应仅输出总和。
• 提交的程序和脚本应该是用户友好的，并且不浪费计算机资源（例如：它们不应声明超大的数组来容纳每个字符）。对此没有严格的奖励或惩罚，但是请成为优秀的程序员。

得分：

主要的评分机制是根据代码长度。分数越低越好。以下奖金和罚款也适用：

• 如果您的代码可以处理所有正数，则奖励-25，例如：1234567891234567891234564789087414984894900000000
• 如果代码可以处理简单表达式，则为-50，例如55*96-12。要获得此奖金，代码应处理+ - / *（加，减，除，乘）运算符并强制执行运算顺序。除法是规则的整数除法。
  • 给定的示例（55*96-12）计算为5268。对于任何一个输入，您的代码都应返回相同的值-正确答案是81393。
• 如果您的代码有资格获得-50奖励并且可以处理^（指数）运算符，则为-10奖励。
• -100奖励，如果您的代码符合-50奖励的条件，并且不使用eval或类似方式处理表达式。
• 如果您的代码依赖于任何网络资源，则+300罚款。

Perl 6：108-（25 + 50 + 100）+ 0 = -67点

打高尔夫球的解决方案（基于xfix的出色解决方案的最终产品）：

$!=get;for '*',&[*],'/',&[/],'+',&[+],'-',&[-] ->$s,&f{$!~~s:g[(\d+)$s(\d+){}]=f |@()}
say [+] (1..$!)».comb

非高尔夫解决方案：

my $expression = get;
for '*', &[*],
    '/', &[/],
    '+', &[+],
    '-', &[-]
-> $sym, &infix {
    $expression ~~ s:g[(\d+) $sym (\d+) {}] = infix($0, $1)
}
say [+] (1..$expression)».comb

该评估步骤在每个符号的工作原理是迭代*，/，+，-，发现当两个整数之间的谎言，而代，使用函数符号代表。

更详细地讲：它接受每个符号（例如+）和它应该表示的infix函数（例如&[+]，它是速记的形式，&infix:<+>并且在执行时与Perl 6调用相同的函数1 + 2），并进行全局替换（例如s:g[…] = …，类似于Perl 5 s/…/…/ge），它匹配用符号（(\d+) $sym (\d+)）分隔的两个整数，并将其替换为用这些整数（infix($0, $1)）调用的相应infix函数的输出。

最后，此求值表达式被输入say [+] (1..$expression)».comb，xfix在他的解决方案中解释得很好。

很抱歉晚到派对☺

编辑：删除了对指数的支持；无论如何，它恰好是10个字符，并且没有正确执行关联性。

Mathematica 30-（10 + 50）= -30

由于ybeltukov，缩短了4个字符。

Range@n返回从1到的数字n。

Integerdigits@n 将这些数字分解成数字。

Total[n,2]对数字求和。2是为了允许在不同级别上求和，即列表列表。

IntegerDigits@Range@#~Total~2&

测试中

IntegerDigits@Range@#~Total~2&[12]

51

IntegerDigits@Range@#~Total~2 &[1000000]

27000001

表达方式

IntegerDigits@Range@#~Total~2 &[55*96 - 12]

55*96 - 12

81393
5268

IntegerDigits@Range@#~Total~2 &[5268]

81393

IntegerDigits@Range@#~Total~2 &[55*96^2 - 12]
55*96^2 - 12

12396621
506868

IntegerDigits@Range@#~Total~2 &[506868]

12396621

C：150 138 - （100 + 50）= -12

a,b,c;main(d){for(scanf("%d ",&a);~scanf("%c%d ",&d,&b);a=d^43?d%5?d%2?a/b:a*b:a-b:a+b);for(;a;)for(b=a--;b;b/=10)c+=b%10;printf("%d",c);}

从这里非常可耻地窃取@Fors答案来进行表达式求值：https ://codegolf.stackexchange.com/a/11423/13877

用法示例：

./a.exe <<< "5 + 7"
51

注意：表达式实现不假定运算符优先级，并在接收它们时使用它们的值；恩，1+2*3 = 9而不是典型的7。

sed，411283-25 = 258

我现在不能打高尔夫球了。:-)不推荐用于甚至大的整数，但是从技术上讲，它可以处理任意大的整数（但是您可能很快会用完RAM，因为我（或多或少必须）将数字编码为一元）。

s/$/x0123456789/
:l
/9$/H
:b
s/(.)(y*x\1)/y\2/
/(.)y*x\1/b b
s/(.)([xy].*)(.)\1/\3\2\3\1/
:c
s/y(.*(.))/\2\1/
/y/b c
/0$/b f
/^0*x.*9$/!b l
x
s/x[^\n]*\n//g
:d
s/(.)(.*x.*(.)\1)/z\3\2/
/[^z0]x/b d
s/0|x.*|\n//g
H;x
s/./0/g
s/$/x9876543210/
x
:e
x
b l
:f
x
s/.//
/./b e
x
s/^0+|x.*//g

样品使用

（输入行缩进以方便阅读。）

  5
15
  12
51
  33
183

蟒蛇，55-（50 + 25 + 10）= -30

低效但更短，也能够处理表达式。

编辑：感谢Wolframh和legoStormtroopr的把戏：D

s,t=0,input()
while t:s+=sum(map(int,`t`));t-=1
print s

蟒蛇，149-（25 + 50 + 10）= 64

我的第一个版本

def d(n):
 if n/10==0:return n*(n+1)/2
 c,t=0,n
 while t/10:c,t=c+1,t/10
 p=10**c;m=n%p
 return d(m)+t*(m+1)+p*t*(t-1)/2+p*c*t*45/10
print d(input())

输入：

1234567891234567891234564789087414984894900000000

输出：

265889343871444899381999757086453238874482500000214

Python-108个字符减去85个奖金（23招），处理非常非常大的输入

这些解决方案中的大多数似乎都是在比输入少的所有整数上进行循环，并将所有数字和加起来。这行得通，但是我觉得这很不礼貌，并且会质疑他们是否真正有资格获得25点奖金，因为我认为他们无法1234567891234567891234564789087414984894900000000在我们的一生中处理输入内容。实际上，在输入n数字时，这些解决方案需要O(10^n)时间。我选择对这个问题进行一些数学运算。

#Returns the sum of all digits in all x-digit numbers
def f(x):
    return x*(10**(x-1))*45

#Returns the sum of all numbers up to x
def g(x):
    return x*(x+1)/2

#Solves the problem quickly
def magic(x):
    digits = [int(y) for y in list(str(x))]
    digits.reverse()
    total = 0

    for (sig, val) in enumerate(digits):
        total += (10**sig)*g(val-1) + val*f(sig) + val + (val*10**sig)*sum(digits[sig+1:])
    return int(total)

所有x数字的集合与集合同构{0,1,2,3,4,5,6,7,8,9}^x。对于一个固定的(n,sig)有x各种不同的值sig，10^x-1与该点sig次指标集到n，并且所有数字的总和0-9是45。这是通过所有处理f。

g 是我们可能都熟悉的东西

magic接受输入数字中的所有数字，并从最低到最高进行迭代。用example输入来追踪它是最简单的1,234,567。

为了处理范围1,234,567-1,234,560，我们必须从加起来所有的数字1来7，并加入7时代的其他数字的总和，应对大于所有数字1,234,560。现在，我们需要处理其余的问题。

要处理该范围1,234,560-1,234,500，我们添加6（val），然后将上限降低到1,234,559。在剩下的部分中，我们将看到每个单位数字6次（val*f(sig)）。我们将看到从0到的所有5精确数字10（(10**sig)*g(val-1)）。我们将看到该数字中的所有其他数字恰好是60倍（(val*10**sig)*sum(digits[sig+1:])）。现在，我们处理的所有数字都严格大于1,234,500。相同的逻辑将适用于所有含义。

多亏了WolframH，高尔夫运动才使该解决方案

d=map(int,str(input()))
print sum(v*(10**s*((v-1)/2+sum(d[:~s]))-~s*9*10**s/2)for s,v in enumerate(d[::-1]))

并且所有整数之和的数字总和1234567891234567891234564789087414984894900000000为265889343871444927857379407666265810009829069029376

我设法在高尔夫球版本上扔出的最大数字是10 ^ 300，这时浮子开始溢出，数值不稳定开始引起问题。使用快速平方和乘幂功能，此问题将消失。

LaTeX支持将非常有用...

TI-BASIC，137-（50 + 10 + 100）= -23

Input A:Disp cumSum(randIntNoRep(1,A))→L₁:"?:For(A,1,dim(L₁:Ans+sub("ABCDEFGHIJKLMNOPQRSTUVWXYZ",L₁(A),1:End:Disp sub(Ans,2,length(Ans)-1

输入最多处理数字1E100并自动求值。可以处理表达式。

尽管它是一个庞大的阵列，但我并没有浪费计算机资源（这是通过计算器运行的）。

斯卡拉66

println((1 to readLine().toInt).flatMap(x=>(x+"").map(_-'0')).sum)

传真77 74

n,v,i;main(){scanf("%d",&n);for(;i||(i=n--);i/=10)v+=i%10;printf("%d",v);}

C，150 124 - 25 = 99

这是一个替代版本，从技术上讲应该有资格获得“任何”正整数的25赠金，但是由于该算法的输入时间是线性时间，因此它是不切实际的缓慢。无论如何，写起来很有趣。手动减去以ASCII字符形式读入的数字。此版本为150个字符。（现在有了可怕的，经过争论的，循环的代码！）

n,v;main(int n,char**a){char*p;do{for(p=a[1];*p>47;p++)v+=*p-48;for(;*--p==48;)*p=57;
p[0]--;}while(p>=a[1]);printf("%d",v);}

C，229 224-（50 + 100）= 74

表达式处理的变化。根据典型规则实现运算符优先级：/ * - +。仅限97个令牌= 48个条款。

#define F(X,Y)for(q=n+1;q+1!=p;)*q-X?q+=2:(q[-1]Y##=q[1],memmove(q,q+2,(p-q)*4))
n[99],*p,*q,v,i;main(){for(p=n;~scanf("%d%c",p,p+1);)p+=2;F('/',/);F('*',*);
F('-',-);F('+',+);for(;i||(i=n[0]--);i/=10)v+=i%10;printf("%d",v);}

GolfScript 18-50 = -32

~),{`+}*' '*~]{+}*

说明：假设输入为“ 12”：

~), # turn input into integer, increment, and then turn into an array of all numbers less than or equal to input.  

堆栈为[0,1,2,3,...,12]。

{`+}* # fold string concatenation across the array

堆栈为"01234...9101112"。

' '* # join a space between all characters

堆栈为"0 1 2 ... 1 0 1 1 1 2"。

~] # evaluate the stack into an array.  No `[` is necessary since the stack is otherwise empty.

堆栈为[0,1,2,...,9,1,0,1,1,1,2]。

{+}* # fold addition across the new array

根据需要，堆栈为51。

此处的输入可以是任何有效的GolfScript表达式，其中可以包含指数。例如：

echo "5 5 + 2 * 8 -" | ruby golfscript.rb h.gs
-> 51

自从2(5 + 5) - 8 = 12。我认为这应该有资格获得奖金，但是也许只有正常的形式才有可能，而不是相反的GolfScript波兰语表示法。

红宝石，37-50 = -13

一路翻腾，一路冲天！与其他Ruby解决方案一样，我认为从理论上讲，这应该可以处理任意数量的数字，但是执行时间会非常糟糕。

p eval [*1..eval(gets)].join.chars*?+

较旧的版本（49-50分）

p"#{[*1..eval(gets)]}".chars.map(&:to_i).inject:+

假设10个字符的奖励实际上要求取幂的字符是一个插入符号，我想添加的最短方法是：

.gsub ?^,'**'

花费的角色比奖励所能提供的更多。

Perl 6（28-75 + 0 = -47字节）

say [+] (1..get.eval)».comb

它可以处理所有正数（但是，大数将花费一些时间，因为当前Perl 6的实现速度很慢，但是Perl 6本身支持大整数）。它使用eval来实现一个简单的计算器（五十个字符对五个字符的惩罚是值得的）。它之所以缓慢是因为当前的实现速度很慢，但是从理论上讲，它应该足够快（即Perl 6实现得到改进时）。另外，令人惊讶的是，我赢得了Mathematica（目前）。

» 该代码实际上是不需要的，但出于性能原因，我将其放在此处（否则，程序将分配整个字符串。之所以在这里，原因是Perl 6没有无限的字符串，但确实有无限的列表。

无论如何，您可能会问这段代码是如何工作的。好吧，我将部分地通过它。

• get.eval

  这将获得一行（get函数），并对其进行评估（eval方法）。

• 1..get.eval

  之后，Perl 6准备一个范围对象，从1到评估值。这是一个范围，因此不会分配任何大笔费用。

• ».comb

  .comb方法将字符串拆分为字符（除非使用参数调用）。例如，'cat'.combreturn 'c', 'a', 't'。»映射列表元素，因此.comb会在其所有项目上运行-不仅在列表本身上运行（例如，(4, 9)».sqrt给定2, 3）。这也不会分配超过所需的资源，因为Perl 6具有无限列表（例如，Haskell）。

  »实际上不需要字符，.comb可以直接在列表上使用，但这涉及隐式字符串强制（而且Perl 6没有无限字符串，因此会浪费内存）。例如，1, 2, 3转换为字符串后的list返回1 2 3。对于Perl 6，空格是一个非常好的数字，表示0，因此即使进行这种转换，代码也可以正常工作。但是，它将滥用计算资源。

• [+]

  这是归约运算符。基本上，[]在这种情况下，您可以放一个运算符+。降低运营后的名单被降低，所以[+] 1, 2, 3是1 + 2 + 3，这是6。Perl 6对数字和字符串使用单独的运算符，因此不会被视为串联。

• say

  最后，say输出结果。毕竟，您想查看最终结果，不是吗？

Perl 31-无奖金

map{s/./$%+=$&/ge}0..<>;print$%

样本输出：

perl -e 'map{s/./$%+=$&/ge}0..<>;print$%'
1000000
27000001

Perl 5 with -p，50-28 bytes：-22

map$\+=$_,/./g for 1..eval}{

在线尝试！

J，22

([:+/[:"."0[:":>:@:i.)

说明

评估从右到左进行。

i. n -> 0 1 2...n-1

>: n -> n+1

": numbers -> 'numbers'

"."0 -> (on each scalar item) apply ". -> '123' -> 1 2 3

+/ -> sum

R，64-（50 + 10）= 4

sum(utf8ToInt(paste(0:eval(parse(t=scan(,""))),collapse=""))-48)

运行此命令时，要求用户输入。

旧版本（无法处理表达式）：46个字符：

sum(utf8ToInt(paste(0:scan(),collapse=""))-48)

批次-（181-50）-131

只是为了一点乐趣。

@set/av=%1
@setLocal enableDelayedExpansion&for /L %%a in (1,1,%v%)do @set a=%%a&powershell "&{'%%a'.length-1}">f&set/pb=<f&for /L %%c in (0,1,!b!)do @set/as+=!a:~%%c,1!
@echo !s!

我将使其更具可读性：

@set /a v=%1
setLocal enableDelayedExpansion
for /L %%a in (1,1,%v%) do (
    @set a=%%a
    powershell "&{'%%a'.length-1}">f
    set /p b=<f
    for /L %%c in (0,1,!b!) do @set /a s+=!a:~%%c,1!
)
@echo !s!

旧方法使用for循环获取powershell命令的输出，而不是写入文件和从文件读取：

@set /a v=%1
@setLocal enableDelayedExpansion&for /L %%a in (1,1,%v%)do @set a=%%a&for /F usebackq %%b in (`powershell "&{'%%a'.length-1}"`)do @for /L %%c in (0,1,%%b)do @set /a s+=!a:~%%c,1!
@echo !s!

将输入到一个变量- v-使用/a接受算术表达式。
不幸的是，必须延迟扩展。
使用for循环从1到输入值-进行计数v。
为了处理数大于9，我不得不使用PowerShell来获取字符串，然后用另一个for循环来拆分串起来的长度，并把它添加到总和 - s。
您可以更改的名称powershell.exe，以p.exe℃在：\ WINDOWS \ SYSTEM32 \ WindowsPowerShell \ V1.0 \然后叫它p "&{'%%a'.length-1}，节省了9个字节。但这并不是真的。

H:\>sumof.bat 12
51
H:\>sumOf.bat (55*96-12)
81393

我午休时让第二个跑步。

我真的不能与那些数字测试过比这大得多，由于它是多么的慢。但是，它应该适用于相当大的数目。2147483647是给出以下错误之前将要使用的最大数字（最大32位整数）-

H:\>sumOf.bat 2147483648
Invalid number.  Numbers are limited to 32-bits of precision.

当然，这使我没有资格参加挑战。

Dyalog APL，9 – 160 * = -151

+/⍎¨∊⍕¨⍳⎕

在线尝试！

⎕得到评估的输入，
 例如"7+5"给出12

⍳索引1 ... n
 [1,2,3,4,5,6,7,8,9,10,12]

⍕¨ 将每个数字格式化为字符串
 ["1","2","3","4","5","6","7","8","9","10","11","12"]

∊ 征募（拼合）
 "123456789101112"

⍎¨ 执行每个字符（单位数数字的收益列表）
 [1,2,3,4,5,6,7,8,9,1,0,1,1,1,2]

+/ 和  51

*得分

-50奖金，因为它甚至接受表达式作为输入。该表达式必须是有效的APL，根据OP可以接受。

-10红利，因为它还可以处理^（*在APL中）。

-100加分，因为无需明确使用eval（即⍎在APL中）处理表达式输入。

C＃（161）

using C=System.Console;using System.Linq;class X{static void Main(){C.WriteLine(Enumerable.Range(1,int.Parse(C.ReadLine())).SelectMany(i=>i+"").Sum(c=>c-48));}}

漂亮

using C = System.Console;
using System.Linq;

class X
{
    static void Main()
    {
        C.WriteLine(
            Enumerable.Range(1, int.Parse(C.ReadLine()))
                .SelectMany(i => i + "")
                .Sum(c => c - 48)
            );
    }
}

Python3 + Bash（78-185 = -107）

python3 -c"print(sum(sum(map(int,str(x+1)))for x in range(int(${1//^/**}))))"

• 可以处理所有正数
• 可以使用+-/ *操作处理表达式
• 可以处理^（幂）运算符。
• 可以处理表达式，而无需评估或类似运算¹

如果表达式的结果不是整数，将首先被截断。如果表达式的结果为负，则结果不确定。

像这样使用它：

bash golf.sh "12 + (42 / 3 + 3^4)"

1：除非您算是这样从Bash调用Python，但是我认为并非如此。如果您认为确实如此，则调整后的分数为-7。

爪哇254

class T
{
    public static void main(String[] a)
    {
        long target = 10, count = 0;
        String[] digits = new String[50];
        for (long i = 1; i <= target; i++)
        {
            digits = String.valueOf(i).split("(?!^)");
            for (int j = 0; j < digits.length; j++)
                if (digits.length > j)
                    count += Integer.parseInt(digits[j]);
        }
        System.out.println(count);
    }
}

处理表达式。给你想要的目标表达。处理直到长度可以处理为止。如果清理掉所有空格并排成一行，并且没有要打印的语句，则该字符数为254个字符（考虑到基于Java语言的长而长的单词）。

PS：这是一个完整的程序，不只是逻辑。程序所提供的字数不只是逻辑。

Java（JDK8），272

我遇到的第一个挑战，欢迎提出建议=）

import java.util.*;import java.util.stream.*;class C{public static void main(String[]a){System.out.print(Arrays.asList(IntStream.range(1,new Integer(a[0])).mapToObj(s->s+"").collect(Collectors.joining()).split("")).stream().map(Integer::valueOf).reduce(0,Integer::sum));}}

缩进：

import java.util.*;
import java.util.stream.*;

class C {

   public static void main(String[] a) {
     System.out.print(Arrays.asList(IntStream.range(1,new Integer(a[0]))
            .mapToObj(s->s+"")
            .collect(Collectors.joining())
            .split(""))
            .stream()
            .map(Integer::valueOf)
            .reduce(0,Integer::sum));
  }
}

CJam，9-25 = -16

CJam比这项挑战还年轻几个月，因此没有绿色复选标记的资格。此外，这并不是首先击败Perl。;）我非常喜欢这种方法，所以无论如何我都想发布它。

l~),s:~:+

在这里测试。

这个想法是创建一个从0到N的范围。然后将该范围转换为一个字符串，该字符串将整数连续地连接在一起。对于N = 12，我们将得到

"0123456789101112"

然后将每个字符转换为，以生成一个整数:~（产生一个整数数组），然后与相加:+。CJam可以处理任意大整数。

Python 3 + astor，1017 1007字节-（25 + 50 + 100）=分数： 842 834

通过删除ts和更改节省了10个字节p

编辑：我无法测试可笑的长整数（1234567891234567891234564789087414984894900000000）[挂起我的计算机]，但据我所知，Python 3支持任意长整数。

这个实现 用途滥用AST。我不会认为滥用AST是“等同或类似的结果”。

from ast import*
from astor import*
nt,bo,m,d,a,s,n,p,ty=NodeTransformer,BinOp,Mult,Div,Add,Sub,Num,map,type
class M(nt):
    def visit_BinOp(t,z):
        if ty(z.left)==bo and ty(z.right)==bo:return bo(t.visit_BinOp(z.left),z.op,t.visit_BinOp(z.right))
        if ty(z.left)==bo:return bo(t.visit_BinOp(z.left),z.op,z.right)
        if ty(z.right)==bo:return bo(z.left,z.op,t.visit_BinOp(z.right))
        if ty(z.op)==m:return n(z.left.n*z.right.n)
        if ty(z.op)==d:return n(z.left.n/z.right.n);return z
class A(nt):
    def visit_BinOp(t,z):
        if ty(z.left)==bo and ty(z.right)==bo:return bo(t.visit_BinOp(z.left),z.op,t.visit_BinOp(z.right))
        if ty(z.left)==bo:return bo(t.visit_BinOp(z.left),z.op,z.right)
        if ty(z.right)==bo:return bo(z.left,z.op,t.visit_BinOp(z.right))
        if ty(z.op)==a:return n(z.left.n+z.right.n)
        if ty(z.op)==s:return n(z.left.n-z.right.n);return z
class S(nt):
    def visit_Num(t,z):return n(sum(p(int,list("".join(p(str,range(1,z.n+1)))))))
print(to_source(S().visit(A().visit(M().visit(parse(input()))))))

懒得写空洞的，所以我给你解释一下这些类：

M(NodeTransformer|nt) - converts multiplication and division into their results.
A(NodeTransformer|nt) - converts addition and subtraction into their results.
S(NodeTransformer|nt) - converts numbers into their sum of digits via the Pythonic (naïve) way.

最后一行只是按照输入上的适当顺序执行这些类，以保留操作顺序并防止不必要的行为。

用法示例（$或>表示用户输入），顺便说一句，实际程序仅接受一次输入：

$ python3 summer.py
> 5
15
> 10
46
> 12
51
> 1000000
27000001
> 55*96-12
81393

C＃（108）

int c(int n){return string.Join("",Enumerable.Range(1,n).Select(i=>i+"")).ToArray().Select(c=>c-'0').Sum();}

漂亮

int c(int n)
{
    return string.Join("", Enumerable.Range(1, n).Select(i => i + "")).ToArray().Select(c => c - '0').Sum();
}

Ruby-> 83-50 = 33

p (1..eval(gets.chomp)).each.inject{|c,e|c+e.to_s.chars.map{|x|x.to_i}.inject(:+)}                     

“要测试”版本：

module Math
  class CountSum
    def sum(number)
      (1..number).each.inject do |c, e|
        c + e.to_s.chars.map{ |x| x.to_i }.inject(:+)                                                  
      end
    end
  end
end 

测试结果

$ rspec sum_spec.rb  --format doc --color

Math::CountSum
  #sum
    single digit number
      when 5, should return 15
    double digit number
      when 12, should return 51
    arbitrary number
      when 1000000 should return 27000001

Finished in 5.34 seconds
3 examples, 0 failures

C＃（80）

这是我的另一尝试。

double c(int n){double s=0;while(n>0)foreach(var c in n--+"")s+=c-48;return s;}

漂亮

double c(int n)
{
    double s = 0;
     while (n > 0)
        foreach(var c in n--+"") 
            s += c - 48;
    return s;
}

Ruby 69-50 = 19（或-4）

这绝对是可以golfed在一起，但这里是第一次第五次尝试

p (1..eval(gets)).inject{|i,s|i+=s.to_s.chars.map(&:to_i).inject :+}

它也适用于所有数字，但是对于它们来说却非常慢，因为它比O（n）慢，因此我不会加上-25。如果缓慢是好的，那么这将是-4虽然

红宝石133-50-25 = 58

这是更快的版本，运行时间少于O（n）（并且使用实际的数学运算！），因此它可以快速提供大整数的结果，因此我添加了-25：

n=eval(gets);p (d=->n,l{k=10**l;c,r=n.to_s[0].to_i,n%k;n<10?n*(n+1)/2:c*45*l*k/10+k*(c*(c-1)/2)+(r+1)*c+d[r,l-1]})[n,n.to_s.length-1]

哈斯克尔74-25 = 49

main=getLine>>=print.sum.map(\c->read[c]).concatMap show.(\x->[0..x]).read

ECMAScript 6，86-50 = 36

for(s="",i=eval(prompt());i;s+=i--)alert(s.replace(/\d/g,c=>Array(-~c).join()).length)

R（72分）

f=function(n) sum(as.integer(strsplit(paste0(1:n,collapse=""),"")[[1]]))

输出：

> f(5)
[1] 15
> f(12)
[1] 51
> f(1000000)
[1] 27000001