この課題は、1から特定の数までの整数内のすべての数字の合計をカウントするプログラムまたはスクリプトを作成することです。

入力、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

明確にするために、これは整数ではなく数字の合計を数えることです。1桁の入力の場合、これは同じです。ただし、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

より大きなテストケース（CORREST RESPONSE）：

Input: 1000000
Output: 27000001

ルールとガイドライン：

• 送信されるコードは、単なる機能ではなく、完全なプログラムまたはスクリプトでなければなりません。コードにインクルード、インポートなどが必要な場合は、投稿されたコードに含める必要があります。
• 番号はユーザーが入力する必要があります-ハードコードされていません。入力は、コマンドライン引数、ファイル、標準入力、または言語がユーザー入力を受け取ることができる他の手段として受け取ることができます。
• コードは、少なくとも最大で入力を適切に処理できる必要があります(2^64)-1。
• コードは合計のみを出力する必要があります。
• 提出されるプログラムとスクリプトは、ユーザーフレンドリーであり、コンピューターリソースを浪費しないものでなければなりません（例：すべてのキャラクターを保持するために、非常に大きな配列を宣言するべきではありません）。これには厳密なボーナスやペナルティはありませんが、優秀なプログラマーにしてください。

得点：

主要なスコアリングメカニズムは、コードの長さによるものです。スコアが低いほど優れています。次のボーナスとペナルティも適用されます。

• -25ボーナスは、コードがすべての正の数を処理できる場合、たとえば：1234567891234567891234564789087414984894900000000
• -50ボーナスは、たとえば、コードが単純な式を処理できる場合55*96-12です。このボーナスの資格を得るには、コードで+ - / *（加算、減算、除算、乗算）演算子を処理し、演算の順序を強制する必要があります。除算は通常の整数除算です。
  • 与えられた例（55*96-12）はに評価され5268ます。あなたのコードは、これらの入力のどちらに対しても同じ値を返すはずです-正解は81393です。
• -10ボーナスもしあなたのコード-50ボーナスの対象と扱うことができます^（指数）演算子を。
• -100ボーナスあなたのコード-50ボーナスの対象となっている場合とは、使用していないevalか、ハンドル式に似ています。
• コードがWebリソースに依存している場合、+ 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:<+>と同じ機能のPerlあなたが実行6つのコールの1 + 2）とグローバル置換（ないs:g[…] = …Perl 5のようなものです、s/…/…/ge）は、シンボル（(\d+) $sym (\d+)）で区切られた2つの整数に一致し、それらの整数（infix($0, $1)）で呼び出された対応する中置関数の出力に置き換えます。

最後に、この評価された式はに供給さ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

注：式の実装では、演算子の優先順位を想定せず、値を受け取ったときに消費します。ex、1+2*3 = 9典型的ではなく7。

sed、411 = 258

私は今それをもっと気にすることはできません。:-)リモートの大きな整数でも使用することはお勧めしませんが、技術的には任意の大きな整数を扱うことができます（ただし、多かれ少なかれ、単項）。

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

python、55-（50 + 25 + 10）= -30

非効率的でありながら短く、式も処理できます。

編集：トリックをありがとうWolframhとlegoStormtroopr：D

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

python、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ストローク、非常に大きな入力を処理

これらのソリューションのほとんどは、入力未満のすべての整数をループし、すべての桁の合計を加算しているようです。これは機能しますが、私はそれが優雅ではないと感じ、彼らが1234567891234567891234564789087414984894900000000私たちの生涯内に入力を処理できるとは思わないので、彼らが本当に25ポイントのボーナスの資格があるかどうか疑問に思うでしょう。実際、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にindex番目のセットはn、すべての数字の合計が0-945これは、全てによって処理されますf。

g おそらく私たち全員がよく知っているものです

magic入力番号のすべての数字を取得し、それらを最下位から最上位まで繰り返します。たとえば、入力例を使用してこれを追跡するのが最も簡単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ます。ドロップの残りの部分を作成する際に、1桁の数字がすべて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で、その時点でフロートがあふれ始め、数値の不安定性が問題を引き起こし始めます。素早い2乗乗算関数を使用すると、この問題はなくなります。

そして、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)

C、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単純な計算機を実装するためにを使用します（50文字の場合、5文字のペナルティはそれだけの価値があります）。現在の実装が遅いからといって遅くなりますが、理論的には十分に速いはずです（Perl 6の実装が改善されたとき、つまり）。また、驚いたことに、私はMathematicaで勝ちました（今のところ）。

» このコードでは実際には必要ありませんが、パフォーマンス上の理由でここに配置します（そうしないと、プログラムは文字列全体を割り当てます。Perl6には無限の文字列がなく、無限のリストがあるためです。

とにかく、このコードがどのように機能するかを尋ねることができます。さて、私は部分的にそれを渡すつもりです。

• get.eval

  これは1行（get関数）を取得し、それを評価します（evalメソッド）。

• 1..get.eval

  その後、Perl 6は1評価された値までの範囲オブジェクトを準備します。これは範囲なので、大きなものは何も割り当てられません。

• ».comb

  .combメソッドは文字列を文字に分割します（引数で呼び出されない限り）。たとえば、を'cat'.comb返します'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、-p、50-28バイト：-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より大きいハンドル番号にするために、私は、その文字列を分割するためにforループを別のものを使用して文字列の長さを取得するにPowerShellを使用し、それを追加する必要がありました合計 - s。
あなたは可能性の名称変更powershell.exeにp.exeCの下に：\ WINDOWS \ System32に\ WindowsPowerShell \ v1.0の\そしてちょうどでそれを呼び出しp "&{'%%a'.length-1}、9つのバイトを保存します。しかし、それは本当の精神ではありません。

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

私が昼休みをとっている間、その2番目のものを走らせました。

速度が遅いため、これよりも大きすぎる数値で実際にテストすることはできません。ただし、かなり大きな数でも機能するはずです。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桁の数字のリストを生成します）
 [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//^/**}))))"

• すべての正数を処理できます
• +-/ *操作で式を処理できます
• ^（パワー）演算子を処理できます。
• evalなどを使用せずに式を処理できる¹

expressionの結果が整数でない場合、最初に切り捨てられます。式の結果が負の場合、結果は未定義です。

次のように使用します。

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

1：BashからPythonを起動することをカウントしない限り、そうではないと思います。実際にそうだと思う場合、調整されたスコアは-7です。

Java、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);
    }
}

式を処理します。ターゲットに望む表現を与えてください。長さの長さが処理できるまで処理します。すべてのスペースを1行にまとめてクリーンアップし、印刷するステートメントがない場合、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()))))))

ungolfedを書くのが面倒なので、クラスの説明をします。

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

ルビー-> 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）

これは間違いなく一緒にゴルフできますが、ここに最初の 5 回目の試行があります

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