चुनौती

इस कार्य में आपके पास कम से कम एक गेंद वाले प्रत्येक सेल के साथ ए गेंदों को बी कोशिकाओं में वितरित करने के तरीकों की संख्या की गणना है।

इनपुट ए और बी एक रिक्त द्वारा अलग लाइन में दिए गए हैं, इनपुट ईओएफ द्वारा समाप्त किए जाते हैं।

आप यहां अपने समाधान की जांच करना पसंद कर सकते हैं ।

इनपुट

उत्पादन

1
0
14676024
540
54420176498688000
23112569077678080000
28332944640000
38528927611574400
2432902008176640000
21785854970880000
510
566658892800
334942064711654400

प्रतिबन्ध

हर A और B में अंतर हो सकता है।
0 <= ए, बी <= 20
आप अपनी पसंद की किसी भी भाषा का उपयोग कर सकते हैं
सबसे छोटा समाधान जीत!

code-golf math combinatorics

— विलक्षण
स्रोत

1

क्या समय सीमाएँ हैं?

@ टिम नॉर्डेनफ़र: अपडेटेड :-)

— क्विक्सोटिक

वह लिंक मेरे लिए अमान्य है।

— मेलमोकब

3

@Debanjan मुझे यहाँ SPOJ से सवाल चिपकाने का विचार पसंद नहीं आया। लोग वहां प्रतिस्पर्धा के लिए अपना कोड जमा करते हैं और यह उनके लिए अनुचित होगा।

— fR0DDY

1

@Debanjan, मैं आपके संदर्भ देख सकते हैं और आप को बढ़ाने मैथवर्ल्ड (eqn। 5 का कहना है कि S(n,0)है 1यदि n=0और 0अन्यथा)। यदि आप चाहते हैं कि मैं मजबूत बयान के लिए एक संदर्भ पा सकता हूं कि स्टर्लिंग 2 घातीय रिओर्डन समूह के सहयोगी उपसमूह में है।

— पीटर टेलर

4

जावास्क्रिप्ट (90 93 )

function f(a,b){n=m=r=1;for(i=b;i>0;n*=-1){r+=n*m*Math.pow(i,a);m=m*i/(b-i--+1)}return--r}

http://jsfiddle.net/RDGUn/2/

जाहिर है, APL जैसी कोई भी गणित-आधारित भाषा मुझे वाक्य रचना की निष्पक्षता और अंतर्निहित गणितीय परिणामों की कमी के कारण हरा देगी :)

संपादित इसके अलावा, मैं समारोह, यकीन नहीं कैसे जावास्क्रिप्ट के साथ मानक इनपुट का उपयोग करने में पारित कर दिया मानकों को छोड़कर किसी भी इनपुट से संबंधित कार्य क्षमता नहीं होती ...

संपादित करें: अभिव्यक्ति i--में जाएं m=m*; ले जाने के n*=-1में for; r=1असाइनमेंट को संयोजित करना और वापसी पर बाहरी को हटाना शुरू करें। (3 वर्ण सहेजें)

— mellamokb
स्रोत

आप spidermonkey खोल का उपयोग कर सकते हैं - यह कम से कम है readlineऔर print। मुझे नहीं पता कि यहां दूसरे क्या उपयोग करते हैं।

— जेसी मिलिकन

@ जेसे: दिलचस्प। मैं वैसे भी हारने जा रहा हूं।

— मेलमोकब

promptऔर alertजावास्क्रिप्ट के "मानक" io हैं, क्योंकि वे विशिष्ट अवरुद्ध io कॉल हैं, इस तथ्य के बावजूद कि आप आमतौर पर जावास्क्रिप्ट के साथ अवरुद्ध io का उपयोग कभी नहीं करेंगे।

— zzzzBov

4

गोल्फस्क्रिप्ट - 56 50 49 48 41 40 38 37 वर्ण

n%{~),{!}%\{0.@{.@+2$*@)@}/;;]}*)p;}/

नोट: यह इनपुट की कई लाइनों को संभालता है, तेज है (परीक्षण मामलों को करने के लिए 1/8 सेकंड), और किसी भी कानूनी इनपुट के लिए नहीं टूटता है।

