कोड की डली

यह ^{^{^{एक काल्पनिक स्थिति है जहां यह है}}} शुक्रवार शाम है, और आपने अपने पसंदीदा शौक: कोड गोल्फिंग में भाग लेने के लिए सामान्य गोल्फिंग मित्रों को आमंत्रित किया है। हालाँकि, जैसा कि यह एक मस्तिष्क-जल निकासी कार्य है, आपको समूह के लिए कुछ मस्तिष्क भोजन लेने की आवश्यकता है ताकि आप अपने कोड से जितना संभव हो उतना गोल्फ कर सकें।

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

चिकन नगेट पैक का आकार सभी जगह होता है, और आप दुनिया में कहां रहते हैं, इसके आधार पर, मानक आकार भी बदलते हैं। हालाँकि, निकटतम [वह जगह जो सोने की डली परोसती है] स्टॉक के निम्न आकार के नगेट्स पैक:

4, 6, 9, 10, 20, 40

अब आप देख सकते हैं कि आप कुछ विशेष नगेट्स के संयोजन का आदेश नहीं दे सकते। उदाहरण के लिए, 11डली संभव नहीं है, क्योंकि कोई संयोजन नहीं है जो 11बिल्कुल समान है। हालाँकि, आप 431 पैक 20, 1 पैक 10, 1 पैक 9और 1 पैक प्राप्त करके बना सकते हैं 4,

20 + 10 + 9 + 4 = 43 (597)

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

काम

आपको एक प्रोग्राम या फ़ंक्शन बनाना चाहिए जो प्रत्येक व्यक्ति की आवश्यकताओं के अनुरूप पूर्णांक की एक सूची लेता है। आपको चिकन नगेट्स खरीदने के लिए सबसे अधिक लागत प्रभावी ^α ऑर्डर की गणना और प्रिंट करना चाहिए । सबसे अधिक लागत प्रभावी ^α आदेश संयोजन है जिसके द्वारा प्रत्येक मात्रा के वर्गों का योग सबसे अधिक है। यदि पूरी तरह से सोने की डली खरीदने का कोई तरीका नहीं है, तो आपको एक नकली मूल्य प्रिंट करना होगा जैसे ,0FalseImpossible! अपनी भाषा में, या , ।

उदाहरण I / O:

[2 7 12 4 15 3] => [20 10 9 4]
     1, 1, 2, 1 => False
  6 5 5 5 5 5 9 => 40
      [6, 4, 9] => 9 10
              1 => 0
            199 => 40, 40, 40, 40, 20, 10, 9
              2 => Impossible!

यहां पहले 400 के लिए आदर्श समाधानों की सूची दी गई है। ध्यान दें कि ये प्रारूपित नहीं हैं कि मैं आपसे कैसे उम्मीद करूंगा कि प्रत्येकtuple फॉर्म में है (N lots of M)।

नियम

कोई मानक खामियां नहीं हैं।
अंतर्निहित कार्यों का कोई उपयोग नहीं जो सभी या अधिकांश कार्य करते हैं, जैसे कि FrobeniusSolveगणितज्ञ।

^{α - एक उदाहरण के साथ इसे स्पष्ट करने के लिए, आप 43 बनाकर भी कर सकते हैं 4 + 6 + 6 + 9 + 9 + 9 = 43 (319), लेकिन यह इष्टतम नहीं होगा, और इस तरह एक गलत आउटपुट, क्योंकि वर्गों का योग उस संयोजन से कम है जो मैंने परिचय में नोट किया था। अनिवार्य रूप से, वर्गों का उच्च योग = कम लागत = सबसे अधिक लागत कुशल।}

code-golf

— Kade
स्रोत

क्या कोई समय / स्मृति सीमाएं हैं?

— डेनिस

@ डेनिस कोई समय या स्मृति सीमा नहीं हैं।

— काडे

4

यह वास्तव में गुरुवार है।

— mbomb007

4

@ mbomb007 सूक्ष्म अवलोकन: P मैंने परिचय को समायोजित किया है।

— केड

2

मैं किसी भी तरह चिकन mcnugget प्रमेय का उपयोग करने की जरूरत है ...

— खिंचाव पागल

7

पायथ, 26 25 बाइट्स

