^{Üniversite kodu meydan okuma yarışmamdan alınan meydan okuma}

^{Bu aslında 0.Gün ama dünkü meydan okuma çok kolaydı ve burada başka bir sorunun bir kopyası olabilir.}

Tetris, 80'li yıllarda popüler hale gelen bir video oyunudur. Bir tahtanın üzerine düşen farklı şekillere sahip bir dizi parçanın yerleştirilmesinden oluşur, böylece mümkün olan en kompakt şekilde sığarlar.

Bu problemde, her biri belirli bir konumda ve değiştirilemeyen belirli bir yönde düşen bir parça diziyi varsayacağız. Parçalar düştükçe yığılır ve tüm sıralar ortadan kaldırılmaz (orijinal oyunda olduğu gibi). Amaç, tüm parçalar düştükten sonra tahtanın her kolonunun son yüksekliğini belirlemektir.

Şekilde gösterilen toplam 7 farklı parça vardır:

Meydan okuma

Bir parça listesi verildiğinde, tüm parçalar düştükten sonra tüm sütunların yüksekliğini tahtadan çıkarın

Bir parça üç sayıdan oluşur: I, R ve P. İlk sayı, I, parçanın tanımlayıcısıdır (şekildeki ile aynı sırayla 1 ile 7 arasında bir sayı). İkinci sayı, R, parçanın dönüşüdür. 0, 90, 180 veya 270 değerlerini alabilir ve parçanın saat yönünün tersine dönme açısını temsil eder. Üçüncü sayı olan P, parçanın konumunu gösterir. Soldaki parçanın kapladığı sütunu temsil eder (bu 1 veya 0 Dizin olabilir. Lütfen belirtin).

Örnek ve Test durumu (1 Dizin)

• verilmiş [[1, 0, 1], [4, 0, 1], [5, 90, 4]]

• Çıktı [3, 3, 1, 3, 2]

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

• Çıktı [0, 0, 0, 9, 9, 8, 3, 3]

• Verilen [[3,0,1],[3,180,3]]Çıktı[1,1,4,4,4]

• Verilen [[2,180,1],[2,0,3]]Çıktı[2,2,4,3,3]

notlar

• Bu kod golfü
• Satır / Sütun 1 veya 0 Dizini olabilir. Lütfen belirtin.
• Giriş değerlerini yeniden tanımlayabilirsiniz (belki de 1. parçayı A vb. Olarak çağırmak istersiniz). Bu durumda lütfen belirtin

Sorular

• Derece cinsinden açı yerine 4 farklı değer kullanabilir miyiz ?: Evet

• Bir parça öncekilere tam olarak uymuyorsa "delikleri" ele almamız gerekiyor mu ?: Evet

• Kartın yüksekliği veya genişliği sınırlanmış mı? Hayır. Ne genişlik ne de yükseklik sınırlıdır

Görüntüler ve test senaryoları için @Arnauld'a teşekkürler *. *

JavaScript (node.js) ,  286 284 270  266 bayt

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

Çevrimiçi deneyin! veya son kartı görüntüleyen gelişmiş bir sürümü deneyin .

Şekil kodlaması

Tüm parçalar, sıralar ters sırada sıralanmış ve en soldaki piksel en az anlamlı bite eşlenmiş olarak tam olarak 4 adet (4x4 bit) olarak saklanır. Başka bir deyişle, şeklin ikili temsili hem dikey hem de yatay olarak yansıtılır.

Misal:

Karma işlevi ve arama tablosu

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

$82$$0$

Bu girişler şu şekilde paketlenmiştir:

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

aşağıdaki 82 nibble değerine genişler:

"717433667233ff47173333276611000000000000113213001112221112123333333311133233221211"

$I$"ff"

Karma işlevinin parametreleri, baştaki ve sondaki sıfırları optimize edecek şekilde kaba zorlandı. Dizenin 1e12, ortadaki sıfırlar ve sağ kısım için taban-16'dan taban-4'e dönüşüm kullanılarak biraz daha sıkıştırılabilmesi sadece hoş ama beklenmedik bir yan etkidir. :-)

