^{대학 코드 챌린지 컨테스트에서 가져온 챌린지}

^{이것은 실제로 Day 0이지만 어제의 도전은 너무 쉬웠으며 여기에서 또 다른 질문을 속일 수 있습니다.}

테트리스는 80 년대에 인기를 얻은 비디오 게임입니다. 보드에 떨어지는 다양한 모양의 일련의 조각을 배치하여 가능한 가장 컴팩트 한 방식으로 맞 춥니 다.

이 문제에서는 각각 특정 위치에 있고 변경할 수없는 특정 방향으로 떨어지는 일련의 조각을 가정합니다. 조각들은 떨어지면서 쌓이고 완전한 줄은 제거되지 않습니다 (원래 게임 에서처럼). 목표는 모든 조각이 떨어진 후 보드의 각 열의 최종 높이를 결정하는 것입니다.

그림과 같이 총 7 개의 서로 다른 조각이 있습니다.

도전

조각 목록이 주어지면 모든 조각이 떨어지는 후 보드에서 모든 열의 높이를 출력하십시오.

조각은 I, R 및 P의 세 숫자로 구성됩니다. 첫 번째 숫자 I은 조각의 식별자입니다 (그림과 동일한 순서로 1과 7 사이의 숫자). 두 번째 숫자 R은 조각의 회전입니다. 0, 90, 180 또는 270 값을 사용할 수 있으며 시계 반대 방향으로 피스의 회전 각도를 나타냅니다. 세 번째 숫자 P는 조각의 위치를 ​​나타냅니다. 조각이 차지하는 왼쪽의 열을 나타냅니다 (1 또는 0 색인 일 수 있습니다. 지정하십시오).

예제 및 테스트 사례 (1 인덱스)

• 주어진 [[1, 0, 1], [4, 0, 1], [5, 90, 4]]

• 산출 [3, 3, 1, 3, 2]

• 주어진 [[6, 270, 4], [1, 180, 5], [1, 90, 6], [7, 0, 4]]

• 산출 [0, 0, 0, 9, 9, 8, 3, 3]

• 주어진 [[3,0,1],[3,180,3]]출력[1,1,4,4,4]

• 주어진 [[2,180,1],[2,0,3]]출력[2,2,4,3,3]

노트

• 이것은 코드 골프입니다
• 행 / 열은 1 또는 0 인덱스 일 수 있습니다. 명시 해주세요.
• 입력 값을 재정의 할 수 있습니다 (1 번을 A 등이라고 부를 수 있음). 이 경우 지정하십시오

질문

• 우리는 정도의 각도 대신 어떤 사 개 고유 한 값을 사용할 수? : 예

• 조각이 이전 조각에 정확히 맞지 않으면 "구멍"을 처리해야합니까? : 예

• 보드의 높이 또는 너비가 제한되어 있습니까? 아니요. 너비와 높이가 모두 제한되지 않습니다

이미지와 테스트 사례에 대한 @Arnauld 감사합니다 *. *

자바 스크립트 (Node.js를) ,  286 284 270  266 바이트

$[0..3]$

a=>a.map(([p,r,x])=>(g=y=>y>3?g(+!Y--):b[Y+y]&(m[y]=('0x'+`717433667233ff4717333327661${1e12+0x5e7056a566ffff57efa65n.toString(4)}`[(p*2+r*56+y*99+13)%113])<<x)?m.map(v=>(g=x=>v&&g(x+1,H[x]=v&1?Y:~~H[x],v>>=1))(0,b[++Y]|=v)):g(y+1))(Y=a.length*4),m=[b=[-1]],H=[])&&H

온라인으로 사용해보십시오! 또는 최종 보드를 표시 하는 고급 버전 을 사용해보십시오 .

모양 인코딩

모든 조각은 정확히 4 개의 니블 (4x4 비트)로 저장되며 행은 역순으로 정렬되고 맨 왼쪽 픽셀은 최하위 비트에 매핑됩니다. 다시 말해, 모양의 이진 표현은 수직 및 수평으로 미러링됩니다.

예:

해시 함수 및 조회 테이블

