रोटी का एक आलसी बैग

Question

मैं एक बेकरी में काम करता हूं जो गेहूं, राई, जौ, अनाज और फ्रेंच ब्रेड परोसता है, लेकिन बेकर को थोड़ा अजीब लगता है - वह रोटियों को यादृच्छिक क्रम में ढेर करता है, और कभी-कभी अंत में कुछ अलमारियों को खाली छोड़ देता है।

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

आसन्न अलमारियों के बीच चलने में एक सेकंड लगता है। यह एक व्यस्त स्टोर है; रोटियों के किसी भी यादृच्छिक विन्यास के लिए, मैं प्रत्येक अद्वितीय पाव रोटी में से एक को प्राप्त करने में लगने वाले समय को कम करना चाहूंगा। मैं किसी भी शेल्फ पर शुरू और समाप्त कर सकता हूं।

यदि आज का आदेश है W B W G F R W, तो एक संभावित मार्ग 0, 3, 5, 1, 4कुल 12 सेकंड के लिए है:abs(3-0) + abs(5-3) + abs(1-5) + abs(4-1) = 12

( 1, 2, 3, 4, 5काम नहीं करता है, क्योंकि रोटी आसन्न अलमारियों से लगातार ली जाती है।)

यदि यह B W B G B F B R B W B Fसंभव मार्ग है 1, 3, 5, 7, 10, तो कुल 9 सेकंड के लिए।

प्रबंधक हमेशा सुनिश्चित करता है कि एक संभावित समाधान है, इसलिए मुझे खराब इनपुट को पकड़ने के बारे में चिंता करने की आवश्यकता नहीं है। वह आमतौर पर मुझे एक फ़ाइल में आदेश भेजता है, लेकिन अगर मैं चाहता हूं, तो मैं इसे एसटीडीआईएन पर टाइप कर सकता हूं या इसे अलग तरीके से पढ़ सकता हूं। मुझे डिफ़ॉल्ट I / O नियमों के अनुसार, सर्वोत्तम पथ के सूचकांकों के साथ-साथ उसके समय को भी प्रिंट करने का कार्यक्रम चाहिए ।

संक्षेप में:

1. 5 प्रकार की रोटी।
2. लोफ ऑर्डर यादृच्छिक क्रम और लंबाई के तार के रूप में प्रकट होता है।
3. प्रत्येक अद्वितीय पाव रोटी में से एक का चयन करना चाहिए।
4. आसन्न लगातार चयन नहीं कर सकते।
5. चयन सूचकांकों के बीच की दूरी कम से कम करें।
6. अमान्य इनपुट के बारे में चिंता करने की ज़रूरत नहीं है।
7. डिफ़ॉल्ट I / O नियम लागू होते हैं।

यह कोड-गोल्फ , सबसे छोटी बाइट गिनती जीत है।

Comments

0+3+5+1+4=13लेकिन 1+3+5+7+10=26, नहीं 9।

— झबरा

@LuisfelipeDejesusMunoz काफी नहीं है, उनमें से कई लगातार मल आसन्न हैं।

— निक रीड

PPCG में आपका स्वागत है, और अच्छी पहली चुनौती है!

— user202729

यह वास्तविक कार्य के लिए महत्वपूर्ण नहीं है, लेकिन मैं उत्सुक हूं: उसे जर्मोफोब होने का मतलब है कि आप लगातार चयन में दो आसन्न अलमारियों से रोटियां नहीं ले सकते हैं?

— सूंदर -

क्या कोई खाली अलमारियां हो सकती हैं जो छोर पर नहीं हैं ? (उदाहरण के लिए 'WBWG FRW'एक वैध इनपुट भी है?

— जोनाथन एलन

Answer 1

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

@Oliver की बदौलत बचा 1 बाइट

वर्णों के एक सरणी के रूप में इनपुट लेता है। एक अल्पविराम से अलग स्ट्रिंग को आउटपुट करता है जहां पहला मान कुल समय है और अगले लोग पथ का वर्णन करते हैं।

a=>(b=g=(r,s=o='',c,p)=>s[c>b|4]?o=(b=c)+r:a.map((v,i)=>s.match(v)||(d=p<i?i-p:p-i)<2||g([r,i],s+v,~~c+d,i))&&o)``

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

टिप्पणी की गई

a => (                          // a[] = input array
  b =                           // b = best score so far (initially a non-numeric value)
  g = (                         // g = recursive function taking:
    r,                          //   r = path
    s =                         //   s = string of collected loaves of bread
    o = '',                     //   o = final output
    c,                          //   c = current cost
    p                           //   p = index of the last visited shelf 
  ) =>                          //
    s[c > b                     // if the final cost is not greater than our best score
            | 4] ?              // and we've successfully collected 5 loaves of bread:
      o = (b = c) + r           //   update the current output and the best score
    :                           // else:
      a.map((v, i) =>           //   for each loaf of bread v at shelf i in a[]:
        s.match(v) ||           //     if we've already collected this kind of bread
        (d =                    //     or the distance d
          p < i ? i - p : p - i //     defined as the absolute value of p - i
        ) < 2 ||                //     is less than 2: stop recursion
        g(                      //     otherwise, do a recursive call to g() with:
          [r, i],               //       r updated with the index of the current shelf
          s + v,                //       s updated with the current loaf of bread
          ~~c + d,              //       c updated with the last distance
          i                     //       i as the index of the last shelf
        )                       //     end of recursive call
      )                         //   end of map()
      && o                      //   return the current output
  )``                           // initial call to g() with r = [""]

Answer 2

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

lambda s:min((sum(h(p)),p)for b in combinations(range(len(s)),5)for p in permutations(b)if(len(set(s[i]for i in p))==5)&all(d>1for d in h(p)))
h=lambda p:[abs(y-x)for x,y in zip(p,p[1:])]
from itertools import*

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

2 बाइट्स जोनाथन फ्रेच के लिए ।

Comments

if len(...)==5and all(...)if(len(...)==5)&all(...)दो बाइट बचाने के लिए किया जा सकता है।

— जोनाथन फ्रीच