İşte tüm parçalar ve tüm rotasyonlar için paketleme sürecinin bir gösterimi .

Yorumlananlar

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 (çınlama) , 253 239 221 212 bayt

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

Çevrimiçi deneyin!

ps UTF-8 kodlu UNICODE karakterlerinden dolayı kod boyutu 221 bayttır (ancak 212 karakter). Ama tio.run bunu 212 bayt kod olarak ele alıyor ...

Bilgisayarımdaki kod boyutu 209 karakterdir (218 bayt). Ama tio.run'da\225 görünür karakterle değiştiremedim 😞

Kod çözülmemiş kod

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

Açıklama

Her bir şeklin üst taban çizgisini ( TBL ) bulalım ve her yatay pozisyon için TBL'nin altında bir dizi hücre olarak tanımlayalım. Ayrıca TBL ( HAT ) üzerindeki hücre sayısını (yükseklik) açıklayalım .

Örneğin:

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

Her bir şekil ve her bir dönüş açısı için TBL'leri ve HAT'ları açıklayalım:

Genişlik TBLs ŞAPKALAR
----- ------- -------
L-rakamlar:
  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 şekil:
  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 °

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

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

Küp:
  2 2 2 0 0 // herhangi bir açı

(Değiştirme Şimdi 2 bitlik bir dizileri gibi bu sayıları kodlayan bir diziye koymak gerekir 4 0ile 3 1-; 1 ile ve azaltma genişlikleri aynı olacaktır sonucu 2 bit sığdırmak için "hat" 90 ° ').

Biz amacıyla kodlayan olacaktır: genişlik (2'de LSB), tbls , HAT'ler (geri döngü için geri). Örneğin, 2 2 1 1 0 T, şekil 270 ° 'olarak kodlanmış 1 0 1 2 1(son 1 olan genişlik 1 ): 0b0100011001 = 281.

12.02 güncellendi:

a) Bir diziyi dizeye dönüştürdüm ve 18 karakter kaydettim (önceki 239 bayt kodunu görebilirsiniz ) :))

b) Daha fazla optimizasyon, kod 9 karakter küçültülür.
Bu benim son girişimim (sanırım lol!) 😀

Ortak Lisp, 634 bayt

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

gereksiz sözlerle dolu

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

Dene

Parçalar, sayı listelerinin dairesel listeleridir. Bu alt listelerin her biri şeklin bir tarafını temsil eder, sayılar karşı taraftan ne kadar uzak olduklarını gösterir. Bu taraf altta olduğunda soldan sağa, yukarıdayken sağdan sola, soldayken yukarıdan aşağıya ve sağdayken aşağıdan yukarıya doğru kalırlar. Bu tasarım seçenekleri, dönüş için kod yazma ihtiyacını ortadan kaldırır. Ne yazık ki, dönme kodu eksikliği uzun şekil gösterimleri veya yeni sütun yüksekliklerini hesaplamak için kullandığım biraz karmaşık mantık için oluşmuş gibi görünmüyor.

Dönüş negatif olmayan bir tamsayıdır. 0 = 0 derece, 1 = 90 derece, 2 = 180 derece, 4 = 270 derece

C # (Visual C # Etkileşimli Derleyici) , 308 bayt

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

Çevrimiçi deneyin!

Tamam - Bu delilikti ... Değirmen koşusu kod golf tekniklerini kullanan bir cevap gönderdim. Ama başkalarının ne gönderdiğini görünce daha iyi bir yol olduğunu fark ettim.

Her (shape, rotation)grup, kopyalar kaldırılmış olarak bir C # dize değişmezine kodlanır. Kodlama işlemi bu konfigürasyonların her birini 2 bayt olarak yakalar.

En düşük 3 bit depo yüksekliği ve sonraki 3 depo genişliği. Bu değerlerin her biri asla 4'ten fazla olmadığından, herhangi bir dönüştürme yapılmadan doğrudan 3 bitten okunabilirler. İşte bazı örnekler:

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

