सभी अंकों की गणना करें

38

यह चुनौती एक प्रोग्राम या स्क्रिप्ट लिखने के लिए है जो पूर्णांक के भीतर सभी अंकों के योग को एक दिए गए नंबर से 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

नियम और दिशानिर्देश:

  • प्रस्तुत कोड एक पूर्ण कार्यक्रम या स्क्रिप्ट होना चाहिए - केवल एक फ़ंक्शन नहीं। यदि कोड में शामिल हैं, आयात, आदि, उन्हें पोस्ट किए गए कोड में शामिल किया जाना चाहिए।
  • उपयोगकर्ता द्वारा नंबर का इनपुट होना चाहिए - हार्ड-कोडेड नहीं। इनपुट को कमांड-लाइन तर्क, फ़ाइल, स्टडिन या किसी अन्य माध्यम से प्राप्त किया जा सकता है जिसके द्वारा आपकी भाषा उपयोगकर्ता इनपुट ले सकती है।
  • कोड को इनपुट को ठीक से कम से कम अप करने के लिए सक्षम होना चाहिए (2^64)-1।
  • कोड केवल राशि का उत्पादन करना चाहिए।
  • प्रस्तुत कार्यक्रम और स्क्रिप्ट उपयोगकर्ता के अनुकूल होनी चाहिए और कंप्यूटर संसाधनों की बर्बादी नहीं होनी चाहिए (उदाहरण के लिए: उन्हें हर चरित्र को धारण करने के लिए पागलपन से बड़े सरणियों की घोषणा नहीं करनी चाहिए)। इसके लिए कोई सख्त बोनस या जुर्माना नहीं है, लेकिन कृपया अच्छे प्रोग्रामर बनें।

स्कोरिंग:

प्राथमिक स्कोरिंग तंत्र कोड की लंबाई से होता है। कम अंक बेहतर हैं। निम्नलिखित बोनस और दंड भी लागू होते हैं:

  • -25 बोनस यदि आपका कोड सभी सकारात्मक संख्याओं को संभाल सकता है, उदाहरण के लिए:1234567891234567891234564789087414984894900000000
  • -50 बोनस अगर आपका कोड सरल अभिव्यक्ति को संभाल सकता है, उदाहरण के लिए 55*96-12। इस बोनस के लिए अर्हता प्राप्त करने के लिए, कोड को संचालन + - / *(इसके अलावा, घटाव, विभाजन, गुणा) ऑपरेटरों को संभालना चाहिए और संचालन के आदेश को लागू करना चाहिए। विभाजन नियमित पूर्णांक विभाजन है।
    • दिए गए उदाहरण ( 55*96-12) का मूल्यांकन करता है 5268। आपका कोड या तो उन इनपुट के लिए वापस आ जाना चाहिए - सही उत्तर है 81393।
  • -10 बोनस यदि आपका कोड -50 बोनस के लिए अर्हता प्राप्त कर लेता है और^ (एक्सपोनेंट) ऑपरेटर को संभाल सकता है ।
  • -100 बोनस यदि आपका कोड -50 बोनस के लिए योग्य है औरeval अभिव्यक्ति को संभालने के लिए उपयोग या समान नहीं है ।
  • +300 जुर्माना अगर आपका कोड किसी भी वेब संसाधन पर निर्भर करता है।
code-golf  math 
— ST3
स्रोत
2
और क्या 55*96-12लौटना चाहिए ?
— प्रोग्रामफॉक्स
1
55 * 96-12 = 5268, 1926 में 5268
— एसटी 3
3
बोनस थोड़ा बड़ा हो सकता है, लगता है सबसे बड़े नकारात्मक स्कोर पर एक प्रतियोगिता बन रही है :)
— Joachim Isaksson
7
@ ST3 यदि बोनस के बिना जीतना लगभग असंभव है, तो यह सिर्फ उन्हें आवश्यकताओं को पूरा करने के लिए बेहतर है, या कम होने के लायक है।
— क्रंचर
3
-1 क्योंकि यह चुनौती "बोनस" के पुराने (और भयावह) प्रोत्साहन का उपयोग करती है।
— mbomb007

जवाबों:

9

पर्ल 6: 108 - (25 + 50 + 100) + 0 = -67 अंक

गोल्फ समाधान (अंतिम लाइन xfix के महान समाधान के आधार पर ):

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

गैर-गोल्फ समाधान:

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

मूल्यांकन कदम के प्रत्येक प्रतीक पर बार-बार दोहराना से काम करता है *, /, +, -ढूंढने, जब दो पूर्णांकों के बीच है कि झूठ और प्रतिस्थापन कि समारोह का उपयोग कर कि प्रतीक का प्रतिनिधित्व करता।

अधिक विवरण में: यह प्रत्येक प्रतीक (जैसे +) और infix फ़ंक्शन को दर्शाता है जिसे यह माना जाता है (उदाहरण के &[+]लिए शॉर्टहैंड &infix:<+>और उसी फ़ंक्शन के लिए पर्ल 6 कॉल जब आप निष्पादित करते हैं 1 + 2) और एक वैश्विक प्रतिस्थापन ( s:g[…] = …, जो पर्ल 5 की तरह होता है) s/…/…/ge), जो प्रतीक द्वारा अलग किए गए दो पूर्णांकों से मेल खाता है ( (\d+) $sym (\d+)), और उन पूर्णांक फ़ंक्शन ( infix($0, $1)) के साथ कहे जाने वाले संगत infix फ़ंक्शन के आउटपुट के साथ इसका प्रतिस्थापन करता है ।