(पहला संस्करण भी मेरा पहला गोल्फस्क्रिप्ट कार्यक्रम था, मैंने कई ट्रिक्स को याद करने के लिए eBusiness को धन्यवाद दिया था)।

इसे एक उपयोगी शैक्षिक पद बनाने के लिए, यहाँ यह भी बताया गया है कि यह कैसे काम करता है। हम पुनरावृत्ति के साथ शुरू करते हैं f(n, k) = k * (f(n-1, k) + f(n-1, k-1))। इसे स्पष्ट रूप से यह कहते हुए समझा जा सकता है कि nअलग- kअलग बाल्टियों में अंतर करने योग्य गेंदों को रखने के लिए, जैसे कि प्रत्येक बाल्टी में कम से कम एक गेंद होती है, आप kपहली गेंद के लिए एक बाल्टी लेते हैं ( k *) और फिर इसमें कम से कम एक गेंद होगी ( f(n-1, k)) या यह ( f(n-1, k-1)) नहीं होगा ।

इस ग्रिड से उत्पन्न मूल्य; लेने nपंक्ति सूचकांक के रूप में और kस्तंभ सूचकांक के रूप में और 0 से दोनों का अनुक्रमण यह शुरू होता है

1   0   0   0    0    0   0 ...
0   1   0   0    0    0   0 ...
0   1   2   0    0    0   0 ...
0   1   6   6    0    0   0 ...
0   1  14  36   24    0   0 ...
0   1  30 150  240  120   0 ...
0   1  62 540 1560 1800 720 ...
.   .   .   .    .    .   . .
.   .   .   .    .    .   .  .
.   .   .   .    .    .   .   .

तो कार्यक्रम की ओर मुड़ते हुए,

n%{~ <<STUFF>> }/

इनपुट को लाइनों में विभाजित करता है और फिर प्रत्येक पंक्ति के लिए इसका मूल्यांकन करता है, स्टैक पर nऔर डाल रहा है k, और फिर कॉल करता है <<STUFF>>, जो इस प्रकार है:

),{!}%\{0.@{.@+2$*@)@}/;;]}*)p;

यह उस ग्रिड k+1की n+1वें पंक्ति की पहली प्रविष्टियों की गणना करता है । शुरू में स्टैक है n k।
),स्टैक के स्टैक n [0 1 2 ... k]
{!}%देता है n [1 0 0 ... 0]जहाँ k0s हैं। शीर्ष पर
\{ <<MORE STUFF>> }*लाता है nऔर इसे हमारे द्वारा निष्पादित किए जाने की संख्या के बराबर बनाता है <<MORE STUFF>>।
हमारा स्टैक वर्तमान में तालिका की एक पंक्ति है: [f(i,0) f(i,1) ... f(i,k)]
0.@उस सरणी से पहले 0s का एक जोड़ा रखता है। पहला वाला होगा jऔर दूसरा वाला होगा f(i,j-1)।
{ <<FINAL LOOP>> }/सरणी के तत्वों के माध्यम से छोरों; प्रत्येक के लिए यह इसे स्टैक के शीर्ष पर रखता है और फिर लूप बॉडी को निष्पादित करता है।
.@+2$*@)@उबाऊ स्टैक हेरफेर करने के लिए उबाऊ ... j f(i,j-1) f(i,j)और उपज ... j*(f(i,j-1)+f(i,j)) j+1 f(i,j)
;;]छोड़ दिया हैk+1 f(i,k)और एक सरणी में सब कुछ इकट्ठा करता है, अगले दौर के लिए तैयार लूप।
अंत में, जब हमने nतालिका की वें पंक्ति को उत्पन्न किया है ,
)p;तो अंतिम तत्व लेता है, इसे प्रिंट करता है, और शेष पंक्ति को हटा देता है।

इस सिद्धांत पर तीन-चार समाधानों के लिए:
n%{~),{!}%\{0.@{.@+@.@*\)@}/;;]}*)p;}/
n%{~),{!}%\{0:x\{x\:x+1$*\)}/;]}*)p;}/
n%{~),{!}%\{0.@{@1$+2$*\@)}/;;]}*)p;}/

