आप कितने तीन-फल पाई बना सकते हैं?

32

एक तीन-फल पाई तीन अलग-अलग फलों से बनती है । आपके द्वारा लिए गए 5 फलों की मात्रा से आप सबसे अधिक तीन फलों वाले पाई क्या बना सकते हैं?

उदाहरण के लिए, साथ 

1 apple
1 banana
4 mangoes 
2 nectarines
0 peaches

आप 2 पाई बना सकते हैं: 

apple, mango, nectarine
banana, mango, nectarine

इनपुट: पांच गैर-नकारात्मक पूर्णांक, या उनमें से एक सूची।

आउटपुट: तीन-फलों की अधिकतम संख्या जो आप उन फलों की मात्रा से बना सकते हैं। सबसे कम बाइट्स जीतता है।

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

1 1 4 2 0
2
2 2 2 2 2
3
0 6 0 6 0
0
12 5 3 2 1
5
1 14 14 3 2
6
0 0 1 0 50
0

लीडरबोर्ड:

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

code-golf 
— XNOR
स्रोत
मेरा मानना ​​है कि आपका उदाहरण दो अतिरिक्त विकल्पों को याद कर रहा है: सेब, केला, आम और सेब, केला, नेक्टराइन। इस प्रकार 1 1 4 2 0परीक्षण के मामले में उत्पादन का उत्पादन किया जाना चाहिए: 4.
— cobaltduck
@cobaltduck लेकिन यदि आप अपनी पहली पाई (Apple / Banana / Mango) में Apple और केला का उपयोग करते हैं, तो आपके पास अपने दूसरे पाई (Apple / Banana / Nectarine) में उपयोग करने के लिए Apple या केला नहीं है।
— AdmBorkBork
2
@ टिम्मी डी: आह, समझ गया। यह स्पष्ट नहीं था कि पाई एक साथ बनाई जा रही थी।
— cobaltduck
@cobaltduck मेरा मानना ​​है कि उन्हें एक साथ नहीं बनाया जाना है, लेकिन आप उन फलों को दोबारा इस्तेमाल करके धोखा नहीं खा सकते हैं जो आपने पहले इस्तेमाल किए थे।
— मिस्टर लिस्टर
@श्री। लिस्टर: शब्दार्थ। यह पर्याप्त है कि एक नियम था जो अस्पष्ट था (कम से कम एक पाठक के लिए) और तब से स्पष्ट किया गया है।
— cobaltduck 12

जवाबों:

34

पायथ, 19 18 14 बाइट्स

-1 बाइट @FryAmTheEggman द्वारा

14-बाइट प्रोग्राम @isaacg द्वारा

मैं दावा करता हूं कि आरोही सूची से बनने वाले पाई की संख्या इस प्रकार [x1,x2,x3,x4,x5]है:

floor(min((x1+x2+x3+x4+x5)/3,(x1+x2+x3+x4)/2,x1+x2+x3))

या कोड में:

JSQhS/Ls~PJ_S3

[TI-BASIC और APL कार्यक्रमों के लिए संशोधन इतिहास देखें]

शुद्धता का प्रमाण

चलो

s3 = x1+x2+x3
s4 = x1+x2+x3+x4
s5 = x1+x2+x3+x4+x5

हम यह दिखाना चाहते हैं कि फलों की संख्या की P(X)=floor(min(s5/3,s4/2,s3))सूची x1≤x2≤x3≤x4≤x5के लिए हमेशा pies की सबसे बड़ी संख्या 1 ~ 5 है।

सबसे पहले, हम बताते हैं कि सभी तीन संख्याएं ऊपरी सीमा हैं।

  • चूंकि s5कुल फल हैं, और प्रत्येक पाई में तीन फल हैं, ⌊s5/3⌋एक ऊपरी बाध्य है।

  • चूंकि ऐसे s4फल हैं जो फल 5 नहीं हैं , और प्रत्येक पाई में कम से कम दो गैर-5 फल आवश्यक हैं, ⌊s4/2⌋एक ऊपरी बाध्य है।

  • चूंकि ऐसे s3फल हैं जो न तो फल 4 हैं और न ही फल 5, और प्रत्येक पाई में कम से कम एक फल की आवश्यकता होती है, s3एक ऊपरी बाध्य है।