अंत में, इस मूल्यांकन की अभिव्यक्ति में फ़ीड है say [+] (1..$expression)».comb, जो xfix अपने समाधान में बहुत अच्छी तरह से समझाता है ।

खेद है कि पार्टी के लिए इतनी देर से to

EDIT: एक्सपट्र्स के लिए हटाए गए समर्थन; यह वैसे भी 10 वर्णों का था और सही ढंग से संगति नहीं करता था।

— Mouq
स्रोत
यह भी खूब रही। मुझे पसंद है कि आपने कैसे एक बहुत ही साधारण पार्सर बनाया - मैंने कोशिश की, लेकिन मैंने इस के रूप में कुछ बनाने का प्रबंधन नहीं किया। इसके बजाय my $gआप कुछ पूर्वनिर्धारित का उपयोग करना चाह सकते हैं (मुझे लगता है कि $!काम कर सकता है, लेकिन मैंने परीक्षण नहीं किया है)।
— कोनराड बोरोस्की
@xfix, मुझे यकीन नहीं है कि यह गोल्फ की मदद कैसे करेगा। वहाँ वास्तव में यह गोल्फ के लिए एक रास्ता है , लेकिन यह अभी तक पूरी तरह कार्यात्मक "infix: [$ var]" वाक्यविन्यास की आवश्यकता नहीं है: my$g=get;for <* / + -> {$g~~s:g[(\d+)$^s(\d+){}]=infix:[$^s] |@()};say [+] (1..$g)».combयह स्कोर 88 chars या -97 अंक नीचे मिल जाएगा
— Mouq
ओह, $! 'मेरे' से छुटकारा पाने में मदद करेगा! धन्यवाद @xfix
— मूक
14

गणितज्ञ 30- (10 + 50) = -30

Ybeltukov के लिए धन्यवाद 4 चार्ट द्वारा छोटा किया गया।

Range@nके माध्यम से 1 से संख्या देता है n।

Integerdigits@n उन अंकों में से प्रत्येक को उसके अंकों में तोड़ देता है।

Total[n,2]अंकों को बताता है। 2 को विभिन्न स्तरों पर सूची की सूचियों की अनुमति देने की अनुमति है।

IntegerDigits@Range@#~Total~2&

परिक्षण

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

51

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

27000001

भाव

IntegerDigits@Range@#~Total~2 &[55*96 - 12]

55*96 - 12

81393
5268

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

81,393 

IntegerDigits@Range@#~Total~2 &[55*96^2 - 12]
55*96^2 - 12

12396621
506868

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

12396621

— DavidC
स्रोत
आपको सभी ब्राउनी अंक प्राप्त करने के लिए मान्य तर्कों पर जानकारी जोड़नी चाहिए: D
— Yves Klett
1
मुझे नहीं पता कि मैं इस बात पर विचार करूंगा कि क्या यह eval का उपयोग नहीं कर रहा है
— Cruncher
3
पुन: गणित में ईवाल। यह एक प्रतीकात्मक भाषा है जिसमें सामने वाला हमेशा मठ को अपने आप हल करने की कोशिश करता है। ऐसा करने से रोकने के लिए आपको अतिरिक्त कोड (होल्ड []] जोड़ना होगा।
— माइकल स्टर्न
1
Tr@Flattenकरने के लिए कम किया जा सकता Total[...,2]: IntegerDigits@Range@#~Total~2&।
— ybeltukov
1
क्या आप मनमाने ढंग से बड़े int को नहीं संभालते हैं और दूसरे -25 के लायक हैं?
— उर्फ.निसे
12

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 = 9बजाय ठेठ 7।

— हंसी मजाक करना
स्रोत
1
यह ऑपरेटर की पूर्ववर्ती स्थिति से नहीं निपटता है, लेकिन यह सवाल निर्दिष्ट नहीं करता है कि क्या मानक ऑपरेटर पूर्वता लागू होनी चाहिए ... ping @ ST3, यह शायद स्पष्ट किया जाना चाहिए। वैसे भी, इसका उत्तर में शायद उल्लेख किया जाना चाहिए।
— फायरफली
@FireFly मैंने इस तथ्य को प्रतिबिंबित करने के लिए उत्तर को संशोधित किया।
— जोश
@ जोश - कृपया 2 के लिए जवाब दें ^ 64 - 5
— सर्गेईज
10

सेड, ४११ २ ,३ - २५ = २५ 4

मुझे अभी और परेशान नहीं किया जा सकता। :-) दूर के बड़े पूर्णांकों के साथ उपयोग के लिए अनुशंसित नहीं है, लेकिन तकनीकी रूप से यह मनमाने ढंग से बड़े पूर्णांकों के साथ सौदा कर सकता है (आप संभवतः रैम से बहुत जल्दी बाहर चले जाएंगे, हालांकि, जब से मैं (और-या-कम है) को संख्या में सांकेतिक शब्दों में बदलना एकल)।

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
— जुगनू
स्रोत
8

पायथन, 55- (50 + 25 + 10) = -30

कुशल अभी तक कम और भी अभिव्यक्ति को संभालने में सक्षम।