e+Zo.aNf!-TCM"  
("./sQ

ध्यान दें कि कुछ अनपेक्षित वर्ण हैं। इसे ऑनलाइन आज़माएँ: प्रदर्शन । यह काफी धीमा है (लेकिन मेरे 26 बाइट समाधान के रूप में धीमा नहीं है)।

स्पष्टीकरण:

                          implicit: Q = input list
                     sQ   sum(Q)
                   ./     generate all integer partitions
       f                  filter for partitions T, which satisfy:
             "   ("          string containing chars with the ASCII-values of 4,6,9,10,20,40
           CM                convert each char to the ASCII-value
         -T                  remove this numbers from T
        !                    and check, if the resulting list is empty
    o                      order the remaining subsets N by:
     .aN                      the vector length of N (sqrt of sum of squares)
  +Z                       insert 0 at the beginning
 e                         print the last element

पायथ, 32 बाइट्स

e+Zo.aNfqsTsQysm*]d/sQdCM"  
(

ध्यान दें कि कुछ अनपेक्षित वर्ण हैं। इसे ऑनलाइन आज़माएँ: प्रदर्शन इस संस्करण का तेज़ तरीका है। यह [6,7,8]लगभग एक सेकंड में इनपुट के लिए समाधान और [30]लगभग 90 सेकंड में इनपुट के लिए समाधान ढूंढता है ।

स्पष्टीकरण:

                                 implicit: Q = input list
                          "...(  the string containing chars with the ASCII-values of 4,6,9,10,20,40
                        CM       convert each char to the ASCII-value
                m                map each number d to:
                  ]d                create the list [d]
                 *  /sQd            and repeat it sum(Q)/d times
               s                 unfold
              y                  generate all subsets
        f                        filter for subsets T, which satisfy:
         qsTsQ                      sum(Q) == sum(T)
    o                            order the remaining subsets N by:
     .aN                            the vector length of N (sqrt of sum of squares)
  +Z                             insert 0 at the beginning
 e                               print the last element

— Jakube
स्रोत

यह वर्ग के योग के वर्गफल के बजाय केवल योग क्यों है?

— mbomb007

1

@ mbomb007 क्योंकि इससे कोई फर्क नहीं पड़ता। यदि a> b, sqrt (a)> sqrt (b) और इसके विपरीत है। और .aविधि का उपयोग करना चुकता और योग से कम है s^R2।

— जकुबे

5

पर्ल, 175 153

sub f{my$n=$_[0];if(!$n){return 1;}foreach$o(40,20,9,10,6,4){if($n>=$o&&f($n-$o)){print"$o ";return 1;}}return 0;}$n+=$_ for@ARGV;if(!f($n)){print":(";}

यह कार्यक्रम तर्क से इनपुट लेता है। प्रिंट a :( अगर यह एक सही समाधान नहीं मिल सकता है।

असिंचित कोड:

sub f
{
    my $n = $_[0];
    if(!$n)
    {
        return 1;
    }
    foreach $o(40,20,9,10,6,4)
    {
        if($n>=$o&&f($n-$o))
        {
            print "$o ";
            return 1;
        }
    }
    return 0;
}

$n += $_ for @ARGV;
if(!f($n))
{
    print ":(";
}

पुनश्च: यह संभवतः पहली प्रविष्टि है जिसमें 10 मिनट का समय नहीं लगता 1 2;)

यहां इसकी जांच कीजिए।

— थॉमस ओल्टमन
स्रोत

जो अब तक का सबसे तेज़ कार्यक्रम प्रतीत होता है, उसके लिए बधाई! यह मेरे संदर्भ कार्यक्रम से भी तेज हो सकता है: पी मैंने आपके पोस्ट के नीचे एक ideone लिंक जोड़ा है ताकि लोग आउटपुट देख सकें।

— केड

आपका कोड गलत आउटपुट उत्पन्न कर सकता है। इनपुट 18प्रिंट होना चाहिए 9 9, नहीं 4 4 10।

— डेनिस

अन्य गलत आउटपुट भी हैं। अगर मैं गलत नहीं हूं, तो आप उन सभी को ठीक कर सकते हैं, 9और के आदेश को स्वैप करके 10।

— डेनिस

@ डेनिस धन्यवाद, इसे ठीक किया!

— थॉमस ओल्टमन

3

CJam, 45 29 28 बाइट्स

q~:+_[40K9A6Z)U]m*_::+@#=0-p

ध्यान दें कि यह दृष्टिकोण बहुत धीमा और स्मृति-गहन है।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह 5 बाइट्स की कीमत पर काफी खर्च किया जा सकता है:

q~:+_40/4+[40K9A6Z)U]m*_::+@#=0-p

जटिलता अभी भी इनपुट के योग में घातांक है, लेकिन यह ऑनलाइन इंटरप्रेटर के साथ 159 तक और कुछ सेकंड में जावा दुभाषिया के साथ 199 तक परीक्षण मामलों को संभालना चाहिए।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

विचार