— पीटर टेलर
स्रोत

1

एक शुरुआत के लिए बहुत अच्छा है, कुछ संभव छोटे पैमाने पर कटौती है, तुरंत मुझे लगता है [0]-> 1,, ज़िप के बाद की जगह को बस हटाया जा सकता है, और यदि आप बस कश्मीर के बजाय एक ऑपरेटर में स्टोर करते हैं तो दूसरी जगह को हटाया जा सकता है। मैंने अभी तक आपके कोड के माध्यम से कदम नहीं उठाया है, लेकिन मुझे संदेह है कि आप कुछ स्थानों में एक सरणी में इसे डाले बिना सिर्फ एक मूल्य का उपयोग करके दूर हो सकते हैं।

— आआआआआआआ आआआआआआ आआआआआआ १३ at११ को

1

+ 1, मुझे गोल्फस्क्रिप्ट समझ में नहीं आता है, लेकिन यह पर्याप्त रूप से तेज़ दिखता है, और फिर भी बहुत छोटा है।

— क्विक्सोटिक

@eBusiness और @Peter टेलर: एक अलग नोट पर .. आप लोग कितना आसान सीखने के पैमाने पर गोल्फस्क्रिप्ट को रेट करते हैं?

— क्विक्सोटिक

@ डिबंजन, उस पर निर्भर करता है जो आप पहले से जानते हैं। यह एक कार्यात्मक स्टैक-आधारित भाषा है। मैंने पहले एक कार्यात्मक भाषाओं का उपयोग किया है (SML - प्लस मैंने OO भाषाओं में कार्यात्मक-शैली कोड लिखा है), और मैंने पहले स्टैक-आधारित भाषाओं का उपयोग किया है (जावा बाइटकोड को जैस्मीन, पोस्टस्क्रिप्ट के साथ इकट्ठा किया गया है), इसलिए केवल वास्तविक बाधा मैं यह सीख रहा हूं कि ऑपरेटर क्या उपलब्ध हैं। यदि आप केवल अल्गोल परिवार (सी, जावा, आदि) से भाषाएँ जानते हैं, तो आपके पास एक ही बार में कूदने के लिए तीन बाधाएँ होंगी।

— पीटर टेलर

@ डिबंजन - यह दिखने में जितना आसान है, आप लगभग तुरंत कोड लिखना शुरू कर सकते हैं, लेकिन निश्चित रूप से सभी छोटी-छोटी ट्रिक्स सीखने में थोड़ा समय लगता है।

— आआआआआआआआआआआ आआआआआ

3

जे, ४०

4 :'|-/x(^~*y!~])i.1x+y'/&.".;._2(1!:1)3

उदाहरण के लिए

4 :'-/((x^~|.@:>:)*y&(!~))i.y'/x:".>{.;:(1!:1)3
15 13
28332944640000

सभी परीक्षण मामलों के लिए <1sec।

संपादित करता

(52 → 47) के साथ कम -/बारी के बजाय (1 _1)*(जेबी के विचार)
(४iced → ५३) अधिसूचित बहुस्तरीय इनपुट आवश्यकता: - /
(५३ → ४ 48) द्विपद की सममिति का शोषण।
(४ t → ४ →) नखरे करो!
(४ 41 → ४१)
(41 → 40) निचोड़ वेतन वृद्धि + में रूपांतरण1x+

— Eelvex
स्रोत

1

अरे! यही मेरा विचार था ! O :-)

— जेबी

ठीक है, मैं उस 1x+समय चोरी करूंगा , लेकिन वह मुझे केवल 1 पात्र वापस खरीद लेगा, जबकि आपने 5 लिया था!

— जेबी

3

आम लिस्प (83)

(defun b (x y)
  (if (= (* x y) 0)
      (if (= (+ x y) 0) 1 0)
      (* y (+ (b (decf x) y) (b x (1- y)))))))