संपादित करें: धन्यवाद वुल्फराम और ट्रिक्स के लिए लेगोस्टॉर्मट्रोप्र : डी

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
— क्या मै था
स्रोत
जब मैं आपके xrangeसमाधान को चलाने की कोशिश करता हूं तो मुझे एक अतिप्रवाह त्रुटि मिलती है1234567891234567891234564789087414984894900000000
— जोश
1
@ जोश से छुटकारा मिला xrange: D
— Wasi
2
कुछ संकेत: आप eval(raw_input())द्वारा प्रतिस्थापित कर सकते हैं input()। whileपाश हो सकता है while t:s+=sum(map(int,टी ));t-=1।
— मोनिका
2
आप पहले से ही अभिव्यक्ति के रूप में input()इसके बजाय का उपयोग करके इसे छोटा कर सकते हैं ! इसका मतलब है कि आप पावर-सिंबल के लिए -10 बिनस और उपयोग न करने के लिए -100 बोनस प्राप्त कर सकते हैं !!! eval(raw_input())inputevaleval
@ LegoStormtroopr नियम कहते हैं evalऔर इसी तरह , इसलिए मुझे लगता है कि -100 गिनती नहीं होगी
— SztupY
8

पायथन - 108 चार्ट्स माइनस 85 बोनस, 23 स्ट्रोक, बहुत बहुत बड़े इनपुट को संभालता है

इनमें से अधिकांश समाधान इनपुट की तुलना में सभी इन्ट्स पर लूपिंग करते हैं और अपने सभी अंकों को जोड़ते हैं। यह काम करता है, लेकिन मुझे लगता है कि यह असंगत है, और यह सवाल करेगा कि क्या वे वास्तव में 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अंकों की संख्याओं का समूह सेट के लिए आइसोमॉर्फिक है {0,1,2,3,4,5,6,7,8,9}^x। एक निश्चित के (n,sig)लिए xअलग - अलग मान हैं sig, वें सूचकांक के 10^x-1साथ अंक , और सभी अंकों का योग 45 है। यह सभी के द्वारा सौंप दिया गया है ।sign0-9f

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। एक ही तर्क सभी महत्वों पर लागू होगा।

वुल्फराम के धन्यवाद के साथ इसे गोल्फ करना इस समाधान को कम कर देता है

d=map(int,str(input()))
print sum(v*(10**s*((v-1)/2+sum(d[:~s]))-~s*9*10**s/2)for s,v in enumerate(d[::-1]))

और सभी पूर्णांकों के अंकों का योग होता 1234567891234567891234564789087414984894900000000है265889343871444927857379407666265810009829069029376

सबसे बड़ी संख्या जिसे मैंने गोल्फ संस्करण में फेंकने में कामयाब रहा है वह 10 ^ 300 है, जिस बिंदु पर फ़्लोट्स अतिप्रवाहित होने लगते हैं और संख्यात्मक अस्थिरता समस्याएं पैदा करने लगती हैं। एक त्वरित वर्ग और बहु-प्रतिपादक फ़ंक्शन के साथ, यह समस्या गायब हो जाएगी।

और LaTeX समर्थन वास्तव में उपयोगी होगा ...

— ymbirtt
स्रोत
अच्छा लगा। मैंने थोड़ी देर पहले गणित के साथ इस समस्या पर हमला करने की कोशिश की, लेकिन अटक गया। मुझे बाद में इस पर ध्यान से जाना होगा और यह सोचना होगा कि यह कैसे काम करता है।
— फायरफली
अच्छा जवाब! यह मेरे द्वारा गिने जाने के तरीके के समान है, यदि इनपुट 1000000 :)
— ST3
1
मैथ्स का उपयोग करने के लिए +1। हालांकि, मुझे मिलता है 2.65889343871e+50, जो वास्तविक समाधान का एक अस्थायी बिंदु है। जाहिरा तौर पर आपने जो कोड दिया था, उसके int(t)बजाय आपने प्रिंट किया था t। यह गलत है; असली समाधान है 265889343871444899381999757086453238874482500000214। बस फ़्लोट्स का उपयोग करने से बचें, अर्थात **(x-1)छोटे की जगह **x/10।
— मोनिका
1
इसे थोड़ा और गोल करना। यह स्पष्ट है कि केवल वैश्विक आवश्यकता है d(क्योंकि इसका उपयोग दो बार किया गया है)। दूसरों को खत्म करना (और कुछ तरकीबों का उपयोग करना) एक d=map(int,str(input()))\nprint sum(v*(10**s*((v-1)/2+sum(d[:~s]))-~s*9*10**s/2)for s,v in enumerate(d[::-1]))(108 वर्णों) पर आता है । किसी भी आकार (जैसे int("1"*1000)) के इनपुट पर ठीक चलता है ।
— मोनिका
1
@ हाइब्रिट 10**-1है 0.1, और वहाँ से सब कुछ फ़्लोट में बदल जाता है। 1/10है 0(पूर्णांक विभाजन), और सब कुछ ints रह सकता है ।
— मोनिका
8

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और स्वचालित रूप से मूल्यांकन करता है। भावों को संभाल सकता है।

यद्यपि यह एक बहुत बड़ा सरणी है, मैं कंप्यूटर संसाधनों को बर्बाद नहीं कर रहा हूं (यह एक कैलकुलेटर से चलाया जाता है )।

— Timtech
स्रोत
1
इस सवाल का सबसे अच्छा जवाब मुझे लगता है। एक साथ संख्या जोड़ने के लिए एक कोड गोल्फ उत्तर लिखने के लिए एक कैलकुलेटर भाषा का उपयोग करना। इतना ठंडा!
— मलाची
1
@ मालाची जैसा कि मैं हमेशा कहता हूं, जब कोड गोल्फ = गणित, यह कैलकुलेटर बाहर खींचने का समय है।
— टाइमटेक
2
मेरा संस्करण जिसने 9E99 तक की संख्या की अनुमति दी थी, वह स्पष्ट रूप से अच्छा नहीं था, इसलिए मुझे नहीं लगता कि आप उस बोनस को गिन सकते हैं। इसके अलावा, मुझे पूरा यकीन है कि आपको कैर्र के मैथमेटिका के उत्तर के अनुसार इनपुट को "eval" के रूप में गिनना होगा।
— फायरफली
1
FireFly से सहमत हूं, उपयोग नहीं करने का बोनस evalनहीं लिया जाना चाहिए।
— ST3
3
कैलकुलेटर कंप्यूटर कैसे नहीं है?
— डेविड कॉनरैड
6

