<< 이전

PPCG 커뮤니티 덕분에 산타는 이제 스토리지 카트의 균형을 잡았습니다. 이제 적재 베이로 보낼 수 있도록 운반 도크로 옮겨야합니다. 불행히도, 카트를 움직일 수있는 트랙은 엉망이며, 그는 함께 충돌하지 않고 모든 카트를 어떻게 움직일 수 있는지 알아 내야합니다!

도전

각 카트의 트랙이 "라벨"(또는 스테이션) 목록으로 제공됩니다. 카트는 언제라도 두 개의 카트가 같은 레이블 / 스테이션에 있지 않도록 이동해야합니다. 본질적으로 카트는 각각 고유 한 레이블이있는 위치 사이를 이동합니다.

직무

라벨 목록 (모든 양의 정수) 목록으로 각 카트에 대한 트랙이 주어지면 모든 카트를 가능한 한 가장 짧은 시간에 목적지로 안전하게 보내기 위해 각 카트를 언제 릴리스해야하는지 결정하십시오.

다음은 전체 트랙 시스템의 작동 방식에 대한 설명입니다. 카트 i가 t_i라벨이 붙은 트랙에 특정 시간 에 출시 되었다고 가정 해 보겠습니다 T_i_1, T_i_2, ..., T_i_n. 그런 다음 t_1to 동안 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여전히 트랙 2 웨이이기 때문에 "안전"합니다.

포맷 사양

입력은 임의의 적절한 형식으로 양의 정수의 행렬로 제공됩니다. 출력은 합리적인 형식의 양의 정수 목록으로 제공되어야합니다. 인덱스가없는 시간 프레임으로 출력을 제공 할 수 있으므로 출력은 임의의 합리적인 형식의 음이 아닌 정수 목록이됩니다.

규칙

• 표준 허점 적용
• 이것은 코드 골프 이므로 바이트 단위의 최단 답변이 이깁니다.
• 응답이 없습니다

테스트 사례

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]

^{참고 : Advent Of Code 에서이 챌린지 시리즈에 대한 영감을 얻었습니다 . 이 사이트와 관련이 없습니다}

여기서 첫 번째 도전 과제의 '링크 된'섹션을 보면 시리즈의 모든 도전 과제 목록을 볼 수 있습니다 .

행복한 골프!

자바 스크립트 (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)

NB : [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