टेट्रिस! अंतिम ऊंचाई (दिन 3)

Question

^{मेरे विश्वविद्यालय कोड चुनौती प्रतियोगिता से लिया गया चैलेंज}

^{यह वास्तव में दिन 0 है, लेकिन कल की चुनौती बहुत आसान थी और यहां एक और सवाल का एक धोखा हो सकता है।}

---

टेट्रिस एक वीडियो गेम है जो 80 के दशक में लोकप्रिय हुआ। इसमें अलग-अलग आकृतियों के साथ टुकड़ों की एक श्रृंखला होती है जो एक बोर्ड पर गिरती हैं, ताकि वे सबसे कॉम्पैक्ट तरीके से फिट हो सकें।

इस समस्या में हम टुकड़ों के एक क्रम को मानेंगे जो गिरते हैं, प्रत्येक एक निश्चित स्थिति में और एक निश्चित अभिविन्यास के साथ जिसे बदला नहीं जा सकता है। टुकड़े गिरते ही ढेर हो जाते हैं और पूरी पंक्तियों का सफाया नहीं होता है (जैसा मूल खेल में है)। उद्देश्य सभी टुकड़ों के गिरने के बाद बोर्ड के प्रत्येक कॉलम की अंतिम ऊंचाई निर्धारित करना है।

कुल 7 अलग-अलग टुकड़े हैं, जो चित्र में दिखाए गए हैं:

चुनौती

टुकड़ों की एक सूची को देखते हुए, सभी टुकड़ों के गिरने के बाद बोर्ड से सभी स्तंभों की ऊंचाई का उत्पादन करें

एक टुकड़े में तीन नंबर होते हैं: I, R और P। पहला नंबर I, टुकड़े का पहचानकर्ता है (1 और 7 के बीच की संख्या, उसी क्रम में जैसा कि आकृति में है)। दूसरा नंबर, आर, टुकड़ा का रोटेशन है। यह 0, 90, 180 या 270 का मान ले सकता है और एंटी-क्लॉकवाइज दिशा में टुकड़े के रोटेशन के कोण का प्रतिनिधित्व करता है। तीसरे नंबर, पी, टुकड़े की स्थिति को इंगित करता है। टुकड़ा द्वारा कब्जा कर लिया बाईं ओर स्तंभ का प्रतिनिधित्व करता है (यह 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 को ए, आदि कहते हैं)। उस मामले में कृपया निर्दिष्ट करें

प्रशन

• क्या हम डिग्री में कोण के बजाय किसी भी 4 विशिष्ट मूल्यों का उपयोग कर सकते हैं ?: हाँ

• क्या हम "छेद" को संभालने वाले हैं यदि कोई टुकड़ा पिछले वाले पर बिल्कुल फिट नहीं है ?: हाँ

• क्या बोर्ड की ऊंचाई या चौड़ाई बंधी है? न तो चौड़ाई और न ही ऊंचाई बंधी है

---

धन्यवाद @Arnauld छवियों और परीक्षण के मामलों के लिए *। *

Comments

क्या I, Rऔर Pएक अलग क्रम में इनपुट किया जा सकता है?

— नील

@ नील हाँ। यह किसी भी क्रम में हो सकता है

— लुइस फेलिप डी जीसस मुनोज़

यदि हम इनपुट मानों को फिर से परिभाषित कर सकते हैं, तो क्या मैं एक मैट्रिक्स के रूप में टुकड़ा आईडी ले सकता हूं जो टुकड़ों के आकार का प्रतिनिधित्व करता है (रोटेशन के बिना)?

— इग्नोरेंस

मुझे लगता है कि हम 2 कारणों से टुकड़ों के आकार का प्रतिनिधित्व करने वाले मैट्रिक्स का इनपुट नहीं कर सकते। इनपुट स्पष्ट रूप से परिभाषित किया गया है: 1,2,3 .. या ए, बी, सी .. और इस चुनौती का एक मौलिक हिस्सा इस बाधा को प्रबंधित करना है।

— AZTECCO

क्या 0 के अनुगामी को शामिल करना ठीक होगा?

— दाना

Answer 1

जावास्क्रिप्ट (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$

$$n=(2p+56r+99y+13)\bmod 113$$

केवल पहले प्रविष्टियाँ स्पष्ट रूप से संग्रहीत हैं। बाकी सब कुछ सेट है ।$82$$0$

ये प्रविष्टियाँ इस प्रकार हैं:

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

जो निम्नलिखित 82 निबल्स तक फैलता है:

"717433667233ff47173333276611000000000000113213001112221112123333333311133233221211"

अंतिम प्रारूप में हेक्साडेसिमल का उपयोग केवल टुकड़े के दो क्षैतिज प्रतिनिधित्व के लिए आवश्यक है , इसलिए उपरोक्त स्ट्रिंग में।$I$"ff"

हैश फ़ंक्शन के पैरामीटर एक तरह से क्रूर-मजबूर थे जो अग्रणी और अनुगामी शून्य को अनुकूलित करते हैं। यह तथ्य कि स्ट्रिंग 1e12को बीच में शून्य के लिए उपयोग करके कुछ और संकुचित किया जा सकता है और दाएं भाग के लिए बेस -16 से बेस -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[]

Comments

अच्छा काम पैकिंग / टुकड़े टुकड़े करना। यह वास्तव में प्रभावशाली है :)