सी, 77 74

n,v,i;main(){scanf("%d",&n);for(;i||(i=n--);i/=10)v+=i%10;printf("%d",v);}

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

सी, 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);}
— जुगनू
स्रोत
सभी सकारात्मक पूर्णांकों का अर्थ है, कि इसे 99 अंकों की संख्या तक भी संभालना चाहिए।
— ST3
@Firefly कूल एल्गोरिथ्म बिलिन न्यूमेरिक्स से बड़ी संख्या में काम करने के लिए है!
— जोश
5

गोल्फस्क्रिप्ट 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, वांछित के रूप में है।

यहां इनपुट किसी भी मान्य गोल्फस्क्रिप्ट अभिव्यक्ति हो सकता है, जिसमें एक्सपोर्टर शामिल हो सकते हैं। उदाहरण के लिए:

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

के बाद से 2(5 + 5) - 8 = 12। मुझे लगता है कि यह बोनस के लिए अर्हता प्राप्त करना चाहिए, लेकिन शायद यह सामान्य रूप में ही होने की उम्मीद थी, गोल्फस्क्रिप्ट के रिवर्स पोलिश अंकन से नहीं।

— बेन रीच
स्रोत
क्या यह भी समर्थन करता है ^?
— स्वस्त्य
यह गोल्फस्क्रिप्ट सिंटैक्स में घातांक का समर्थन करता है, जो है?
— बेन रीच
आपको बोनस 10 नहीं मिलता है, क्योंकि कार्यक्रम को समर्थन करना चाहिए ^, नहीं ?या powआदि
— एसटी 3
@ ST3 जैसा आप चाहते हैं!
— बेन रीच
4

रूबी, 37 - 50 = -13

डबल eval, आकाश भर में सभी तरह! अन्य रूबी समाधानों के साथ, मुझे लगता है कि यह सैद्धांतिक रूप से बड़ी संख्या में मनमाने ढंग से काम करने में सक्षम होना चाहिए, लेकिन निष्पादन समय होगा ... किराया।

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

पुराना संस्करण (49 - 50 स्कोर)

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

10 कैरेक्टर बोनस को वास्तव में एक्सप्रेशन के लिए कैरेक्टर के लिहाज से एक कैरेट की जरूरत होती है, इसके लिए सबसे छोटा तरीका मैं यह सोच सकता हूं कि:

.gsub ?^,'**'

जो बोनस की तुलना में अधिक पात्रों की लागत देता है।

— पॉल प्रेस्टिज
स्रोत
आप कुछ चार्ट निकाल सकते हैं:p"#{[*1..eval(gets)]}".chars.map(&:to_i).inject :+
— SztupY
@ अच्छा, अच्छा कॉल धन्यवाद! मैं &गोल्फ में लगभग पर्याप्त उपयोग नहीं करते । वास्तव में, आप के बीच injectऔर जगह की जरूरत नहीं है :+।
— पॉल प्रेस्टिज
4

पर्ल 6 (28 - 75 + 0 = -47 बाइट्स)

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

यह सभी सकारात्मक संख्याओं को संभाल सकता है (हालांकि, बड़े लोगों को एक लंबा समय लगेगा, क्योंकि वर्तमान में पर्ल 6 कार्यान्वयन धीमा हैं, लेकिन पर्ल 6 मूल रूप से बड़े पूर्णांकों का समर्थन करता है)। यह evalएक साधारण कैलकुलेटर को लागू करने के लिए उपयोग करता है (पचास वर्णों के लिए पांच वर्ण दंड इसके लायक है)। यह सिर्फ इसलिए धीमा है क्योंकि वर्तमान कार्यान्वयन धीमा है, लेकिन सिद्धांत रूप में, यह काफी तेज होना चाहिए (जब पर्ल 6 कार्यान्वयन में सुधार होता है, तो)। इसके अलावा, आश्चर्यजनक रूप से, मैं गणितज्ञ (अब के लिए) के साथ जीता हूं।

