सांता को अपने उपहार देने में कितना समय लगेगा?

12

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

जनसंख्या वृद्धि के कारण, सांता इस वर्ष समय के लिए थोड़ा अधिक दबाया गया है। यद्यपि अतीत में हमने बहुत ही अतुल्यकालिक रूप से काम किया है, हम अधिक से अधिक सिंक्रनाइज़ होने के साथ प्रयोग करने लगे हैं। इसलिए, सांता को यह जानने की जरूरत है कि दिए गए कल्पित बौने के साथ प्रत्येक क्षेत्र में प्रस्तुत करने में उसे कितना समय लगेगा।

कोयले का वजन पिछले दो वर्षों में नहीं बदला है - यह अभी भी प्रस्तुत की तुलना में भारी है, इसलिए सांता को घर में प्रति शरारती व्यक्ति को तीन बछड़ों की जरूरत है, और घर में प्रति अच्छे व्यक्ति को दो बछड़ों की जरूरत है।

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

कल्पित वस्तुएं देने वाले को चार सेकंड खर्च करने की आवश्यकता होती है * प्रत्येक प्रस्तुत करने वाले को खर्च करने की आवश्यकता होती है, और कल्पित कोयला देने वाले एल्विस को पांच सेकंड खर्च करने की आवश्यकता होती है * प्रत्येक को इसे वितरित करना (सांता एविएशन एडमिनिस्ट्रेशन के नियमों के अनुसार, उन पर कोयले की धूल के साथ दस्ताने तुरंत उखाड़ना चाहिए) बेपहियों की गाड़ी पर चढ़ना, जिसमें कुछ समय लगता है)। इसके अतिरिक्त, मकानों को उस क्रम में जाना चाहिए, जो वे नक्शे पर हैं, बाएं से दाएं, और कल्पित बौने दूसरे घरों में तब तक प्रस्तुत करना शुरू नहीं कर सकते हैं जब तक कि सभी उपहारों को उस घर में वितरित नहीं किया जाता है जब वे वर्तमान में हैं।

यदि हमने यह मान लिया कि सांता के पास इस क्षेत्र के लिए पर्याप्त से अधिक कल्पित बौने हैं, तो यह केवल उतना ही समय लगेगा जितना कि किसी को वर्तमान में शरारती सूची, 5 सेकंड, प्रति घर, या 4 सेकंड प्रति घर, यदि सभी को अच्छा लगे, तो देने में लगेगा।

फिर भी, पिछले सीज़न के विपरीत, इस आने वाले क्रिसमस सांता के पास प्रत्येक क्षेत्र के लिए पर्याप्त से अधिक कल्पित बौने नहीं हो सकते हैं, इसलिए 4 सेकंड समय की पूर्ण न्यूनतम राशि है * कि यह किसी भी दिए गए घर को प्रस्तुत करने में ले जाएगा, जब तक कि 0 न हों। अच्छे लोग और 0 शरारती लोग जिस मामले में 0 सेकंड का समय लेंगे।

इसके अतिरिक्त, अगर घरों में से किसी में भी शरारती सूची में कोई है, तो सांता को कम से कम तीन कल्पित बौनों की आवश्यकता होगी। यदि कम से कम घरों में से किसी में अच्छी सूची है और उनमें से कोई भी शरारती सूची में नहीं है, तो सांता को कम से कम दो बछड़ों की आवश्यकता होगी। यदि कोई भी घर क्रिसमस की भावना में नहीं है, तो किसी भी संख्या में कल्पित (0 सहित) 0 सेकंड लगते हैं।

सांता के नक्शे पर, एक घर का प्रतिनिधित्व किया जाता है *, और प्रत्येक घर को एक से विभाजित किया जाता है +। सांता अभी भी अन्य चुनौती के रूप में एक ही नक्शे का उपयोग करता है , लेकिन मैं यहाँ उनके बारे में प्रलेखन शामिल करूँगा।

घर के दोनों ओर एक नंबर होगा - एक बाईं ओर, जो घर में शरारती लोगों की संख्या का प्रतिनिधित्व करता है, और एक सही में घर में अच्छे लोगों की संख्या का प्रतिनिधित्व करता है। यदि एक तरफ कोई संख्या नहीं है, तो इसे 0 के रूप में व्याख्या की जाती है।

