Bu zorluk, 1'den 1'e kadar olan sayıları içeren ve belirli bir sayı içeren tüm rakamların toplamını sayan bir program veya senaryo yazmaktır.

Girdi, bir pozitif tamsayı. Çıktı, bu sayıdaki rakamların toplamı ve tüm küçük sayılar.

Örnekler:

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

Açık olmak gerekirse, bu tamsayıları değil, rakamların toplamını saymaktır . Tek basamaklı girişler için bu aynı olacaktır. Ancak, 10'dan büyük olan girdilerin farklı yanıtları olacaktır. Bu yanlış bir cevap olacaktır:

Input: 12
Output: 78

Farkı göstermek için başka bir örnek:

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

Daha büyük bir test durumu (DOĞRU YANIT)

Input: 1000000
Output: 27000001

Kurallar ve Yönergeler:

• Gönderilen kod tam bir program veya komut dosyası olmalıdır - sadece bir işlev değil. Kod gerektiriyorsa, içeri aktarıyorsa, vb. Gerekiyorsa, kaydedilen koda dahil edilmelidir.
• Numara kullanıcı tarafından girilmelidir - kodlanmış değil. Girdi, komut satırı argümanı, dosya, stdin veya dilinizin kullanıcı girdisini alabileceği herhangi bir diğer yol olarak alınabilir.
• Kod, en azından en çok girişleri düzgün şekilde kullanabilmelidir (2^64)-1.
• Kod yalnızca toplamı vermelidir.
• Gönderilen programlar ve scriptler kullanıcı dostu olmalı ve bilgisayar kaynaklarına zarar vermemelidir (örneğin: her karakteri tutmak için delicesine büyük diziler bildirmemeliler). Bunun için kesin bir bonus veya ceza yoktur, ancak lütfen iyi programcılar olun.

puanlama:

Birincil puanlama mekanizması kod uzunluğu gereğidir. Düşük puanlar daha iyidir. Aşağıdaki ikramiye ve cezalar da uygulanır:

• -25 Eğer kodunuz tüm pozitif sayıları işleyebilirse, örneğin:1234567891234567891234564789087414984894900000000
• -50 Örneğin, kodunuz basit ifadelerle başa çıkabilirse 55*96-12. Bu bonusa hak kazanmak için kodun + - / *(toplama, çıkarma, bölme, çarpma) operatörlerini işlemesi ve işlem sırasını zorlaması gerekir. Bölünme, normal tamsayı bölümüdür.
  • Verilen örnek ( 55*96-12) olarak değerlendirilir 5268. Bu girişlerden herhangi biri için kodunuz aynı şekilde dönmelidir - doğru cevap 81393.
• -10 Bonus eğer kod -50 ödülüne hak ve işleyebilir ^(üs) operatörünü.
• -100 Bonus , kodunuz -50 bonus için uygunsa veeval ifadeleri işlemek için kullanmaz veya kullanmazsa .
• Kodunuz herhangi bir web kaynağına dayanıyorsa, +300 Ceza .

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