» इस कोड में वास्तव में जरूरत नहीं है, लेकिन मैंने इसे प्रदर्शन कारणों के लिए यहां रखा है (अन्यथा, कार्यक्रम पूरे स्ट्रिंग को आवंटित करेगा। यही कारण है कि पर्ल 6 में अनंत तार नहीं हैं, लेकिन इसमें अनंत सूचियां हैं।

वैसे भी, आप पूछ सकते हैं कि यह कोड कैसे काम करता है। ठीक है, मैं इसे भाग द्वारा पास करने जा रहा हूं।

  • get.eval

    यह एक पंक्ति ( getफ़ंक्शन) प्राप्त करता है, और इसका मूल्यांकन करता है ( evalविधि)।

  • 1..get.eval

    उसके बाद, पर्ल 6 1मूल्यांकन मूल्य से, एक रेंज ऑब्जेक्ट तैयार करता है । यह एक सीमा है, इसलिए कुछ भी बड़ा आवंटित नहीं किया जाता है।

  • ».comb

    .combविधि वर्णों पर स्ट्रिंग विभाजित करती है ( जब तक कि एक तर्क के साथ नहीं कहा जाता है )। उदाहरण के लिए, 'cat'.combरिटर्न 'c', 'a', 't'। »सूची तत्वों को मैप करता है, इसलिए .combइसके प्रत्येक आइटम पर भाग लिया जाता है - न केवल सूची पर ही (उदाहरण के लिए, (4, 9)».sqrtदेता है 2, 3)। यह भी जरूरत से ज्यादा आवंटित नहीं करता है, क्योंकि पर्ल 6 में अनंत सूचियां हैं (जैसे हास्केल, उदाहरण के लिए)।

    »चरित्र की वास्तव में जरूरत नहीं है, जैसा कि .combसीधे सूची में उपयोग किया जा सकता है, लेकिन इसमें अंतर्निहित स्ट्रिंग सहसंबंध शामिल हैं (और पर्ल 6 में अनंत तार नहीं हैं, इसलिए यह स्मृति को बर्बाद कर देगा)। उदाहरण के लिए, 1, 2, 3स्ट्रिंग रिटर्न में रूपांतरण के बाद सूची 1 2 3। पर्ल 6 के लिए, एक स्थान एक बिल्कुल ठीक संख्या 0 है, इसलिए कोड ऐसे रूपांतरण के साथ भी काम करेगा। हालाँकि, यह कंप्यूटिंग संसाधनों का दुरुपयोग करेगा।

  • [+]

    यह एक कम ऑपरेटर है। मूल रूप से, इस बीच [], आप इस मामले में उपयोग करने के लिए एक ऑपरेटर रख सकते हैं +। कम ऑपरेटर के बाद की सूची कम है, ऐसा [+] 1, 2, 3है 1 + 2 + 3, जो है 6। पर्ल 6 संख्याओं और तारों के लिए अलग-अलग ऑपरेटरों का उपयोग करता है, इसलिए इसे सहमति नहीं माना जाएगा।

  • say

    अंत में, sayपरिणाम को आउटपुट करता है। आखिरकार, आप अंतिम परिणाम देखना चाहते हैं, क्या नहीं?

— कोनराड बोरोस्की
स्रोत
हम्म् ... [+] 1,2,3,4,5,6,7,8,9,10है 1+2+3+4+5+6+7+8+9+10, क्या मैं सही हूँ?
— ST3
@ ST3: हाँ। कम ऑपरेटर को पर्ल 6 में कई दिलचस्प तरीकों से इस्तेमाल किया जा सकता है। उदाहरण के लिए, >जंजीर हो सकती है, 3 > 2 > 1यह सच है। एक ही संपत्ति ऑपरेटरों को कम करने के लिए लागू होती है, इसलिए [>] 3, 2, 1यह अभी भी सच है, क्योंकि इसका मतलब है 3 > 2 > 1- यह [>]निर्धारित करने के लिए इस्तेमाल किया जा सकता है कि क्या नंबर अवरोही क्रम में हैं।
— कोनराड बोरोस्की
के get.Intबजाय आप का उपयोग नहीं कर सकता eval? क्या इसे गणित के भावों की जरूरत है?
— शुक्र
@ user1737909: "-50 बोनस यदि आपका कोड सरल अभिव्यक्ति को संभाल सकता है"। इसके अलावा, पर्ल 6 को डिजाइन द्वारा कास्टिंग की आवश्यकता नहीं है (कुछ दुर्लभ किनारे मामलों की sortतुलना में , बिना तुलना विधि तर्क के)।
— कोनराड बोरोस्की
3

जे, २२

([:+/[:"."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
— DevonMcC
स्रोत
डाउनवॉटर को इस उत्तर पर अपनी आपत्तियों की व्याख्या करने की आवश्यकता है। मैंने अभी-अभी इसकी कोशिश की है, जबकि यह कोई बोनस नहीं कमाता है, यह अभी तक ठीक काम करता है जहाँ तक मैं देख सकता हूँ।
— गारेथ
वास्तव में, शीर्ष उत्तर पर गौर करने से, यह भी 22-60 = -38 के स्कोर के लिए भाव और पावर ऑपरेटर बोनस अर्जित करने लगता है।
— गारेथ
यह +/,10#.inv>:i.छोटा होगा। लेकिन यह अभी भी एक समारोह है और ओपी के अनुसार पूरा कार्यक्रम नहीं है।
— बेंत की मार
@ गैरेथ बोनस इस उत्तर पर लागू नहीं होते हैं, क्योंकि आप सिर्फ कोड के अंदर अभिव्यक्ति लिखेंगे और इनपुट के रूप में नहीं।
— बेंत की मार
1
@swish यह वही है जो मैंने पहले सोचा था, लेकिन गणित का जवाब इस तरह से बहुत काम करता है।
— गारेथ
3

आर, 64 - (50 + 10) = 4

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

जब इसे चलाया जाता है, तो उपयोगकर्ता से इनपुट के लिए कहा जाता है।

पुराना संस्करण (अभिव्यक्ति को संभाल नहीं सकता): 46 वर्ण:

sum(utf8ToInt(paste(0:scan(),collapse=""))-48)
— स्वेन होहेंस्टीन
स्रोत
यह मेरे लिए होता है कि कोडगुल्ल एकल-प्रतीक कार्यों वाली भाषाओं के प्रति बेतहाशा पक्षपाती है। यदि हम पूर्वनिर्धारित वगैरह हों तो यह समाधान काफी कम होगा u<-function(x) utf8ToInt(x)।
— कार्ल विट्ठॉफ्ट
@CarlWitthoft यह सच है। लेकिन पूर्वनिर्धारण भी वर्णों की संख्या के लिए मायने रखता है। वैसे: यह u <- utf8ToIntबिना के लिए पर्याप्त है function। यदि फ़ंक्शन कई बार उपयोग किया जाता है तो यह कोड गोल्फ के लिए सहायक हो सकता है।
— स्वेन होइनस्टीन
इसलिए यदि मैं एक Rcheatcodegolfपैकेज बनाता हूं, तो क्या उस पैकेज में पूर्वनिर्धारित कार्यों का उपयोग करना कानूनी है? :-)
— कार्ल विटथॉफ्ट
@CarlWitthoft हाँ, संकुल का उपयोग किया जा सकता है। बेशक, पैकेज को कार्य के लिए नहीं लिखा जाना चाहिए। लेकिन अगर इसमें केवल कार्यों के लिए संक्षिप्त नाम शामिल हैं, तो यह ठीक है।
— स्वेन होइनस्टीन
3

बैच - (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!

पुरानी विधि लूप के लिए पॉवरशेल कमांड का आउटपुट प्राप्त करने के लिए उपयोग करती है, जैसा कि किसी फाइल से लिखने और पढ़ने के लिए:

@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 से अधिक संख्याओं को संभालने के लिए, मुझे स्ट्रिंग की लंबाई प्राप्त करने के लिए पॉवरशेल का उपयोग करना था, फिर उस स्ट्रिंग को विभाजित करने के लिए लूप के लिए दूसरे का उपयोग करें, और इसे योग में जोड़ें - s।
आप सकता का नाम बदलने powershell.exeके लिए p.exeसी के तहत: \ 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.

यह पाठ्यक्रम मुझे चुनौती से अयोग्य घोषित करता है।

— unclemeat
स्रोत
1
अच्छा समाधान! यह नीचे गोल्फ के लिए कुछ तरीके हैं। 1. आप अस्थायी चर से छुटकारा पा सकते हैं vऔर %1सीधे उपयोग कर सकते हैं। 2. आप अपने PowerShell स्क्रिप्ट में 1 को लम्बाई के बजाय घटा सकते हैं @set /a b=%%b-1जो आपको एक गुच्छा बचाता है। उन परिवर्तनों के साथ, मेरे पास मूल 240 से 211 तक नीचे है। :-)
— मार्क
उफ़, मैं अब देख रहा हूँ कि आपने अपना अस्थायी चर (बोनस अंक के लिए) क्यों रखा है। PowerShell टिप अभी भी खड़ा है, हालांकि ...
— मार्क
अच्छी तरह से देखा, धन्यवाद। अब वह बदल जाएगा।
— चाचा
बैच काम नहीं करेगा। यह (2 ^ 31) -1 (हस्ताक्षरित 32-बिट पूर्णांक) तक सीमित है। चुनौती के लिए (2 ^ 64) -1 (अहस्ताक्षरित 64-बिट पूर्णांक, लेकिन उस मान के लिए आउटपुट इसे अतिप्रवाह होगा) तक इनपुट से निपटने की आवश्यकता होती है। यह वह जगह है जहां पावरशेल का एक अलग फायदा है - इसका [decimal]प्रकार मानों के लिए अनुमति देता है (2 ^ 96) -1।
— 22
1
यद्यपि, मैं पूर्णांक विभाजन में चूक के लिए बैच को कुछ अच्छा श्रेय दूंगा, हालांकि। यह ऐसा कुछ है जो पावरशेल पूरी तरह से गायब है।
— 22
3

डायलॉग एपीएल , 9 - 160 * = -151

+/⍎¨∊⍕¨⍳⎕

इसे ऑनलाइन आज़माएं!

⎕मूल्यांकन इनपुट मिलता है
 जैसे "7+5"देता है12

⍳सूचकांक 1 ... एन
 [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 बोनस के रूप में यह भी अभिव्यक्ति इनपुट के रूप में स्वीकार करता है। अभिव्यक्ति मान्य एपीएल होनी चाहिए, जो ओपी के अनुसार स्वीकार्य हो ।

-10 बोनस क्योंकि यह ^( *एपीएल में) भी संभालता है ।

-100 बोनस क्योंकि अभिव्यक्ति इनपुट eval( ⍎APL में) के स्पष्ट उपयोग के बिना नियंत्रित किया जाता है ।

— एडम
स्रोत
क्या आप सुनिश्चित हैं कि -100 बोनस यहां जोड़ा गया है? क्योंकि यह बताता है कि " -100 बोनस अगर आपका कोड -50 बोनस के लिए अर्हता प्राप्त करता है और अभिव्यक्ति को संभालने के लिए उपयोग eval या समान नहीं करता है । " चूँकि ⍎¨यह प्रत्येक वर्ण को एक-एक करके निष्पादित करता है, इसलिए यह एक eval के समान है (सिवाय इसके कि पात्रों को निष्पादित करता है। एक ही समय में सभी के बजाय एक जैसा evalहोता है)।
— केविन क्रूज़सेन
@KevinCruijssen हाँ, क्योंकि यह अभिव्यक्ति को संभालने के लिए eval या समान का उपयोग नहीं करता है । ⍎¨इसका उपयोग केवल अंकों को पूर्णांक में बदलने के लिए किया जाता है, न कि अभिव्यक्ति को संभालने के लिए।
— Adám
आह रुको, मैंने आपके स्पष्टीकरण को गलत तरीके से देखा। लेकिन ⎕तब थोथा इनपुट या ईवैल बिलिन नहीं होता है, या एक्सप्रेशन हमेशा स्पष्ट रूप से किया जाता है जब भाव इनपुट होते हैं?
— केविन क्रूज़सेन 12
1
@KevinCruijssen ⎕हमेशा इनपुट के रूप में एक अभिव्यक्ति लेता है, उसका मूल्यांकन करता है, और उसका परिणाम देता है। तो एक स्ट्रिंग इनपुट करने के लिए, आपको इसके चारों ओर उद्धरण लगाने होंगे। तथ्य यह है कि संबंधित बिल्ट-इन ( ⍞) कच्चे पाठ के रूप में इनपुट लौटाता है (विशेषकर चूंकि प्रतीकों से संकेत मिलता है कि ⎕प्राथमिक इनपुट विधि है, और ⍞एक विशेष संस्करण है), अन्यथा अन्यथा बोनस प्राप्त करने के लिए एक गणित को लागू करने की आवश्यकता होगी। मूल्यांकनकर्ता - मुख्य एक की तुलना में पूरी तरह से अलग कार्य। मुझे बोनस पसंद नहीं है, और -100 एक बस मूर्खतापूर्ण है या मन में एपीएल था, लेकिन इमो, यह बोनस के लिए एक सटीक फिट लगता है।
— अड्म
यदि ⎕वास्तव में इनपुट प्राप्त करने का सामान्य तरीका है और स्वचालित रूप से अभिव्यक्ति को संभालता है, तो मैं वास्तव में इसे बोनस में भी फिट देखता हूं, इसलिए मुझसे +1। बोनस वैसे भी इन दिनों मूर्खतापूर्ण हैं, लेकिन अपने स्कोर को कम करने के लिए उनका उपयोग करने का अच्छा तरीका है।
— केविन क्रूज़सेन
2

सी # (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)
            );
    }
}
— FIRO
स्रोत
2

पायथन 3 + बैश (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: जब तक आप बैश से अजगर को इस तरह से आमंत्रित नहीं करते, लेकिन मुझे नहीं लगता कि ऐसा है। यदि आपको लगता है कि यह वास्तव में है, तो समायोजित स्कोर -7 है।

— स्टेफानो सैनफिलिपो
स्रोत
मैं कहूंगा कि यदि आपने एक अभिव्यक्ति मूल्यांकनकर्ता नहीं लिखा है, तो आप कुछ समान का उपयोग कर रहे हैं। लेकिन मैं ओपी नहीं हूं, इसलिए शुभकामनाएं!
— तोबिया
@ टोबिया से सहमत, अभिव्यक्ति मूल्यांकनकर्ता के लिए कोई बोनस नहीं।
— ST3
2

जावा, 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 चार्ट (लंबे लंबे शब्दों पर आधारित जावा प्रोग्रामिंग पर विचार) के लिए मायने रखता है।

पुनश्च: यह एक पूर्ण कार्यक्रम है, न कि केवल तर्क। कार्यक्रम के लिए दिए गए शब्द गिनती, केवल तर्क नहीं हैं।

— श्री
स्रोत
2

जावा (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));
  }
}
— whyem
स्रोत
+1 जो हर कोई जो जावा में गोल्फ कोड चुनौती करता है, वह इसके हकदार हैं, लेकिन लगता है जैसे स्ट्रीम एपीआई आपको गोल्फ खेलने के दौरान फायदा नहीं देता है। यदि आप अपने समाधान को फिर से लिखते हैं तो आप शर्त लगा सकते हैं और आप धाराओं का उपयोग करेंगे बजाय धाराओं के यह छोटा होगा।
— user902383
2

