^{Thử thách Lấy từ cuộc thi thử thách mã trường đại học của tôi}

^{Đây thực sự là Ngày 0 nhưng thử thách của ngày hôm nay quá dễ dàng và có thể là một câu hỏi bịp lại ở đây.}

Tetris là một trò chơi video đã trở nên phổ biến vào những năm 80. Nó bao gồm việc đặt một loạt các mảnh với hình dạng khác nhau rơi trên một bảng, để chúng phù hợp theo cách nhỏ gọn nhất có thể.

Trong bài toán này, chúng tôi sẽ giả sử một chuỗi các mảnh rơi, mỗi mảnh ở một vị trí nhất định và với một hướng nhất định không thể thay đổi. Các mảnh được xếp chồng lên nhau khi chúng rơi xuống và các hàng hoàn chỉnh không bị loại bỏ (như trong trò chơi gốc). Mục tiêu là xác định chiều cao cuối cùng của mỗi cột của bảng sau khi tất cả các mảnh rơi xuống.

Có tổng cộng 7 mảnh khác nhau, được hiển thị trong hình:

Thử thách

Đưa ra một danh sách các mảnh, xuất chiều cao của tất cả các cột từ bảng sau khi tất cả các mảnh rơi xuống

Một mảnh bao gồm ba số: I, R và P. Số đầu tiên, I, là định danh của mảnh (một số từ 1 đến 7, theo cùng thứ tự như trong hình). Số thứ hai, R, là vòng quay của mảnh. Nó có thể lấy các giá trị 0, 90, 180 hoặc 270 và biểu thị góc quay của mảnh theo hướng ngược chiều kim đồng hồ. Số thứ ba, P, cho biết vị trí của mảnh. Đại diện cho cột bên trái bị chiếm đóng bởi mảnh (đây có thể là 1 hoặc 0 Index. Vui lòng ghi rõ).

Ví dụ và trường hợp thử nghiệm (1 Index)

• Được [[1, 0, 1], [4, 0, 1], [5, 90, 4]]

• Đầu ra [3, 3, 1, 3, 2]

• Được [[6, 270, 4], [1, 180, 5], [1, 90, 6], [7, 0, 4]]

• Đầu ra [0, 0, 0, 9, 9, 8, 3, 3]

• Cho [[3,0,1],[3,180,3]]đầu ra[1,1,4,4,4]

• Cho [[2,180,1],[2,0,3]]đầu ra[2,2,4,3,3]

Ghi chú

• Đây là môn đánh gôn
• Hàng / Cột có thể là 1 hoặc 0 Index. Xin hãy chỉ ra cụ thể.
• Bạn có thể xác định lại các giá trị đầu vào (có thể bạn muốn gọi phần 1 là A, v.v.). Trong trường hợp đó, vui lòng ghi rõ

Câu hỏi

• Chúng ta có thể sử dụng bất kỳ 4 giá trị khác biệt thay vì một góc trong độ ?: Có

• Có phải chúng ta phải xử lý "lỗ" nếu một mảnh không chính xác phù hợp so với giá cũ trước ?: Có

• Là chiều cao hoặc chiều rộng của bảng giới hạn? Không. Cả chiều rộng và chiều cao đều không bị giới hạn

Cảm ơn @Arnauld về hình ảnh và các trường hợp thử nghiệm *. *

JavaScript (Node.js) ,  286 284 270  266 byte

$[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

Hãy thử trực tuyến! hoặc thử một phiên bản nâng cao cũng hiển thị bảng cuối cùng.

Mã hóa hình dạng

Tất cả các mảnh được lưu trữ chính xác là 4 nibble (4 bit) với các hàng được sắp xếp theo thứ tự ngược lại và pixel ngoài cùng bên trái được ánh xạ tới bit có trọng số thấp nhất. Nói cách khác, biểu diễn nhị phân của hình được nhân đôi theo chiều dọc và chiều ngang.

Thí dụ:

Hàm băm và bảng tra cứu

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

$82$$0$

Các mục này được đóng gói như:

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

mở rộng tới 82 nibble sau:

"717433667233ff47173333276611000000000000113213001112221112123333333311133233221211"

$I$"ff"

Các tham số của hàm băm bị ép buộc theo cách tối ưu hóa các số 0 đứng đầu và dấu. Thực tế là chuỗi có thể được nén thêm một số bằng cách sử dụng 1e12các số 0 ở giữa và việc chuyển đổi từ cơ sở 16 sang cơ sở 4 cho phần bên phải chỉ là một tác dụng phụ đáng hoan nghênh nhưng không ngờ tới. :-)

Dưới đây là một minh chứng về quá trình giải nén cho tất cả các mảnh và tất cả các phép quay.

