Tantangan ini adalah untuk menulis program atau skrip yang menghitung jumlah semua digit dalam bilangan bulat dari 1 hingga dan termasuk angka yang diberikan.

Input, satu bilangan bulat positif. Output, jumlah digit dalam angka itu dan semua angka yang lebih kecil.

Contoh:

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

Agar jelas, ini untuk menghitung jumlah digit - bukan bilangan bulat. Untuk input satu digit, ini akan sama. Namun, input yang lebih besar dari 10 akan memiliki respons yang berbeda. Ini akan menjadi respons yang salah :

Input: 12
Output: 78

Contoh lain, untuk menunjukkan perbedaan:

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

Kasus uji yang lebih besar (TANGGAPAN YANG BENAR):

Input: 1000000
Output: 27000001

Aturan & Pedoman:

• Kode yang dikirim harus berupa program atau skrip yang lengkap - bukan hanya fungsi. Jika kode mengharuskan termasuk, impor, dll, mereka harus dimasukkan dalam kode yang diposting.
• Nomor tersebut harus dimasukkan oleh pengguna - bukan kode-keras. Input dapat diterima sebagai argumen baris perintah, file, stdin, atau cara lain yang dengannya bahasa Anda dapat mengambil input pengguna.
• Kode harus dapat menangani input dengan baik setidaknya hingga (2^64)-1.
• Kode seharusnya hanya menampilkan jumlah.
• Program & skrip yang diajukan harus ramah pengguna dan tidak boros sumber daya komputer (mis.: Mereka tidak boleh mendeklarasikan array yang sangat besar untuk menampung setiap karakter). Tidak ada bonus atau penalti yang ketat untuk ini, tetapi harap menjadi pemrogram yang baik.

Mencetak:

Mekanisme penilaian utama adalah dengan panjang kode. Skor yang lebih rendah lebih baik. Bonus dan penalti berikut juga berlaku:

• -25 Bonus jika kode Anda dapat menangani semua angka positif, misalnya:1234567891234567891234564789087414984894900000000
• -50 Bonus jika kode Anda dapat menangani ekspresi sederhana, misalnya 55*96-12. Agar memenuhi syarat untuk bonus ini, kode harus menangani + - / *(penambahan, pengurangan, pembagian, penggandaan) operator dan menegakkan urutan operasi. Divisi adalah divisi integer reguler.
  • Contoh yang diberikan ( 55*96-12) dievaluasi menjadi 5268. Kode Anda harus mengembalikan yang sama untuk salah satu dari input tersebut - jawaban yang benar adalah 81393.
• -10 Bonus jika kode Anda memenuhi syarat untuk bonus -50 dan dapat menangani ^operator (eksponen).
• -100 Bonus jika kode Anda memenuhi syarat untuk bonus -50 dan tidak menggunakan evalatau mirip untuk menangani ekspresi.
• +300 Denda jika kode Anda bergantung pada sumber daya web apa pun.

Perl 6: 108 - (25 + 50 + 100) + 0 = -67 poin

Solusi golf (Baris akhir berdasarkan solusi hebat xfix ):

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

Solusi un-golf:

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

Langkah evaluasi bekerja dengan iterasi masing-masing simbol *, /, +, -, menemukan ketika itu terletak di antara dua bilangan bulat, dan mengganti yang menggunakan fungsi simbol mewakili.

Secara lebih rinci: dibutuhkan setiap simbol (misalnya +) dan fungsi infiks yang seharusnya diwakilinya (misalnya &[+]yang merupakan singkatan untuk &infix:<+>dan fungsi yang sama yang dipanggil Perl 6 saat Anda jalankan 1 + 2) dan melakukan subtitusi global ( s:g[…] = …, yang seperti Perl 5 s/…/…/ge), yang cocok dengan dua bilangan bulat yang dipisahkan oleh simbol ( (\d+) $sym (\d+)), dan menggantinya dengan output dari fungsi infiks terkait yang disebut dengan bilangan bulat tersebut ( infix($0, $1)).

Akhirnya, ekspresi yang dievaluasi ini dimasukkan ke dalam say [+] (1..$expression)».comb, yang dijelaskan oleh xfix dengan sangat baik dalam solusinya .

Maaf terlambat datang ke pesta ☺