सीजाम, 9 - 25 = -16

CJam इस चुनौती से कुछ महीने छोटा है, इसलिए यह ग्रीन चेकमार्क के लिए योग्य नहीं है। इसके अलावा, यह पहली जगह में पर्ल की पिटाई नहीं कर रहा है। ;) मुझे दृष्टिकोण बहुत पसंद था, हालांकि, मैं इसे वैसे भी पोस्ट करना चाहता था।

l~),s:~:+

इसका परीक्षण यहां करें।

विचार 0 से N तक की सीमा बनाने का है। यह सीमा तब एक स्ट्रिंग में परिवर्तित हो जाती है, जो केवल पूर्णांक को बैक में समेटती है। N = 12 के लिए, हमें मिलेगा

"0123456789101112"

तब प्रत्येक वर्ण एक पूर्णांक में परिवर्तित हो जाता है :~( पूर्णांक की एक सरणी उपज), और फिर साथ में अभिव्यक्त किया जाता है :+। CJam मनमाने ढंग से बड़े पूर्णांकों से निपट सकता है।

— मार्टिन एंडर
स्रोत
2

पायथन 3 + एस्टर ,1017 1007 बाइट्स - (25 + 50 + 100) = स्कोर: 842 834

10 बाइट्स निकालकर tsऔर बदलकर बचायाp

