Thử thách này là viết một chương trình hoặc tập lệnh đếm tổng của tất cả các chữ số trong các số nguyên từ 1 đến và bao gồm một số đã cho.

Đầu vào, một số nguyên dương. Đầu ra, tổng các chữ số trong số đó và tất cả các số nhỏ hơn.

Ví dụ:

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

Để rõ ràng, đây là để tính tổng các chữ số - không phải là số nguyên. Đối với đầu vào một chữ số, điều này sẽ giống nhau. Tuy nhiên, đầu vào lớn hơn 10 sẽ có phản hồi khác nhau. Đây sẽ là một phản hồi không chính xác :

Input: 12
Output: 78

Một ví dụ khác, để cho thấy sự khác biệt:

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

Một trường hợp thử nghiệm lớn hơn (ĐÚNG ĐÚNG):

Input: 1000000
Output: 27000001

Nội quy & Nguyên tắc:

• Mã đã gửi phải là một chương trình hoặc tập lệnh hoàn chỉnh - không chỉ là một chức năng. Nếu mã yêu cầu bao gồm, nhập khẩu, vv, chúng phải được bao gồm trong mã được đăng.
• Số phải được nhập bởi người dùng - không được mã hóa cứng. Đầu vào có thể được nhận dưới dạng đối số dòng lệnh, tệp, stdin hoặc bất kỳ phương tiện nào khác mà ngôn ngữ của bạn có thể lấy đầu vào của người dùng.
• Mã phải có khả năng xử lý đúng các đầu vào ít nhất lên đến (2^64)-1.
• Mã chỉ nên xuất tổng.
• Các chương trình & tập lệnh được gửi phải thân thiện với người dùng và không lãng phí tài nguyên máy tính (ví dụ: họ không nên khai báo các mảng cực lớn để giữ mọi ký tự). Không có tiền thưởng hoặc hình phạt nghiêm ngặt cho việc này, nhưng xin hãy là những lập trình viên giỏi.

Ghi điểm:

Cơ chế tính điểm chính là theo chiều dài mã. Điểm thấp hơn là tốt hơn. Các khoản thưởng và phạt sau đây cũng được áp dụng:

• -25 Tiền thưởng nếu mã của bạn có thể xử lý tất cả các số dương, ví dụ:1234567891234567891234564789087414984894900000000
• -50 Tiền thưởng nếu mã của bạn có thể xử lý các biểu thức đơn giản, ví dụ 55*96-12. Để đủ điều kiện nhận phần thưởng này, mã phải xử lý các toán tử + - / *(cộng, trừ, chia, nhân) và thực thi thứ tự các thao tác. Phân chia là phân chia số nguyên thường xuyên.
  • Ví dụ đã cho ( 55*96-12) ước tính cho 5268. Mã của bạn sẽ trả về giống nhau cho một trong những đầu vào đó - câu trả lời đúng là 81393.
• -10 Phần thưởng nếu mã của bạn đủ điều kiện nhận phần thưởng -50 và có thể xử lý ^toán tử (số mũ).
• -100 Phần thưởng nếu mã của bạn đủ điều kiện nhận phần thưởng -50 và không sử dụng evalhoặc tương tự để xử lý các biểu thức.
• +300 Hình phạt nếu mã của bạn phụ thuộc vào bất kỳ tài nguyên web nào.

Perl 6: 108 - (25 + 50 + 100) + 0 = -67 điểm

Giải pháp được đánh gôn (Dòng cuối cùng dựa trên giải pháp tuyệt vời của xfix ):

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

Giải pháp không chơi gôn:

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

Bước đánh giá hoạt động bằng cách iterating trên mỗi biểu tượng của *, /, +, -, tìm khi mà sự dối trá giữa hai số nguyên, và thay rằng việc sử dụng các chức năng đó biểu tượng đại diện.