$p \in [0..6]$$r \in [0..3]$$y \in [0..3]$$n$

$82$$0$

이러한 항목은 다음과 같이 포장됩니다.

`717433667233ff4717333327661${1e12+0x5e7056a566ffff57efa65n.toString(4)}`

이는 다음 82 개의 니블로 확장됩니다.

"717433667233ff47173333276611000000000000113213001112221112123333333311133233221211"

$I$"ff"

해시 함수의 매개 변수는 선행 및 후행 0을 최적화하는 방식으로 무차별 강제 적용되었습니다. 1e12중간에 0 을 사용 하고 오른쪽 부분을 base-16에서 base-4로 변환 하여 문자열을 더 압축 할 수 있다는 사실 은 환영하지만 예기치 않은 부작용입니다. :-)

다음은 모든 조각과 모든 회전에 대한 포장 풀기 과정을 보여줍니다 .

댓글

a => a.map(([p, r, x]) => (     // for each piece p with rotation r and position x:
  g = y =>                      //   g = recursive function taking y
    y > 3 ?                     //   if y is greater than 3:
      g(+!Y--)                  //     reset y to 0, decrement Y and try again
    :                           //   else:
      b[Y + y] & (              //     test if we have a collision of the board with
        m[y] =                  //     the y-th row m[y] of the current piece
          ('0x' + `717...`[     //     which is extracted from a lookup table
            (p * 2 + r * 56 +   //     using the hash function described in the
             y * 99 + 13) % 113 //     previous paragraph
          ]) << x               //     and shifted to the left according to x
      ) ?                       //     if we have a collision:
        m.map(v => (            //       we iterate again on the piece rows stored in m[]
          g = x =>              //         g = recursive function taking x
            v &&                //         if v is not equal to 0:
            g(                  //           do a recursive call:
              x + 1,            //             increment x
              H[x] =            //             update the height at x:
                v & 1 ?         //               if this bit is set:
                  Y             //                 set it to Y
                :               //               else:
                  ~~H[x],       //                 leave it unchanged or force it to 0
                                //                 if it was still undefined
              v >>= 1           //             shift v to the right
            )                   //           end of recursive call
          )(0,                  //         initial call to g with x = 0
               b[++Y] |= v)     //         increment Y and copy the piece row to the board
        )                       //     end of map()
      :                         //   else (no collision):
        g(y + 1)                //     do a recursive call to test the next row
  )(Y = a.length * 4),          //   initial call to g with y = Y = 4 * the number of pieces
                                //   (assuming the worst case: piled vertical I pieces)
  m = [b = [-1]], H = []        //   initialize m[], b[] and H[]
                                //   we set a full line at the bottom of b[]
) && H                          // end of map(); return H[]

C (연타) , 253 (239) 221 212 바이트

t(*a,*b,c){char*z="VP\225TBUIUVAaUZ@AWVDeTf@EVWhU😎EQV😀RTYT😉UU";for(size_t*p,f,n,y,i;c--;b++){f=1<<(8-*b)/3;p=z+*b++*8+*b++%f*2;f=n=*p;for(y=i=0;i<=f%4;y=fmax(y,a[*b+i++]+n%4))n/=4;for(;i--;a[*b+i]=y+n%4)n/=4;}}

온라인으로 사용해보십시오!

ps 실제로 UTF-8로 코딩 된 UNICODE 문자로 인해 코드 크기는 221 바이트 (그러나 212 자)입니다. 그러나 tio.run 은 그것을 212 바이트 코드로 취급합니다 ...

내 컴퓨터의 코드 크기는 209 자 (218 바이트)입니다. 그러나 tio.run \225에서 보이는 char로 바꿀 수 없었습니다.

Ungolfed 코드

// a - output array (must be zeroed), b - array of block info, c - number of blocks

// Figure codes: 2->0, 3->1, 6->2, 1->3, 5->4, 7->5, 4->6 (0,1 are L-figures, 2 is is T-figure, 3 is a line 1x4; 4,5 are zigzags; 6 is a cube 2x2)
// Vertical and horizontal positions are zero-indexed, angles = 0..3