संपादित करें: मैं हास्यास्पद रूप से लंबे पूर्णांक (1234567891234567891234564789087414984894900000000) [मेरे कंप्यूटर को लटका देता है] का परीक्षण करने में असमर्थ हूं, लेकिन मेरे ज्ञान से, पायथन 3 पूरी तरह से लंबे पूर्णांक का समर्थन करता है।

यह कार्यान्वयन का उपयोग करता हैएएसटी को गालियां। मैं एएसटी को "निष्कासन या समान" के रूप में दुरुपयोग करने पर विचार नहीं करूंगा।

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
यह आश्चर्यजनक है, लेकिन अभी तक भयानक है। निश्चित नहीं है कि इसकी अनुमति है (जानबूझकर एक लंबे समाधान का उपयोग करने के लिए), लेकिन मुझ से 10/10।
— R
@ E @slyIʀᴋ जानबूझकर एक लंबे समाधान का उपयोग करने की अनुमति क्यों नहीं है? मुझे कोई समस्या नहीं दिख रही है। कम से कम मैं 842+ स्कोर के साथ समाधान हराऊंगा;)
वे प्रतिस्पर्धात्मक उत्तर देने वाले होते हैं, जिसका अर्थ है प्रयास दिखाना। इसके अलावा, यह टिप्पणी करें। एज के लिए एसई सीमा 13 है !!! आपको शायद तब तक इंतजार करना चाहिए जब तक कि आप कानूनी रूप से चालू न हों। COPPA (Google इसे) के कारण, आपको इस तरह से इंटरनेट का उपयोग करने के लिए 13 होना चाहिए।
— R
@ E @s wasIʀᴋ अब मैं उत्सुक हूं, वह उपयोगकर्ता कौन था?
— बिल्ली
1
@cat एक अरबी नाम जिसका मैं उच्चारण नहीं कर सकता था? शायद नुक्कड़ वाला हिसाब।
— R
1

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();
}
— microbian
स्रोत
3
यह एक मान्य उत्तर नहीं है क्योंकि यह कार्य है और चार गिनती बड़ी है
— ST3
1
आपको एस की जरूरत नहीं है int; सी में, सब कुछ चूक int... ओह, यह सी # है।
— wizzwizz4
1