Chi tiết hơn: phải lấy từng ký hiệu (ví dụ +) và hàm infix mà nó phải đại diện (ví dụ: tốc &[+]ký &infix:<+>và cùng chức năng Perl 6 gọi khi bạn thực thi 1 + 2) và thực hiện thay thế toàn cục ( s:g[…] = …giống như Perl 5 s/…/…/ge), khớp với hai số nguyên được phân tách bằng ký hiệu ( (\d+) $sym (\d+)) và thay thế nó bằng đầu ra của hàm infix tương ứng được gọi bằng các số nguyên đó ( infix($0, $1)).

Cuối cùng, biểu thức được đánh giá này được đưa vào say [+] (1..$expression)».comb, mà xfix giải thích rất rõ trong giải pháp của anh ta .

Xin lỗi vì đến bữa tiệc quá muộn

EDIT: Loại bỏ hỗ trợ cho số mũ; dù sao nó cũng chính xác là 10 ký tự và không thực hiện kết hợp chính xác.

Toán học 30- (10 + 50) = -30

Rút ngắn 4 ký tự nhờ ybeltukov.

Range@ntrả về các số từ 1 đến n.

Integerdigits@n chia mỗi số đó thành các chữ số của nó.

Total[n,2]tổng hợp các chữ số. 2 là cho phép tổng hợp qua các cấp khác nhau, tức là danh sách các danh sách.

IntegerDigits@Range@#~Total~2&

Kiểm tra

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

51

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

27000001

Biểu thức

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

Rất đáng xấu hổ khi ăn cắp @Fors trả lời từ đây để thực hiện đánh giá biểu thức: https://codegolf.stackexchange.com/a/11423/13877

Sử dụng mẫu:

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

Lưu ý: việc thực hiện biểu thức giả định không có quyền ưu tiên của toán tử và tiêu thụ các giá trị khi nó nhận được chúng; ex, 1+2*3 = 9chứ không phải là điển hình 7.

trầm tích, 411 283 - 25 = 258

Tôi không thể bận tâm để chơi nó nhiều hơn bây giờ. :-) Không được khuyến nghị sử dụng với các số nguyên lớn từ xa, nhưng về mặt kỹ thuật, nó có thể xử lý các số nguyên lớn tùy ý (có thể bạn sẽ hết RAM khá nhanh, vì tôi (ít nhiều phải) mã hóa số trong đơn phương).

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

Sử dụng mẫu

(Dòng đầu vào thụt vào để đọc dễ dàng hơn.)

  5
15
  12
51
  33
183

trăn, 55- (50 + 25 + 10) = -30

Không hiệu quả nhưng ngắn hơn và cũng có thể xử lý các biểu thức.

EDIT: Cảm ơn Wolframh và legoStormtroopr vì những mánh khóe: D

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

trăn, 149- (25 + 50 + 10) = 64

Phiên bản đầu tiên của tôi

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

đầu vào:

1234567891234567891234564789087414984894900000000

đầu ra:

265889343871444899381999757086453238874482500000214

Python - 108 ký tự trừ 85 phần thưởng, 23 nét, xử lý các đầu vào rất rất rất lớn

Hầu hết các giải pháp này dường như được lặp qua tất cả các số nguyên nhỏ hơn đầu vào và cộng tất cả các tổng số chữ số của chúng. Điều này hoạt động, nhưng tôi cảm thấy nó không phù hợp, và sẽ đặt câu hỏi liệu họ có thực sự đủ điều kiện nhận phần thưởng 25 điểm hay không, vì tôi không nghĩ rằng họ có thể xử lý đầu vào 1234567891234567891234564789087414984894900000000trong vòng đời của chúng tôi. Thật vậy, trên đầu vào của các nchữ số, các giải pháp này mất O(10^n)thời gian. Tôi đã chọn thay vì ném một số toán học vào vấn đề này.

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

Tập hợp tất cả các xsố có dạng đẳng cấu với tập hợp {0,1,2,3,4,5,6,7,8,9}^x. Đối với một cố định (n,sig)có xcác giá trị khác nhau cho sig, 10^x-1các điểm có sigchỉ số thứ được đặt thành nvà tổng của tất cả các chữ số 0-9là 45. Tất cả được xử lý bởi f.