दूसरा, हम दिखाते हैं कि तीन सबसे बड़े बवासीर से फल लेने की विधि हमेशा बंधे को संतुष्ट करती है। हम इसे इंडक्शन द्वारा करते हैं।

आधार मामला: 0 पाई स्पष्ट रूप से किसी भी मान्य सूची से बनाई जा सकती है P(X)>=0।

आगमनात्मक कदम: किसी भी सूची को देखते हुए , Xजहां P(X) > 0हम एक पाई को पीछे छोड़ सकते हैं, एक सूची X'को पीछे छोड़ सकते हैं P(X') >= P(X)-1। हम सबसे बड़े तीन बवासीर से एक फल ले कर ऐसा करते हैं 3,4,5, फिर जरूरत पड़ने पर सहारा लेते हैं । धैर्य रखने के लिए अनुरोध; कुछ केसवर्क है।

  • यदि x2<x3, तो हमें फलों को हटाने के बाद सूची को क्रमबद्ध करने की आवश्यकता नहीं है। हमारे पास पहले से ही एक वैध है X'। हम जानते हैं कि P(X') = P(X)-1क्योंकि s5'3 कम है (क्योंकि टाइप 1 के तीन फल ~ 5 हटा दिए गए थे), s4'2 कम है, और s3'1 कम है। तो P(X')पी (एक्स) से बिल्कुल कम है।
  • यदि x3<x4, तो हम इसी तरह किया जाता है।

  • अब हम मामले को लेते हैं x2=x3=x4। हमें इस बार सूची को फिर से व्यवस्थित करना होगा।

    • यदि x5>x4, तो हम बवासीर 4 और 2 को स्विच करके सूची को फिर से व्यवस्थित करते हैं s5'और s4'अभी भी क्रमशः 3 और 2 की कमी है, लेकिन s3'=s3-2। यह कोई समस्या नहीं है, क्योंकि यदि x2=x3=x4, तब 2*x4<=s3-> 2*x4+s3 <= 2*s3-> (x4 + s4)/2 <= s3। हमारे पास दो उप-मामले हैं:

    • समानता, अर्थात (x4,x3,x2,x1)=(1,1,1,0), किस मामले में P(X)= 1और हम स्पष्ट रूप से बवासीर से पाई बना सकते हैं 5,4,3, या:

    • (s4+1)/2 <= s3जिस स्थिति में s4अतिरिक्त द्वारा घटने का 1मतलब पी (एक्स) में अतिरिक्त कमी नहीं है।

  • अब हम इस मामले से बचे हैं x1<x2=x3=x4=x5। अब 1 s3से भी कम हो जाएगा, इसलिए हमें (s5/3+1)होना चाहिए <=s4/2; वह है, 8x5+2x1+2<=9x5+3x1या x5+x1>=2। इससे छोटे सभी मामलों को मैन्युअल रूप से जांचा जा सकता है।

  • यदि प्रत्येक संख्या समान है, तो यह स्पष्ट है कि हम उस सीमा को प्राप्त कर सकते हैं ⌊s5/3⌋, जो हमेशा अन्य दो की तुलना में कम है - हम केवल क्रम में संख्याओं से गुजरते हैं।

अंत में हम कर रहे हैं। कृपया टिप्पणी करें कि क्या मुझे कुछ याद आ रहा है, और मैं एक अधिक सुंदर प्रमाण के लिए एक छोटा सा इनाम दूंगा।

— lirtosiast
स्रोत
मुझे लगता है कि आपका दावा @ fryamtheeggman के पुनरावृत्त समाधान से मेल खाता है।
— बजे
@Srr मैं यह साबित करने की कोशिश कर रहा हूं कि मेरी सीमा fryamtheeggman के तरीके का उपयोग करने योग्य है।
— lirtosiast
2
इसे 4 बाइट्स द्वारा एक लूप में बदलकर गोल्फ किया जा सकता है:JSQhS/Ls~PJ_S3
— isaacg
3
मेरा मानना ​​है कि मुझे प्रति पाई nऔर kसामग्री के लिए एक प्रमाण मिला है , लेकिन यह इस टिप्पणी बॉक्स के लिए बहुत लंबा है । कृपया ऐसी कोई भी त्रुटि बताएं जो आपको मिल सकती है, ताकि हम यह साबित कर सकें।
— मेगो :
7