रूबी -> 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
— Beterraba
स्रोत
1

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;
}
— microbian
स्रोत
क्या व्हाट्सएप के बीच n--और +जरूरत है? मुझे नहीं लगता कि यह अन्य सी-शैली भाषाओं में है।
— फायरफली
1
क्या यह दी गई सीमा के साथ काम करता है? के लिए परिणाम 2^64-164 बिट में फिट नहीं है।
— मारिनस
2
यह एक मान्य उत्तर नहीं है क्योंकि यह कार्य है और चार गिनती बड़ी है।
— ST3
@marinus क्या आप हमें 2 ^ 64-1 का परिणाम दे सकते हैं ताकि हम जान सकें कि हमें किस सीमा तक काम करने की आवश्यकता है? मेरी हिम्मत नहीं हुई कि इसकी भाषा (पॉवरशेल) में परीक्षण करूं क्योंकि प्रसंस्करण का समय बहुत बड़ा होगा।
— इस्सी
@ आईजी: मैं वास्तव में इसे चलाने नहीं जा रहा हूं, लेकिन आप कुछ गणित कर सकते हैं: 1) एक अंक का औसत मूल्य है 4.5; 2) 20 अंकों की औसत राशि 90( 2^6420 अंक है); इसलिए अपेक्षित मूल्य लगभग हो जाएगा 90 * 2^64 ≈ 1.66*10^21। तो आपको कम से कम 71बिट्स की जरूरत होगी 72।
— मारिनस
1

रूबी 69-50 = 19 (या -4)

यह निश्चित रूप से एक साथ गोल्फ हो सकता है लेकिन यहां पहला पांचवा प्रयास है

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

यह सभी नंबरों के लिए भी काम करता है, लेकिन यह उनके लिए बहुत धीमा है क्योंकि यह ओ (एन) की तुलना में धीमा चलता है, इसलिए मैं -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]
— SztupY
स्रोत
हम बिलकुल एक ही कोड लिखते हैं (आपने थोड़ा और गोल्फ किया है)!
— बेतराबा
@Beterraba हाँ, और लगभग एक ही समय में, लेकिन आप थोड़ा तेज थे, इसलिए मुझे कुछ अलग करने की ज़रूरत है :)
— SztupY
1

हास्केल, 74-25 = 49

main=getLine>>=print.sum.map(\c->read[c]).concatMap show.(\x->[0..x]).read

— Vektorweg
स्रोत
उपयोग करना interactऔर इस तथ्य के बारे में कि >>=सूचियों के लिए समान है flip concatMap, आप इसे इस तरह से 63 वर्णों तक नीचे ले जा सकते हैं:main=interact$show.sum.map(\c->read[c]). \x->[0..read x]>>=show
— Flonk
को बचाने के लिए एक और बाइट: \c->read[c]हैread.(:[])
— nimi
1

ECMAScript 6, 86 - 50 = 36

for(s="",i=eval(prompt());i;s+=i--)alert(s.replace(/\d/g,c=>Array(-~c).join()).length)
— जुगनू
स्रोत
एक वर्ण कम for(i=eval(prompt(s=""));i;s+=i--)alert(s.replace(/\d/g,c=>Array(-~c).join()).length):।
— टूथब्रश
थोड़ा छोटा (आपको इसकी आवश्यकता नहीं है .join()) for(i=eval(prompt(s=""));i;s+=i--)alert(s.replace(/\d/g,c=>Array(-~c)).length):। 78 - 50 = 28 !
— टूथब्रश
1

आर (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
— djhurio
स्रोत
इन चुनौतियों में आपको "f = function (n)" या n के साथ केवल फ़ंक्शन को स्पष्ट रूप से लिखने की आवश्यकता है?
— स्कैन
@skan, यह आवश्यकताओं पर निर्भर करता है। आमतौर पर यह एक स्पष्ट कार्य करने के लिए आवश्यक नहीं है।
— djhurio
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.