<< Prec

Grazie alla comunità PPCG, Babbo Natale ora ha bilanciato i suoi carrelli di stoccaggio. Ora, ha bisogno di spostarli nei moli di trasporto in modo che possano essere inviati alle baie di carico. Sfortunatamente, i binari per spostare i carrelli sono un casino, e ha bisogno di capire come farli girare senza che si rompano insieme!

Sfida

Ti verranno dati i brani per ciascuno dei carrelli come elenchi di "etichette" (o stazioni). I carrelli devono essere spostati in modo tale che, in qualsiasi momento, non vi siano due carrelli sulla stessa etichetta / stazione. In sostanza, i carrelli si spostano tra le posizioni che hanno ciascuna un'etichetta unica.

Compito

Considerando le tracce per ciascuno dei carrelli come un elenco di elenchi di etichette (che sono tutti numeri interi positivi), determinare quando ogni carrello deve essere rilasciato per inviare tutti i carrelli alle loro destinazioni in sicurezza nel più breve tempo possibile.

Ecco una spiegazione di come funziona l'intero sistema di binari. Supponiamo che il carrello ivenga rilasciato in un momento t_isu una traccia con etichette T_i_1, T_i_2, ..., T_i_n. Quindi, durante t_1a t_i-1, il carrello inon è sulla griglia e può essere ignorato.

In un intervallo di tempo t_i, il carrello si trova sull'etichetta T_i_1e per ogni intervallo di tempo compreso t_ktra (metà compreso), il carrello si trova sull'etichetta .t_it_i+nT_i_k+1

Per tutti i tempi successivi e successivi t_i+n, il carrello è a destinazione e non è più sulla griglia.

Il tempo totale t_Timpiegato è l'ultimo intervallo di tempo con un carrello ancora su una traccia nel sistema.

specificazioni

Dato un sistema di binari, restituisci un elenco di intervalli di tempo in [t_1, t_2, ..., t_n]cui il icarrello inizia in quel momento t_i, in modo tale che nessun altro accordo consentirebbe ai carrelli di raggiungere le loro destinazioni in sicurezza con un tempo totale inferiore.

In termini di "sicurezza", se in qualsiasi momento da un cartellone t_1all'altro t_Tsi trova più di un carrello su qualsiasi etichetta, allora si scontrano e la disposizione non è "sicura". Nota che due carrelli possono passare da a, ba b, aed essere ancora "sicuro", perché le piste sono a 2 vie.

Specifiche di formattazione

L'input verrà dato come una matrice di numeri interi positivi in ​​qualsiasi formato ragionevole. L'output deve essere fornito come un elenco di numeri interi positivi in ​​qualsiasi formato ragionevole. È possibile fornire un output in intervalli di tempo a zero, quindi l'output sarà un elenco di numeri interi non negativi in ​​qualsiasi formato ragionevole.

Regole

• Si applicano scappatoie standard
• Questo è un code-golf quindi vince la risposta più breve in byte
• Nessuna risposta sarà accettata

Casi test

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]

^{Nota: ho tratto ispirazione per questa serie di sfide da Advent Of Code . Non ho alcuna affiliazione con questo sito}

Puoi vedere un elenco di tutte le sfide della serie guardando la sezione "Linked" della prima sfida qui .

Buon golf!

JavaScript (ES7), 172 byte

Restituisce una matrice di intervalli di tempo indicizzati 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 : Questo può funzionare solo con etichette in [0-31]. Questo è un limite JS, non un limite dell'algoritmo.

Casi test

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]

Commentate

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