g là một cái gì đó có lẽ chúng ta đều quen thuộc với

magiclấy tất cả các chữ số trong số đầu vào và lặp lại chúng từ ít nhất đến quan trọng nhất. Thật dễ dàng để theo dõi điều này với một ví dụ đầu vào, nói 1,234,567.

Để xử lý phạm vi 1,234,567-1,234,560, chúng ta phải cộng tất cả các chữ số từ 1đến 7và cộng vào 7lần tổng của các chữ số khác, để xử lý tất cả các số lớn hơn 1,234,560. Bây giờ chúng ta cần phải đối phó với phần còn lại.

Để xử lý phạm vi 1,234,560-1,234,500, chúng tôi thêm vào 6( val) và thả giới hạn trên xuống 1,234,559. Trong phần còn lại của sự sụt giảm, chúng ta sẽ thấy mỗi số có một chữ số 6 lần ( val*f(sig)). Chúng ta sẽ thấy tất cả các số từ chính xác 0đến từng lần ( ). Chúng ta sẽ thấy tất cả các chữ số khác trong số này chính xác 60 lần ( ). Bây giờ chúng tôi đã xử lý tất cả các con số lớn hơn . Logic tương tự sẽ được áp dụng theo quy nạp trên tất cả các ý nghĩa.510(10**sig)*g(val-1)(val*10**sig)*sum(digits[sig+1:])1,234,500

Chơi golf này, nhờ có WolframH, giảm giải pháp này xuống

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

Và tổng của các chữ số của tất cả các số nguyên lên đến 1234567891234567891234564789087414984894900000000là265889343871444927857379407666265810009829069029376

Con số lớn nhất mà tôi quản lý để ném vào phiên bản chơi gôn là 10 ^ 300, tại thời điểm đó, các phao bắt đầu tràn ra và sự mất ổn định số bắt đầu gây ra vấn đề. Với hàm lũy thừa vuông và nhân nhanh chóng, vấn đề này sẽ biến mất.

Và hỗ trợ LaTeX sẽ thực sự hữu ích ...

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

Đầu vào xử lý số lượng lên đến 1E100và tự động đánh giá. Có thể xử lý biểu thức.

Mặc dù nó là một mảng cực kỳ lớn, tôi không lãng phí tài nguyên máy tính (điều này được chạy từ máy tính ).

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

Đây là một phiên bản thay thế về mặt kỹ thuật đủ điều kiện nhận 25 phần thưởng cho số nguyên dương "bất kỳ", nhưng nó thực sự chậm vì thuật toán là thời gian tuyến tính trong đầu vào của nó. Bất kể, đó là niềm vui để viết. Trừ thủ công một số được đọc dưới dạng ký tự ASCII. Phiên bản này có 150 ký tự. (Bây giờ với mã khủng khiếp, lập luận, mã lặp!)

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

Biến thể xử lý biểu thức. Thực hiện ưu tiên toán tử theo các quy tắc điển hình : / * - +. Giới hạn ở 97 mã thông báo = 48 điều khoản.

#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

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

Giải thích: Giả sử đầu vào là "12":

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

Chồng là [0,1,2,3,...,12].

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

Chồng là "01234...9101112".

' '* # join a space between all characters

Chồng là "0 1 2 ... 1 0 1 1 1 2".

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

Chồng là [0,1,2,...,9,1,0,1,1,1,2].

{+}* # fold addition across the new array

Stack là 51, như mong muốn.

Đầu vào ở đây có thể là bất kỳ biểu thức GolfScript hợp lệ nào, có thể bao gồm số mũ. Ví dụ:

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

Kể từ đó 2(5 + 5) - 8 = 12. Tôi nghĩ rằng điều này sẽ đủ điều kiện nhận tiền thưởng, nhưng có lẽ nó chỉ được dự kiến ​​nếu ở dạng bình thường, không phải là ký hiệu ngược của Ba Lan về GolfScript.