ऐसा लगता है कि आधार मामलों का परीक्षण करने के लिए एक छोटा तरीका होना चाहिए, लेकिन मेरे लिए कुछ भी नहीं होता है।

— डॉ। दर्द
स्रोत

3

जे, 38 से 42

इंटरैक्टिव भाषाओं और आउटपुट प्रस्तुति के बारे में आपकी सख्ती वरीयताओं के आधार पर, समाधान के जे दर्शक से अपनी पिक लें:

38 सबसे छोटा इंटरेक्टिव: 4 :'|-/(!&y*^&x)i.1x+y'/&".;._2(1!:1)3
लॉन्च जोंकॉल, इसे दर्ज करें, फिर इनपुट पेस्ट करें (सीडी के साथ अंत)। आप देखेंगे कि आउटपुट स्पेस-सेपरेटेड है (J एक वेक्टर लैंग्वेज है, यह संपूर्ण इनपुट पर कंप्यूटेशन को संपूर्ण रूप में निष्पादित करता है और इसे 1D वेक्टर के रूप में लौटाता है, जिसकी डिफ़ॉल्ट प्रस्तुति सिंगल लाइन पर है)। मुझे लगता है कि ठीक है, इस समस्या की भावना संगणना है, प्रस्तुति नहीं। लेकिन अगर आप इसके बजाय नए अंक होने पर जोर देते हैं:
39 अब इंटरैक्टिव: 4 :'|-/(!&y*^&x)i.1x+y'/&.".;._2(1!:1)3
जगह लिखें ( &साथ) के तहत ( &.) तार का एक वेक्टर, जिनकी प्रस्तुति अलग पंक्ति में समाप्त होता है देता है।
42 बैच मोड: 4 :'echo|-/(!&y*^&x)i.1x+y'/&".;._2(1!:1)3
कमांड लाइन से के रूप में चलाएँ$ jconsole balls.ijs < balls.in

यदि आपने इसे वोट दिया है, तो आप एलाक्स के समाधान को कुछ क्रेडिट देना चाहेंगे ।

— जेबी
स्रोत

&.इंटरेक्टिव मोड पर ठीक से काम करने के लिए आपको इसके लिए एक अंडर चाहिए ।

— बारह

@ बारहवीं में आपके पास "ठीक से" की एक अलग व्याख्या होनी चाहिए। मैं jconsole, पेस्ट कोड, पेस्ट इनपुट, Cd शुरू करता हूं और आउटपुट प्राप्त करता हूं। जरूरत के तहत नहीं। आपका क्या है?

— जेबी

हमारे कोड संयुक्त 4 :'|-/(!&y*^&x)i.1x+y'/&.".;._2(1!:1)3:। 39 चरस।

— बारह

इको या अंडर के बिना मुझे केवल एक लाइन (कई लाइनों के बजाय) में आउटपुट मिलता है।

— बारहवीं

@ बारह वास्तव में, लेकिन यह स्पष्ट रूप से निषिद्ध नहीं है।

— जेबी

3

GolfScript - 45 38 36 अक्षर

मध्यम-बल गंदे कार्यान्वयन पुनरावृत्ति संबंध ( 38 36 वर्ण):