EDIT: Dukungan yang dihapus untuk eksponen; itu tepatnya 10 karakter dan tidak melakukan asosiatif dengan benar.

Mathematica 30- (10 + 50) = -30

Dipersingkat oleh 4 karakter berkat ybeltukov.

Range@n mengembalikan angka dari 1 hingga n .

Integerdigits@n memecah masing-masing angka menjadi digit-nya.

Total[n,2]menjumlahkan digit. 2 adalah untuk memungkinkan penjumlahan di berbagai tingkatan, yaitu daftar daftar.

IntegerDigits@Range@#~Total~2&

Pengujian

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

51

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

27000001

Ekspresi

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

Sangat memalukan mencuri @Fors jawaban dari sini untuk melakukan evaluasi ekspresi: https://codegolf.stackexchange.com/a/11423/13877

Penggunaan sampel:

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

Catatan: implementasi ekspresi mengasumsikan tidak ada operator diutamakan dan mengkonsumsi nilai saat menerimanya; ex, 1+2*3 = 9daripada tipikal 7.

sed, 411 283 - 25 = 258

Saya tidak bisa diganggu untuk golf lebih banyak sekarang. :-) Tidak direkomendasikan untuk digunakan dengan bilangan bulat besar yang bahkan jarak jauh, tetapi secara teknis hal itu dapat menangani bilangan bulat besar yang sewenang-wenang (kemungkinan besar Anda akan kehabisan RAM, karena saya (lebih atau kurang harus) menyandikan angka dalam unary).

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

Penggunaan sampel

(Baris input indentasi untuk memudahkan membaca.)

  5
15
  12
51
  33
183

python, 55- (50 + 25 + 10) = -30

In-efisien namun lebih pendek dan juga mampu menangani ekspresi.

EDIT: Terima kasih Wolframh dan legoStormtroopr untuk triknya: D

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

python, 149- (25 + 50 + 10) = 64

Versi pertamaku

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

memasukkan:

1234567891234567891234564789087414984894900000000

keluaran:

265889343871444899381999757086453238874482500000214

Python - 108 karakter dikurangi 85 bonus, 23 pukulan, menangani input yang sangat sangat sangat besar

Sebagian besar solusi ini tampaknya perulangan semua int kurang dari input dan menjumlahkan semua jumlah digit mereka. Ini bekerja, tetapi saya merasa itu tidak berlaku, dan akan mempertanyakan apakah mereka benar-benar memenuhi syarat untuk bonus 25 poin, karena saya tidak berpikir mereka akan mampu menangani input 1234567891234567891234564789087414984894900000000dalam hidup kita. Memang, pada input ndigit, solusi ini membutuhkan O(10^n)waktu. Saya memilih untuk melempar matematika pada masalah ini.

#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)

Himpunan semua xangka digit isomorfis ke himpunan {0,1,2,3,4,5,6,7,8,9}^x. Untuk suatu fix (n,sig)ada xnilai yang berbeda untuk sig, 10^x-1poin dengan sigindeks th diatur ke n, dan jumlah semua digit 0-9adalah 45. Ini semua ditangani olehf .

g adalah sesuatu yang mungkin kita semua kenal

magicmengambil semua digit pada nomor input, dan beralih dari mereka dari yang paling signifikan. Paling mudah untuk melacak ini dengan contoh input, katakanlah 1,234,567.

Untuk menangani rentang 1,234,567-1,234,560, kita harus menjumlahkan semua digit dari 1hingga 7, dan menambahkan pada 7waktu jumlah dari digit lainnya, untuk menangani semua angka lebih besar dari 1,234,560. Kita sekarang perlu berurusan dengan sisanya.

Untuk menangani rentang 1,234,560-1,234,500, kami menambahkan pada 6( val), dan menjatuhkan batas atas ke 1,234,559. Dalam membuat sisa drop, kita akan melihat setiap angka satu digit 6 kali ( val*f(sig)). Kita akan melihat semua angka dari 0ke 5persis 10kali setiap ( (10**sig)*g(val-1)). Kami akan melihat semua digit lainnya dalam angka ini tepat 60 kali ( (val*10**sig)*sum(digits[sig+1:])). Kami sekarang telah berurusan dengan semua angka yang benar-benar lebih besar dari1,234,500 . Logika yang sama akan berlaku secara induktif di semua signifikansi.