सीजेएम, 34

q~L{J2be!\f{\.-_W#){j)7}|;}0+:e>}j

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

स्पष्टीकरण:

q~          read and evaluate the input array
L{…}j       calculate with memoized recursion and no initial values
             using the input array as the argument
  J2b       convert 19 to base 2 (J=19), obtaining [1 0 0 1 1]
  e!        get permutations without duplicates
             these are all the combinations of three 1's and two 0's
             which represent the choices of fruit for one pie
  \         swap with the argument array
  f{…}      for each combination and the argument
    \       swap to bring the combination to the top
    .-      subtract from the argument array, item by item
    _       duplicate the resulting array
    W#)     does it contain the value -1? (calculate (index of W=-1) + 1)
    {…}|    if not
      j     recursively solve the problem for this array
      )7    increment the result, then push a dummy value
    ;       pop the last value (array containing -1 or dummy value)
  0+        add a 0 in case the resulting array is empty
             (if we couldn't make any pie from the argument)
  :e>       get the maximum value (best number of pies)
— aditsu
स्रोत
पुनरावृत्ति लागत बाइट्स याद है? कोई रन-टाइम सीमा नहीं है।
— xnor
2
@xnor मुझे लगता है कि यह वास्तव में 1 बाइट यहां बचाता है :)
— aditsu 19
7

हास्केल, 62 बाइट्स

f x=maximum$0:[1+f y|y<-mapM(\a->a:[a-1|a>0])x,sum y==sum x-3]

यह एक फ़ंक्शन को परिभाषित करता है f जो फलों की सूची में लेता है xऔर अधिकतम संख्या में पाई लौटाता है।

व्याख्या

हम पुनरावर्ती रूप से पाई की संख्या की गणना करते हैं। भाग किसी भी सकारात्मक प्रविष्टियों को घटाकर mapM(\a->a:[a-1|a>0])xप्राप्त की xगई सभी सूचियों की सूची का मूल्यांकन करता है । यदि x = [0,1,2], इसका परिणाम होता है

[[0,1,2],[0,1,1],[0,0,2],[0,0,1]]

बाहरी के बीच का हिस्सा []एक सूची की समझ है: हम yउपरोक्त सूची में सभी के माध्यम से पुनरावृत्ति करते हैं और उन लोगों को फ़िल्टर करते हैं जिनकी राशि के बराबर नहीं है sum(x)-3, इसलिए हमें सभी सूचियां मिलती हैं जहां 3 अलग-अलग फलों को एक पाई में बनाया गया है। फिर हम fइन सूचियों पर पुनर्मूल्यांकन 1करते हैं, प्रत्येक को जोड़ते हैं, और उनमें से अधिकतम 0(और आधार मामला, अगर हम किसी भी तरह से पाई नहीं कर सकते हैं) लें।

— Zgarb
स्रोत
7

C #, 67

जब तक आप बाहर नहीं निकलते हैं, तब तक फल के साथ पुनरावृत्ति एक पाई करें।

int f(List<int>p){p.Sort();p[3]--;p[4]--;return p[2]-->0?1+f(p):0;}

यहां टेस्ट केस

— AXMIM
स्रोत
C # से परिचित नहीं है, लेकिन क्या आप शायद p[2]--उसी समय चेक कर सकते हैं p[2]>-1?
— xnor
अच्छा बिंदु, मैं एक सेकंड में उत्तर को अपडेट करूंगा।
— AXMIM
6

अजगर, २ ९

Wtt=QS-Q0=Q+tPPQtM>3.<Q1=hZ;Z

परीक्षण सूट

इनपुट सूची को सॉर्ट करता है और शून्य हटाता है। फिर, जब तक आपके पास 3 फल होते हैं, पहले और दो अंतिम तत्वों को घटाते हैं, और शेष तत्वों को सूची में जोड़ते हैं, इसे छाँटने से पहले और फिर से शून्य हटाते हैं। फिर 1 से एक काउंटर बढ़ाएँ।

यह वास्तव में इतनी जल्दी है जब तक कि केवल 5 फल हैं, यह फलों के बहुत बड़े डिब्बे के लिए हल कर सकता है, अर्थात 1000,1000,1000,1000,1000एक सेकंड के अंदर।

— FryAmTheEggman
स्रोत
क्या आप साबित कर सकते हैं कि यह सही है?
— aditsu
@aditsu मैंने इसे साबित नहीं किया है, लेकिन मैंने इसे आपके खिलाफ कई अतिरिक्त मूल्यों के लिए जाँच किया है। मैं वास्तव में इस तरह से कुछ के लिए एक सबूत नहीं लिखा है, लेकिन मैं कोशिश करूँगा। अभी के लिए, मैं कहूंगा कि यह समझ में आता है कि यह काम करना चाहिए क्योंकि आप हमेशा फलों के सबसे बड़े ढेर से लेते हैं, जब तक कि आप छोटे लोगों को समाप्त नहीं करते। जबकि लालची रणनीति स्पष्ट रूप से हमेशा स्वाभाविक रूप से सही नहीं होती है, मैं यह नहीं सोच सकता कि यह यहां क्यों काम नहीं करता है।
— FryAmTheEggman
@FryAmTheEggman क्या मैं सही समझता हूं कि आप दो सबसे आम फल और सबसे दुर्लभ फल लेते हैं?
— xnor
@xnor हाँ, यह सही है। क्या वह काम नहीं करता है?
— FryAmTheEggman
1
@TimmyD नहीं, मुझे नहीं लगता (मुझे लगता है), हालांकि इस कार्यक्षमता को हटाने के लिए किसी भी बाइट की लागत नहीं है (यह वास्तव में खर्च होता है)। मैंने कहा, मुझे उम्मीद है कि रेटो कोराडी का समाधान अधिकांश भाषाओं में कम है, और जाहिर है कि थॉमस अधिक संक्षिप्त है। मुझे लगता है कि आपके द्वारा पुन: छांटे जाने का कारण यह नहीं है कि इससे कोई फर्क नहीं पड़ता कि आपके द्वारा लिए गए 3 छोटे बवासीर में से कौन सा है।
— FryAmTheEggman
6

अजगर, सामान्य समाधान, 128 92 बाइट्स

@Xnor से -36 बाइट्स, आप असली mvp दा

g=lambda l,k:0if k>sum(l)else-(-1in l)or-~g(map(sum,zip(sorted(l),[0]*(len(l)-k)+[-1]*k)),k))

