ความท้าทายนี้คือการเขียนโปรแกรมหรือสคริปต์ซึ่งนับผลรวมของตัวเลขทั้งหมดภายในจำนวนเต็มตั้งแต่ 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ได้ เพื่อให้มีคุณสมบัติสำหรับโบนัสนี้รหัสควรจัดการ+ - / *(เพิ่มเติม, ลบ, หาร, การคูณ) ตัวดำเนินการและบังคับใช้ลำดับของการดำเนินการ Division คือการหารจำนวนเต็มปกติ
  • ตัวอย่างที่กำหนด ( 55*96-12) 5268ประเมิน รหัสของคุณควรจะกลับเหมือนกันสำหรับทั้งของปัจจัยการผลิตเหล่านั้น - 81393คำตอบที่ถูกต้องคือ
• -10 โบนัสหากรหัสของคุณมีคุณสมบัติเพียงพอสำหรับ -50 โบนัสและสามารถจัดการ^ผู้ประกอบการ (เลขยกกำลัง)
• -100 โบนัสหากรหัสของคุณมีสิทธิ์ได้รับ -50 โบนัสและไม่ได้ใช้evalหรือคล้ายกับการจัดการการแสดงออก
• +300 โทษหากรหัสของคุณขึ้นอยู่กับแหล่งข้อมูลบนเว็บใด ๆ

Perl 6: 108 - (25 + 50 + 100) + 0 = -67 คะแนน

สารละลาย Golfed (บรรทัดสุดท้ายจากโซลูชันที่ยอดเยี่ยมของ 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

ขั้นตอนการประเมินผลการทำงานโดย iterating มากกว่าสัญลักษณ์ของแต่ละ*, /, +, -หาเมื่อที่อยู่ระหว่างสองจำนวนเต็มแทนว่าการใช้ฟังก์ชั่นที่แสดงให้เห็นถึงสัญลักษณ์

รายละเอียดเพิ่มเติม: ใช้แต่ละสัญลักษณ์ (เช่น+) และฟังก์ชั่น infix ที่ควรแสดง (เช่น&[+]ชวเลข&infix:<+>และฟังก์ชัน Perl 6 สายเดียวกันเมื่อคุณเรียกใช้1 + 2) และทำการทดแทนทั่วโลก ( s:g[…] = …ซึ่งเหมือนกับ Perl 5 s/…/…/ge) ซึ่งตรงกับจำนวนเต็มสองจำนวนคั่นด้วยสัญลักษณ์ ( (\d+) $sym (\d+)) และแทนที่ด้วยเอาต์พุตของฟังก์ชัน infix ที่สอดคล้องกันที่เรียกว่าด้วยจำนวนเต็มเหล่านั้น ( infix($0, $1))

ในที่สุดการแสดงออกการประเมินนี้จะป้อนเข้าสู่say [+] (1..$expression)».combซึ่งxfix อธิบายได้เป็นอย่างดีในการแก้ปัญหาของเขา

ขออภัยที่มาช้าไปงานเลี้ยง☺

แก้ไข: ลบการสนับสนุนสำหรับ exponents; อย่างไรก็ตามมีความยาว 10 อักขระและไม่สามารถเชื่อมโยงได้อย่างถูกต้อง

Mathematica 30- (10 + 50) = -30

สั้นลง 4 ตัวอักษรด้วย ybeltukov

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 = 97

sed, 411 283 - 25 = 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

หลาม, 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 จังหวะจัดการอินพุตที่มีขนาดใหญ่มาก

โซลูชันเหล่านี้ส่วนใหญ่ดูเหมือนจะวนลูปมากกว่า int ทั้งหมดน้อยกว่าอินพุทและบวกผลรวมหลักทั้งหมด ใช้งานได้ แต่ฉันรู้สึกว่าไม่เหมาะสมและจะถามว่าพวกเขามีสิทธิ์ได้รับโบนัส 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ตัวเลขหลักคือ isomorphic {0,1,2,3,4,5,6,7,8,9}^xการตั้งค่า สำหรับคง(n,sig)มีxค่าแตกต่างกันสำหรับsig, 10^x-1จุดกับsigSET Index วันที่ไปnและผลรวมของตัวเลขทั้งหมด0-9เป็น 45 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บนไป ในการทำให้ส่วนที่เหลือของการลดลงเราจะเห็นทุกตัวเลขหลักเดียว 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

จำนวนที่มากที่สุดที่ฉันสามารถจัดการได้ที่เวอร์ชัน golfed คือ 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)

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 ที่ถูกต้องซึ่งอาจรวมถึง exponents ตัวอย่างเช่น:

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'.comb แม็พอิลิเมนต์รายการดังนั้นจึงรันบนทุกไอเท็ม - ไม่เพียง แต่ในรายการเท่านั้น (ตัวอย่างเช่นให้) สิ่งนี้ยังไม่จัดสรรเกินความจำเป็นเนื่องจาก Perl 6 มีรายการไม่สิ้นสุด (เช่น Haskell เป็นต้น)'c', 'a', 't'».comb(4, 9)».sqrt2, 3

  »ไม่จำเป็นต้องใช้ตัวอักษรเนื่องจาก.combสามารถใช้โดยตรงในรายการ แต่สิ่งนี้เกี่ยวข้องกับการบังคับใช้สตริงโดยนัย (และ Perl 6 ไม่มีสตริงไม่ จำกัด ดังนั้นสิ่งนี้จะทำให้เสียหน่วยความจำ) ยกตัวอย่างเช่นรายการหลังจากการแปลงผลตอบแทนสตริง1, 2, 3 1 2 3สำหรับ Perl 6 ช่องว่างคือจำนวนที่ดีที่สุดซึ่งแปลว่า 0 ดังนั้นโค้ดจะใช้ได้แม้ว่าจะมีการแปลงเช่นนี้ก็ตาม อย่างไรก็ตามมันจะใช้ทรัพยากรในทางที่ผิด