Bermain golf ini, dengan terima kasih kepada WolframH, mengurangi solusi ini

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]))

Dan jumlah jumlah digit dari semua bilangan bulat hingga 1234567891234567891234564789087414984894900000000adalah265889343871444927857379407666265810009829069029376

Jumlah terbesar yang berhasil saya lemparkan pada versi golf adalah 10 ^ 300, di mana titik pelampung mulai meluap dan ketidakstabilan angka mulai menyebabkan masalah. Dengan fungsi eksponensial kuadrat dan kelipatan cepat, masalah ini akan hilang.

Dan dukungan LaTeX akan sangat berguna ...

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

Input menangani angka hingga 1E100 dan secara otomatis mengevaluasi. Dapat menangani ekspresi.

Meskipun ini adalah array yang sangat besar, saya tidak menghabiskan sumber daya komputer (ini dijalankan dari a kalkulator ).

Scala 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

Berikut ini adalah versi alternatif yang secara teknis harus memenuhi syarat untuk bonus 25 untuk bilangan bulat "apa pun", tetapi tidak praktis karena algoritma ini linear-waktu dalam inputnya. Bagaimanapun juga, itu menyenangkan untuk ditulis. Kurangi angka yang dibaca sebagai karakter ASCII secara manual. Versi ini adalah 150 karakter. (Sekarang dengan kode yang mengerikan, mendera argumen, loopful!)

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

Variasi penanganan ekspresi. Operator didahulukan alat sesuai dengan aturan yang khas: / * - +. Terbatas hingga 97 token = 48 istilah.

#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

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

Penjelasan: Misalkan input adalah "12":

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

Stack adalah [0,1,2,3,...,12].

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

Stack adalah "01234...9101112".

' '* # join a space between all characters

Stack adalah "0 1 2 ... 1 0 1 1 1 2".

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

Stack adalah [0,1,2,...,9,1,0,1,1,1,2].

{+}* # fold addition across the new array

Stack adalah 51, seperti yang diinginkan.

Input di sini dapat berupa ekspresi GolfScript yang valid, yang dapat menyertakan eksponen. Sebagai contoh:

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

Sejak 2(5 + 5) - 8 = 12. Saya pikir ini harus memenuhi syarat untuk bonus, tapi mungkin itu diharapkan hanya jika dalam bentuk normal, bukan notasi Polandia sebaliknya GolfScript.

Ruby, 37 - 50 = -13

Eval ganda, jauh-jauh melintasi langit! Seperti dengan solusi Ruby lainnya, saya pikir ini secara teoritis harus dapat bekerja dengan jumlah besar yang sewenang-wenang, tetapi waktu eksekusi akan ... mengerikan.

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

Versi lebih lama (skor 49 - 50)

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

Dengan asumsi bonus 10 karakter sebenarnya membutuhkan karakter eksponensial menjadi tanda sisipan, cara terpendek yang bisa saya pikirkan untuk menambahkannya adalah:

.gsub ?^,'**'

Yang harganya lebih banyak karakter daripada bonus akan memberikan.

Perl 6 (28 - 75 + 0 = -47 byte)

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

Ini dapat menangani semua angka positif (namun, yang besar akan memakan waktu lama, karena implementasi Perl 6 saat ini lambat, tetapi Perl 6 mendukung bilangan bulat besar secara asli). Itu menggunakaneval , untuk menerapkan kalkulator sederhana (hukuman lima karakter untuk lima puluh karakter tidak sia-sia). Ini lambat hanya karena implementasi saat ini lambat, tetapi secara teori, itu harus cukup cepat (ketika implementasi Perl 6 meningkat, yaitu). Juga, secara mengejutkan, saya menang dengan Mathematica (untuk saat ini).

