मैक्सिमल स्कैटल आनंद

17

आपको स्किटल्स का एक बैग दिया गया है। हर कोई जानता है कि विभिन्न स्वादों की सबसे अधिक सराहना करने के लिए, आपको स्वादों के बीच घूमने की जरूरत है।

मूल बातें:

  1. आप एक समय में केवल 1 स्किलेट खा सकते हैं
  2. आपके स्किटल्स खाने का आदेश समय-समय पर होना चाहिए।
  3. प्रत्येक अवधि में एक से अधिक बार एक विशेष स्वाद नहीं हो सकता है।
  4. आपके बैग में केवल इतने सारे स्किटल हैं। आप अपने बैग में दिखाई देने वाले स्कर्टल के किसी विशेष स्वाद का अधिक सेवन नहीं कर सकते।
  5. आप जितने चाहें उतने स्कीटल्स खा सकते हैं (यह हमेशा संभव नहीं हो सकता है)

उदाहरण:

कहते हैं कि आप 3 लाल, 2 नीले, और 3 हरे रंग के साथ शुरू करते हैं:

R B G R B G R G       Invalid:  The last R must be followed by a B, not a G
R B G R B G R         Valid, but sub-optimal
R R R                 Valid, but sub-optimal
R G B R G B R G       Valid and optimal
G R B G R B G R       Also valid and optimal (there are multiple good solutions)

इनपुट आउटपुट

  • आपको रंग गणना के लिए धनात्मक पूर्णांक की एक गैर-रिक्त सूची दी गई है। (उपरोक्त उदाहरण होगा [3,2,3])।
  • आपको एक सूची वापस करने की आवश्यकता है जिसमें वैध और इष्टतम ऑर्डरिंग है।
  • रंगों का उपयोग करने के बजाय, आप इनपुट सूची से सूचकांकों का उपयोग करेंगे। (ऊपर अंतिम उदाहरण आउटपुट होगा [2,0,1,2,0,1,2,0])।
  • आपका आउटपुट 0-अनुक्रमित या 1-अनुक्रमित हो सकता है। मेरे उदाहरण 0-अनुक्रमित होंगे

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

1                          0
4                          0 0 0 0
4 1                        0 0 0 0
3 1                        0 1 0                   or  0 0 0
5 2 2                      0 1 2 0 1 2 0
2 3 5                      2 1 0 2 1 0 2 1         or  1 2 0 1 2 0 1 2
2 4 5                      2 1 2 1 2 1 2 1 2
3 4 5                      2 1 0 2 1 0 2 1 0 2 1   or  1 2 0 1 2 0 1 2 0 1 2
1 1 1 1 1 6                5 0 1 2 3 4 5           (lots of other solutions)
1 1 1 1 1 8                5 5 5 5 5 5 5 5
2 4 6 8                    3 2 1 3 2 1 3 2 1 3 2 1 3 2

यह एक कोड-गोल्फ है , इसलिए अपनी पसंदीदा भाषा में यथासंभव अपने समाधान करें!

code-golf 
— नाथन मेरिल
स्रोत
1
साथ ही से जोड़ा जा सकता इस
— जोनाथन एलन
2
@ जोनाथनअल्लन और यही कारण है कि मुझे अपने कंजूस भोग को सुनिश्चित करने के लिए एक कंप्यूटर की आवश्यकता है :)
— नाथन मेरिल

जवाबों:

4

जावास्क्रिप्ट (ईएस 6), 177 175 बाइट्स

a=>a.map((n,i)=>[n,l=i]).sort((a,b)=>a[0]-b[0]).reduce((P,x,i,a)=>(v=a.reduce((p,c,j)=>j<i?p:p+Math.min(c[0],x[0]+1),0))>m?[...Array(m=v)].map((_,k)=>a[l-k%(l+1-i)][1]):P,m=0)

प्रारूपित और टिप्पणी की गई

