<< Anterior

Graças à comunidade PPCG, o Papai Noel agora equilibra seus carrinhos de armazenamento. Agora, ele precisa movê-los para as docas de transporte, para que possam ser enviados para os compartimentos de carregamento. Infelizmente, as faixas para mover os carros são uma bagunça, e ele precisa descobrir como contorná-los sem baterem juntos!

Desafio

Você receberá as faixas de cada carrinho como lista de "etiquetas" (ou estações). Os carros devem ser movidos de forma que, a qualquer momento, não haja dois carros na mesma etiqueta / estação. Essencialmente, os carrinhos se movem entre as posições em que cada uma possui um rótulo exclusivo.

Tarefa

Dadas as faixas de cada um dos carrinhos como uma lista de listas de rótulos (todos inteiros positivos), determine quando cada carrinho deve ser liberado para enviar todos os carrinhos para seus destinos com segurança no menor tempo possível.

Aqui está uma explicação de como todo o sistema de pistas funciona. Digamos que o carrinho iseja liberado às vezes t_iem uma faixa com etiquetas T_i_1, T_i_2, ..., T_i_n. Em seguida, durante t_1a t_i-1, o carrinho inão está na grade e pode ser ignorado.

No período de tempo t_i, o carro está no rótulo T_i_1, e para cada período de tempo t_ka partir t_ide t_i+n(meia-inclusive), o carrinho está na etiqueta T_i_k+1.

Para todos os períodos após e inclusive t_i+n, o carrinho está no seu destino e não está mais na grade.

O tempo total t_Tgasto é o último período de tempo com um carrinho ainda em uma faixa no sistema.

Especificações

Dado um sistema de trilhos, retorne uma lista de prazos em [t_1, t_2, ..., t_n]que o icarro é iniciado no horário t_i, de forma que nenhum outro arranjo permita que os carros cheguem com segurança aos seus destinos com uma quantidade total de tempo menor.

Em termos de "segurança", se em qualquer período de tempo a partir t_1de t_Tlá é mais do que um carrinho em qualquer rótulo, então eles colidem e o arranjo não era "seguro". Note-se que dois carros podem passar de a, ba b, ae ainda ser "seguro" porque as faixas são 2-way.

Especificações de formatação

A entrada será fornecida como uma matriz de números inteiros positivos em qualquer formato razoável. A saída deve ser fornecida como uma lista de números inteiros positivos em qualquer formato razoável. Você pode fornecer resultados em períodos de tempo indexados a zero, para que o resultado seja uma lista de números inteiros não negativos em qualquer formato razoável.

Regras

• As brechas padrão se aplicam
• Este é um código-golfe, então a resposta mais curta em bytes vence
• Nenhuma resposta será aceita

Casos de teste

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: Eu me inspirei para esta série de desafios da Advent Of Code . Não tenho afiliação com este site}

Você pode ver uma lista de todos os desafios da série consultando a seção 'Vinculado' do primeiro desafio aqui .

Golfe feliz!

JavaScript (ES7), 172 bytes

Retorna uma matriz de prazos indexados em 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)

Nota : isso só pode funcionar com etiquetas em [0-31]. Este é um limite de JS, não um limite do algoritmo.

Casos de teste

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]

Comentado

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