t(*a,*b,c)
{
  char*z="VP\225TBUIUVAaUZ@AWVDeTf@EVWhU😎EQV😀RTYT😉UU";  // UTF-8
//char*z="VP\225TBUIUVAaUZ@AWVDeTf@EVW\1hU😎\26EQV😀RTYT😉UU";  // 3 bytes longer (use it if you can't copy previous string correctly) :)
  // Blocks
  for(size_t*p,f,n,y,i;c--;b++){
    f=1<<(8-*b)/3;  // number of figure variants
    p=z+*b++*8+*b++%f*2;
    // Get top base line position (y)
    f=n=*p;  // figure width, TBLs and HATs
    for(y=i=0;i<=f%4;
      y=fmax(y,a[*b+i++]+n%4))
      n/=4;
    // Add heights (HATs)
    for(;i--;
      a[*b+i]=y+n%4)
      n/=4;
  }
}  // 215 chars (224 bytes)

기술

각 그림의 상단 기준선 ( TBL )을 찾아서 각 수평 위치에 대해 TBL 아래의 여러 셀로 설명하겠습니다. 또한 TBL ( HAT ) 위의 셀 수 (높이)를 설명하겠습니다 .

예 :

                       ________ ________
_ [] _____ HAT = 1,0,0 [] [] [] HAT = 0,0,0 ___ [] [] _ ​​HAT = 0,1,1 [] [] [] HAT = 0,0,0
 [] [] [] TBL = 1,1,1 [] TBL = 2,1,1 [] [] TBL = 1,1,0 [] TBL = 1,2,1

각 그림 및 각 회전 각도에 대한 TBL 및 HAT를 설명하겠습니다.

폭 TBL HAT
----- ------- -------
L- 피겨 :
  311 11 10 // 0 °
  2 1 0 2 // 90 °
  3112 20 // // 180 °
  2 3 0 0 // 270 °

  3 11 1 0 1 // 0 °
  2 3 0 0 // 90 °
  3112 10 // // 180 °
  2112 2 // 270 °

T 그림 :
  311 1010 // 0 °
  2212 1 // 90 °
  3112 0 // // 180 °
  212 1 // 270 °

선:
  4 1 1 10 10 0 // 0 °, 180 °
  140 // 90 °, 270 °

지그재그 :
  3110 0 1 // 0 °, 180 °
  2212 // // 90 °, 270 °

  301111 // // 0 °, 180 °
  212 1 // 90 °, 270 °

입방체:
  2 2 0 0 // 모든 각도

(대체 이제 우리는 2 비트의 시퀀스로 이들 숫자를 인코딩 및 배열에 넣어야 4 0로 3 1- 1에 의해 감소 폭이 동일하게 될 것이다 따라서 2 비트에 맞는 "라인"90 ° 각도).

너비 (2 LSB), TBL , HAT (후진 루프의 경우 뒤로 )의 순서로 인코딩 합니다. 예 2 2 1 1 0 를 들어 T- 피겨의 270 ° 각도에 대해 1 0 1 2 1(마지막 1 은 너비 -1 ) 로 인코딩됩니다 0b0100011001 = 281.

12.02 업데이트 :

a) 배열을 문자열로 변환하고 18자를 저장했습니다 (이전 239 바이트 코드를 볼 수 있습니다 ) :))

b)보다 최적화 된 코드는 9 문자로 줄어 듭니다.
이것은 나의 마지막 시도이다 (나는 그렇게 생각한다, lol!) 😀

공통 리스프, 634 바이트

