^{Challenge ถ่ายจากการแข่งขันเพื่อชิงรหัสมหาวิทยาลัย}

^{นี่คือวันที่ 0 แต่ความท้าทายของเมื่อวานเป็นเรื่องง่ายเกินไปและอาจเป็นคำถามอื่นที่นี่}

Tetris เป็นวิดีโอเกมที่ได้รับความนิยมในยุค 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 และอื่น ๆ ) ในกรณีนั้นโปรดระบุ

คำถาม

• เราสามารถใช้ค่าที่แตกต่างกัน 4 ค่าใด ๆ แทนมุมเป็นองศาได้หรือไม่: ใช่

• เราควรจะจัดการกับ "หลุม" หากชิ้นส่วนไม่พอดีกับชิ้นก่อนหน้าหรือไม่?: ใช่

• ความสูงหรือความกว้างของกระดานล้อมรอบหรือไม่? ไม่ทั้งความกว้างและความสูงไม่ถูก จำกัด ขอบเขต

ขอบคุณ @Arnauld สำหรับภาพและกรณีทดสอบ *. *

JavaScript (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 nibbles (4x4 บิต) โดยเรียงแถวเรียงลำดับกลับกันและพิกเซลซ้ายสุดจับคู่กับบิตที่มีนัยสำคัญน้อยที่สุด กล่าวอีกนัยหนึ่งการแทนค่าแบบไบนารี่ของรูปร่างนั้นถูกสะท้อนทั้งในแนวตั้งและแนวนอน

ตัวอย่าง:

ฟังก์ชันแฮชและตารางการค้นหา

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

$82$$0$

รายการเหล่านี้บรรจุเป็น:

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

ซึ่งขยายไปยัง 82 nibbles ต่อไปนี้:

"717433667233ff47173333276611000000000000113213001112221112123333333311133233221211"

$I$"ff"

พารามิเตอร์ของฟังก์ชั่นแฮชถูกบังคับด้วยวิธีการที่ปรับค่าศูนย์นำหน้าและท้ายสุดให้เหมาะสมที่สุด ความจริงที่ว่าสตริงนั้นสามารถถูกบีบอัดได้มากกว่าโดยการใช้1e12สำหรับศูนย์ที่อยู่ตรงกลางและการแปลงจาก 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 จริง ๆ แล้วขนาดรหัสคือ 221 ไบต์ (แต่ 212 ตัวอักษร) เนื่องจากตัวอักษร UNICODE ที่เข้ารหัสใน UTF-8 แต่tio.runถือว่ามันเป็นรหัส 212 ไบต์ ...

ขนาดรหัสในคอมพิวเตอร์ของฉันคือ 209 ตัวอักษร (218 ไบต์) แต่ฉันไม่สามารถแทนที่\225โดยถ่านมองเห็นได้ในtio.run 😞

รหัสที่ไม่ได้รับการปรับปรุง

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

ลักษณะ

ลองหา base base ( 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

ลองอธิบาย TBLs และ HAT สำหรับแต่ละรูปและแต่ละมุมการหมุน:

ความกว้าง TBLs HATs
----- ------- -------
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 °

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 °

ไลน์:
  4 1 1 1 1 1 0 0 0 0 // 0 °, 180 °
  1 4 0 // 90 °, 270 °

zigzags:
  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 °

Cube:
  2 2 2 0 0 // มุมใดก็ได้

ตอนนี้เราควรเข้ารหัสตัวเลขเหล่านี้เป็นลำดับ 2 บิตและใส่ลงในอาร์เรย์ (แทนที่4 0ด้วย3 190 องศาของ "เส้น" เพื่อให้พอดีกับ 2 บิต - ผลจะเหมือนกันและลดความกว้าง 1)

เราจะเข้ารหัสตามลำดับ: ความกว้าง (ใน 2 LSB), TBLs , HAT (ย้อนกลับสำหรับวนย้อนหลัง) เช่น2 2 1 1 0 270 °มุมของ T-ร่างจะถูกเข้ารหัสเป็น1 0 1 2 1(ในช่วง1คือความกว้าง-10b0100011001 = 281 ):

อัปเดต 12.02:

a) ฉันได้แปลงอาร์เรย์เป็นสตริงและบันทึก 18 ตัวอักษร (คุณสามารถดูรหัส 239 ไบต์ก่อนหน้านี้:)))

b) การปรับให้เหมาะสมยิ่งขึ้นโค้ดถูกลดขนาดด้วย 9 ตัวอักษร
นี่คือความพยายามครั้งสุดท้ายของฉัน (ฉันคิดอย่างนั้นฮ่า ๆ !) 😀

Lisp ทั่วไป, 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 # Interactive Compiler)ขนาด 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;}

ลองออนไลน์!

ตกลง - นั่นเป็นบ้า ... ฉันส่งคำตอบที่ใช้เทคนิค code-golf run-of-the-mill แต่เมื่อฉันเห็นสิ่งที่คนอื่นกำลังส่งฉันรู้ว่ามีวิธีที่ดีกว่า

(shape, rotation)tuple แต่ละรายการจะถูกเข้ารหัสเป็นสตริงตัวอักษร 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)tuple ใน 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

เอาต์พุตที่ไม่ซ้ำกันทั้งหมดจะถูกกำหนดและบันทึกเป็น a byte[]และแปลงเป็นสตริงตัวอักษร C # เพื่อให้ค้นหาได้อย่างรวดเร็วโดยที่รูปร่างนั้นอิงIและR7 ไบต์แรกของอาร์เรย์นั้นประกอบด้วยคีย์การค้นหาที่เข้ารหัส

ด้านล่างนี้เป็นลิงค์ไปยังโปรแกรมที่ฉันใช้ในการบีบอัดข้อมูล

ลองออนไลน์!

รหัส golfed น้อยลงและแสดงความคิดเห็น:

// 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] โดยที่ฉันอยู่ระหว่าง 0 ถึง 6, R มาจาก 0 o 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