^{Herausforderung Aus meinem Hochschulcode-Herausforderungswettbewerb entnommen}

^{Dies ist eigentlich Tag 0, aber die gestrige Herausforderung war zu einfach und kann hier ein Betrug einer anderen Frage sein.}

Tetris ist ein Videospiel, das in den 80er Jahren populär wurde. Es besteht aus einer Reihe von Stücken mit unterschiedlichen Formen, die auf ein Brett fallen, damit sie möglichst kompakt passen.

In diesem Problem nehmen wir eine Folge von Stücken an, die jeweils in einer bestimmten Position und mit einer bestimmten Ausrichtung abfallen, die nicht geändert werden können. Die Steine ​​werden beim Fallen gestapelt und die kompletten Reihen werden nicht eliminiert (wie im ursprünglichen Spiel). Ziel ist es, die endgültige Höhe jeder Brettsäule zu bestimmen, nachdem alle Teile gefallen sind.

Es gibt insgesamt 7 verschiedene Teile, die in der Abbildung dargestellt sind:

Herausforderung

Wenn Sie eine Stückliste erhalten haben, geben Sie die Höhe aller Spalten von der Tafel aus, nachdem alle Stücke gefallen sind

Ein Stück besteht aus drei Zahlen: I, R und P. Die erste Zahl, I, ist die Kennung des Stücks (eine Zahl zwischen 1 und 7 in derselben Reihenfolge wie in der Abbildung). Die zweite Zahl, R, ist die Drehung des Stücks. Sie kann die Werte 0, 90, 180 oder 270 annehmen und repräsentiert den Drehwinkel des Werkstücks gegen den Uhrzeigersinn. Die dritte Zahl P gibt die Position des Teils an. Stellt die Spalte auf der linken Seite dar, die von dem Stück belegt ist (dies kann ein Index von 1 oder 0 sein. Bitte angeben).

Beispiel und Testfall (1 Index)

• Gegeben [[1, 0, 1], [4, 0, 1], [5, 90, 4]]

• Ausgabe [3, 3, 1, 3, 2]

• Gegeben [[6, 270, 4], [1, 180, 5], [1, 90, 6], [7, 0, 4]]

• Ausgabe [0, 0, 0, 9, 9, 8, 3, 3]

• Gegebene [[3,0,1],[3,180,3]]Ausgabe[1,1,4,4,4]

• Gegebene [[2,180,1],[2,0,3]]Ausgabe[2,2,4,3,3]

Anmerkungen

• Das ist Code-Golf
• Zeile / Spalte kann 1 oder 0 Index sein. Bitte spezifizieren.
• Sie können Eingabewerte neu definieren (möglicherweise möchten Sie Teil 1 als A usw. bezeichnen). In diesem Fall bitte angeben

Fragen

• Können wir 4 verschiedene Werte anstelle eines Winkels in Grad verwenden ?: Ja

• Sollen wir mit "Löchern" umgehen, wenn ein Teil nicht genau über die vorherigen passt ?: Ja

• Ist die Höhe oder die Breite der Tafel begrenzt? Nein, weder die Breite noch die Höhe sind begrenzt

Danke @Arnauld für die Bilder und die Testfälle *. *

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

Teile und Positionen sind 0-indiziert. Winkel sind in$[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

Probieren Sie es online! Oder versuchen Sie es mit einer erweiterten Version , die auch die endgültige Karte anzeigt.

Formkodierung

Alle Teile werden als genau 4 Halbbytes (4 × 4 Bits) gespeichert, wobei die Zeilen in umgekehrter Reihenfolge sortiert sind und das am weitesten links stehende Pixel dem niedrigstwertigen Bit zugeordnet ist. Mit anderen Worten wird die binäre Darstellung der Form sowohl vertikal als auch horizontal gespiegelt.

Beispiel:

Hash-Funktion und Nachschlagetabelle

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

Nur die ersten Einträge werden explizit gespeichert. Alles andere wird auf .$82$$0$

Diese Einträge sind gepackt als:

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

Das erweitert sich auf die folgenden 82 Knabbereien:

"717433667233ff47173333276611000000000000113213001112221112123333333311133233221211"

Die Verwendung von Hexadezimal im endgültigen Format ist nur für die beiden horizontalen Darstellungen des Stücks erforderlich , daher die in der obigen Zeichenfolge.$I$"ff"

Die Parameter der Hash-Funktion wurden auf eine Weise brutal erzwungen, die führende und nachfolgende Nullen optimiert. Die Tatsache, dass die Zeichenfolge durch Verwendung 1e12der Nullen in der Mitte und einer Konvertierung von base-16 zu base-4 für den rechten Teil noch weiter komprimiert werden kann, ist nur ein willkommener, aber unerwarteter Nebeneffekt. :-)