(let((w(make-hash-table))(r 0))(defun z(c)(or(gethash c w)0))(defun x(c v)(setf r(max r c))(setf(gethash c w)v))(defun m(s)(dolist(c s)(apply(lambda(n u p)(let*((i(let*((j'(2 2 2))(k'(3 3))(l'(2 3))(m'(3 2))(o(case n(1(list'(1 1 1 1)'(4)))(2(list j k'(1 1 2)'(3 1)))(3(list j'(1 3)'(2 1 1)k))(4(list'(2 2)))(5(list'(2 2 1)l))(6(list j l'(1 2 1)m))(7(list'(1 2 2)m)))))(setf(cdr(last o))o)))(o(nth(+ u 2)i))(b(nth u i))(s(length o))(d 0)(h 0))(dotimes(i s)(let*((w(nth i b))(g(z(+ i p)))(m(+ g w)))(when(> m d)(setf d m)(setf h(- g(-(apply'max b)w))))))(dotimes(i s)(x(-(+ s p)i 1)(+(nth i o)h)))))c))(dotimes(i r)(print(z (+ i 1))))))

말 수가 많은

(defun circular (list)
  (setf (cdr (last list)) list))

(defun get-piece (piece-number)
  (circular (case piece-number
              (1 (list '(1 1 1 1)
                       '(4)))
              (2 (list '(2 2 2)
                       '(3 3)
                       '(1 1 2)
                       '(3 1)))
              (3 (list '(2 2 2)
                       '(1 3)
                       '(2 1 1)
                       '(3 3)))
              (4 (list '(2 2)))
              (5 (list '(2 2 1)
                       '(2 3)))
              (6 (list '(2 2 2)
                       '(2 3)
                       '(1 2 1)
                       '(3 2)))
              (7 (list '(1 2 2)
                       '(3 2))))))

(let ((world (make-hash-table))
      (rightmost-column 0))
  (defun get-world-column (column)
    (or (gethash column world) 0))

  (defun set-world-column (column value)
    (setf rightmost-column (max rightmost-column column))
    (setf (gethash column world) value))

  (defun drop-piece (piece-number rotation position)
    (let* ((piece (get-piece piece-number))
           (top (nth (+ rotation 2) piece))
           (bottom (nth rotation piece))
           (size (length top))
           (max-combined-height 0)
           (contact-height 0))
      (dotimes (i size)
        (let* ((down-distance (nth i bottom))
               (height (get-world-column (+ i position)))
               (combined-height (+ height down-distance)))
          (when (> combined-height max-combined-height)
            (setf max-combined-height combined-height)
            (setf contact-height
                  (- height
                     (- (apply #'max bottom)
                        down-distance))))))
      (dotimes (i size)
        (set-world-column (- (+ size position) i 1)
                          (+ (nth i top) contact-height)))))

  (defun drop-pieces (pieces)
    (dolist (piece pieces)
      (apply #'drop-piece piece)))

  (defun print-world ()
    (loop for i from 1 to rightmost-column
          do (print (get-world-column i)))))

(defun play-tetris (pieces)
  (drop-pieces pieces)
  (print-world))

그것을 테스트

조각은 숫자 목록의 원형 목록입니다. 이 하위 목록은 각각 모양의 측면을 나타내며 숫자는 반대쪽에서 얼마나 멀리 떨어져 있는지 나타냅니다. 측면이 맨 아래에있을 때 왼쪽에서 오른쪽으로, 맨 위에있을 때 오른쪽에서 왼쪽으로, 왼쪽에서 맨 아래에서, 오른쪽에서 맨 아래에서 맨 아래입니다. 이러한 설계 선택은 회전을 위해 코드를 작성할 필요가 없습니다. 불행히도 회전 코드가 부족하여 긴 모양 표현이나 새로운 열 높이를 계산하는 데 사용한 다소 복잡한 논리를 구성하지 않은 것 같습니다.

회전은 음이 아닌 정수입니다. 0 = 0도, 1 = 90도, 2 = 180도, 4 = 270도

C # (Visual C # 대화식 컴파일러) , 308 바이트

a=>{var o=new int[a.Max(x=>x.Item3+4)];foreach(var(i,r,p)in a){var b="\"4TqzŒª!\0\0HSš	Ó\0$\n\0!“A“š š@";int m=0,n=b[i],t=0,u=n/8+r%(n%8),v=b[u*=2]<<8|b[u-1];for(;t<v/8%8;m=m>n?m:n)n=o[p+t]+v%8-(n=(u=v>>6+3*t++)/2&1)-(n&u);for(;t-->0;)o[p+t]=m-(n=(u=v>>6+3*t)/4&1)-(n&u);}return o;}

온라인으로 사용해보십시오!

OK-그건 광기 였어. 나는 방앗간 코드 골프 기술을 사용한 답을 제출했다. 그러나 다른 사람들이 제출하는 것을 보았을 때 더 좋은 방법이 있다는 것을 깨달았습니다.

각 (shape, rotation)튜플은 중복이 제거 된 C # 문자열 리터럴로 인코딩됩니다. 인코딩 프로세스는 이러한 각 구성을 2 바이트로 캡처합니다.

가장 낮은 3 비트 저장 높이와 다음 3 개 저장 너비. 이러한 각 값은 4를 넘지 않기 때문에 변환없이 3 비트에서 직접 읽을 수 있습니다. 여기 몇 가지 예가 있어요.

  W   H
010 010 (2x2)
010 011 (2x3)
001 100 (1x4)
011 010 (3x2)
100 001 (4x1)

다음으로 각 열은 3 비트로 저장됩니다. 내가 저장하는 가장 유용한 것은 열의 상단과 하단에서 누락 된 사각형의 수였습니다.

// missing squares per column

+------ 0 top / 0 bottom
|+----- 0 top / 1 bottom
||+---- 0 top / 1 bottom
|||
HHH (L-Shape)         HH (Jagged-Shape)
H                    HH
                     |||
1 top / 0 bottom ----+||
0 top / 0 bottom -----+|
0 top / 1 bottom ------+

상단 또는 하단에서 2 개 이상의 사각형이 누락되지 않으며 동시에 두 개에서 1 개 이상의 사각형이 누락되지 않습니다. 이 제약 조건이 주어지면 다음 인코딩을 생각해 냈습니다.

// column encoding of missing squares per column

000: none missing
100: 1 missing on top
101: 2 missing on top
010: 1 missing on bottom
011: 2 missing on bottom
110: 1 missing on top and bottom

위 또는 아래에 누락 된 사각형이있는 최대 3 개의 열을 고려해야하므로 각 (shape, rotation)튜플을 15 비트로 인코딩 할 수 있습니다 .

 C3  C2  C1   W   H
000 000 000 010 010 - 2x2 with no missing squares
000 000 000 100 001 - 4x1 with no missing squares
100 000 100 011 010 - 3x2 with missings square on top of columns 1 and 3
000 110 000 010 011 - 2x3 with missing squares on top and bottom of column 2

마지막으로 중복 모양이 제거되었습니다. 다음 예제는 여러 (shape,rotation)튜플이 다른 회전에서 동일한 모양에 대해 중복 출력을 생성 하는 방법을 보여줍니다 .

// Square
HH  (0, 90, 180, 270)
HH
#-------------------------------#
// ZigZag
HH  (0, 180)    H  (90, 270)
 HH            HH
               H
#-------------------------------#
// T
 H  (0)        HHH  (180)
HHH             H

 H  (90)       H    (270)
HH             HH
 H             H

모든 고유 출력은 결정되어 byte[]C # 문자열 리터럴로 변환됩니다. 신속 형상에 기초하여 위치를 조회하기 위해 I그리고 R상기 어레이의 제 7 바이트는 인코딩 된 조회 키 구성.

아래는 조각을 압축하는 데 사용한 프로그램에 대한 링크입니다.

온라인으로 사용해보십시오!

덜 골퍼하고 주석이 달린 코드 :

// a: input list of (i,r,p) tuples
a=>{
  // create an output array that 4 more than
  // the largest position. this may result
  // in some trailing 0's
  var o=new int[a.Max(x=>x.Item3+4)];

  // iterate over each (i,r,p) tuple
  foreach(var(i,r,p)in a){
    // escaped string
    var b="\"4Tqzª!\0\0HS   Ó\0$\n\0!A @";
    // declare several variables that will be used later
    int m=0,n=b[i],t=0,
      // u is the decoded index into b for the current (i,r) pair
      u=n/8+r%(n%8),
      // convert 2 bytes from b into an encoded (shape,rotation) pair
      v=b[u*=2]<<8|b[u-1];
    // iterate over the columns, determining the top of the current
    // piece. The formula here is:
    //   piece_top = max(column_height + shape_height - shape_space_bottom)
    for(;t<v/8%8;m=m>n?m:n)
      n=o[p+t]+v%8-(n=(u=v>>6+3*t++)/2&1)-(n&u);
    // iterate over the columns again, saving the the new height
    // in each column. The formula here is:
    //   new_column_height = piece_top - shape_space_top
    for(;t-->0;)
      o[p+t]=m-(n=(u=v>>6+3*t)/4&1)-(n&u);
  }
  return o;
}

숯 , 98 바이트

Ｆθ«≔§⪪§⪪”)¶∧↷"e«↨U∧0%3；D∧⁼~h⊟⁵h/₂dΦ↗(EＦ”2⊟ι1⊟ιη≔⊟ιζＷ‹Ｌυ⁺ζＬη⊞υ⁰≔⌈Ｅη⁻§υ⁺ζλ﹪Ｉκ³εＦＬη§≔υ⁺ζκ⁺ε⊕÷Ｉ§ηκ³»Ｉυ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 입력을 [P, R, I] 값의 배열로 취합니다. 여기서 I는 0에서 6, R은 0에서 3, P는 0으로 인덱스됩니다. 설명:

Ｆθ«

입력 조각을 반복합니다.

≔§⪪§⪪”)¶∧↷"e«↨U∧0%3；D∧⁼~h⊟⁵h/₂dΦ↗(EＦ”2⊟ι1⊟ιη

현재 조각과 회전에 대한 설명을 추출하십시오. (아래 참조)

≔⊟ιζ

위치를 추출하십시오.

Ｗ‹Ｌυ⁺ζＬη⊞υ⁰

피스를 놓을 수있는 수평 공간이 충분한 지 확인하십시오.

≔⌈Ｅη⁻§υ⁺ζλ﹪Ｉκ³ε

조각을 놓을 수있는 수직 공간이 충분한 지 확인하십시오.

ＦＬη§≔υ⁺ζκ⁺ε⊕÷Ｉ§ηκ³

영향을받는 열의 새 높이를 계산하십시오.

»Ｉυ

모든 조각이 처리되면 열 높이의 최종 목록을 별도의 줄에 출력하십시오.

압축 된 문자열은 원래 문자열을 나타냅니다 00001923001061443168200318613441602332034173203014614341642430137. 여기서 2s는 I구분 기호이고 1s는 R구분 기호입니다. 따라서 조각은 다음과 같이 디코딩됩니다.

P\R  0    1    2    3
0    0000 9
1    300  06   443  68
2    003  86   344  60
4    33
5    034  73
6    030  46   434  64
7    430  37

결 측값 R은 자동으로 차콜에 의해 주기적으로 채워집니다. 그런 다음 각 숫자는 다음 표에 따라 돌출부와 총 높이의 두 값에 매핑됩니다.

\ O H
0 0 1
3 0 2
4 1 2
6 0 3
7 1 3
8 2 3
9 0 4

돌출부와 총 높이는 다음과 같이 기둥 높이와 관련이 있습니다. 주어진 위치 e에 배치 할 조각이 있으면 기둥 중 하나가 키보다 크더라도 조각을 배치 할 수 있습니다 e. 여분의 공간은 돌출부에 의해 제공됩니다. 피스 배치 후 컬럼의 새로운 높이는 단순히 배치 된 위치에 총 높이를 더한 것입니다.

예 : 5열 1에 피스를 배치하는 것으로 시작한다고 가정합니다. 다른 것은 없기 때문에 피스가 위치 0에 배치되고 열 1과 3의 높이가 1이고 열 2의 높이가 2입니다. 그러면 6피스 를 배치하려고합니다. 하여 1다음 열 0의 회전 위치 우리는 실제로 0이 조각을 배치 할 수; 열 1의 높이는 1이지만 조각의 돌출부는 1이므로 놓을 공간이 충분합니다. 열 0은 높이 2로 끝나고 열 1은 3 높이로 끝납니다.