Đã bình luận

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 (tiếng kêu) , 253 239 221 212 byte

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;}}

Hãy thử trực tuyến!

ps Trên thực tế kích thước mã là 221 byte (nhưng là 212 ký tự) do các ký tự UNICODE được mã hóa theo UTF-8. Nhưng tio.run coi nó là mã 212 byte ...

Kích thước mã trên máy tính của tôi là 209 ký tự (218 byte). Nhưng tôi không thể thay thế \225bằng char có thể nhìn thấy trong tio.run 😞

Mã bị đánh cắp

// 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)

Sự miêu tả

Chúng ta hãy tìm dòng cơ sở hàng đầu ( TBL ) của mỗi hình và mô tả nó như một số ô bên dưới TBL cho mỗi vị trí nằm ngang. Ngoài ra, hãy mô tả số lượng tế bào (chiều cao) trên TBL ( HAT ).

Ví dụ:

                       ________ ________
_ [] _____ 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

Hãy mô tả TBL và HAT cho từng hình và từng góc quay:

TBL chiều rộng HAT
----- ------- -------
Số liệu L:
  3 1 1 1 1 0 0 // 0 °
  2 1 1 0 2 // 90 °
  3 1 1 2 0 0 0 // 180 °
  2 3 1 0 0 // 270 °

  3 1 1 1 0 0 1 // 0 °
  2 1 3 0 0 // 90 °
  3 2 1 1 0 0 0 // 180 °
  2 1 1 2 0 // 270 °

Hình chữ T:
  3 1 1 1 0 1 0 // 0 °
  2 1 2 0 1 // 90 °
  3 1 2 1 0 0 0 // 180 °
  2 2 1 1 0 // 270 °

Hàng:
  4 1 1 1 1 0 0 0 0 // 0 °, 180 °
  1 4 0 // 90 °, 270 °

Đường ngoằn ngoèo:
  3 1 1 0 0 1 1 // 0 °, 180 °
  2 1 2 1 0 // 90 °, 270 °

  3 0 1 1 1 1 0 // 0 °, 180 °
  2 2 1 0 1 // 90 °, 270 °

Khối lập phương:
  2 2 2 0 0 // mọi góc

Bây giờ chúng ta nên mã hóa các số này thành một chuỗi gồm 2 bit và đặt vào một mảng (thay thế 4 0bằng 3 1góc "đường" 90 ° để khớp với 2 bit - kết quả sẽ giống nhau và giảm độ rộng xuống 1).

Chúng tôi sẽ mã hóa theo thứ tự: chiều rộng (trong 2 LSB), TBL , HAT (lùi cho vòng lặp ngược). Ví dụ: 2 2 1 1 0 góc 270 ° của hình chữ T sẽ được mã hóa thành 1 0 1 2 1( 1 cuối cùng là chiều rộng-1 ) : 0b0100011001 = 281.

cập nhật 12.02:

a) Tôi đã chuyển đổi một mảng thành một chuỗi và lưu 18 ký tự (bạn có thể thấy mã 239 byte trước đó ) :))

b) Tối ưu hóa nhiều hơn, mã được thu nhỏ lại bằng 9 ký tự.
Đây là nỗ lực cuối cùng của tôi (tôi nghĩ như vậy, lol!) 😀

Lisp thông thường, 634 byte

(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))))))

Rực rỡ

(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))

Kiểm tra nó

Các mảnh là vòng tròn - danh sách các danh sách các số. Mỗi danh sách phụ này đại diện cho một bên của hình dạng, các con số cho biết chúng cách phía đối diện bao xa. Chúng nằm từ trái sang phải khi bên đó ở phía dưới, phải sang trái khi ở trên, trên xuống dưới khi ở bên trái và từ dưới lên trên khi ở bên phải. Những lựa chọn thiết kế loại bỏ sự cần thiết phải viết mã để xoay. Thật không may, việc thiếu mã xoay dường như không bù đắp cho các biểu diễn hình dạng dài hoặc logic hơi phức tạp mà tôi đã sử dụng để tính chiều cao cột mới.

Xoay là một số nguyên không âm. 0 = 0 độ, 1 = 90 độ, 2 = 180 độ, 4 = 270 độ

C # (Trình biên dịch tương tác Visual C #) , 308 byte

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;}

Hãy thử trực tuyến!

OK - Đó là sự điên rồ ... Tôi đã gửi một câu trả lời sử dụng các kỹ thuật chơi gôn mã. Nhưng khi tôi nhìn thấy những gì người khác đang gửi, tôi nhận ra có một cách tốt hơn.