Hier sehen Sie eine Demonstration des Auspackvorgangs für alle Teile und alle Umdrehungen.

Kommentiert

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 (clang) , 253 239 221 212 Bytes

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

Probieren Sie es online!

ps Tatsächlich beträgt die Codegröße 221 Byte (aber 212 Zeichen), da UNICODE-Zeichen in UTF-8 codiert sind. Aber tio.run behandelt es als 212-Byte-Code ...

Die Codegröße auf meinem Computer beträgt 209 Zeichen (218 Byte). Aber ich konnte nicht \225durch sichtbares Zeichen in tio.run replace ersetzen

Ungolfed Code

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

Beschreibung

Finden wir die obere Grundlinie ( TBL ) jeder Figur und beschreiben sie als eine Anzahl von Zellen unterhalb der TBL für jede horizontale Position. Beschreiben wir auch die Anzahl der Zellen (Höhe) über TBL ( HAT ).

Z.B:

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

Beschreiben wir TBLs und HATs für jede Figur und jeden Drehwinkel:

Breite TBLs HATs
----- ------- -------
L-Figuren:
  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-Figur:
  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 °

Linie:
  4 1 1 1 1 0 0 0 0 // 0 °, 180 °
  1 4 0 // 90 °, 270 °

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

Würfel:
  2 2 2 0 0 // beliebiger Winkel

Jetzt sollten wir diese Zahlen als Sequenzen von 2 Bits codieren und in ein Array einfügen (Ersetzen 4 0durch 3 1für einen 90 ° -Winkel der "Linie", um 2 Bits zu passen - das Ergebnis ist dasselbe und die Breite wird um 1 verringert).

Wir werden in der Reihenfolge codieren: width (in 2 LSB), TBLs , HATs (Rückwärts für Rückwärtsschleife). ZB 2 2 1 1 0 für 270 ° Winkel von T-Zahl wird als codiert wird 1 0 1 2 1(letzte 1 ist Breite-1 ): 0b0100011001 = 281.

aktualisiert am 12.02:

a) Ich habe ein Array in einen String konvertiert und 18 Zeichen gespeichert (Sie können den vorherigen 239-Byte-Code sehen ) :))

b) Mehr Optimierung, Code wird um 9 Zeichen verkleinert.
Dies ist mein letzter Versuch (ich denke schon, lol!) 😀

Common Lisp, 634 Bytes

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

Ausführlich

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

Probier es aus

Die Stücke sind Kreislisten von Nummernlisten. Diese Unterlisten stellen jeweils eine Seite der Form dar, wobei die Zahlen angeben, wie weit sie von der gegenüberliegenden Seite entfernt sind. Sie sind von links nach rechts, wenn diese Seite unten ist, von rechts nach links, wenn oben, von oben nach unten, wenn links und von unten nach oben, wenn rechts. Diese Entwurfsentscheidungen machen das Schreiben von Code für die Drehung überflüssig. Leider scheint das Fehlen eines Rotationscodes die langen Formdarstellungen oder die etwas komplizierte Logik, die ich zur Berechnung neuer Spaltenhöhen verwendet habe, nicht kompensiert zu haben.

Die Drehung ist eine nicht negative ganze Zahl. 0 = 0 Grad, 1 = 90 Grad, 2 = 180 Grad, 4 = 270 Grad

C # (Visual C # Interactive Compiler) , 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;}

Probieren Sie es online!

OK - Das war Wahnsinn ... Ich reichte eine Antwort ein, die Standard-Code-Golftechniken verwendete. Aber als ich sah, was andere einreichten, erkannte ich, dass es einen besseren Weg gab.

Jedes (shape, rotation)Tupel wird in ein C # -Stringliteral codiert, wobei Duplikate entfernt werden. Der Codierungsprozess erfasst jede dieser Konfigurationen in 2 Bytes.

