<< Önceki

PPCG topluluğu sayesinde Santa artık depolama arabalarını dengeledi. Şimdi, yükleme alanlarına gönderilebilmeleri için onları nakliye limanlarına taşıması gerekiyor. Ne yazık ki, arabaları hareket ettirmek için izler bir karışıklıktır ve birlikte çökmeden onları nasıl ele alacağını bulması gerekir!

Meydan okuma

Her bir araba için parkurlara "etiket" (veya istasyonlar) listesi verilecektir. Arabalar, herhangi bir zaman diliminde aynı etiket / istasyonda iki araba bulunmayacak şekilde hareket ettirilmelidir. Esasen, arabaların her biri benzersiz bir etikete sahip konumlar arasında hareket eder.

Görev

Her bir araba için izlerin bir etiket listesi (hepsi pozitif tamsayılar) listesi olarak verildiğinde, tüm arabaları hedeflerine mümkün olan en kısa sürede güvenli bir şekilde göndermek için her bir arabanın ne zaman serbest bırakılması gerektiğini belirleyin.

İşte tüm ray sisteminin nasıl çalıştığına dair bir açıklama. Diyelim ki araba etiketli bir parçaya izamanında bırakıldı . Ardından sırasında To , sepeti ızgarada değildir ve göz ardı edilebilir.t_iT_i_1, T_i_2, ..., T_i_nt_1t_i-1i

Zaman çerçevesi de t_i, sepeti etiketin üzerinde T_i_1ve her zaman dilimi için t_kgelen t_iiçin t_i+n(yarı dahil), sepeti etiketin üzerinde T_i_k+1.

Sonraki ve dahil tüm zaman dilimleri için t_i+n, araba hedefindedir ve artık ızgarada değildir.

Toplam t_Tsüre, bir sepeti sistemde hala izleyen son zaman dilimidir.

Özellikler

Bir parça sistem göz önüne alındığında, zaman dilimlerinde listesini döndürür [t_1, t_2, ..., t_n]nereye ianda inci sepeti başlar t_ibaşka hiçbir düzenleme güvenle için arabaları zamanın daha az toplam miktarı ile hedeflerine ulaşmak sağlayacak şekilde,.

Herhangi bir zaman çerçevesi de eğer "güvenli" açısından, t_1için t_Therhangi bir etikete birden fazla sepeti var, o zaman onlar çarpışır ve düzenleme "güvenli" değildi. İki arabaları hareket anlamına Not a, biçin b, ave hala izleri 2 yönlü oldukları için "güvenli" olması.

Biçimlendirme Spesifikasyonları

Girdi herhangi bir makul formatta pozitif tamsayılar matrisi olarak verilecektir. Çıktı herhangi bir makul biçimde pozitif tamsayıların bir listesi olarak verilmelidir. Çıktıyı sıfır dizinli zaman dilimlerinde verebilirsiniz, bu nedenle çıktı herhangi bir makul formatta negatif olmayan tamsayıların bir listesi olacaktır.

kurallar

• Standart Loopholes Uygula
• Bu bir kod golfüdür, bu nedenle bayttaki en kısa cevap kazanır
• Hiçbir cevap kabul edilmeyecek

Test Durumları

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]

^{Not: Advent Of Code'dan bu meydan okuma serisi için ilham aldım . Bu siteyle hiçbir bağlantım yok}

Buradaki ilk zorluğun 'Bağlantılı' bölümüne bakarak dizideki tüm zorlukların bir listesini görebilirsiniz .

Mutlu Golf!

JavaScript (ES7), 172 bayt

0 dizinli zaman dilimlerinin bir dizisini döndürür.

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)

Not : Bu yalnızca [0-31] içindeki etiketlerle çalışabilir. Bu bir JS sınırıdır, algoritmanın sınırı değildir.

Test senaryoları

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]

Yorumlananlar

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