n%{~{.2$*{\(.2$f\2$(f+*}{=}if}:f~p}/

पुनरावर्तन संबंध मैंने पीटर टेलर के समाधान से चुराया, यह इस प्रकार है:

f(x, y) = y * ( f(x-1, y) + f(x-1, y-1) )

विशेष मामलों के साथ अगर या तो चर 0 है।

मेरा कार्यान्वयन पिछले परिणामों का पुन: उपयोग नहीं करता है, इसलिए प्रत्येक फ़ंक्शन कॉल शाखा को दो नए कॉल करता है, जब तक कि शून्य मामलों में से एक तक नहीं पहुंचा गया हो। यह 2 ^ 21-1 फ़ंक्शन कॉल का सबसे खराब मामला देता है जो मेरी मशीन पर 30 सेकंड लेता है।

प्रकाश बल श्रृंखला समाधान (45 वर्ण):

n%{~.),0\{.4$?3$,@[>.,,]{1\{)*}/}//*\-}/p;;}/

— aaaaaaaaaaaa
स्रोत

2

जे, 55 वर्ण

(wd@(4 :'(y^x)--/(!&y*^&x)|.i.y')/@".@,&'x');._2(1!:1)3

वर्तमान परीक्षण मामलों को पास करता है। मुझे लगता है कि मैं गणित को समझता हूं ...
j602, केवल कंसोल ( wd)। स्टड पर इनपुट, स्टडआउट पर आउटपुट।

बैश परीक्षण स्क्रिप्ट:

jconsole disballs.ijs <<END
12 4
6 3
END

— जेसी मिलिकन
स्रोत

उस j6xx का क्या करता है wd?

— JB

मैं वास्तव में j602 का मतलब था ... मुझे लगता है कि यह j601 में भी है। इसे इस रूप में परिभाषित किया गया है echo, जिसे इस रूप में परिभाषित किया गया है 0 0&$@(1!:2&2)। मुझे यकीन नहीं है कि इसका क्या मतलब है, लेकिन यह लाइन-ब्रेक के साथ सुंदर-प्रिंट रैंक 1 आइटम जैसा कुछ करता है। (मैं अभी देख रहा हूँ कि 4 के बजाय 2 का उपयोग करता है ... मुझे लगता है कि यह अभी भी कंसोल मोड में कम से कम चला जाता है।)

— जेसी मिलिकन

मुझे यह कोड चलाने में समस्या हो रही है। क्या मैं इसे कंसोल में टाइप करता हूं?

— मेलमोकब

@ mellamokb मैंने ऊपर दिए गए टेस्ट स्क्रिप्ट की तरह कुछ का उपयोग किया है, इस प्रोग्राम को disballs.ijs और j602 / bin / jconsole के लिए सही रास्ते के रूप में सहेजा गया है।

— जेसी मिलिकन

@ जेसे: मैं इसे विंडोज़ पर चला रहा हूँ। मुझे << was unexpected at this time. माफ करना, मैं जे इनपुट के लिए नया हूं, मैंने हमेशा इसे कंसोल मोड में उपयोग किया है।

— मेलामोकब

2

गोल्फस्क्रिप्ट - 26 वर्ण

चेतावनी: 12 4 मामले में बहुत अधिक मेमोरी की आवश्यकता होती है (हालांकि नीचे दिए गए उत्तर के रूप में ज्यादा नहीं) और चलाने के लिए काफी समय लगता है

~:)\?:x,{x+)base(;.&,)=},,

स्पष्ट रूप से इस उत्तर में कुछ समस्याएं हैं, लेकिन मैं इसे यहां छोड़ दूंगा क्योंकि टिप्पणियां इसे संदर्भित करती हैं और मेलमोकब का उत्तर इसके आधार पर है।

गोल्फस्क्रिप्ट - 24 वर्ण

चेतावनी: 12 4 मामले में बहुत अधिक मेमोरी की आवश्यकता होती है और इसे चलाने में काफी समय लगता है

~:o)\?,{o)base[0]-,o=},,

— gnibbler
स्रोत

2

मैं समझ नहीं पा रहा हूं कि आप उस कोड के साथ कैसे आए, न केवल यह विधि बड़े इनपुट के लिए मेमोरी से बाहर चले जाएगी, मैं यह भी समझ नहीं पा रहा हूं कि वेतन वृद्धि ऑपरेटरों के लिए क्या अच्छा है। आप वास्तव में 6 3 के लिए लक्ष्य मारा कि भाग्य के अलावा कुछ भी नहीं लगता है।

— आआआआआआआ आआआआआआआआआआआ

वह कोई विदूषक नहीं है, वह मेरी पत्नी है!

— जेसी मिलिकन

2

मुझे गोल्फस्क्रिप्ट समझ में नहीं आता, लेकिन जैसा कि आपने कहा था और मैं मानता हूं कि आपका दृष्टिकोण बहुत धीमा है।

— क्विक्सोटिक

3