Hồng ngọc, 37 - 50 = -13

Đôi eval, tất cả các cách trên bầu trời! Cũng như các giải pháp Ruby khác, tôi nghĩ rằng về mặt lý thuyết, nó có thể hoạt động với số lượng lớn tùy ý, nhưng thời gian thực hiện sẽ rất ... khủng khiếp.

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

Phiên bản cũ hơn (49 - 50 điểm)

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

Giả sử phần thưởng 10 ký tự thực sự đòi hỏi nhân vật theo cấp số nhân phải là một dấu mũ, cách ngắn nhất tôi có thể nghĩ để thêm vào đó là:

.gsub ?^,'**'

Mà chi phí nhiều nhân vật hơn tiền thưởng sẽ cung cấp.

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

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

Nó có thể xử lý tất cả các số dương (tuy nhiên, các số lớn sẽ mất nhiều thời gian, vì hiện tại việc triển khai Perl 6 chậm, nhưng Perl 6 hỗ trợ các số nguyên lớn nguyên bản). Nó sử dụng eval, để thực hiện một máy tính đơn giản (hình phạt năm ký tự cho năm mươi ký tự là xứng đáng). Nó chậm chỉ vì các triển khai hiện tại chậm, nhưng về lý thuyết, nó phải đủ nhanh (khi triển khai Perl 6 được cải thiện, nghĩa là như vậy). Ngoài ra, đáng ngạc nhiên, tôi giành chiến thắng với Mathematica (bây giờ).

» trong mã này thực sự không cần thiết, nhưng tôi đặt nó ở đây vì lý do hiệu năng (nếu không, chương trình sẽ phân bổ toàn bộ chuỗi. Lý do tại sao Perl 6 không có chuỗi vô hạn, nhưng nó có danh sách vô hạn.

Dù sao, bạn có thể hỏi làm thế nào mã này thậm chí hoạt động. Vâng, tôi sẽ vượt qua nó một phần.

• get.eval

  Điều này nhận được một dòng ( gethàm) và đánh giá nó ( evalphương thức).

• 1..get.eval

  Sau đó, Perl 6 chuẩn bị một đối tượng phạm vi, từ 1giá trị được đánh giá. Đây là một phạm vi, vì vậy không có gì lớn được phân bổ.

• ».comb

  .combphương thức chia chuỗi thành các ký tự ( trừ khi được gọi với một đối số ). Ví dụ, 'cat'.combtrả về 'c', 'a', 't'. »ánh xạ các thành phần danh sách, do đó, .combđược chạy trên mỗi mục của nó - không chỉ trên chính danh sách (ví dụ: (4, 9)».sqrtđưa ra 2, 3). Điều này cũng không phân bổ nhiều hơn mức cần thiết, vì Perl 6 có danh sách vô hạn (ví dụ như Haskell).

  »ký tự thực sự không cần thiết, vì .combcó thể được sử dụng trực tiếp trong danh sách, nhưng điều này liên quan đến ép buộc chuỗi ngầm định (và Perl 6 không có chuỗi vô hạn, vì vậy điều này sẽ lãng phí bộ nhớ). Ví dụ, 1, 2, 3danh sách sau khi chuyển đổi thành chuỗi trả về 1 2 3. Đối với Perl 6, một khoảng trắng là một số hoàn toàn tốt có nghĩa là 0, vì vậy mã sẽ hoạt động, ngay cả với chuyển đổi như vậy. Tuy nhiên, nó sẽ lạm dụng tài nguyên máy tính.

• [+]

  Đây là một toán tử giảm. Về cơ bản, giữa [], bạn có thể đặt một toán tử để sử dụng, trong trường hợp này +. Danh sách sau khi giảm toán tử được giảm, đó [+] 1, 2, 3là 1 + 2 + 3, đó là 6. Perl 6 sử dụng các toán tử riêng cho các số và chuỗi, vì vậy nó sẽ không được coi là nối.

• say

  Cuối cùng, đưa sayra kết quả. Rốt cuộc, bạn muốn xem kết quả cuối cùng, phải không?

Perl 31 - Không có tiền thưởng

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

Đầu ra mẫu:

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

Perl 5 với -p, 50 - 28 byte: -22

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

Hãy thử trực tuyến!

J, 22

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

Giải trình

Đánh giá tiến hành từ phải sang trá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)

