<< Trước đó

Nhờ cộng đồng PPCG, Santa giờ đã cân bằng giỏ hàng của mình. Bây giờ, anh ta cần phải di chuyển chúng vào bến tàu vận chuyển để chúng có thể được gửi đến các khoang tải. Thật không may, các dấu vết để di chuyển các xe đẩy xung quanh là một mớ hỗn độn, và anh ta cần phải tìm ra cách để có được tất cả xung quanh mà không bị rơi cùng nhau!

Thử thách

Bạn sẽ được cung cấp các bản nhạc cho mỗi giỏ hàng dưới dạng danh sách "nhãn" (hoặc trạm). Các xe đẩy phải được di chuyển sao cho vào bất kỳ khung thời gian nào, không có hai xe nào trên cùng một nhãn / trạm. Về cơ bản, các xe đẩy di chuyển giữa các vị trí mà mỗi vị trí có một nhãn duy nhất.

Bài tập

Đưa ra các dấu vết cho mỗi giỏ hàng dưới dạng danh sách các nhãn (tất cả đều là số nguyên dương), xác định thời điểm mỗi giỏ hàng sẽ được phát hành để gửi tất cả các giỏ hàng đến đích một cách an toàn trong thời gian ngắn nhất.

Đây là một lời giải thích về cách toàn bộ hệ thống theo dõi hoạt động. Giả sử giỏ hàng iđược phát hành tại một thời điểm t_itrên đường đua có nhãn T_i_1, T_i_2, ..., T_i_n. Sau đó, trong thời gian t_1tới t_i-1, giỏ hàng ikhông nằm trên lưới và có thể bỏ qua.

Tại khung thời gian t_i, giỏ hàng là trên nhãn T_i_1, và đối với mỗi khung thời gian t_ktừ t_iđến t_i+n(nửa bao gồm), giỏ hàng là trên nhãn T_i_k+1.

Đối với tất cả các khung thời gian sau và bao gồm t_i+n, giỏ hàng đã đến đích và không còn trên lưới.

Tổng thời gian t_Tthực hiện là khung thời gian cuối cùng với một giỏ hàng vẫn còn trên đường đua trong hệ thống.

Thông số kỹ thuật

Đưa ra một hệ thống theo dõi, trả về một danh sách các khung thời gian [t_1, t_2, ..., t_n]mà igiỏ hàng bắt đầu tại thời điểm đó t_i, sao cho không có sự sắp xếp nào khác cho phép các xe đẩy đến đích một cách an toàn với tổng thời gian ít hơn.

Xét về "an toàn", nếu tại bất kỳ khung thời gian từ t_1để t_Tcó nhiều hơn một giỏ hàng trên bất kỳ nhãn, sau đó họ va chạm và sự sắp xếp không "an toàn". Lưu ý rằng hai xe có thể di chuyển từ a, bđến b, avà vẫn "an toàn" vì các tuyến đường là 2 chiều.

Định dạng thông số kỹ thuật

Đầu vào sẽ được đưa ra dưới dạng ma trận các số nguyên dương ở bất kỳ định dạng hợp lý nào. Đầu ra phải được đưa ra dưới dạng danh sách các số nguyên dương ở bất kỳ định dạng hợp lý nào. Bạn có thể cung cấp đầu ra trong các khung thời gian được lập chỉ mục bằng 0, do đó, đầu ra sẽ là một danh sách các số nguyên không âm ở bất kỳ định dạng hợp lý nào.

Quy tắc

• Áp dụng sơ hở tiêu chuẩn
• Đây là một môn đánh gôn, vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng
• Không có câu trả lời sẽ được chấp nhận

Các trường hợp thử nghiệm

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]

^{Lưu ý: Tôi đã lấy cảm hứng cho loạt thử thách này từ Advent Of Code . Tôi không có liên kết với trang web này}

Bạn có thể xem danh sách tất cả các thử thách trong chuỗi bằng cách xem phần 'Liên kết' của thử thách đầu tiên tại đây .

Chúc bạn chơi golf vui vẻ!

JavaScript (ES7), 172 byte

Trả về một mảng các khung thời gian 0 chỉ mục.

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 : Điều này chỉ có thể hoạt động với các nhãn trong [0-31]. Đây là giới hạn JS, không phải giới hạn của thuật toán.

Các trường hợp thử nghiệm

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]

Đã bình luận

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