एक इष्टतम खरीद (चौकों की अधिकतम राशि) एक वैध खरीद (सोने की डली की सही संख्या) है, जो संभव के रूप में 40 के रूप में है, तो कई के रूप में संभव के रूप में 20 है, तो कई 9 के रूप में संभव है (जैसे, 9 9है) बेहतर 10 4 4) और आगे 10 'एस, 6 ' एस और 4 'एस के लिए आगे।

इस दृष्टिकोण में, हम सरणी [40 20 9 10 6 4 4 0] की एन प्रतियों के कार्टेशियन उत्पाद को उत्पन्न करते हैं , जहां एन वांछित संख्या में सोने की डली है। N एक खराब (खराब) है जिसकी खरीद के लिए हमें बाध्य होना पड़ता है। कोड के स्पेड अप संस्करण में, हम इसके बजाय N / 40 + 4 का उपयोग करते हैं।

सरणी का आदेश देने के कारण, कार्टेशियन उत्पाद वेक्टर [40 ... 40] के साथ शुरू होगा और वेक्टर के साथ समाप्त होगा [...] [...] । हम पहले वेक्टर के सूचकांक की गणना करते हैं जिसमें सही राशि है (जिसमें वर्गों का इष्टतम योग भी होगा), संबंधित सरणी तत्व को पुनः प्राप्त करें, प्लेसहोल्डर्स के रूप में सेवा करने वाले शून्य को हटा दें और परिणाम प्रिंट करें।

यदि कोई वेक्टर नहीं मिला, तो इंडेक्स -1 होगा , इसलिए हम पुनः प्राप्त करते हैं [0 ... 0] , जो इसके बजाय एक खाली सरणी प्रिंट करेगा।

कोड

q~                            e# Read from STDIN and evaluate the input.
  :+                          e# Push N, the sum of all elements of the resulting array.
     [40K9A6Z)U]              e# Push B := [40 20 9 10 6 4 0].
    _           m*            e# Push B**N, the array of all vectors of dimension N
                              e# and coordinates in B.
                  _::+        e# Copy and replace each vector by its sum.
                      @#      e# Get the first index of N.
                        =     e# Retrieve the corresponding element.
                         0-p  e# Remove 0's and print.

— डेनिस
स्रोत

यह उन कुछ स्थितियों में से एक हो सकता है जहां हाथ से समाधान निकालने से कोड खत्म होने से अधिक तेजी से काम होगा .. अच्छा काम चाहे जो भी हो :)

— Kade

2

जूलिया, 126 बाइट्स

r->(t=filter(i->all(j->j∈[4,6,9,10,20,40],i),partitions(sum(r)));show(!isempty(t)&&collect(t)[indmax(map(k->sum(k.^2),t))]))

यह एक अनाम फ़ंक्शन बनाता है जो किसी सरणी को इनपुट के रूप में स्वीकार करता है और किसी सरणी या बूलियन को STDOUT में प्रिंट करता है, जो इस बात पर निर्भर करता है कि कोई समाधान मौजूद है या नहीं। इसे कॉल करने के लिए, इसे एक नाम दें, उदा f=n->...।

असंगठित + स्पष्टीकरण:

function f(r)
    # Nugget pack sizes
    packs = [4, 6, 9, 10, 20, 40]

    # Filter the set of arrays which sum to the required number of nuggets
    # to those for which each element is a nugget pack
    t = filter(i -> all(j -> j ∈ packs, i), partitions(sum(r)))

    # Print the boolean false if t is empty, otherwise print the array of
    # necessary nugget packs for which the sum of squares is maximal
    show(!isempty(t) && collect(t)[indmax(map(k -> sum(k.^2), t))])
end

उदाहरण:

julia> f([1])
false

julia> f([2,7,12,4,15,3])
[20,10,9,4]

— एलेक्स ए।
स्रोत

1

पायथन 3 - 265 वर्ण

import itertools as i
n=list(map(int,input().split(',')));m=[]
for f in range(1,9):
 for j in range(6*f):
  for x in i.combinations((4,6,9,10,20,40,)*f,j+1):
   if sum(n)==sum(x):m.append(x)
if m!=[]:v=[sum(l**2for l in q)for q in m];print(m[v.index(max(v))])
else:print(0)

रिक्ति दिखा रहा है:

import itertools as i
n=list(map(int,input().split(',')));m=[]
for f in range(1,5):
 for j in range(6*f):
\tfor x in i.combinations((4,6,9,10,20,40,)*f,j+1):
\t if sum(n)==sum(x):m.append(x)
\t\tif m!=[]:v=[sum(l**2for l in q)for q in m];print(m[v.index(max(v))])
else:print(0)