Khi điều này được chạy, người dùng được yêu cầu đầu vào.

Phiên bản cũ (không thể xử lý biểu thức): 46 ký tự:

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

Mẻ - (181 - 50) - 131

Chỉ cho một chút niềm vui.

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

Tôi sẽ làm cho nó dễ đọc hơn một chút:

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

Phương thức cũ sử dụng vòng lặp để nhận đầu ra của lệnh powershell, trái ngược với việc ghi và đọc từ tệp:

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

Đặt đầu vào thành một biến - v- sử dụng /ađể chấp nhận các biểu thức số học.
Thật không may cho phép mở rộng chậm trễ là cần thiết.
Sử dụng vòng lặp for để đếm từ 1 đến giá trị được nhập - v.
Để xử lý các số lớn hơn 9, tôi đã phải sử dụng powershell để lấy độ dài của chuỗi sau đó sử dụng một vòng lặp khác để tách chuỗi đó lên và thêm nó vào tổng - s.
Bạn có thể thay đổi tên của powershell.exethành p.exeC: \ WINDOWS \ System32 \ WindowsPowerShell \ v1.0 \ sau đó gọi nó chỉ bằng p "&{'%%a'.length-1}, tiết kiệm 9 byte. Nhưng đó không thực sự là tinh thần của nó.

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

Còn lại cái thứ hai chạy trong khi tôi nghỉ trưa.

Tôi thực sự không thể kiểm tra nó với những con số quá lớn hơn con số này do tốc độ của nó chậm. Tuy nhiên, nó sẽ làm việc cho số lượng khá lớn. 2147483647là số lớn nhất mà nó sẽ lấy (số nguyên tối đa 32 bit) trước khi đưa ra lỗi sau -

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

Điều này tất nhiên loại tôi ra khỏi thử thách.

Thuốc nhuộm APL , 9 - 160 * = -151

+/⍎¨∊⍕¨⍳⎕

Hãy thử trực tuyến!

⎕được đánh giá đầu vào,
 ví dụ như "7+5"cho12

⍳chỉ số 1 ... n
 [1,2,3,4,5,6,7,8,9,10,12]

⍕¨ định dạng mỗi số thành chuỗi
 ["1","2","3","4","5","6","7","8","9","10","11","12"]

∊ tranh thủ (làm phẳng)
 "123456789101112"

⍎¨ thực hiện từng ký tự (mang lại danh sách các số có một chữ số)
 [1,2,3,4,5,6,7,8,9,1,0,1,1,1,2]

+/ tổng  51

* Chấm điểm

-50 tiền thưởng vì nó thậm chí chấp nhận biểu thức làm đầu vào. Biểu thức phải là APL hợp lệ, được chấp nhận theo OP .

-10 tiền thưởng vì nó cũng xử lý ^( *trong APL).

-100 phần thưởng vì đầu vào biểu thức được xử lý mà không sử dụng rõ ràng eval(tức là ⍎trong 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));}}

Đẹp

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

• có thể xử lý tất cả các số dương
• có thể xử lý các biểu thức với thao tác + - / *
• có thể xử lý toán tử ^ (power).
• có thể xử lý các biểu thức, mà không có eval hoặc tương tự¹

Nếu kết quả của biểu thức không phải là số nguyên, nó sẽ bị cắt trước. Nếu kết quả của biểu thức là âm, kết quả là không xác định.

Sử dụng nó như:

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

