অ্যাডভেন্ট চ্যালেঞ্জ 8: স্টোরেজ কার্ট পরিবহন পরিকল্পনা!

Question

<< পূর্ববর্তী

পিপিসিজি সম্প্রদায়ের জন্য ধন্যবাদ, সান্তা এখন তার স্টোরেজ কার্টগুলিকে ভারসাম্যপূর্ণ করেছে। এখন, সেগুলি তাদের ট্রান্সপোর্ট ডক্সে স্থানান্তরিত করা দরকার যাতে এগুলি লোডিং বেতে প্রেরণ করা যায়। দুর্ভাগ্যক্রমে, গাড়িগুলি চারপাশে সরানোর জন্য ট্র্যাকগুলি একটি গোলমাল, এবং সেগুলি একসাথে ক্র্যাশ না করে কীভাবে তাদের চারপাশে আনতে হবে তা নির্ধারণ করা দরকার!

চ্যালেঞ্জ

আপনাকে "প্রতিটি লেবেল" (বা স্টেশন) এর তালিকা হিসাবে প্রতিটি গাড়ীর ট্র্যাক দেওয়া হবে। কার্টগুলি অবশ্যই এমনভাবে সরানো হবে যে কোনও সময় ফ্রেমে কোনও দুটি গাড়ি একই লেবেল / স্টেশনে নেই। মূলত, কার্টগুলি প্রতিটি পদের একটি স্বতন্ত্র লেবেলযুক্ত অবস্থানগুলির মধ্যে চলে।

কার্য

প্রতিটি গাড়ীর ট্র্যাকগুলি লেবেলের তালিকাগুলির তালিকা হিসাবে দেওয়া হয়েছে (যা সমস্ত ধনাত্মক পূর্ণসংখ্যার), সম্ভাব্য স্বল্পতম সময়ের মধ্যে সমস্ত কার্টকে তাদের গন্তব্যে নিরাপদে প্রেরণের জন্য কখন প্রতিটি কার্ট ছেড়ে দেওয়া উচিত তা নির্ধারণ করুন।

পুরো ট্র্যাক সিস্টেমটি কীভাবে কাজ করে তার একটি ব্যাখ্যা এখানে। ধরা যাক কার্ট লেবেল সহ একটি ট্র্যাকের iসময়ে সময়ে প্রকাশিত হয়েছিল । এর পরে, সময় থেকে , কার্ট না গ্রিড চালু থাকে এবং উপেক্ষা করা যাবে।t_iT_i_1, T_i_2, ..., T_i_nt_1t_i-1i

সময় ফ্রেম এ 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-মুখী।

ফর্ম্যাটিং স্পেসিফিকেশন

ইনপুটটি যেকোন যুক্তিসঙ্গত বিন্যাসে ইতিবাচক পূর্ণসংখ্যার ম্যাট্রিক্স হিসাবে দেওয়া হবে। আউটপুটটি যেকোন যুক্তিসঙ্গত বিন্যাসে ইতিবাচক পূর্ণসংখ্যার তালিকা হিসাবে দেওয়া উচিত। আপনি শূন্য-সূচক সময় ফ্রেমে আউটপুট দিতে পারেন, সুতরাং আউটপুটটি কোনও যুক্তিসঙ্গত বিন্যাসে অ-নেতিবাচক পূর্ণসংখ্যার তালিকা হবে।

বিধি

• স্ট্যান্ডার্ড লুফোলস প্রয়োগ করুন
• এটি একটি কোড-গল্ফ তাই বাইটের মধ্যে সংক্ষিপ্ত উত্তর w
• কোন উত্তর গৃহীত হবে না

পরীক্ষার কেস

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]

^{দ্রষ্টব্য: আমি অ্যাডভেন্ট অফ কোড থেকে এই চ্যালেঞ্জ সিরিজের জন্য অনুপ্রেরণা তৈরি করেছি । এই সাইটের সাথে আমার কোনও সম্পর্ক নেই}

আপনি এখানে প্রথম চ্যালেঞ্জের 'লিঙ্কযুক্ত' বিভাগটি দেখে সিরিজের সমস্ত চ্যালেঞ্জের একটি তালিকা দেখতে পারেন ।

শুভ গল্ফিং!

Comments

প্রয়োজনীয়তা বুঝতে পারছেন না: একটি কার্ট = একটি অ্যারে?

— l4m2

পেয়েছি: [i] [টি-আউট [i]] কোনও টিয়ের জন্য সমস্ত আলাদা, এবং সর্বোচ্চ আউট [i] + ইন-দৈর্ঘ্য ক্ষুদ্রতম, যদি আমি নমুনায় সঠিকভাবে অনুমান করি

— l4m2

@ l4m2 আপনি কি সম্পর্কে বিভ্রান্ত? আমি মনে করি আমি

— স্পষ্টটি

আমি সাবধানে লেখাটি পড়িনি (আমার পক্ষে পড়া খুব কঠিন, আমার খারাপ) এবং ভেবেছিলাম এটি 2 ডি প্লেট ছিল

— l4m2

Answer 1

জাভাস্ক্রিপ্ট (ES7), 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)

এনবি : এটি কেবল [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

আমি মনে করি এটি বিটওয়াইজ অপারেটরগুলির কারণে? ( <<এবং |) পরিবর্তে

— বুলির

@ ব্যবহারকারী 202729 হ্যাঁ, এটি সঞ্চিত মানগুলিতে বিটওয়াইজ অপারেটরগুলির কারণে o[]। (এটি সত্যই অন্যভাবে করা যেতে পারে, তবে আমি প্রথমে গল্ফিয়ারের ফলাফলের জন্য এই পদ্ধতিটি বেছে নিয়েছি))

— আর্নাউল্ড