def g(a,k):b=[i for i in a if i];return 0if len(b)<k;c=sorted(b,reverse=True);return 1+g([c[i]-(k-1>i)for i in range(len(c))],k)

यह तब तक काम करता है जब तक मेरा प्रमाण सही है। यदि यह नहीं है, तो मुझे बताएं कि मैं इसे ठीक करने की कोशिश क्यों कर सकता हूं। अगर यह असुविधाजनक है, तो मुझे बताएं, और मैं कुछ कप कॉफी के बाद इस पर हमला करूंगा।

— मेगो
स्रोत
सब कुछ मुझे अब तंग लगता है।
— lirtosiast
@Mego इस पर काम करने के लिए धन्यवाद! क्या आप टीई एसई पोस्ट में प्रमाण शामिल कर सकते हैं? एक सामान्य चिंता यह है कि इस साल पढ़ने वाले किसी को मृत लिंक मिल सकता है। LaTeX फॉर्मेटिंग को केवल MathJax में काम करना चाहिए।
— xnor
@ मैं ओह, मैं भूल गया कि MathJax यहाँ सक्षम नहीं है। हम्म, मैं पूछता हूं कि क्या करना है।
— xnor
मैं इस सबूत के लिए इनाम दे रहा हूं। बधाई!
— xnor
@ मेगो नोप, मुझे लगता है कि आपका MathCloud लिंक हमारे पास सबसे अच्छा है।
— xnor
5

