चुनौती चुनौती 8: भंडारण गाड़ी परिवहन योजना!

Question

<< प्रीव

पीपीसीजी समुदाय के लिए धन्यवाद, सांता ने अब अपनी भंडारण गाड़ियां संतुलित कर दी हैं। अब, उन्हें परिवहन डॉक में ले जाने की आवश्यकता है ताकि उन्हें लोडिंग बे में भेजा जा सके। दुर्भाग्य से, गाड़ियों को इधर-उधर ले जाने वाली पटरियाँ एक गड़बड़ हैं, और उन्हें यह पता लगाने की ज़रूरत है कि बिना एक साथ दुर्घटनाग्रस्त हुए उन सभी को कैसे प्राप्त किया जाए!

चुनौती

आपको "लेबल" (या स्टेशन) की सूची के रूप में प्रत्येक गाड़ी के लिए ट्रैक दिए जाएंगे। गाड़ियां ऐसी स्थानांतरित की जानी चाहिए कि किसी भी समय सीमा पर, कोई भी दो गाड़ियां एक ही लेबल / स्टेशन पर न हों। अनिवार्य रूप से, गाड़ियां उन स्थितियों के बीच चलती हैं जिनमें से प्रत्येक में एक अद्वितीय लेबल होता है।

कार्य

लेबल की सूचियों (जो सभी सकारात्मक पूर्णांक हैं) की सूची के रूप में प्रत्येक गाड़ी के लिए पटरियों को देखते हुए, निर्धारित करें कि प्रत्येक कार्ट को कम से कम समय में सुरक्षित रूप से सभी गाड़ियों को उनके गंतव्य तक भेजने के लिए जारी किया जाए।

यहां संपूर्ण ट्रैक सिस्टम कैसे काम करता है, इसका विवरण दिया गया है। मान लें कि लेबल के साथ ट्रैक पर कार्ट iसमय t_iपर रिलीज़ होती है T_i_1, T_i_2, ..., T_i_n। फिर, के दौरान t_1करने के लिए t_i-1, गाड़ी iनहीं ग्रिड पर है और ध्यान नहीं दिया जा सकता है।

समय सीमा पर t_i, गाड़ी लेबल पर है T_i_1, और प्रत्येक समय सीमा के लिए t_kसे t_iकरने के लिए t_i+n(आधे सम्मिलित), गाड़ी लेबल पर है T_i_k+1।

सभी समय और बाद के फ्रेम के लिए t_i+n, कार्ट अपने गंतव्य पर है और अब ग्रिड पर नहीं है।

समय की कुल राशि t_Tप्रणाली में एक ट्रैक पर एक गाड़ी के साथ अंतिम समय सीमा है।

विशेष विवरण

एक ट्रैक सिस्टम को देखते हुए, टाइम फ्रेम की एक सूची लौटाएं [t_1, t_2, ..., t_n]जहां iवें कार्ट समय पर शुरू होता है t_i, जैसे कि कोई अन्य व्यवस्था कार्ट को कम समय की कुल राशि के साथ सुरक्षित रूप से अपने गंतव्य तक जाने की अनुमति नहीं देती है।

के "सुरक्षित रूप से" संदर्भ में, से किसी भी समय सीमा में यदि t_1करने के लिए t_Tक्या कोई लेबल पर एक से अधिक गाड़ी है, तो वे टकराने और व्यवस्था "सुरक्षित" नहीं था। ध्यान दें कि दो कार्ट से स्थानांतरित कर सकते हैं a, bकरने के लिए b, aऔर अभी भी "सुरक्षित" हो क्योंकि पटरियों 2 तरह कर रहे हैं।

स्वरूपण विनिर्देशों

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

नियम

• स्टैंडर्ड लोफॉल्स लागू होते हैं
• यह एक कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा जवाब है
• कोई उत्तर स्वीकार नहीं किया जाएगा

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

Input -> Output
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] -> [1, 1, 1]
[[1, 2, 3], [1, 2, 3]] -> [1, 2]
[[1, 2, 3], [3, 2, 1]] -> [1, 2]
[[1, 2, 3, 4], [4, 3, 2, 1]] -> [1, 1]
[[1, 1, 1], [1, 1, 1]] -> [1, 4]
[[1, 2, 3, 4], [2, 4, 3, 1]] -> [2, 1]
[[1, 2, 3, 4, 5, 6, 7], [2, 3, 3, 4], [5, 4, 3]] -> [1, 3, 4]
[[1, 2, 3, 4, 4], [1, 2, 3, 5, 4], [1, 2, 3, 4, 5]] -> [2, 3, 1]

^{नोट: मैंने इस चुनौती श्रंखला के लिए Advent of Code से प्रेरणा ली । मेरा इस साइट से कोई जुड़ाव नहीं है}

आप यहां पहली चुनौती के 'लिंक्ड' सेक्शन को देखकर श्रृंखला की सभी चुनौतियों की सूची देख सकते हैं ।

हैप्पी गोल्फिंग!

Comments