— दाना

Answer 2

सी (क्लैंग) , 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;}}

इसे ऑनलाइन आज़माएं!

वास्तव में यूटीएफ -8 में कोडित कोड के कारण कोड का आकार 221 बाइट्स (लेकिन 212 चार्ट) है। लेकिन 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)

विवरण

आइए प्रत्येक आकृति की शीर्ष आधार रेखा ( TBL ) पाए और इसे प्रत्येक क्षैतिज स्थिति के लिए TBL से नीचे की कोशिकाओं की संख्या के रूप में वर्णित करें। इसके अलावा टीबीएल ( एचएटी ) से ऊपर की कोशिकाओं (ऊंचाई) की संख्या का वर्णन करें ।

उदाहरण के लिए:

                       ________ ________
_ [] _____ HAT = 1,0,0 [] [] [] HAT = ०,०,० ___ [] [] _ ​​HAT = ०,१,११ [] [] [] HAT = ०,०,०
 [] [] [] टीबीएल = १,१,१ [] टीबीएल = २,१,१ [] [] टीबीएल = ११,० [] टीबीएल = १,२,१

आइए प्रत्येक आकृति और प्रत्येक रोटेशन कोण के लिए TBLs और HAT का वर्णन करें:

चौड़ाई TBLs HATs
----- ------- -------
एल आंकड़े:
  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 °

टी आंकड़ा:
  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 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 °

घन:
  2 2 2 0 0 // किसी भी कोण पर

अब हम 2 बिट्स की एक दृश्यों के रूप में इन नंबरों सांकेतिक शब्दों में बदलना और एक सरणी में रखना चाहिए (जगह 4 0से 3 190 डिग्री "पंक्ति" 2 बिट्स में फिट करने के कोण के लिए - परिणाम एक ही हो जाएगा; 1 द्वारा और कमी चौड़ाई)।

हम क्रम में सांकेतिक शब्दों में बदलना होगा: चौड़ाई (2 LSB में), TBLs , HATs (पिछड़े पाश के लिए पिछड़े)। उदाहरण के लिए 2 2 1 1 0 270 ° टी आंकड़ा के कोण के लिए के रूप में एन्कोड किया जाएगा 1 0 1 2 1(पिछले 1 है चौड़ाई -1 ): 0b0100011001 = 281।

अद्यतन 12.02:

a) मैंने एक सरणी को स्ट्रिंग में परिवर्तित किया है और 18 वर्णों को बचाया है (आप पिछले 239 बाइट्स कोड देख सकते हैं ) :))

बी) अधिक अनुकूलन, कोड 9 वर्णों द्वारा सिकुड़ा हुआ है।
यह मेरा आखिरी प्रयास (मुझे ऐसा लगता है, lol!) है 😀

Comments

आप का उपयोग कर हड़ताल कर सकते हैं <s> ... </s>।

— जोनाथन फ्रेच

243 बाइट्स ।

— जोनाथन फ्रेच

ओह बढ़िया। धन्यवाद। लोल :))

— जिन एक्स

वाह! निम्न स्तर के टेट्रिस 🤔

— Rustem बी

टीबीएल उच्चतम रेखा के नीचे संख्या में कोशिकाएं हैं जिनके नीचे और ऊपर केवल खाली स्थान या सेल ब्लॉक हैं (कोई खाली स्थान और फिर कोशिकाएं नहीं)। TBL + HAT = आंकड़ा की ऊंचाई (प्रत्येक क्षैतिज स्थिति पर)। TBL> 0 और HAT> 0 भी।

— जिन एक्स

Answer 3

आम लिस्प, 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 डिग्री

Answer 4

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 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;}

इसे ऑनलाइन आज़माएं!

ठीक है - यह पागलपन था ... मैंने एक जवाब प्रस्तुत किया जिसमें रन-ऑफ-द-मिल कोड-गोल्फ तकनीक का इस्तेमाल किया गया था। लेकिन जब मैंने देखा कि अन्य क्या प्रस्तुत कर रहे हैं, तो मैंने महसूस किया कि एक बेहतर तरीका था।

प्रत्येक (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[]एक सी # स्ट्रिंग शाब्दिक में परिवर्तित किए जाते हैं। आदेश जल्दी से देखने के लिए जहां एक आकार के आधार पर किया जाता है 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;
}

Answer 5

चारकोल , 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 की ऊंचाई के साथ समाप्त होता है।