1: trừ khi bạn tính việc gọi Python từ Bash như vậy, nhưng tôi không nghĩ đó là trường hợp. Nếu bạn nghĩ rằng nó thực sự là, thì điểm điều chỉnh là -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);
    }
}

Xử lý biểu hiện. Đưa ra bất kỳ biểu hiện nào bạn mong muốn trong mục tiêu. Xử lý cho đến khi chiều dài dài có thể xử lý. Nếu bạn dọn sạch tất cả các khoảng trắng thành một dòng và không có câu lệnh nào để in, thì nó sẽ được tính đến 254 ký tự (xem xét các từ dài dựa trên lập trình Java).

PS: Đây là một chương trình hoàn chỉnh, không chỉ logic. Các từ được đưa ra cho chương trình, không chỉ là logic.

Java (JDK8), 272

Thử thách đầu tiên của tôi là tôi tham gia, đề xuất được chào đón =)

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

Thụt lề:

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 trẻ hơn thử thách này vài tháng, vì vậy điều này không đủ điều kiện cho dấu kiểm màu xanh lá cây. Hơn nữa, điều này không đánh bại Perl ở nơi đầu tiên. ;) Tôi khá thích cách tiếp cận này, vì vậy tôi vẫn muốn đăng nó.

l~),s:~:+

Kiểm tra nó ở đây.

Ý tưởng là tạo ra một phạm vi từ 0 đến N. Phạm vi này sau đó được chuyển đổi thành một chuỗi, nó chỉ nối các số nguyên trở lại. Với N = 12, chúng tôi sẽ nhận được

"0123456789101112"

Sau đó, mỗi ký tự được chuyển đổi thành một số nguyên với :~(thu được một mảng các số nguyên), và sau đó được tóm tắt với :+. CJam có thể đối phó với các số nguyên lớn tùy ý.

Python 3 + astor ,1017 1007 byte - (25 + 50 + 100) = Điểm: 842 834

đã lưu 10 byte bằng cách xóa tsvà thay đổip

chỉnh sửa: Tôi không thể kiểm tra số nguyên dài vô lý (1234567891234567891234564789087414983614900000000) [treo máy tính của tôi] nhưng theo hiểu biết của tôi, Python 3 hỗ trợ các số nguyên dài vô hạn.

Việc thực hiện này sử dụnglạm dụng AST. Tôi sẽ không coi việc lạm dụng AST là "eval hoặc tương tự".

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

Quá lười để viết không đúng, vì vậy tôi sẽ giải thích cho bạn về các lớp:

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.

Dòng cuối cùng chỉ thực hiện các lớp này theo thứ tự phù hợp trên đầu vào, để duy trì thứ tự các hoạt động và ngăn chặn hành vi không mong muốn.

Ví dụ sử dụng ($ hoặc> có nghĩa là đầu vào của người dùng) và nhân tiện, chương trình thực tế chỉ nhận đầu vào một lần:

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

Đẹp

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

Hồng ngọc -> 83-50 = 33

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

Phiên bản "Để kiểm tra":

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 

Kết quả xét nghiệm

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

Đó là một nỗ lực khác của tôi.

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

Đẹp

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

Ruby 69-50 = 19 (hoặc -4)

Điều này chắc chắn có thể được chơi golf cùng nhau nhưng đây là lần thử thứ năm đầu tiên

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

Nó cũng hoạt động cho tất cả các số nhưng rất chậm đối với chúng vì nó chạy chậm hơn O (n), vì vậy tôi sẽ không thêm -25. Nếu chậm là tốt, sau đó nó sẽ là -4 dù

Hồng ngọc 133-50-25 = 58

Đây là phiên bản nhanh hơn, chạy trong thời gian ít hơn O (n) (và sử dụng toán học thực tế!), Vì vậy nó có thể cung cấp kết quả cho các số nguyên lớn nhanh chóng, do đó tôi đã thêm -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 điểm)

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

Đầu ra:

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