Mỗi (shape, rotation)bộ dữ liệu được mã hóa thành một chuỗi ký tự C # với các bản sao được loại bỏ. Quá trình mã hóa nắm bắt từng cấu hình trong 2 byte.

Chiều cao lưu trữ 3 bit thấp nhất và chiều rộng 3 cửa hàng tiếp theo. Vì mỗi giá trị này không bao giờ nhiều hơn 4, chúng có thể được đọc trực tiếp từ 3 bit mà không cần chuyển đổi. Dưới đây là một số ví dụ:

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

Tiếp theo, mỗi cột được lưu trữ trong 3 bit. Điều hữu ích nhất đối với tôi để lưu trữ là số lượng hình vuông bị thiếu từ trên cùng và dưới cùng của cột.

// 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 ------+

Không bao giờ có nhiều hơn 2 hình vuông bị thiếu từ trên xuống hoặc dưới cùng, và không bao giờ có nhiều hơn 1 hình vuông bị thiếu từ cả hai cùng một lúc. Đưa ra các ràng buộc này, tôi đã đưa ra mã hóa sau:

// 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

Vì chúng ta phải chiếm tối đa 3 cột với các ô vuông bị thiếu ở trên hoặc bên dưới, chúng ta có thể mã hóa mỗi (shape, rotation)bộ trong 15 bit.

 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

Cuối cùng, hình dạng trùng lặp đã được loại bỏ. Ví dụ sau đây cho thấy cách nhiều (shape,rotation)bộ dữ liệu có thể tạo đầu ra trùng lặp cho cùng một hình dạng ở các góc quay khác nhau:

// 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

Tất cả các kết quả đầu ra duy nhất được xác định và lưu vào a byte[]và được chuyển đổi thành chuỗi ký tự C #. Để nhanh chóng tra cứu nơi hình dạng được dựa trên Ivà R, 7 byte đầu tiên của mảng bao gồm khóa tra cứu được mã hóa.

Dưới đây là một liên kết đến chương trình mà tôi đã sử dụng để nén các mảnh.

Hãy thử trực tuyến!

Mã ít chơi và nhận xét:

// 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;
}

Than , 98 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Lấy đầu vào dưới dạng một mảng các giá trị [P, R, I], trong đó I từ 0 đến 6, R là từ 0 o 3 và P cũng được lập chỉ mục 0. Giải trình:

Ｆθ«

Vòng qua các mảnh đầu vào.

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

Trích xuất mô tả của mảnh hiện tại và xoay. (Xem bên dưới.)

≔⊟ιζ

Trích xuất vị trí.

Ｗ‹Ｌυ⁺ζＬη⊞υ⁰

Đảm bảo rằng có đủ phòng ngang để đặt mảnh.

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

Đảm bảo rằng có đủ phòng dọc để đặt mảnh.

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

Tính độ cao mới của các cột bị ảnh hưởng.

»Ｉυ

Khi tất cả các phần đã được xử lý, xuất danh sách chiều cao cột cuối cùng trên các dòng riêng biệt.

Chuỗi nén đại diện cho chuỗi gốc 00001923001061443168200318613441602332034173203014614341642430137. Ở đây 2s là Idải phân cách và 1s là Rdải phân cách. Các mảnh do đó giải mã như sau:

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

Các Rgiá trị bị thiếu được tự động điền theo chu kỳ bằng Than. Mỗi chữ số sau đó ánh xạ tới hai giá trị, nhô ra và tổng chiều cao, theo bảng sau:

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

Phần nhô ra và tổng chiều cao liên quan đến chiều cao cột như sau: Cho một mảnh mà chúng ta muốn đặt tại một vị trí nhất định e, có thể đặt mảnh đó ngay cả khi một trong các cột cao hơn e. Số lượng không gian dự phòng được đưa ra bởi phần nhô ra. Chiều cao mới của cột sau khi đặt mảnh chỉ đơn giản là vị trí được đặt cộng với tổng chiều cao.

Ví dụ: Giả sử chúng ta bắt đầu bằng cách đặt một 5mảnh vào cột 1. Vì không có gì khác, do đó, mảnh được đặt ở vị trí 0 và cột 1 và 3 bây giờ có chiều cao 1 trong khi cột 2 có chiều cao 2. Sau đó, chúng tôi muốn đặt một 6mảnh với 1vòng quay trong cột 0. Ở đây chúng ta thực sự có thể đặt mảnh này ở vị trí 0; mặc dù cột 1 có chiều cao bằng 1, mảnh có phần nhô ra là 1 và do đó có đủ không gian để đặt nó. Cột 0 kết thúc với chiều cao là 2 và cột 1 kết thúc với chiều cao là 3.