पायथन 2, 78 बाइट्स

इनपुट के रूप में 5 नंबर लेना: 91 89 88 बाइट्स

s=sorted([input()for x in[0]*5])
while s[2]:s[2]-=1;s[3]-=1;s[4]-=1;s.sort();x+=1
print x

संपादित करें : 1 बाइट बचाता s=sorted([input()for x in[0]*5])द्वारा बदल रहा है s=sorted(map(input,['']*5));x=0।

इनपुट के रूप में 5 नंबर लेता है और संभव pies की संख्या प्रिंट करता है जिसे बनाया जा सकता है। यह रीटो कोराडी के उत्तर के साथ-साथ बाइट काउंट में सुधार करने के लिए एक ही दृष्टिकोण लेता है- लेकिन ऐसा लगा कि यह प्रश्न पायथन में उत्तर याद कर रहा है।

धन्यवाद @ThomasKwa और @xsot आपके सुझाव के लिए।

यह काम किस प्रकार करता है

 s=sorted([input()for x in[0]*5]) takes 5 numbers as input, puts them in a list 
                                  and sorts it in ascending order. The result
                                  is then stored in s 

 while s[2]:                      While there are more than 3 types of fruit 
                                  we can still make pies. As the list is                     
                                  sorted this will not be true when s[2] is 0. 
                                  This takes advantage of 0 being equivalent to False.

 s[2]-=1;s[3]-=1;s[4]-=1          Decrement in one unit the types of fruit 
                                  that we have the most

 s.sort()                         Sort the resulting list

 x+=1                             Add one to the pie counter

 print x                          Print the result

ध्यान दें कि वेरिएबल xको कभी भी परिभाषित नहीं किया जाता है, लेकिन कार्यक्रम में कुछ लीकेज अजगर 2.7 के लिए है। सूची के sसाथ सूची को परिभाषित करते समय पुनरावृत्ति में अंतिम मान ( [0]*5इस मामले में) को पुनरावृति में प्रयुक्त चर में संग्रहीत किया जाता है।

चीजों को स्पष्ट करने के लिए: 

>>>[x for x in range(10)]
>>>x
9

इनपुट के रूप में एक सूची लेना: 78 बाइट्स

एक सूची में इनपुट बदलने का सुझाव देने के लिए @xnor @xsot और @ThomasKwa को धन्यवाद।

s=sorted(input());x=0
while s[2]:s[2]-=1;s[3]-=1;s[4]-=1;s.sort();x+=1
print x

यह काम किस प्रकार करता है

यह उपरोक्त कोड के समान कार्य करता है, लेकिन इस मामले में इनपुट पहले से ही एक सूची है, इसलिए इसे बनाने की कोई आवश्यकता नहीं है और चर xको परिभाषित करना होगा।

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

— Ioannes
स्रोत
1
आपको सूची में पहले से ही इनपुट की अनुमति है; s[2]>0-> s[2], क्योंकि ढेर में संख्या हमेशा nonnegative है।
— lirtosiast
थॉमस क्वा ने बताया कि आप मान सकते हैं कि इनपुट पहले से ही एक सूची के रूप में दिया गया है, इसलिए आप ऐसा कर सकते हैं s=sorted(input())। इसके अलावा, आपकी वर्तमान बाइट गिनती 89 है; newlines एक चार के रूप में गिना जाता है।
— xnor
@ThomasKwa ने पहले ही बताया कि आप इनपुट को एक सूची के रूप में स्वीकार कर सकते हैं, लेकिन यदि आप मल्टी-लाइन इनपुट को स्वीकार करने पर जोर देते हैं, तो बाइट को बचाने के लिए पहली पंक्ति को निम्नलिखित के साथ बदलें s=sorted(map(input,['']*5));x=0:।
— xsot
4

सीजेएम, 23 बाइट्स