a => a                              // given an array a:
.map((n, i) => [n, l = i])          // map it to [value, index] arrays / set l = length - 1
.sort((a, b) => a[0] - b[0])        // sort it by values in ascending order
.reduce((P, x, i, a) =>             // for each reference entry x at position i:
  (v = a.reduce((p, c, j) =>        //   for each entry c at position j:
    j < i ?                         //     if c is before x:
      p                             //       keep the previous sum (which is 0)
    :                               //     else:
      p + Math.min(c[0], x[0] + 1), //       add minimum(value[j], value[i] + 1)
    0                               //   initialize the sum at 0
  )) > m ?                          //   if the new sum v is better than our current best m:
    [...Array(m = v)].map((_, k) => //     update m to v and update the result to an array
      a[l - k % (l + 1 - i)][1]     //     of length m filled with indices picked repeatedly
    )                               //     between i and l
  :                                 //   else:
    P,                              //     keep the previous result
  m = 0                             // start with best score m = 0
)                                   // the final result is returned by the outer reduce()

प्रयुक्त सूत्र

नीचे एक तालिका दिखाई गई है कि सूत्र कैसे F(i, j) = minimum(value[j], value[i] + 1)काम कर रहा है, यहां i = 0और इनपुट के साथ [ 5, 2, 2 ]।

इस सूत्र की व्याख्या इस प्रकार की जा सकती है: प्रत्येक स्कैटल प्रकार के लिए, हम कम से कम उपलब्ध टाइप वन प्लस की संख्या से अधिक का चयन नहीं कर सकते हैं।

 j | Sorted    | value[j] | F(0, j) | Selected        | Output
   | input     |          |         | Skittles        | (starting from bottom left)
---+-----------+----------+---------+-----------------+-----------------------------
 0 | 2 2       |     2    |    2    | [2] [2]         | \
 1 | 1 1       |     2    |    2    | [1] [1]         |  > 0 1 2 0 1 2 0
 2 | 0 0 0 0 0 |     5    |    3    | [0] [0] [0] 0 0 | /

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

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

— Arnauld
स्रोत
योग (0) के कम होने के आरोपों को कम किया mजा रहा है और "लूप्स" गोल्फ-प्रेरित के अंत में है या यह सिर्फ "जेएस" है?
— जोनाथन एलन
@JonathanAllan यह JS तरीका है : कॉलबैक के बाद कम करने का प्रारंभिक मूल्य () स्थित है। लाना m=0यहां गोल्फ प्रेरित क्योंकि मैं (यह वैसे भी ओवरराइट किया जा रहा है) इस लूप के प्रारंभिक मूल्य के बारे में परवाह नहीं है, हालांकि,। आरंभ किया जा रहा mवहाँ सुविधाजनक है।
— अरनुलद
आह, मुझे लगता है कि यह लूप की तुलना में फ़ंक्शन कॉल की तरह है (जैसे पायथन के कम फ़ंक्शन का वैकल्पिक प्रारंभिक मूल्य है)।
— जोनाथन एलन
@JonathanAllan हाँ, बिल्कुल। [1,2,3].reduce((x, y) => x+y, 10)जेएस reduce(lambda x,y: x+y, [1,2,3], 10)में पायथन में होगा (मुझे लगता है), दोनों में जिसके परिणामस्वरूप 16।
— अरनुलद
2

जेली , 22 बाइट्स

ċЀṢN
ỤṚ;\Ṛẋ"‘Ṣ$ḣ"ÇLÞṪ

1-आधारित अनुक्रमण।

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

कैसे?

मूल्य के आधार पर छांटे गए अनुक्रमित के प्रत्येक उपसर्ग को एक से अधिक बार दोहराते हैं, जो कि दिए गए बैग के साथ प्राप्त करने योग्य होगा, फिर इनमें से प्रत्येक को अंतिम स्कैटल या स्किटल को हटाने के लिए आवश्यक है ताकि उन्हें प्राप्त किया जा सके, और सबसे अधिक के साथ एक को लौटाता है ।

जिस संख्या को एक अतिरिक्त आवधिक पुनरावृत्ति से हटाया जाना चाहिए, वह उपसर्ग भर में न्यूनतम गणना के साथ सिर्फ संख्या है।