Die niedrigsten 3 Bits speichern die Höhe und die nächsten 3 die Breite. Da jeder dieser Werte niemals mehr als 4 ist, können sie ohne Konvertierung direkt aus den 3 Bits gelesen werden. Hier sind einige Beispiele:

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

Als nächstes wird jede Spalte in 3 Bits gespeichert. Am nützlichsten für mich war die Anzahl der fehlenden Quadrate oben und unten in der Spalte.

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

Es fehlen nie mehr als 2 Felder oben oder unten und es fehlt nie mehr als 1 Feld in beiden gleichzeitig. Angesichts dieser Einschränkungen habe ich die folgende Codierung gefunden:

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

Da wir höchstens 3 Spalten mit fehlenden Quadraten darüber oder darunter berücksichtigen müssen, können wir jedes (shape, rotation)Tupel in 15 Bits codieren .

 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

Zuletzt wurden doppelte Formen entfernt. Das folgende Beispiel zeigt, wie mehrere (shape,rotation)Tupel bei verschiedenen Umdrehungen doppelte Ausgaben für dieselbe Form erzeugen können:

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

Alle eindeutigen Ausgaben werden ermittelt und byte[]in einem C # -Zeichenfolgenliteral gespeichert und konvertiert. Um schnell nachzuschlagen, wo eine Form auf Iund basiert R, bestehen die ersten 7 Bytes des Arrays aus einem codierten Nachschlageschlüssel.

Unten ist ein Link zu dem Programm, mit dem ich die Teile komprimiert habe.

Probieren Sie es online!

Code mit weniger Golfspielen und Kommentaren:

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

Kohle , 98 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Nimmt die Eingabe als Array von [P, R, I] -Werten an, wobei I zwischen 0 und 6 liegt, R zwischen 0 und 3 liegt und P ebenfalls mit 0 indiziert ist. Erläuterung:

Ｆθ«

Schleife über die Eingangsstücke.

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

Extrahieren Sie die Beschreibung des aktuellen Teils und der Rotation. (Siehe unten.)

≔⊟ιζ

Extrahieren Sie die Position.

Ｗ‹Ｌυ⁺ζＬη⊞υ⁰

Stellen Sie sicher, dass genügend horizontaler Raum vorhanden ist, um das Teil zu platzieren.

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

Stellen Sie sicher, dass genügend vertikaler Raum vorhanden ist, um das Teil zu platzieren.

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

Berechnen Sie die neuen Höhen der betroffenen Spalten.

»Ｉυ

Wenn alle Teile verarbeitet wurden, geben Sie die endgültige Liste der Spaltenhöhen in separaten Zeilen aus.

Die komprimierte Zeichenfolge repräsentiert die ursprüngliche Zeichenfolge 00001923001061443168200318613441602332034173203014614341642430137. Hier sind das 2s ITrennzeichen und das 1s RTrennzeichen. Die Stücke dekodieren daher wie folgt:

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

Fehlende RWerte werden von Charcoal automatisch zyklisch aufgefüllt. Jede Ziffer ist dann gemäß der folgenden Tabelle zwei Werten zugeordnet: Überhang und Gesamthöhe:

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

Der Überhang und die Gesamthöhe beziehen sich auf die Säulenhöhen wie folgt: Bei einem Stück, das wir an einer bestimmten Position platzieren möchten e, ist es möglicherweise möglich, das Stück zu platzieren, obwohl eine der Säulen größer als ist e. Die Menge des freien Platzes ergibt sich aus dem Überhang. Die neue Höhe der Säule nach dem Platzieren des Teils ist einfach die platzierte Position plus die Gesamthöhe.

Beispiel: Angenommen, wir beginnen mit der Platzierung eines 5Stücks in Spalte 1. Da noch nichts anderes vorhanden ist, wird das Stück an Position 0 platziert, und die Spalten 1 und 3 haben jetzt die Höhe 1, während Spalte 2 die Höhe 2 hat. Dann möchten wir ein 6Stück platzieren mit 1Drehung in Spalte 0. Hier können wir dieses Stück tatsächlich an Position 0 platzieren; Obwohl Spalte 1 eine Höhe von 1 hat, hat das Teil einen Überhang von 1, sodass genügend Platz vorhanden ist, um es zu platzieren. Spalte 0 endet mit einer Höhe von 2 und Spalte 1 endet mit einer Höhe von 3.