0l~{\)\$2/~+:(+_2=)}g;(

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

यह प्रत्येक पुनरावृत्ति में 3 सबसे बड़े बवासीर से फल लेता है, और पुनरावृत्तियों की संख्या गिनता है।

मेरे पास गणितीय प्रमाण नहीं है कि यह हमेशा सही परिणाम देता है। यह दिए गए परीक्षण उदाहरणों के लिए करता है, और मुझे विश्वास होगा कि यह सभी मामलों के लिए काम करता है जब तक कि कोई मुझे एक काउंटर उदाहरण नहीं देता है।

सहज स्पष्टीकरण मैं खुद को समझाने के लिए इस्तेमाल किया: pies की संख्या को अधिकतम करने के लिए, आप के रूप में आप कर सकते हैं के रूप में कई बवासीर गैर-खाली रखने की जरूरत है। ऐसा इसलिए है क्योंकि आप 3 या अधिक खाली बवासीर होते ही अधिक पाई बनाने की क्षमता खो देते हैं।

यह हमेशा सबसे बड़े बवासीर से फल लेने के द्वारा प्राप्त किया जाता है। मैं ऐसे मामले के बारे में नहीं सोच सकता जहाँ छोटे ढेर से फल लेना एक बड़े ढेर से फल लेने की तुलना में बेहतर स्थिति में ले जाए।

मेरे सिर में कुछ और औपचारिक तर्क हैं। मैं इसे शब्दों / सूत्र में रखने का तरीका सोचने की कोशिश करूँगा।

— रेटो कोराडी
स्रोत
मैं इंडक्शन का उपयोग करने की कोशिश कर रहा हूं; शायद हम औपचारिक प्रमाण खोजने के लिए अपने विचारों को जोड़ सकते हैं।
— lirtosiast
@ThomasKwa मैं कुछ भी स्पष्ट नहीं कर पाया हूं, अगर मैं इसे लिखूं तो मुझे यकीन होगा। यह सब इस तथ्य पर उतरता है कि मैं बिल्कुल कोई कारण नहीं देखता कि छोटे स्टैक से बड़े स्टैक पर ले जाना बेहतर क्यों होगा। जबकि स्पष्ट रूप से ऐसी स्थितियां हैं, जहां छोटे स्टैक से लेना बदतर होगा। मैंने खदान और एडित्सू के समाधानों में कुछ यादृच्छिक रूप से बड़ी संख्या में प्रवेश किया, और उन्होंने उसी परिणाम का उत्पादन किया। मेरे द्वारा किए गए उदाहरणों के लिए मेरा सूत्र भी आपके सूत्र के अनुरूप है।
— रेटो कोराडी
3

> <>, 76 बाइट्स

0&4\/~}&?!/
@:@<\!?:}$-1@@$!?&+&:)@:@
,:&:@(?$n;/++:&+::2%-2,:&:@(?$&~+:3%-3

> <> में छँटाई करना आसान नहीं है! यह कार्यक्रम थॉमस केवा द्वारा सच साबित होने के लिए लगाए गए प्रमाण पर निर्भर करता है, जो निश्चित रूप से परीक्षण मामलों के मामले में दिखता है।

कार्यक्रम के प्रारंभ में स्टैक पर 5 इनपुट नंबर मौजूद होने की उम्मीद है।

पहली दो पंक्तियाँ स्टैक पर संख्याओं को क्रमबद्ध करती हैं, और तीसरा गणना floor(min((x1+x2+x3+x4+x5)/3,(x1+x2+x3+x4)/2,x1+x2+x3))थॉमस के उत्तर से ली गई गणना करती है ।

— सोक
स्रोत
क्या यह छोटा होगा यदि आप तीन / चार तत्वों के सभी योगों की गणना करते हैं, और उन की न्यूनतम?
— lirtosiast
@ThomasKwa मुझे लगता है कि इनपुट सेट के क्रमपरिवर्तन को खोजने के लिए, प्रत्येक के सबसे ऊपरी 3 और 4 तत्वों को सम्‍मिलित करना और उनमें से सबसे छोटा लेना होगा? मुझे नहीं लगता कि क्रमबद्धता / गणना के दृष्टिकोण की तुलना में मेरे द्वारा उपयोग किए जा रहे क्रमपरिवर्तन को ढूंढना संभव नहीं है, विशेष रूप से स्टैक-आधारित भाषा में। यदि स्टैक-आधारित भाषा में क्रमपरिवर्तन करने के लिए किसी भी उपयोगी एल्गोरिदम का पता हो तो मैं देखना चाहूंगा: o)
— सोक
2

अजगर 2, 59 बाइट्स

h=lambda l,k=3:k*'_'and min(h(sorted(l)[:-1],k-1),sum(l)/k)

एक सामान्य विधि जो किसी के लिए काम करती है nऔर k। k=33 करने के लिए पाई डिफ़ॉल्ट प्रति फल देता है, लेकिन आप एक अलग मूल्य में पारित कर सकते हैं। पुनरावृत्ति इस तथ्य का उपयोग करता है कि पायथन 2 में संख्याओं की तुलना में तार बड़े हैं, जिससे खाली स्ट्रिंग अनंत के आधार मामले का प्रतिनिधित्व करती है।

यह विधि इस तथ्य का उपयोग करती है कि हमेशा सबसे आम फल लेना इष्टतम है, इसलिए हम फल के प्रत्येक संभावित रैंक को सीमित कारक मानते हैं। मैंने उस तथ्य को नीचे लिखा है।

मेगो के प्रमाण ने मुझे इस अधिक प्रत्यक्ष प्रमाण के बारे में सोचा जो बार-बार सबसे आम फल लेने के लिए इष्टतम है। यह kफल के pies के साथ कहा गया है ।

प्रमेय: बार-बार kसबसे आम फल लेने से पाईज़ की इष्टतम संख्या मिलती है।

प्रमाण: हम बताएंगे कि यदि Npies संभव है, तो सबसे आम-फल रणनीति कम से कम Npies का उत्पादन करती है । हम ऐसा करते हैं कि फलों को Nपीज़ के बीच स्विच करके , उन्हें इस रणनीति द्वारा उत्पादित लोगों से मेल खाने के लिए बनाते हैं, जबकि पीज़ को वैध रखते हैं।

आइए इसे बनाते हैं पहला पाई (इसे कॉल करें p) में सबसे आम फल होते हैं। यदि यह अभी तक नहीं है, तो इसमें एक फल होना चाहिए i, लेकिन अधिक सामान्य फल नहीं j। फिर, शेष पाई में फल की jतुलना में कड़ाई से अधिक फल होते हैं i, और इसलिए कुछ अन्य पाई में qहोना चाहिए, jलेकिन नहीं i। फिर, हम फल स्वैप कर सकते हैं iपाई से pफलों के साथ jपाई से qहै, जो रहता है Npies अलग फल हो रही है।

इस प्रक्रिया को तब तक दोहराएं जब तक pकि kसबसे आम फल न हों।

फिर, पाई को pएक तरफ सेट करें , और अगले पाई के लिए इस प्रक्रिया को दोहराएं ताकि यह सबसे आम शेष फल हो। ऐसा तब तक करते रहें जब तक कि पाई सबसे आम-फल स्टैपी द्वारा निर्मित अनुक्रम न हो।

— XNOR
स्रोत
1

पॉवरशेल, 92 बाइट्स

$a=($args|sort)-ne0;while($a.count-ge3){$a[0]--;$a[-1]--;$a[-2]--;$a=($a-ne0;$c++}($c,0)[!$c]

FryAmTheEggman के जवाब के रूप में एक ही लालची-आधारित एल्गोरिथ्म का उपयोग करता है ... पॉवरशेल में बस एक बहुत ही wordier ...।

$a=($args|sort)-ne0  # Take input arguments, sort them, remove any 0's
while($a.count-ge3){ # So long as we have 3 or more fruit piles
  $a[0]--            # Remove one from the first element...
  $a[-1]--           # ... the last element ...
  $a[-2]--           # ... and the second-to-last.
  $a=$a-ne0          # Remove any 0's from our piles
  $c++               # Increment how many pies we've made
}                    #
($c,0)[!$c]          # Equivalent to if($c){$c}else{0}
— AdmBorkBork
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.