@mellamokb, यह काम करने के तरीके के लिए आप पर अच्छा है :) यह केवल उस बग को ठीक करने के लिए 2 अतिरिक्त चार्ट लिया। अब हम मुर्की क्षेत्र में हैं जहाँ सबसे छोटा कोड सही हो सकता है लेकिन व्यावहारिक नहीं। कोड-गोल्फ को बहुत ही अयोग्य जवाबों से भरा जाता है, लेकिन माइक्रोसेकंड बनाम सेकंड आमतौर पर कोई फर्क नहीं पड़ता। यह एक चरम मामला है ( बहुत सारी मेमोरी भी)। देबंजन ने संकेत दिया है कि उत्तरों को तेज़ करने की आवश्यकता है, लेकिन यह साइट SPOJ नहीं है , इस सवाल का कोड कोड गोल्फ है

— gnibbler

1

@gnibbler, 0 0उत्पादन करना चाहिए 1; 0 kकिसी भी अन्य के लिए kउत्पादन करना चाहिए 0; n 1के लिए n > 0उत्पादन करना चाहिए 1।

— पीटर टेलर

2

पायथन 140 चरस

import sys
f=lambda n,k:(n and k and n>=k and k*(f(n-1,k-1)+f(n-1,k)))or(n+k==0 and 1)or 0
for l in sys.stdin:print f(*(map(int,l.split())))

— fR0DDY
स्रोत

2

डीसी, 100 वर्ण

[0q]s5[1q]s6[l2l3>5l3 0>5l2 0=6l2 1-S2l3dS3 1-S3l1xL3s9l1xL2s9+L3*]s1[?z0=5S3S2l1xL3L2+s9fs9l4x]ds4x

काश, डीसी ideone द्वारा समर्थित प्रतीत नहीं होता है। वहाँ एक चरित्र या दो अभी भी बाहर निचोड़ करने के लिए हो सकता है, लेकिन यह सोने का समय है।

ध्यान दें: यह इनपुट की कई लाइनों का समर्थन करता है 20 19, जब तक मैं अपने समाधान को बर्बाद नहीं करता, तब तक के लिए सही आउटपुट देने के लिए पर्याप्त सटीकता होती है (आपके लिए, पर्ल,!), और इसके लिए सही आउटपुट देता है 0 0।

नायब के सुझाव कम से कम जहाँ तक हो सके कम करने की अनुमति देते हैं

[0q]sZ[1q]sI[?z0=ZSkSn[lnlk>Zlk0>Zln0=Iln1-SnlkdSk1-SklFxLks9lFxLns9+Lk*]dsFxfs9l4x]ds4x

रजिस्टर स्टाॅक में कबाड़ छोड़ने की कीमत पर (और इस प्रकार स्मृति से बाहर चल रहे हैं यदि हम अरबों उत्तरों की गणना करते हैं)।

— पीटर टेलर
स्रोत

रजिस्टर्स हमेशा एकल वर्ण होते हैं (आप किसी भी वर्ण का उपयोग कर सकते हैं, जो कोड को अधिक पठनीय बना देगा), इसलिए l11इसे पार्स किया गया है l1 1( यदि आप वैसे भी सटीक परिवर्तन नहीं करने जा रहे हैं तो आप Kएकल वर्ण टोकन के रूप में उपयोग कर सकते हैं 0)। आप इनपुट लूप को बदल सकते हैं ?[...?z1=4]। आप रजिस्टर में मैक्रो को इनलाइन कर सकते हैं 1। और आप संभवतः सामान्य रूप से अधिक वर्णों को सहेज सकते हैं, लेकिन मैं इसे समझने की प्रतीक्षा करूंगा।

— नब

@ नब, आह, मैंने मैन पेज को ध्यान से नहीं पढ़ा। मैं केवल 8 या 9 रजिस्टरों का उपयोग कर रहा हूं, इसलिए मैं अपनी गलतफहमी के परिणामों में नहीं चला। धन्यवाद।

— पीटर टेलर

1

गोल्फस्क्रिप्ट (28 31 37 )