सभी परीक्षण मामलों को पारित करता है

नोट: मुझे नहीं पता कि यह सभी मामलों को पारित करेगा क्योंकि यह बहुत धीमा है ... लेकिन यह होना चाहिए ...

— बीटा डिके
स्रोत

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

— काडे

@ Vioz- शानदार! : डी

— बीटा डिके

ऐसा लगता है कि मैं गलत हो सकता हूं, 36 के परीक्षण के बाद यह लगभग 40 मिलियन संयोजनों (40,007,602 सटीक होने के लिए) एक मेमोरीएयर में चलने से पहले हो जाता है। यह मेरी कार्य मशीन की एक सीमा हो सकती है, हालांकि इसमें केवल 4GB मेमोरी है।

— केड

@ Vioz- Hm ... वैसे यह मेरे लिए अपने फोन पर परीक्षण करने के लिए निराशाजनक है ...

— Beta Decay

1

@undergroundmonorail यदि आप इसे केवल एक बार उपयोग कर रहे हैं, तो <= 4 चार्ट के लिए एक सीधा आयात बेहतर है (5 ब्रेक भी)। लेकिन अगर आप इसे एक से अधिक बार उपयोग कर रहे हैं तो from blah import*हमेशा सबसे अच्छा है। एकमात्र अपवाद मैं उपरोक्त के बारे में सोच सकता हूं, हालांकि यदि आपके पास कई importएस हैं, जो कि एकमात्र समय है जो दिमाग में आता है जहां asवास्तव में उपयोगी है।

— Sp3000

1

जावास्क्रिप्ट, 261 256 261

d="length";function g(a){for(z=y=0;y<a[d];z+=+a[y++]);return z}x=[40,20,10,9,6,4];l=prompt().split(",");o=g(l);p=[];for(i=0;i<x[d];i++)r=g(p),s=r+x[i],(s<o-3||s==o)&&p.push(x[i]),(i==x[d]-1||40<o-r)&&r+x[i]<o-3&&(i=-1,0==i||o-r<p[p[d]-1]&&p.pop());g(p)==o&&p||0

मुझे यकीन नहीं है कि यह ठीक है, यह काम करने लगता है लेकिन मैं निश्चित रूप से चीजों को याद कर रहा हूं।

हालांकि 123456यह धीमा प्रतीत नहीं होता है, लेकिन यह [40 x 3086, 10, 6]लगभग तुरंत परिणाम देता है।

स्पष्टीकरण:

सोने का डला आकार (पहले सबसे बड़ा)

यदि स्टैक का योग प्लस नगेट का आकार लक्ष्य से कम है - 3 -> इसे स्टैक पर धकेलें
यदि 40 से अधिक बचे हैं -> लूप काउंटर रीसेट करें
यदि अंतिम डंडे के आकार तक पहुंचने पर स्टैक का योग लक्ष्य से अधिक है -> अंतिम तत्व पॉप करें, लूप काउंटर रीसेट करें
यदि स्टैक का योग बढ़ता है, तो इसे वापस लौटाएं, अन्यथा 0 वापस करें

199 के लिए | 1 निर्मित स्टैक इस तरह दिखता है

i | stack
0   [40]
0   [40, 40]
0   [40, 40, 40]
0   [40, 40, 40, 40]
0   [40, 40, 40, 40]
1   [40, 40, 40, 40, 20]
2   [40, 40, 40, 40, 20, 10]
3   [40, 40, 40, 40, 20, 10, 9]
4   [40, 40, 40, 40, 20, 10, 9]
5   [40, 40, 40, 40, 20, 10, 9]
==> [40, 40, 40, 40, 20, 10, 9]

1 के लिए

i | stack
0   []
1   []
2   []
3   []
4   []
5   []
==> 0

— C5H8NNaO4
स्रोत

1

यदि लक्ष्य तक पहुँचा जा सकता है, तो आपका दृष्टिकोण जाँच नहीं करता है। 11प्रिंट [6]और 18प्रिंट [10, 4]।

— डेनिस

@ डेनिस अरे, यह इंगित करने के लिए धन्यवाद। कल देर रात हो गई। इसे 5 वर्णों के लिए निश्चित किया। 18 छपा [10,4]क्योंकि मुझे एक जोड़ी परेड याद आ रही थी। चेक वास्तव में गलत था, मैंने अभी चेक किया कि क्या परिणाम में कम से कम एक तत्व था, न कि अगर यह सही तरीके से बोता है। मुझे नहीं पता कि मैंने वहाँ क्या सोचा था

— C5H8NNO4