<< ก่อนหน้า

ต้องขอบคุณชุมชน PPCG ตอนนี้ซานต้าจึงมีรถเข็นจัดเก็บของเขาสมดุล ตอนนี้เขาต้องการย้ายพวกเขาไปยังท่าเรือขนส่งเพื่อให้พวกเขาสามารถส่งไปยังอ่าวโหลด โชคไม่ดีที่แทร็คที่จะย้ายเกวียนเป็นเรื่องยุ่งเหยิงและเขาต้องการที่จะเข้าใจว่าจะนำพวกมันไปรอบ ๆ ได้อย่างไรโดยที่พวกเขาไม่ชนกัน!

ท้าทาย

คุณจะได้รับแทร็กสำหรับรถเข็นแต่ละรายการเป็นรายการของ "ป้ายกำกับ" (หรือสถานี) รถเข็นต้องเคลื่อนย้ายโดยไม่ต้องมีรถเข็นสองคันอยู่บนฉลาก / สถานีเดียวกัน โดยพื้นฐานแล้วรถเข็นจะเลื่อนไปมาระหว่างตำแหน่งที่แต่ละป้ายมีป้ายกำกับที่ไม่ซ้ำกัน

งาน

กำหนดแทร็กสำหรับรถเข็นแต่ละคันให้เป็นรายการของป้ายกำกับ (ซึ่งเป็นจำนวนเต็มบวกทั้งหมด) กำหนดว่าควรปล่อยรถเข็นแต่ละคันเมื่อใดเพื่อส่งรถเข็นทั้งหมดไปยังจุดหมายปลายทางอย่างปลอดภัยในเวลาอันสั้นที่สุด

นี่คือคำอธิบายว่าระบบติดตามทั้งหมดทำงานอย่างไร รถเข็นพูด Let 's 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ยังและยังคง "ปลอดภัย" ได้เพราะแทร็กนั้นเป็นแบบสองทาง

การจัดรูปแบบข้อมูลจำเพาะ

อินพุตจะได้รับเป็นเมทริกซ์ของจำนวนเต็มบวกในรูปแบบที่เหมาะสม ควรให้เอาต์พุตเป็นรายการของจำนวนเต็มบวกในรูปแบบที่เหมาะสม คุณอาจให้ผลลัพธ์ในกรอบเวลาที่ไม่มีการทำดัชนีดังนั้นผลลัพธ์จะเป็นรายการของจำนวนเต็มที่ไม่เป็นลบในรูปแบบที่เหมาะสม

กฎระเบียบ

• ช่องโหว่มาตรฐานใช้
• นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ
• จะไม่ยอมรับคำตอบ

กรณีทดสอบ

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]

^{หมายเหตุ: ผมดึงแรงบันดาลใจสำหรับชุดความท้าทายนี้จากการจุติของรหัส ฉันไม่มีส่วนเกี่ยวข้องกับเว็บไซต์นี้}

คุณสามารถดูรายการของความท้าทายทั้งหมดในซีรีส์โดยดูที่ส่วน 'เชื่อมโยง' ของความท้าทายแรกที่นี่

มีความสุขในการเล่นกอล์ฟ!

JavaScript (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] เท่านั้น นี่เป็นขีด จำกัด JS ไม่ใช่ขีด จำกัด ของอัลกอริทึม

กรณีทดสอบ

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