~~~):$\.($\?:@;?,{@+}%{$base$,\-[0]=},,~~

gnibblerगोल्फ गोल्फ समाधान के लिए संशोधन । मुझे लगता है कि यह एक सही समाधान है - सही उत्तर के लिए [3,2], [4,2], [6,3], और [9,2] के साथ परीक्षण किया गया। (मैंने कीवर्ड के चारों ओर अंतरिक्ष को कसने के लिए उपयोग किया $और @चर के लिए base)।

दो समस्याओं के gnibblerवर्तमान समाधान के साथ हैं।

[0] को हटाने के बाद लंबाई की जाँच करना एक समाधान की गारंटी नहीं देता है, क्योंकि [1,1,1,1] इनपुट [4,2] के लिए मान्य होगा, भले ही सभी 4 गेंदें एक ही सेल (1) में हों। इसलिए मैंने यह जांचने के लिए संशोधित किया है कि सभी अंकों का उपयोग किया जाता है, अर्थात, सरणी में 1-2 होते हैं, इसलिए प्रत्येक सेल में कम से कम एक गेंद होती है।
इनपुट [४,२] के मामले में, संख्या ०-२ [का आधार -३ प्रारूप ४ अंकों से कम है, और बाएं-सबसे ० शामिल नहीं हैं। इसका मतलब है कि [1,1] को एक वैध समाधान के रूप में शामिल किया गया है, भले ही यह तकनीकी रूप से वास्तव में है [0,0,1,1], जिसका अर्थ है कि पहली दो गेंदों को कहीं भी नहीं रखा गया है। मैं प्रत्येक प्रविष्टि में 3 ^ 3 जोड़कर ठीक करता हूं (सामान्य रूप से k ^ n प्रविष्टियों की सरणी के लिए n-1) ताकि पहले प्रविष्टियों को आधार-के प्रारूप में कम से कम n-अंक होने के लिए ऊपर की ओर स्थानांतरित किया जाए, और अंतिम प्रविष्टियाँ स्वचालित रूप से वैसे भी अमान्य होंगी और समाधान को प्रभावित नहीं करेंगी (क्योंकि दूसरा अंक हमेशा 0 होगा)।

संपादित करें

~~~:@\?:$,{$+}%{@base(;@,\-,0=},,~~

`~:@\?:$,{$+@base(;@,\-,0=},,`

बेहतर समाधान अभी तक! वेतन वृद्धि की कोई आवश्यकता नहीं है, बस सभी संख्याओं को जोड़ दें ताकि वे [1] से शुरू हों, और कोई अंक गायब नहीं होगा (0 के बाएँ-गद्दी सहित) जब आप उस पहले अंक को हटा देंगे। यह समाधान काम करना चाहिए और ऊपर समान प्रविष्टियों के साथ परीक्षण किया गया है। यह बहुत तेज़ है क्योंकि हम सरणी उत्पन्न करने के लिए घातांक लेने से पहले वेतन वृद्धि नहीं कर रहे हैं (लेकिन अभी भी बड़े इनपुट के लिए समान प्रदर्शन / मेमोरी समस्या से ग्रस्त हैं)।

संपादित करें : अतिरिक्त चरण के बजाय फ़िल्टर gnibblerके $अंदर ले जाने के विचार का उपयोग करें । (3 वर्ण सहेजें)।

— mellamokb
स्रोत

इनपुट पर टूट जाता है 0 0।

— पीटर टेलर

इनपुट की केवल एक पंक्ति को संभालना भी प्रतीत होता है।

— पीटर टेलर

और n 1किसी भी एन के लिए टूट जाता है , इसे लटका देता है। हम्म ..

— mellamokb

1

बेस 1 में संख्याओं को परिवर्तित करना :) :)

— gnibbler

@gnibbler: क्या आपके पास कोई सुझाव है? क्या मुझे उन मामलों को पकड़ने के लिए शुरुआत में बयान देने की जरूरत है? लगता है कि मैं इस तरह से बहुत सारे मैदान खो दूंगा।

— मेलमोकब

0

05AB1E , 19 बाइट्स

#D`ULX.Œʒ€gßĀ}gs_P+

नोट: यह बेहद धीमा है, और पहले से ही समय के लिए बाहर 12 4। हालांकि, यह इरादा के अनुसार काम कर रहा है। देखेंगे कि क्या मैं एक वैकल्पिक विधि के साथ आ सकता हूं जो उचित समय में सभी परीक्षण मामलों के लिए काम करता है। बहुत तेज़ संस्करण के लिए नीचे देखें जो सभी परीक्षण मामलों को एक सेकंड से भी कम समय में चलाता है।

इसे ऑनलाइन आज़माएं या कुछ और (छोटे) परीक्षण मामलों की पुष्टि करें ।

स्पष्टीकरण:

#               # Split the (implicit) input-string by spaces
 D              # Duplicate it
  `             # Push both values to the stack
   U            # Pop and store the second value in variable `X`
    L           # Create a list in the range [1,n] for the first value
     X.Œ        # Create a list of all possible ways to divide this list into `X` partitions
                # (including empty sublists, so we'll have to filter them out:)
        ʒ       # Filter this list of lists of partition-lists by:
         €g     #  Get the length of each partition-list
           ß    #  Get the minimum length
            Ā   #  Truthify; 0 remains 0 (falsey); anything else becomes 1 (truthy)
             }g # After the filter, take the length to get the amount left
 s              # Swap so the duplicated input-list is at the top of the stack again
  _             # Check for each value if they're equal to 0 (1 if truthy; 0 if falsey)
   P            # Take the product of the two to check if both input-values are 0
    +           # And add it to the earlier calculated product (edge case for [0,0] = 1)
                # (After which the result is output implicitly)

05AB1E , 29 बाइट्स

यहां बहुत तेज संस्करण है जो TIO पर लगभग 0.5 सेकंड में सभी परीक्षण मामलों के लिए काम करता है:

Î#R`V©LRvyYmX*NÈ·<*+Xy*®y->÷U

पोर्ट @mellamokb का जावास्क्रिप्ट जवाब है , इसलिए उसे उभारना सुनिश्चित करें!

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

Î                    # Push (result=) 0 and the input
 #                   # Split the input by spaces
  R`                 # Push the values to the stack reversed
    V                # Pop and store the first value in variable `Y`
     ©               # Store the second value in variable `®` (without popping)
      LRv            # Loop `y` in the range [`®`,1], with index `N` in the range [0,`®`):
         yYm         #  Calculate `y` to the power `Y`
            X*       #  Multiply it by `X`
                     #  (Note: `X` is 1 before setting it to another value initially)
              NÈ     #  Check if index `N` is even (1 if truthy; 0 if falsey)
                ·<   #  Double it; and decrease it by 1 (1 if truthy; -1 if falseY0
                  *  #  Multiply it to the earlier number
                   + #  And add it to the result
         Xy*         #  Push `X` multiplied by `y`
         ®y->        #  Push `®` - `y` + 1
             ÷       #  Integer divide them
              U      #  Pop and store it as new variable `X`
                     # (output the result at the top of the stack implicitly after the loop)

नोट: 0 0इस मामले में किनारे मामले के लिए काम करता है (जावास्क्रिप्ट जवाब के विपरीत मैंने इस विधि को पोर्ट किया है), क्योंकि Lबिलिन एक सूची बनाएगा [0,1]।

— केविन क्रूज़सेन
स्रोत

कोड गोल्फ: गेंदों का वितरण (I)

चुनौती

जावास्क्रिप्ट (90 93 )

गोल्फस्क्रिप्ट - 56 50 49 48 41 40 38 37 वर्ण

जे, ४०

संपादित करता

आम लिस्प (83)

जे, 38 से 42

GolfScript - 45 38 36 अक्षर

मध्यम-बल गंदे कार्यान्वयन पुनरावृत्ति संबंध ( 38 36 वर्ण):

प्रकाश बल श्रृंखला समाधान (45 वर्ण):

जे, 55 वर्ण

गोल्फस्क्रिप्ट - 26 वर्ण

डीसी, 100 वर्ण

गोल्फस्क्रिप्ट (28 31 37 )

05AB1E , 19 बाइट्स

05AB1E , 29 बाइट्स