आवश्यकता नहीं समझें: एक गाड़ी = एक सरणी?

— l4m2

मिल गया: [i] [t-out [i]] किसी भी t के लिए सभी अलग-अलग, और अधिकतम [i] + in.length सबसे छोटा, अगर मैं नमूने पर सही अनुमान

— लगाता हूं

@ l4m2 तुम किस बारे में भ्रमित हो? मुझे लगता है कि मैंने कल्पना को पर्याप्त रूप से स्पष्ट कर दिया है ... सरणी प्रत्येक गाड़ी द्वारा लिए गए पथ का प्रतिनिधित्व करती है

— हाइपरयूट्रीनो

मैंने ध्यान से पाठ नहीं पढ़ा (मेरे लिए पढ़ना बहुत मुश्किल है, शायद मेरी बुरी बात) और सोचा कि यह एक 2D प्लेट है

— l4m2

Answer 1

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

0-अनुक्रमित समय फ़्रेम की एक सरणी देता है।

a=>(g=k=>a.map((a,i)=>[l=a.length+1,i,a,L=L<l?l:L]).sort(([a],[b])=>a-b).every(([,n,b],i)=>b.every((c,t)=>o[t+=A[n]=k/L**i%L|0]&1<<c?0:o[t]|=1<<c),o=[],A=[])?A:g(k+1))(L=0)

NB : यह केवल [0-31] में लेबल के साथ काम कर सकता है। यह जेएस सीमा है, एल्गोरिथ्म की सीमा नहीं है।

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

let f =

a=>(g=k=>a.map((a,i)=>[l=a.length+1,i,a,L=L<l?l:L]).sort(([a],[b])=>a-b).every(([,n,b],i)=>b.every((c,t)=>o[t+=A[n]=k/L**i%L|0]&1<<c?0:o[t]|=1<<c),o=[],A=[])?A:g(k+1))(L=0)

console.log(JSON.stringify(f([[1, 2, 3], [4, 5, 6], [7, 8, 9]])))                   // -> [0, 0, 0]
console.log(JSON.stringify(f([[1, 2, 3], [1, 2, 3]])))                              // -> [0, 1] or [1, 0]
console.log(JSON.stringify(f([[1, 2, 3], [3, 2, 1]])))                              // -> [0, 1] or [1, 0]
console.log(JSON.stringify(f([[1, 2, 3, 4], [4, 3, 2, 1]])))                        // -> [0, 0]
console.log(JSON.stringify(f([[1, 1, 1], [1, 1, 1]])))                              // -> [0, 3] or [3, 0]
console.log(JSON.stringify(f([[1, 2, 3, 4], [2, 4, 3, 1]])))                        // -> [1, 0]
console.log(JSON.stringify(f([[1, 2, 3, 4, 5, 6, 7], [2, 3, 3, 4], [5, 4, 3]])))    // -> [0, 2, 3]
console.log(JSON.stringify(f([[1, 2, 3, 4, 4], [1, 2, 3, 5, 4], [1, 2, 3, 4, 5]]))) // -> [1, 2, 0]

टिप्पणी की गई

a => (                         // given a = array of tracks
  g = k =>                     // g = recursive function taking k = counter
    a.map((t, i) => [          // map each track t in a to a new entry made of:
      l = t.length + 1,        //   - its length + 1 (l)
      i,                       //   - its original index in the input array
      t,                       //   - the original track data
      L = L < l ? l : L        //   and update the maximum track length L
    ])                         // end of map()
    .sort(([a], [b]) =>        // let's sort the tracks from shortest to longest
      a - b                    // so that solutions that attempt to delay short
    )                          // tracks are tried first
    .every(([, n, b],          // for each track b with an original position n,
                      i) =>    // now appearing at position i:
      b.every((c, t) =>        //   for each label c at position t in b:
        o[t += A[n] =          //     add to t the time frame A[n] corresponding
          k / L**i % L | 0     //     to this position (i) and this combination (k)
        ] & 1 << c ?           //     if the station c is already occupied at time t:
          0                    //       make every() fail
        :                      //     else:
          o[t] |= 1 << c       //       mark the station c as occupied at time t
      ),                       //   end of inner every()
      o = [],                  //   start with: o = empty array (station bitmasks)
      A = []                   //               A = empty array (time frames)
    ) ?                        // end of outer every(); if successful:
      A                        //   return A
    :                          // else:
      g(k + 1)                 //   try the next combination
)(L = 0)                       // initial call to g() + initialization of L

Comments

मुझे लगता है कि यह बिटवाइज़ ऑपरेटरों के कारण है? ( <<और |) इसके बजाय बूल की एक सरणी का उपयोग करके तय किया जा सकता है ...

— user202729

@ user202729 हां, क्योंकि इसमें संग्रहीत मूल्यों पर बिटवाइज़ ऑपरेटरों की वजह से है o[]। (यह अलग ढंग से वास्तव में किया जा सकता है, लेकिन मैं पहली जगह में golfier परिणाम के लिए इस विधि का फैसला किया।)

— Arnauld