Daha sonra, her sütun 3 bitte saklanır. Saklamam gereken en yararlı şey, sütunun üstünden ve altından eksik karelerin sayısıydı.

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

Üstte veya altta asla 2'den fazla kare eksik olmaz ve aynı anda her ikisinde de 1'den fazla kare eksik olmaz. Bu kısıtlamalar seti göz önüne alındığında, aşağıdaki kodlamayı buldum:

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

Üzerinde veya altında eksik kareler bulunan en fazla 3 sütunu hesaba (shape, rotation)katmamız gerektiğinden, her bir tupleı 15 bit olarak kodlayabiliriz .

 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

Son olarak, yinelenen şekiller kaldırıldı. Aşağıdaki örnek, birden fazla (shape,rotation)tuple'ın aynı şekil için farklı dönüşlerde nasıl çift ​​çıktı üretebileceğini göstermektedir :

// 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üm benzersiz çıktılar belirlenir ve a kaydedilir byte[]ve bir C # string değişmezine dönüştürülür. Bir şeklin dayandığı Ive Rdizinin ilk 7 baytının hızlı bir şekilde aranması için kodlanmış bir arama anahtarından oluşur.

Aşağıda parçaları sıkıştırmak için kullandığım programın bir bağlantısı var.

Çevrimiçi deneyin!

Daha az golf edilmiş ve yorumlanmış kod:

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

Kömür , 98 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Girişi [P, R, I] değerlerinin bir dizisi olarak alır; burada I, 0'dan 6'ya, R, 0'dan 3'e ve P de 0'a endekslenir. Açıklama:

Ｆθ«

Giriş parçalarının üzerinden geçin.

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

Geçerli parçanın ve dönüşün açıklamasını çıkarın. (Aşağıya bakınız.)

≔⊟ιζ

Konumu çıkarın.

Ｗ‹Ｌυ⁺ζＬη⊞υ⁰

Parçayı yerleştirmek için yeterli yatay alan bulunduğundan emin olun.

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

Parçayı yerleştirmek için yeterli dikey alan olduğundan emin olun.

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

Etkilenen sütunların yeni yüksekliklerini hesaplayın.

»Ｉυ

Tüm parçalar işlendiğinde, sütun satırlarının son listesini ayrı satırlara çıktılayın.

Sıkıştırılmış dize orijinal dizeyi temsil eder 00001923001061443168200318613441602332034173203014614341642430137. Burada 2s Iayırıcılar ve 1s Rayırıcılar. Bu nedenle parçalar şu şekilde çözülü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

Eksik Rdeğerler otomatik olarak Kömür tarafından otomatik olarak doldurulur. Her basamak aşağıdaki tabloya göre çıkıntı ve toplam yükseklik olmak üzere iki değerle eşleşir:

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

Çıkıntı ve toplam yükseklik, sütun yükseklikleri ile aşağıdaki gibidir: Belirli bir konuma yerleştirmek istediğimiz bir parça verildiğinde e, sütunlardan biri daha uzun olmasına rağmen parçayı yerleştirmek mümkün olabilir e. Boş alan miktarı çıkıntı tarafından verilir. Parçayı yerleştirdikten sonra sütunun yeni yüksekliği basitçe yerleştirilen konum artı toplam yüksekliktir.

Örnek: 5Sütun 1'e bir parça yerleştirerek başladığımızı varsayalım. Başka bir şey olmadığından, parça bu nedenle 0 konumuna yerleştirilir ve sütun 1 ve 3 şimdi sütun 1 yükseklik 2 iken sütun 1 şimdi 3 olur. Sonra bir 6parça yerleştirmek isteriz ile 1Burada sütununda 0. rotasyona biz aslında 0 konumunda bu taş koyabilir; sütun 1'in yüksekliği 1 olmasına rağmen, parçanın 1 çıkıntısı vardır ve bu nedenle yerleştirmek için yeterli alan vardır. Sütun 0, 2 yüksekliğinde ve sütun 1, 3 yüksekliğinde sona erer.