» dalam kode ini sebenarnya tidak diperlukan, tapi saya taruh di sini untuk alasan kinerja (jika tidak, program akan mengalokasikan seluruh string. Alasan mengapa di sini adalah bahwa Perl 6 tidak memiliki string yang tak terbatas, tetapi ia memiliki daftar yang tak terbatas.

Bagaimanapun, Anda mungkin bertanya bagaimana kode ini bekerja. Baiklah, saya akan memberikannya bagian demi bagian.

• get.eval

  Ini mendapat satu baris ( getfungsi), dan mengevaluasinya ( evalmetode).

• 1..get.eval

  Setelah itu, Perl 6 menyiapkan objek jangkauan, dari 1nilai yang dievaluasi. Ini adalah rentang, jadi tidak ada alokasi besar.

• ».comb

  .combmetode membagi string ke karakter ( kecuali dipanggil dengan argumen ). Misalnya, 'cat'.combkembali 'c', 'a', 't'. »memetakan elemen daftar, sehingga .combdijalankan pada setiap item - tidak hanya pada daftar itu sendiri (misalnya,(4, 9)».sqrt memberi 2, 3). Ini juga tidak mengalokasikan lebih dari yang dibutuhkan, karena Perl 6 memiliki daftar tak terbatas (seperti Haskell, misalnya).

  »karakter sebenarnya tidak diperlukan, seperti yang .combdapat digunakan secara langsung pada daftar, tetapi ini melibatkan paksaan string implisit (dan Perl 6 tidak memiliki string tak terbatas, jadi ini akan menghabiskan memori). Misalnya, 1, 2, 3daftar setelah konversi ke string kembali 1 2 3. Untuk Perl 6, spasi adalah angka yang sangat baik artinya 0, sehingga kode akan berfungsi, bahkan dengan konversi tersebut. Namun, itu akan menyalahgunakan sumber daya komputasi.

• [+]

  Ini adalah operator pengurangan. Pada dasarnya, di antara [], Anda dapat menempatkan operator untuk digunakan, dalam hal ini +. Daftar setelah dikurangi operator dikurangi, begitu [+] 1, 2, 3juga 1 + 2 + 3, yang 6. Perl 6 menggunakan operator terpisah untuk angka dan string, sehingga tidak akan dianggap sebagai gabungan.

• say

  Akhirnya, sayoutput hasilnya. Lagi pula, Anda ingin melihat hasil akhirnya, bukan?

Perl 31 - Tidak ada bonus

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

Output sampel:

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

Perl 5 dengan -p, 50 - 28 byte: -22

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

Cobalah online!

J, 22

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

Penjelasan

Evaluasi berasal dari kanan ke kiri.

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)

Ketika ini dijalankan, pengguna diminta untuk input.

Versi lama (tidak dapat menangani ekspresi): 46 karakter:

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

Gelombang - (181 - 50) - 131

Hanya untuk sedikit kesenangan.

@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!

Saya akan membuatnya sedikit lebih mudah dibaca:

@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!

Metode lama menggunakan untuk loop untuk mendapatkan output dari perintah powershell, sebagai lawan dari menulis ke dan membaca dari file:

@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!

Tetapkan input ke variabel - v- gunakan /auntuk menerima ekspresi aritmatika.
Sayangnya memungkinkan ekspansi yang tertunda diperlukan.
Gunakan for for untuk menghitung dari 1 hingga nilai yang dimasukkan - v.
Untuk menangani angka yang lebih besar dari 9, saya harus menggunakan PowerShell untuk mendapatkan panjang string kemudian gunakan yang lain untuk loop untuk membagi string itu ke atas, dan menambahkannya ke jumlah - s.
Anda dapat mengubah nama powershell.exemenjadi di p.exebawah C: \ WINDOWS \ System32 \ WindowsPowerShell \ v1.0 \ kemudian menyebutnya dengan adil p "&{'%%a'.length-1}, menghemat 9 byte. Tapi itu tidak benar-benar dalam semangat itu.

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

Meninggalkan yang kedua berjalan sementara saya istirahat makan siang.

Saya tidak bisa benar-benar mengujinya dengan angka yang terlalu besar daripada ini karena seberapa lambat itu. Namun harus bekerja untuk jumlah yang cukup besar. 2147483647adalah jumlah terbesar yang akan diambil (integer maksimum 32 bit) sebelum memberikan kesalahan berikut -

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

Ini tentu saja mendiskualifikasi saya dari tantangan.

Dyalog APL , 9 - 160 * = -151

+/⍎¨∊⍕¨⍳⎕

Cobalah online!

⎕mendapatkan input yang dievaluasi
 misalnya "7+5"memberi12

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

⍕¨ memformat setiap angka menjadi string
 ["1","2","3","4","5","6","7","8","9","10","11","12"]