• [+]

  นี่คือตัวดำเนินการลด โดยทั่วไป[]คุณสามารถใช้โอเปอเรเตอร์เพื่อใช้งานในกรณี+นี้ รายการหลังจากที่ลดผู้ประกอบการจะลดลงเพื่อให้[+] 1, 2, 3เป็นซึ่งเป็น1 + 2 + 3 6Perl 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!

วิธีเก่าใช้สำหรับวนรอบเพื่อรับเอาต์พุตของคำสั่ง 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เพื่อยอมรับนิพจน์ทางคณิตศาสตร์
น่าเสียดายที่การเปิดใช้งานการขยายล่าช้านั้นจำเป็น
ใช้สำหรับวงที่จะนับตั้งแต่วันที่ 1 ถึงมูลค่าป้อน v-
ในการสั่งซื้อไปยังหมายเลขที่จับมากกว่า 9 ผมใช้ PowerShell ที่จะได้รับความยาวของสตริงแล้วใช้อีกสำหรับวงที่จะแยกสตริงที่ขึ้นและเพิ่มไปยังผลรวมs -
คุณสามารถเปลี่ยนชื่อของpowershell.exeเป็นp.exeภายใต้ C: \ 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 ที่ถูกต้องซึ่งเป็นที่ยอมรับตาม OPOP

-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 หรือคล้ายกันได้

หากผลลัพธ์ของการแสดงออกไม่ใช่จำนวนเต็มจะถูกตัดทอนก่อน หากผลลัพธ์ของนิพจน์เป็นลบผลลัพธ์จะไม่ถูกกำหนด

ใช้มันเหมือน:

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

1: เว้นแต่คุณจะนับการเรียกใช้ Python จาก Bash เช่นนี้ แต่ฉันไม่คิดว่าเป็นเช่นนั้น หากคุณคิดว่ามันเป็นจริงแล้วคะแนนที่ปรับคือ -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);
    }
}

จัดการการแสดงออก แสดงสิ่งที่คุณต้องการในเป้าหมาย จับจนกว่าความยาวความยาวสามารถจัดการได้ หากคุณล้างการเว้นช่องว่างทั้งหมดในบรรทัดเดียวและไม่มีคำสั่งให้พิมพ์จะนับเป็น 254 ตัวอักษร (พิจารณาจากการเขียนโปรแกรมจาวาแบบยาวโดยใช้คำยาว)

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

บันทึก 10 ไบต์โดยการลบtsและเปลี่ยนp

แก้ไข: ฉันไม่สามารถทดสอบจำนวนเต็มยาวขัน (1234567891234567891234564789087414984894900000000) [แฮงคอมพิวเตอร์ของฉัน] แต่จากความรู้ของฉัน Python 3 รองรับจำนวนเต็มยาวโดยไม่ได้ตั้งใจ

การดำเนินการนี้ การใช้งานการละเมิด AST ฉันจะไม่พิจารณาการใช้ AST ในทางที่ผิดว่าเป็น "Eval หรือคล้ายกัน"

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

ทับทิม 69-50 = 19 (หรือ -4)

นี่สามารถเล่นกอล์ฟด้วยกันได้ แต่นี่เป็นความพยายามครั้งที่ห้าครั้งแรก

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]

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 คะแนน)

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

เอาท์พุท:

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