Golf çözümü ( xfix'in mükemmel çözümüne dayanan son hat ):

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

Golfsüz çözüm:

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

Değerlendirme aşaması her sembol üzerinde yineleme çalışır *, /, +, -, iki tamsayı arasındaki yalan ve fonksiyonunu kullanarak sembolü temsil eden bu ikame bulmak zaman.

Daha ayrıntılı olarak: her sembol (örneğin alır +(örn temsil ettiğini gerekiyordu o) ve infix işlevini &[+]ifadesinin kısaltmasıdır &infix:<+>ve aynı işlevi Perl sen yürütmek 6 çağrılar 1 + 2) ve küresel ikame (does s:g[…] = …Perl 5 gibidir, s/…/…/ge( (\d+) $sym (\d+)) sembolü ile ayrılan iki tamsayıyla eşleşen ve onu, bu tamsayılarla ( infix($0, $1)) çağrılan karşılık gelen ek fonksiyonunun çıktısıyla değiştirir .

Son olarak, bu değerlendirilen ifade beslenmektedir say [+] (1..$expression)».combki, onun çözümü çok iyi açıklıyor xfix .

Partiye çok geç kaldığım için özür dilerim ☺

EDIT: Üstler için kaldırılmış destek; Zaten tam olarak 10 karakterdi ve doğru ilişkilendirme yapmadı.

Mathematica 30- (10 + 50) = -30

Ybeltukov sayesinde 4 karakter kısaltıldı.

Range@n1'den 1'e kadar olan sayıları döndürür n.

Integerdigits@n bu sayıların her birini rakamlarına böler.

Total[n,2]rakamları toplar. 2, farklı seviyelerde, yani listelerde listelerde toplanmaya izin vermektir.

IntegerDigits@Range@#~Total~2&

Test yapmak

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

51

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

27000001

İfade

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

Çok utanç verici çalmak @Fors ifadesini değerlendirmek için buradan cevap veriyor: https://codegolf.stackexchange.com/a/11423/13877

Örnek kullanım:

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

Not: İfade uygulaması, operatör önceliği yoktur ve değerleri aldıkça tüketir; Örneğin, 1+2*3 = 9tipik değil 7.

sed, 411 283 - 25 = 258

Şu an daha çok golf oynamaktan rahatsız olamam. :-) Uzaktan büyük tamsayılarla bile kullanılması tavsiye edilmez, ancak teknik olarak keyfi olarak büyük tamsayılarla başa çıkabilir (büyük olasılıkla RAM'i çok hızlı bir şekilde bitirdiniz, çünkü sayıyı kodlamak zorundayım. tekli).

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

Örnek kullanım

(Giriş satırları kolay okunması için girintilidir.)

  5
15
  12
51
  33
183

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

Verimli değil, aynı zamanda daha kısa ve ifadeleri de kullanabiliyor.

EDIT: Teşekkürler Wolframh ve püf noktaları için legoStormtroopr : D

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

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

İlk versiyonum

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

giriş:

1234567891234567891234564789087414984894900000000

çıktı:

265889343871444899381999757086453238874482500000214

Python - 108 karakter eksi 85 bonus, 23 vuruş, çok çok çok büyük girdiler

Bu çözümlerin birçoğu girdiden daha küçük olan tüm girdilerin üzerinden geçiyor ve tüm rakam toplamlarını toplıyor gibi görünüyor. Bu işe yarıyor, ama inelegant olduğunu hissediyorum ve 25 puan bonusu için gerçekten uygun olup olmadıklarını sorgulayacağım, çünkü 1234567891234567891234564789087414984894900000000yaşamlarımızdaki girdiyi idare edebileceklerini sanmıyorum . Aslında, bir nbasamak girişte , bu çözümler O(10^n)zaman alır. Bunun yerine bazı matematik dersleri almayı seçtim.

#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üm xbasamaklı sayılar kümesi küme için izomorfiktir {0,1,2,3,4,5,6,7,8,9}^x. Bir sabit için , th endeksinin ayarlandığı noktalar için (n,sig)tüm xdeğerler ve tüm basamakların toplamı 45'tir. Bu, hepsi tarafından gerçekleştirilir .sig10^x-1sign0-9f

g Muhtemelen hepimizin aşina olduğu bir şey

magicgiriş numarasındaki tüm basamakları alır ve bunların üzerinde en azdan en önemlisi tekrar eder. Örnek bir girişle bunu takip etmek en kolay yoldur 1,234,567.

Aralık ile başa çıkmak için , 1,234,567-1,234,560arasındaki tüm basamakları toplamalı ve onlardan daha büyük olan tüm rakamlarla başa çıkmak için diğer rakamların toplamını zamana eklemeliyiz . Şimdi kalanlarla başa çıkmamız gerekiyor.1771,234,560

Aralık ile baş etmek için 1,234,560-1,234,500, 6( val) karakterini ekler ve üst limiti düşürürüz 1,234,559. Düşüşün kalanını yaparken, her bir rakamı 6 kez görürüz ( val*f(sig)). Biz tüm sayılarını göreceksiniz 0için 5tam 10zamanlarda her ( (10**sig)*g(val-1)). Bu sayıdaki diğer tüm rakamları tam olarak 60 kez göreceğiz ( (val*10**sig)*sum(digits[sig+1:])). Şimdi tüm sayılardan kesinlikle daha büyük olanları ele aldık 1,234,500. Aynı mantık, tüm anlamlar için endüktif olarak uygulanacaktır.

Golf oynamak, WolframH sayesinde, bu çözümü

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

Ve tüm tamsayılar haneli toplamları toplamı kadar 1234567891234567891234564789087414984894900000000olduğu265889343871444927857379407666265810009829069029376

Golf edilmiş sürümde fırlatmayı başardığım en büyük sayı 10 ^ 300'dür, bu noktada yüzmeler taşmaya başlar ve sayısal dengesizlik sorunlara neden olur. Hızlı bir kare ve çarpma üstelleştirme işleviyle bu sorun ortadan kalkacaktı.

Ve LaTeX desteği gerçekten faydalı olurdu ...

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

Giriş, sayıları yönetir 1E100ve otomatik olarak değerlendirir. İfadeleri işleyebilir.

Delicesine büyük bir dizi olmasına rağmen, bilgisayar kaynaklarını boşa harcamıyorum (bu bir hesap makinesinden çalıştırılır ).

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

Teknik olarak "herhangi bir" pozitif tamsayı için 25 bonusa hak kazanması gereken alternatif bir versiyon var , ancak algoritma girişte doğrusal olduğu için pratik olarak yavaştır. Ne olursa olsun, yazmak çok eğlenceliydi. ASCII karakterleri olarak okunan bir sayıyı elle çıkarır. Bu sürüm 150 karakterdir. (Şimdi korkunç, argüman hırsızlık, döngüsel kod!)

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

İfade işleme varyasyonu. Tipik kurallara göre uygulayan operatör önceliği: / * - +. 97 belirteçle sınırlıdır = 48 terim.

#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

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

Açıklama: Girişin "12" olduğunu varsayalım:

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

Yığın olduğunu [0,1,2,3,...,12].

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

Yığın olduğunu "01234...9101112".

' '* # join a space between all characters

Yığın olduğunu "0 1 2 ... 1 0 1 1 1 2".

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

Yığın olduğunu [0,1,2,...,9,1,0,1,1,1,2].

{+}* # fold addition across the new array

İstenildiği gibi, yığın 51'dir.

Buradaki giriş, üstler içerebilen herhangi bir geçerli GolfScript ifadesi olabilir. Örneğin:

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

Beri 2(5 + 5) - 8 = 12. Bunun bonus için geçerli olması gerektiğini düşünüyorum, ama belki de normal formda olması bekleniyordu, Polonya'daki GolfScript'in tersine yazılması değildi.

Ruby, 37 - 50 = -13

Çifte değerlendirme, gökyüzü boyunca! Diğer Ruby çözümlerinde olduğu gibi, bunun teorik olarak keyfi olarak büyük sayılarla çalışabilmesi gerektiğini düşünüyorum, ancak yürütme süresi ... korkunç olurdu.

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

Eski versiyon (49 - 50 puan)

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

10 karakterlik bonusun, üstelik üstelik bir şapka olması için bir karakter gerektirdiğini varsayarsak, eklemeyi düşündüğüm en kısa yol şudur:

.gsub ?^,'**'

Hangi bonus daha fazla karakter verecek.

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

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

Tüm pozitif sayıları idare edebilir (ancak, büyük rakamlar uzun zaman alacaktır, çünkü şu anda Perl 6 uygulamaları yavaştır, ancak Perl 6 doğal olarak büyük tamsayıları destekler). evalBasit bir hesap makinesi uygulamak için kullanır (elli karakter için beş karakter cezası buna değer). Mevcut uygulamalar yavaş olduğu için yavaştır, ancak teoride yeterince hızlı olmalıdır (Perl 6 uygulamaları düzeldiğinde). Ayrıca, şaşırtıcı bir şekilde, Mathematica ile kazandım (şimdilik).

» Bu kodda aslında gerekli değil, ancak performans nedenleriyle buraya koydum (aksi halde program tüm dizgiyi tahsis eder. Buradaki neden Perl 6'nın sonsuz dizgelere sahip olmadığı, ancak sonsuz listeleri olduğu.

Her neyse, bu kodun nasıl çalıştığını bile sorabilirsiniz. Eh, kısmen bölüm geçeceğim.

• get.eval

  Bu bir satır ( getişlev) alır ve değerlendirir ( evalyöntem).

• 1..get.eval

  Bundan sonra Perl 6, bir 1değer nesnesini, değerlendirilen değere kadar hazırlar . Bu bir aralıktır, bu yüzden devasa bir şey tahsis edilmez.

• ».comb

  .combyöntem dizgiyi karakterlere böler ( bir argümanla çağrılmadığı sürece ). Örneğin, 'cat'.combgeri döner 'c', 'a', 't'. »liste öğelerini eşler, böylece .combyalnızca listenin kendisinde (örneğin, (4, 9)».sqrtverir 2, 3) değil, her öğesinde çalıştırılır . Bu, ayrıca gerekenden fazlasını da tahsis etmemektedir, çünkü Perl 6'nın sonsuz listeleri vardır (örneğin Haskell gibi).

  ».combdoğrudan listede kullanılabildiği için karakter aslında gerekli değildir , ancak bu örtük dize zorlaması içerir (ve Perl 6 sonsuz dizgelere sahip değildir, bu nedenle bu bellek boşa harcanır). Örneğin 1, 2, 3, dizgeye dönüştürüldükten sonraki liste geri döner 1 2 3. Perl 6 için, boşluk 0 anlamına gelen kusursuz bir rakamdır, bu nedenle kod bu dönüşümle bile çalışır. Ancak, bilgisayar kaynaklarını kötüye kullanır.

• [+]

  Bu bir azaltma operatörüdür. Temelde, arasında [], bu durumda, kullanmak için bir operatör koyabilirsiniz +. Operatörünü azaltmak sonra liste yüzden azalır [+] 1, 2, 3olduğu 1 + 2 + 3olan 6. Perl 6, sayılar ve dizgiler için ayrı operatörler kullanır, bu nedenle birleştirme olarak değerlendirilmez.

• say

  Sonunda saysonucu çıkarır. Ne de olsa nihai sonucu görmek istiyorsun, değil mi?

Perl 31 - Bonus yok

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

Örnek çıktı:

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

Perl 5 ile -p, 50-28 bayt: -22

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

Çevrimiçi deneyin!

J, 22

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

açıklama

Değerlendirme sağdan sola doğru ilerler.

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)

Bu çalıştırıldığında, kullanıcıdan giriş istenir.

Eski sürüm (ifadeleri işleyemez): 46 karakter:

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

Toplu iş - (181 - 50) - 131

Sadece biraz eğlenmek için.

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

Biraz daha okunaklı hale getireceğim:

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

Eski yöntem bir dosyaya yazma ve okuma yerine, powershell komutunun çıktısını almak için loop için kullanır:

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

Girdiyi bir değişkene ayarlayın - v- /aaritmetik ifadeleri kabul etmek için kullanın.
Maalesef gecikmeli genişlemeyi etkinleştirmek gerekliydi.
Girilen değere 1'den saymak için bir for döngüsü kullanın - v.
9'dan büyük sayıları işlemek için, dize uzunluğunu elde etmek için powershell kullanmak zorunda kaldım, sonra dize ayırmak için loop için bir tane daha kullandım ve bunu toplamaya - ekle s.
Sen olabilir adını değiştirmek powershell.exeiçin p.exeC altında: \ WINDOWS \ System32 \ WindowsPowerShell \ v1.0 \ sonra sadece birlikte diyoruz p "&{'%%a'.length-1}9 bayt tasarruf. Ama bu gerçekten onun ruhunda değil.

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

Ben öğle tatilinde iken o ikinci koşuş bıraktı.

Gerçekten ne kadar yavaş olduğu için bundan çok daha büyük sayılarla test edemiyorum . Bununla birlikte, oldukça fazla sayıda çalışmalıdır. 2147483647Aşağıdaki hatayı vermeden önce alacağı en büyük sayıdır (en fazla 32 bit tam sayı) -

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

Bu, elbette beni bu meydan okumadan diskalifiye ediyor.

Dyalog APL , 9 - 160 * = -151

+/⍎¨∊⍕¨⍳⎕

Çevrimiçi deneyin!

⎕değerlendirilen girdi almak
 örn "7+5"verir12

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

⍕¨ Her sayıyı dizeye biçimlendir
 ["1","2","3","4","5","6","7","8","9","10","11","12"]

∊ enlist (düzleştirmek)
 "123456789101112"

⍎¨ Her karakteri yürüt (tek basamaklı sayı numaralarının listesini verir)
 [1,2,3,4,5,6,7,8,9,1,0,1,1,1,2]

+/ toplam  51

* Puanlama

-50 bonus olarak bile ifadeleri girdi olarak kabul eder. İfade, OP'ye göre kabul edilebilir geçerli APL olmalıdır .

-10 bonus çünkü aynı zamanda ^( *APL'de) de işlemektedir .

-100 bonus çünkü ifade girişi açıkça kullanılmadan kullanılır eval(yani ⍎APL'de).

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

Güzel

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

• Tüm pozitif sayıları idare edebilir
• + - / * işlemi ile ifadeleri işleyebilir
• ^ (güç) operatörünü kullanabilir.
• ifadeleri eval veya benzeri olmadan yapabilir

İfadenin sonucu tamsayı değilse, önce kesilir. İfadenin sonucu negatifse, sonuç tanımsızdır.

Gibi kullanın:

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

1: Bash'den Python'u bu şekilde çağırdığınızı saymazsanız, ancak durumun böyle olduğunu sanmıyorum. Bunun gerçekten olduğunu düşünüyorsanız, düzeltilmiş puan -7'dir.

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

İfadeleri işler. Hedefe istediğiniz ifadeyi verin. Uzun süre idare edene kadar kolları. Tüm alanları tek bir satıra çıkarmakla ve yazdırmak için bir açıklama yapmamanız durumunda, 254 karaktere kadar sayılır (Java programlamasına dayalı uzun uzun sözcükleri dikkate alarak).

Not: Bu sadece bir mantık değil, eksiksiz bir programdır. Program için verilen sözcük sayımı, sadece mantık değil.

Java (JDK8), 272

Benim ilk meydan okumam, önerilerim memnuniyetle karşılanır =)

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

Girintili'ye:

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 bu mücadeleden birkaç ay daha genç olduğundan, bu durum yeşil onay işareti için uygun değil. Dahası, bu ilk başta Perl'i geçmiyor. ;) Yine de yaklaşımı çok beğendim, bu yüzden yine de göndermek istedim.

l~),s:~:+

Burada test et.

Buradaki fikir, 0 ila N arasında bir aralık oluşturmaktır. Bu aralık daha sonra tam sayıları arka arkaya bitiştiren bir dizgeye dönüştürülür. N = 12 için alırız

"0123456789101112"

Sonra her karakter bir tamsayıya dönüştürülür :~( bir tamsayı dizisi verir) ve sonra toplanır :+. CJam keyfi büyük tam sayılarla ilgilenebilir.

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

çıkartarak tsve değiştirerek 10 bayt kaydettip

düzenleme: Ben gülünç uzun tamsayı test edemiyorum (1234567891234567891234564789087414984894900000000) [bilgisayarımı askıda] ancak benim bilgimden, Python 3 keyfi uzun tamsayıları destekliyor.

Bu uygulama kullanımlarıAST'yi kötüye kullanıyor. AST'yi kötüye kullanmanın "eval ya da benzer" olduğunu düşünmezdim.

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

Ungolded yazmak için çok tembel, bu yüzden size sınıfları hakkında bir açıklama vereceğim:

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.

Son satır, işlemlerin sırasını korumak ve istenmeyen davranışları önlemek için bu sınıfları girdi üzerinde uygun sırayla çalıştırır.

Örnek kullanım ($ veya> kullanıcı girişi anlamına gelir) ve bu arada, gerçek program yalnızca bir kez girdi alır:

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

Güzel

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

Yakut -> 83-50 = 33

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

"Test etmek" versiyonu:

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 

Test sonuçları

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

Onun başka bir girişimi.

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

Güzel

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

Yakut 69-50 = 19 (veya -4)

Bu kesinlikle birlikte golf oynayabilir ama işte ilk beşinci deneme

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

Aynı zamanda tüm sayılar için çalışır ancak O (n) 'den daha yavaş çalıştığı için onlar için çok yavaştır, bu yüzden -25 eklemem. Yavaşlık ince ise, o zaman olurdu -4 olsa

Yakut 133-50-25 = 58

Bu, O (n) süresinden daha kısa sürede çalışan (ve gerçek matematiği kullanan!) Daha hızlı olan sürümdür, bu nedenle büyük tamsayılar için hızlı sonuçlar sağlayabilir, bu nedenle -25 ekledim:

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

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

Çıktı:

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