मुझे पता है कि यह पागल लग सकता है, लेकिन कुछ लोगों को "क्रिसमस पसंद नहीं है", इसलिए कभी-कभी, एक घर में इसके दोनों ओर एक नंबर नहीं हो सकता है।

सांता के नक्शे में से एक ऐसा कुछ दिख सकता है।

1*3+2*+*5+*+4*7

बता दें कि सांता की नींद में नौ बछड़े हैं।

  1. (0s) पहले घर में 1 शरारती और 3 अच्छे लोग हैं। कल्पित बौने में से तीन कोयला लेते हैं, पाँच सेकंड लेते हैं, और छह प्रस्तुत करते हैं, चार सेकंड लेते हैं। पाँच सेकंड के बाद, सांता की नींद अगले घर में चली गई

  2. (5s) दूसरे घर में 2 शरारती और 0 अच्छे लोग हैं। छह कल्पित बौने पाँच सेकंड लेते हुए कोयला पहुँचाते हैं। पाँच सेकंड के बाद, सांता की नींद अगले घर में चली गई

  3. (१०) तीसरे घर में ० शरारती और ५ अच्छे लोग हैं। कल्पित बौने में से चार प्रस्तुत करने के लिए जाते हैं (जो पीछे छोड़ दिया जाता है वह वर्तमान नहीं दे सकता है)। चार सेकंड के बाद, सभी कल्पित बौने वापस आ गए हैं, और उनमें से दो अन्य वर्तमान देने के लिए जाते हैं (स्लीव को अगले घर जाने से पहले वापस जाने के लिए कल्पित बौने का इंतजार करना चाहिए), एक और चार सेकंड ले

  4. (18) चौथा घर क्रिसमस की भावना में नहीं है, इसलिए 0 शरारती और 0 अच्छे लोग हैं, और छोड़ दिया जाता है

  5. (१ () पांचवें घर में ४ शरारती और fifth अच्छे लोग हैं। यह थोड़ा जटिल हो जाता है ...

    I. सभी नौ कल्पित बौने कोयले के तीन उपहार देने के लिए जाते हैं (t + 0s, वापसी t + 5s) II। 5 एस के बाद, वे सभी बेपहियों की गाड़ी पर वापस आ जाते हैं, और उनमें से तीन कोयले के अंतिम वर्तमान को देने के लिए जाते हैं (टी + 5 एस, रिटर्न टी + 10 एस) छोड़ते हैं, जबकि उनमें से अन्य छह तीन अच्छे उपहार देने के लिए जाते हैं (टी + छोड़ दें) 5s, वापसी t + 9s)।

    तृतीय। चार सेकंड के बाद, कल्पित बौने में से छह वापस आ जाते हैं और तीन और अच्छे उपहार देने के लिए जाते हैं (टी + 9 एस, रिटर्न टी + 13 एस)।

    चतुर्थ। उनके जाने के बाद एक सेकेंड बाद, जो तीन बछड़े कोयले की डिलीवरी कर रहे थे, वे वापस मिल गए, और उनमें से दो अंतिम अच्छा प्रेजेंट देने के लिए निकल गए (लीव + 10 s, रिटर्न t + 14s)

  6. (१ (+ १४ = ३२ सेकंड ) सैंटा उस क्षेत्र में उपहार वितरित कर रहा है।

जैसा कि हम देख सकते हैं, सांता को इस क्षेत्र में प्रस्तुत करने के लिए कुल 32 सेकंड लगते हैं। हालांकि, यह सांता के नक्शे में से एक का एक सरलीकृत संस्करण था। आम तौर पर, सांता के नक्शे में कई लाइनें होती हैं, और उनकी सूची में बेहतर फिट होने के लिए एक चौकोर आकार में होते हैं। एक सामान्य नक्शा कुछ इस तरह दिख सकता है ( \nप्रत्येक पंक्ति के अंत में)

1*2+*+*4+1*
2*4+3*+1*6+*
*+*+4*2+1*1
*4+*3+1*+2*3
3*10+2*+*5+*

साथ 26 कल्पित बौने (या किसी भी उच्च राशि), यह सांता ले जाएगा 71 सेकंड । 20 कल्पित बौने के
साथ , यह सांता 76 सेकंड ले जाएगा । 15 कल्पित बौने के साथ , यह सांता को 80 सेकंड का समय लगेगा । 3 कल्पित बौने के साथ , यह सांता 288 सेकंड लेगा । साथ 2 कल्पित बौने (या किसी भी कम राशि), यह होगा असंभव।


ओह, और एक और बात - जिस क्रम में कल्पित बौने प्रस्तुत करते हैं (शरारती / अच्छे लोगों को प्रस्तुत करने के समय के अंतर के कारण), इसलिए आपके कोड को हमेशा कम से कम मात्रा में आउटपुट देना चाहिए जो कल्पित उपहार प्रस्तुत कर सकता है।

चुनौती

सांता को यह निर्धारित करने में मदद करें कि प्रस्तुत करने के लिए कल्पित बौने की कितनी संख्या में समय लगेगा।

मकानों

  • एक घर एक द्वारा प्रतिनिधित्व किया है *
  • मकान बंट जाते हैं +
  • घर के बाईं ओर की संख्या शरारती लोगों की संख्या का प्रतीक है (संख्या का मतलब 0 नहीं है)
  • दाईं ओर संख्या अच्छे लोगों की संख्या का प्रतीक है (संख्या का मतलब 0 नहीं है)
  • \nइनपुट में न्यूलाइन्स ( ) हो सकते हैं , जिन्हें स्प्लिट के रूप में भी हैंडल किया जाना चाहिए

कल्पित बौने

  • सांता को शरारती लोगों के लिए तीन कल्पित बौनों से मदद की ज़रूरत है (कोयला प्रस्तुतिकरण की तुलना में बहुत भारी है), और प्रस्तुतियाँ देने के लिए इन कल्पित पंक्तियों को पांच सेकंड * लगेगा
  • सांता को अच्छे लोगों के लिए दो कल्पित बौनों से मदद की ज़रूरत होती है , और प्रस्तुतियाँ देने में इन कल्पितों को चार सेकंड * लगेंगे
  • यदि घर के दोनों ओर कोई संख्या नहीं है, तो सांता उस घर का दौरा नहीं करेगा, और उसके बाद इसमें कोई समय नहीं लगेगा (क्रिसमस की भावना में लोग कोयले के लायक भी नहीं हैं)

सांता

  • सांता को एक-एक करके घरों में पर्चे पहुँचाने होंगे
  • सांता अगले घर की ओर तब तक नहीं बढ़ सकता जब तक कि सभी बछड़े बेपहियों की गाड़ी पर वापस न आ जाएं और सभी के सारे सामान उस घर में पहुंचा दिए जाएं (हम अब तक के बछड़ों को पीछे नहीं छोड़ना चाहते, अब?)
  • सांता की नींद किसी भी समय घर से यात्रा पर नहीं जाती है (फिर, उन कारणों के लिए जो मैं साझा करने के लिए स्वतंत्रता में नहीं हूं)

क्या करें

घरों के नक्शे और बछड़ों की संख्या को देखते हुए, प्रिंट पर मकानों को प्रस्तुत करने में सांता को कितना समय लगेगा।

* (हो सकता है कि प्रस्‍तुतियों को वितरित करने में जितना समय लगता है, उतने समय के लिए मैं साझा नहीं कर सकता। मैं इस चुनौती में शामिल समय की न तो पुष्टि कर सकता हूं और न ही इससे इनकार कर सकता हूं)

नियम

  • दो इनपुट हैं - नक्शा और कल्पित बौने की संख्या। इनपुट्स को किसी फ़ंक्शन के लिए या STDIN या समकक्ष से तर्क के रूप में लिया जा सकता है । यदि आपकी भाषा में दो इनपुट लेना असंभव है, तो केवल और केवल तब आप दो इनपुट को एक इनपुट स्ट्रिंग के रूप में स्वीकार कर सकते हैं, कुछ वर्ण द्वारा सीमांकित सामान्य रूप से इनपुट में नहीं है ( +*\nया एक में से नहीं 0-9- इनपुट स्ट्रिंग अस्पष्ट नहीं हो सकती) उदा ,।
  • कल्पित बौने की संख्या हमेशा एक गैर-नकारात्मक पूर्णांक होगी (0 वैध है)
  • आउटपुट या तो फ़ंक्शन का रिटर्न मान हो सकता है, या STDOUT या समकक्ष के लिए मुद्रित किया जा सकता है । यदि सांता के लिए दिए गए क्षेत्र में कल्पित बौने की संख्या के साथ प्रस्तुत करना असंभव है, तो आपको एक सुसंगत नकारात्मक संख्या, या बिना किसी संख्या के एक सुसंगत संदेश का उत्पादन करना होगा।
  • STDERR पर मुद्रित सभी चीज़ों को अनदेखा कर दिया जाएगा, इसलिए आप परिणाम या त्रुटि संदेश को STDERR पर प्रिंट नहीं कर सकते
  • आपका कार्यक्रम किसी क्षेत्र के लिए कल्पित संख्या को देखते हुए दुर्घटनाग्रस्त नहीं हो सकता है
  • आउटपुट केवल कुल मात्रा में होना चाहिए यह सांता को दिए गए कल्पित अंक के साथ प्रस्तुत करने के लिए ले जाएगा।
  • आउटपुट हमेशा कम से कम मात्रा में होना चाहिए, जो कल्पित बौने को प्रस्तुत करने के लिए लेता है
  • इनपुट केवल नंबर, शामिल होंगे +, *और नई-पंक्तियों \n(जब तक आप जो इनपुट शामिल होंगे एक और चरित्र को निर्दिष्ट करता है, तो अपनी भाषा नहीं दो आदानों ले जा सकते हैं (देखो पहला नियम) )
  • मानक खामियां लागू होती हैं

परीक्षण के मामलों

"1*1", 5 elves => 5
"1*1", 3 elves => 9
"1*2", 7 elves => 5
"1*2", 5 elves => 10
"1*2", 3 elves => 13
"2*1", 8 elves => 5
"2*1", 5 elves => 9
"2*1", 3 elves => 14
"1*" , 3 elves => 5
"1*" , 2 elves => (error message)
"*1" , 2 elves => 4
"*1" , 0 elves => (error message)
"*"  , 0 elves => 0

"1*1+1*1",   5 elves => 10
"1*1+1*1",   3 elves => 18
"1*1+*+1*1", 3 elves => 18
"1*2+2*1",   8 elves => 10
"1*2+2*1",   7 elves => 14
"1*2+2*1",   6 elves => 18
"1*2+2*1",   3 elves => 27
"1*2+2*1",   2 elves => (error message)
"*+*+*+*",   2 elves => 0
"*+*+*+*",   0 elves => 0

"1*3+2*+*5+*+4*7", 9 elves => 32

(उम्मीद है कि मुझे यह सब सही लगा)

स्कोरिंग

सांता हर एक दिन हमेशा बहुत सी चीजों को देखता रहता है - सभी प्रस्तुत करने वाले, जो कि उसके पास हैं, सभी के पास वह सब घर है, जिसे वह प्रस्तुत कर रहा है ... सांता के लिए, सबसे अच्छा क्रिसमस वर्तमान होगा। कुछ का थोड़ा सा देखने में सक्षम। इस कारण से, बाइट्स में सबसे कम सबमिशन जीत जाता है ।

लीडरबोर्ड

यह एक स्टैक स्निपेट है जो एक लीडरबोर्ड और भाषा द्वारा विजेताओं के अवलोकन दोनों को उत्पन्न करता है।

अपने उत्तर को सुनिश्चित करने के लिए, कृपया निम्नलिखित मार्कडाउन टेम्पलेट का उपयोग करके अपने उत्तर को शीर्षक के साथ शुरू करें

## Language Name, N bytes

जहाँ N आकार में है, बाइट्स में, आपके सबमिशन का

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (उदाहरण के लिए, पुराने स्कोर के माध्यम से, या बाइट की गिनती में झंडे सहित), तो बस यह सुनिश्चित कर लें कि वास्तविक शीर्षक आपके हेडर में अंतिम संख्या है।

## Language Name, <s>K</s> X + 2 = N bytes

कोड स्निपेट दिखाएं

code-golf  string 
— Jojodmo
स्रोत
मुझे लगता है कि 288 को 281 पढ़ना चाहिए : (1+0+0+1+2+3+1+0+0+0+4+1+0+0+1+2+3+2+0+0)*5+(2+0+4+0+4+0+6+0+0+0+2+1+4+3+0+3+10+0+5+0)*4=21*5+44*4=105+176=281(हालांकि मुझे कहना चाहिए कि मैंने पूरा "निबंध" नहीं पढ़ा है!)
— जोनाथन एलन
@JonathanAllan Yea ... मैंने गलती से चुनौती लिखने में बहुत समय व्यतीत कर दिया ... उफ़ ... वैसे भी, जो महत्वपूर्ण बात याद आ रही है वह यह है कि सांता के बेपहियों की गाड़ी चलने से पहले वापस आने के लिए सभी को इंतजार करना होगा। अगले घर, इसलिए हालांकि सभी नंबरों को जोड़ना और उन्हें गुणा करना कुछ मामलों में काम कर सकता है, लेकिन यह अधिकांश में काम नहीं करता है। उदाहरण के लिए, 9 बछड़ों के साथ घर 4*7में 14 सेकंड लगते हैं (यह "निबंध" में लगभग आधे रास्ते को कवर किया जाता है, 2 डी मानचित्र पेश किए जाने से ठीक पहले) लेकिन (4 * 5) + (7 * 4) = 48
— जोजोड्मो
288 मूल्य 3 कल्पित बौने के साथ उदाहरण के लिए है, इसलिए उन्हें हमेशा naughty*5+nice*4प्रत्येक घर में पूरी तरह से अजीब प्रदर्शन करना होगा, है ना? (ध्यान दें कि 4*7उस उदाहरण में कोई नहीं है)
— जोनाथन एलन
क्या कल्पित बौने को हमेशा पहले (जैसे आपके उदाहरण में) कोयला निकलता है या वे कुशलता से शेड्यूल करते हैं? उदाहरण के लिए यदि नक्शा था 5*15और वहाँ 9कल्पित बौने थे तो यह न्यूनतम (न्यूनतम) 20 सेकंड या 22 सेकंड होगा? देखें इन शाब्दिक अभ्यावेदन कि उदाहरण का एक उदाहरण देखने के लिए।
— जोनाथन एलन
ऊपर 5*15पढ़ने के लिए EDIT चाहिए 4*15।
— जोनाथन एलन

जवाबों:

4

रूबी , 433 400 बाइट्स

खैर, यह एक वास्तव में कठिन है, क्योंकि यह योगिनी शेड्यूलिंग एनपी कठिन है।

इसके अलावा, कृपया अच्छा हो, यह मेरा पहला सबमिशन है, इसलिए मुझे कुछ स्पष्ट अनुकूलन याद हो सकते हैं:

->e,h{h.split(/\+|\n/).map{|h|n,g=h.split(?*).map(&:to_i)+[0,0];return-1if(g>0&&e<2)||(n>0&&e<3);([[3,5]]*n+[[2,4]]*g).permutation.map{|j|c=[0]*e;j.map{|q|w,y=q;k=l=0;r=c.map{|x|a=b=0;c[k..e].map{|r|r<=x ?a+=1:break};(t=k+=1).times{c[t-=1]<=x ?b+=1:break};[a,b]};d=r.inject([]){|v,x|v<<l if x[0]>=w;l+=1;v}.min{|a,b|c[a]<=>c[b]};b=d-r[d][1]+1;z=c[d]+y;(b..(b+w-1)).map{|x|c[x]=z}};c.max}.min||0}.sum}

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

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

— elyalvarado
स्रोत
2
PPCG में आपका स्वागत है! आपने निश्चित रूप से अपने पहले उत्तर के लिए एक कठिन चुनौती चुन ली
— जो किंग
2

जावा (ओपनजेडके 8) , 344 बाइट्स

एल्फ शेड्यूलिंग जितना मैंने सोचा था उससे अधिक कठिन है, इसलिए इसमें थोड़ा समय लगा, और यह बहुत लंबा है।

इसके बावजूद, यह निश्चित रूप से गोल्फ को कोड करने की मेरी पसंदीदा चुनौती रही है! 

(e,d)->{int r=0,x,y,c,p,b,g,m;for(String h:d[0].split("\\+")){d=h.split("\\*",-1);b=new Byte("0"+d[0]);g=new Byte("0"+d[1]);m=-1>>>1;for(y=1;y<=e/3&(x=(e-y*3)/2)>0;c=b/y+(b%y++<1?0:1),p=g/x+(g%x<1?0:1),x=c*5>p*4?c*5:p*4,m=x<m?x:m);for(y=0;b+g>0;b-=c,g-=p){c=e/3<b?e/3:b;x=(e-c*3)/2;p=x<g?x:g;if(c+p<1)return-1;y+=c>0?5:4;}r+=m<y?m:y;}return r;}

इसे ऑनलाइन (सभी परीक्षणों के साथ) आज़माएं!

स्पष्टीकरण;

अपने आप को संभालो: यह एक लंबा है

    int r=0,x,y,c,p,b,g,m;               // Define all the variables I need

    for(String h:d[0].split("\\+")){     // Split houses on '+' and loop through them

        d=h.split("\\*",-1);             // Split the current house on '*' using the limit
                                         // to preserve empty strings.

        b=new Byte("0"+d[0]);            // Parse the naughty (b) and nice (g) people
        g=new Byte("0"+d[1]);

        m=-1>>>1;                        // Initialise minimum time as max integer using
                                         // overflow

        for(y=1;y<=e/3&(x=(e-y*3)/2)>0;  // For each number of elves that can concurrently
                                         // deliver coal, and still leave enough elves to
                                         // deliver presents

            c=b/y+(b%y++<1?0:1),         // Determine the number of runs needed to deliver
                                         // all coal using this number of elves

            p=g/x+(g%x<1?0:1),           // Determine the number of runs needed to deliver
                                         // all presents using this number of elves

            x=c*5>p*4?c*5:p*4,           // Get the maximum time required for the
                                         // delivery of coal or presents

            m=x<m?x:m);                  // If this is less than the current minimum time,
                                         // set it as the minimum time


        for(y=0;b+g>0;b-=c,g-=p){        // While there are still people to deliver to;

            c=e/3<b?e/3:b;               // Determine the max amount of coal to deliver

            x=(e-c*3)/2;                 // Determine how many presents can be
                                         // delivered with the remaining elves.

            p=x<g?x:g;                   // If this number is more than nice people
                                         // remaining, just use the nice people remaining

            if(c+p<1)return-1;           // If no presents can be delivered, return the
                                         // error code (-1)

            y+=c>0?5:4;                  // Increase the time by 5 if coal was
                                         // delivered, and 4 if only presents

        }                                // At the end of each loop (see above)
                                         // remove the presents and coal delivered
                                         // from the number of naughty and nice houses

        r+=m<y?m:y;                      // Increment the total time by which ever
                                         // is smaller of the calculated times
    }
    return r;                            // Return the total time

एनबी: यह उत्तर परीक्षण मामलों के मेरे सुधारों पर सही होने पर निर्भर करता है

— ल्यूक स्टीवंस
स्रोत
मुझे लगता है (e-y*3)/2-> e-y*3>>1एक बाइट बचाता है। (सबसे अधिक संभावना यह भी लागू होती है (e-c*3)/2।)
— जोनाथन फ्रीच
runTest("1*4",5,12);विफल रहता है (आप प्राप्त करते हैं "1*4", 5 elves => 13 FAILED। मैं चकित था कि इतने सारे बाइट्स में शेड्यूल करने के लिए आपका एल्गोरिदम कितना अच्छा था, इसलिए मैंने इसे 0 से 7 (कल्पित, शरारती और अच्छा) के सभी संभावित संयोजनों के खिलाफ चलाया और कुछ ही पाया जहां यह विफल हो जाता है इष्टतम समय दें। यह सबसे छोटा संयोजन है जो विफल हो गया। BTW, शेड्यूल करने के लिए अद्भुत तर्क, लंबे समय तक मुझे नहीं पता था कि आपने यह कैसे किया है।
— elyalvarado
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.