∊ minta (ratakan)
 "123456789101112"

⍎¨ mengeksekusi setiap karakter (menghasilkan daftar nomor digit tunggal)
 [1,2,3,4,5,6,7,8,9,1,0,1,1,1,2]

+/ jumlah  51

* Mencetak gol

-50 bonus karena bahkan menerima ekspresi sebagai input. Ekspresi harus APL yang valid, yang dapat diterima menurut OP .

-10 bonus karena karena juga menangani ^( *dalam APL).

-100 bonus karena input ekspresi ditangani tanpa penggunaan eksplisit eval(yaitu ⍎dalam 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));}}

Cantik

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//^/**}))))"

• dapat menangani semua angka positif
• dapat menangani ekspresi dengan operasi + - / *
• dapat menangani operator ^ (daya).
• dapat menangani ekspresi, tanpa eval atau yang serupa¹

Jika hasil ekspresi tidak bilangan bulat, itu akan dipotong terlebih dahulu. Jika hasil dari ekspresi negatif, hasilnya tidak terdefinisi.

Gunakan seperti:

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

1: kecuali jika Anda menghitung memanggil Python dari Bash, tapi saya rasa tidak demikian. Jika Anda berpikir bahwa itu sebenarnya, maka skor yang disesuaikan adalah -7.

Jawa, 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);
    }
}

Menangani ekspresi. Berikan ekspresi apa pun yang Anda inginkan dalam target. Pegangan hingga panjangnya bisa ditanganinya. Jika Anda membersihkan semua ruang menjadi satu baris, dan tidak ada pernyataan untuk dicetak, itu dihitung menjadi 254 karakter (mengingat kata-kata panjang berbasis pemrograman Java).

PS: Ini adalah program yang lengkap, bukan hanya logika. Jumlah kata yang diberikan untuk program, bukan hanya logika.

Java (JDK8), 272

Tantangan pertama saya, saya menerima saran =)

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

Bertakuk:

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 beberapa bulan lebih muda dari tantangan ini, jadi ini tidak memenuhi syarat untuk tanda centang hijau. Selain itu, ini bukan mengalahkan Perl. ;) Saya cukup menyukai pendekatan itu, jadi saya tetap ingin mempostingnya.

l~),s:~:+

Uji di sini.

Idenya adalah untuk membuat rentang dari 0 hingga N. Kisaran ini kemudian dikonversi ke string, yang hanya menyatukan bilangan bulat kembali ke belakang. Untuk N = 12, kita dapatkan

"0123456789101112"

Kemudian setiap karakter dikonversi menjadi bilangan bulat dengan :~(menghasilkan array bilangan bulat), dan kemudian disimpulkan dengan :+. CJam dapat berurusan dengan bilangan bulat besar yang sewenang-wenang.

Python 3 + astor ,1017 1007 byte - (25 + 50 + 100) = Skor: 842 834

menyimpan 10 byte dengan menghapus tsdan mengubahp

sunting: Saya tidak dapat menguji bilangan bulat yang sangat panjang (1234567891234567891234564789087414984894900000000) [hang komputer saya] tetapi dari pengetahuan saya, Python 3 mendukung bilangan bulat yang terlalu panjang.

Implementasi ini menggunakanpenyalahgunaan AST. Saya tidak akan menganggap penyalahgunaan AST sebagai "eval atau serupa".

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

Terlalu malas untuk menulis ungolfed, jadi saya akan memberi Anda penjelasan tentang kelas:

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.

The last line just executes these classes in the appropriate order on the input, to preserve order of operations, and prevent unwanted behavior.

Example usage ($ or > means user input) and by the way, the actual program takes input only once:

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

Pretty

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(:+)}                     

"To test" version:

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 

Tests results

$ 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)

Its my another attempt.

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

Pretty

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

Ruby 69-50 = 19 (or -4)

This can definitely be golfed together but here is the first fifth try

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

It also works for all numbers but is very slow for them as it runs slower than O(n), so I wouldn't add the -25. If slowness is fine, then it would be -4 though

Ruby 133-50-25 = 58

This is the faster version, that runs in less-than O(n) time (and uses actual math!), so it can provide results for large integers fast, thereby I added the -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]

Haskell, 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 points)

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

Output:

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