ỤṚ;\Ṛẋ"‘Ṣ$ḣ"ÇLÞṪ - Main link                   e.g. [6,4,2,8]
Ụ                - grade up: sort indices by value  [3,2,1,4]
 Ṛ               - reverse                          [4,1,2,3]
   \             - cumulative reduce with
  ;              -     concatenation (get prefixes) [[4],[4,1],[4,1,2],[4,1,2,3]]
    Ṛ            - reverse                          [[4,1,2,3],[4,1,2],[4,1],[4]]
         $       - last two links as a monad
       ‘         -     increment                    [7,5,3,9]
        Ṣ        -     sort                         [3,5,7,9]
      "          - zip with
     ẋ           -     list repetition              [[4,1,2,3,4,1,2,3,4,1,2,3],[4,1,2,4,1,2,4,1,2,4,1,2,4,1,2],[4,1,4,1,4,1,4,1,4,1,4,1,4,1],[4,4,4,4,4,4,4,4,4]]
            Ç    - call last link (1) as a monad    [-1,-1,-1,-1]
          "      - zip with
           ḣ     - head list to (remove excess)     [[4,1,2,3,4,1,2,3,4,1,2],[4,1,2,4,1,2,4,1,2,4,1,2,4,1],[4,1,4,1,4,1,4,1,4,1,4,1,4],[4,4,4,4,4,4,4,4]]
              Þ  - sort by
             L   -     length                       [[4,4,4,4,4,4,4,4],[4,1,2,3,4,1,2,3,4,1,2],[4,1,4,1,4,1,4,1,4,1,4,1,4],[4,1,2,4,1,2,4,1,2,4,1,2,4,1]]
               Ṫ - tail                             [4,1,2,4,1,2,4,1,2,4,1,2,4,1]

ċЀṢN - Link 1: head amounts (negative of skittle excess of each N+1 repeated period)
   Ṣ  - sort                                        [2,4,6,8]
 Ѐ   - for each mapped over right argument
ċ     - count                                       [1,1,1,1]
    N - negate                                      [-1,-1,-1,-1]
— जोनाथन एलन
स्रोत
1

python3, 174 172 167 बाइट्स

विचार

उदाहरण के लिए 3 रेड, 2 ब्लू और 3 ग्रीन स्किटल्स को एक ग्रिड और रंग और मात्रा के आधार पर व्यवस्थित कर सकते हैं:

r g
r g b
r g b

यदि मैं वास्तव में आई स्किटल खाने की कोशिश करता हूं, तो कम से कम मैं * सी स्किटल्स खा सकता हूं, जहां आर-वें कॉलम में सी स्किटल्स की संख्या है, उदाहरण के लिए i = 2 के लिए कम से कम 6 स्किटल खा सकते हैं।

r g
# # #
# # #

केवल एक चीज को छोड़ दिया जाता है, यह गणना की जाती है कि अपूर्ण अवधि तक कितने अतिरिक्त स्किटल खाए जा सकते हैं।

golfed

def f(a):
 r=range;f=m=0;s=r(len(a));b=sorted(zip(a,s))[::-1]
 for i in s:
  c=b[i][0];n=-~i*c+sum(c<e[0]for e in b)
  if n>m:f,m=i+1,n
 return[b[j%f][1]for j in r(m)]

टिप्पणी की गई

def f(a):
    r = range;
    f = m = 0;                          - Some variables we need later on
    s = r(len(a));                      - Integers from 0 to (num_skittles - 1)
    b = sorted(zip(a,s))[::-1]          - Zip with s to remember initial order,
                                          then sort and reverse
    for i in s:
        c = b[i][0]
        n = (i+1)*c                     - If we attempt to eat i different skittles,
                                          we can surely eat (i+1)*c skittles.
          + sum(1 for e in b if e[0]>c) - The additional sum corresponds to an incomplete period.
        if n>m:                         - If a better way of eating skittles is found:
            f,m = i+1,n                 - update variables
    return [b[j%f][1] for j in r(m)]

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

संपादित करें: 2 बाइट्स को बचाने के लिए प्रतिस्थापित (i+1)किया -~iगया।

संपादित करें: -5 बाइट्स डेड पॉसम के लिए धन्यवाद

— Elvorfirilmathredia
स्रोत
आप बदल सकते हैं sum(1for e in b if e[0]>c)करने के लिए sum(c<e[0]for e in b)। यह ट्रू को 1 में बदल देगा और आपको 5 बाइट्स बचाएगा
— डेड पॉसम
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.