यह कौन सा टेट्रिनो है?

Question

एक अहस्ताक्षरित 16-बिट पूर्णांक एन को देखते हुए , आपका कार्य यह निर्धारित करना है कि 4x4 मैट्रिक्स के अंदर मैप किया गया बाइनरी प्रतिनिधित्व एक टेट्रोमिनो आकार से मेल खा रहा है , और यदि हां, तो यह किस आकार का है।

आव्यूह

N का प्रत्येक बिट 4x4 मैट्रिक्स के अंदर मैप किया जाता है, बाएं से दाएं और ऊपर से नीचे, सबसे महत्वपूर्ण एक के साथ शुरू होता है।

उदाहरण :

N = 17600
binary representation: 0100010011000000
matrix: [ [ 0, 1, 0, 0 ],
          [ 0, 1, 0, 0 ],
          [ 1, 1, 0, 0 ],
          [ 0, 0, 0, 0 ] ]

टेट्रोमिनो आकार

आधार आकार

O , I , S , Z , L , J और T अक्षर से पहचाने जाने वाले 7 टेट्रोमिनो आकार हैं :

रोटेशन और अनुवाद

यदि किसी आकृति का अनुवाद और / या 4x4 मैट्रिक्स के भीतर घुमाया जाता है, तो उसे अभी भी उसी टेट्रोमिनो का वैध रूपांतर माना जाता है। उदाहरण के लिए, 17600, 1136, 2272 और 1604 सभी को जे टेट्रोमिनो के रूप में पहचाना जाना चाहिए :

लपेटो मत!

हालांकि, आकृतियों को मैट्रिक्स के किसी भी सीमा से परे लपेट या स्थानांतरित नहीं किया जा सकता है। उदाहरण के लिए, न तो 568 और न ही 688 को J tetrominoes के रूप में पहचाना जाना चाहिए (अकेले किसी भी अन्य आकार को दें):

स्पष्टीकरण और नियम

• आप इनपुट को पूर्णांक के रूप में या सीधे 16 बाइनरी अंकों के रूप में किसी भी उचित प्रारूप में ले सकते हैं, जैसे कि 2 डी सरणी, एक फ्लैट सरणी या एक सीमांकित स्ट्रिंग।
• इनपुट को एक अहस्ताक्षरित 16-बिट पूर्णांक (या एक सरणी या एक स्ट्रिंग के रूप में इसके समकक्ष प्रतिनिधित्व) की गारंटी दी जाती है।
• जब एक मान्य आकार की पहचान की जाती है, तो आपको आकृति की पहचान करने वाले पत्र को मुद्रित करना या वापस करना होगा , या तो निचले या ऊपरी मामले में।
• यदि कोई आकृति की पहचान नहीं की गई है, तो आपको किसी ऐसे मूल्य को प्रिंट या वापस करना होगा जो किसी भी टेट्रोमिनो पत्र से मेल नहीं खाता है। आप कुछ भी नहीं लौटाने का विकल्प चुन सकते हैं।
• वैध माना जाने के लिए, मैट्रिक्स में किसी भी अतिरिक्त कोशिकाओं के बिना सटीक टेट्रोमिनो आकार होना चाहिए (परीक्षण में 1911 और 34953 देखें)।
• यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!

परीक्षण के मामलों

परीक्षण मामलों को 2D सरणियों के रूप में प्राप्त करने के लिए आप इस लिंक का अनुसरण कर सकते हैं।

0      -> false
50     -> false
51     -> 'O'
1911   -> false
15     -> 'I'
34952  -> 'I'
34953  -> false
1122   -> 'S'
3168   -> 'Z'
785    -> 'L'
1136   -> 'J'
568    -> false
688    -> false
35968  -> 'T'
19520  -> 'T'

Comments

दिलचस्प बात यह है कि मैं दूसरे दिन एक बहुत ही समान समस्या पर काम कर रहा था, इससे पहले कि मैं func1 . func2 . func3जेएस में फ़ंक्शन चेन का उपयोग करने के लिए एक तकनीक का निर्माण करने से विचलित हो गया : P

— ETHproductions

क्या मैं चार पंक्तियों के साथ जुड़ने के लिए इनपुट ले सकता हूं 0, यानी के 1111011110111101111लिए 65535?

— ETHproductions

@ETHproductions जो ठीक लगता है। मैंने चुनौती को थोड़ा आराम इनपुट प्रारूप के साथ संपादित किया है।

— अरनौलद

I: 15,240,3840,4369,8738,17476,34952,61440J: 71,113,142,226,275,550,802,1100,1136,1604,1808,2272,3208,3616,4400,8800,12832,17600,18176,25664,28928,36352,51328,57856L: 23,46,116,232,368,547,736,785,1094,1570,1856,2188,3140,3712,5888,8752,11776,12560,17504,25120,29696,35008,50240,59392O: 51,102,204,816,1632,3264,13056,26112,52224S: 54,108,561,864,1122,1728,2244,8976,13824,17952,27648,35904T: 39,78,114,228,305,562,610,624,1124,1220,1248,1824,2248,3648,4880,8992,9760,9984,17984,19520,19968,29184,35968,58368Z:99,198,306,612,1224,1584,3168,4896,9792,19584,25344,50688

— Engineer Toast

^ लिन के पायथन 3 उत्तर का उपयोग करके उत्पन्न किया गया क्योंकि इसमें सुविधाजनक इनपुट / आउटपुट प्रारूप थे।

— इंजीनियर टोस्ट

Answer 1

जेली ,  54 43 42  41 बाइट्स

-1 बाइट की बदौलत एरिक आउटगोलर (बार-बार चेन के अंदर स्थानांतरित करें)

T€FṀ⁸ṙ€Zµ⁺F
ZU$3СǀḄṂ“çc3Ð6'G‘i’ị“¥Çıƭ⁵»

एक monadic लिंक पूर्णांकों (की एक 2 डी सरणी ले जा रहा 1है और 0रों) और एक छोटा अक्षर लौटने oiszljtसंबंधित tetromino के लिए या wअमान्य है।

इसे ऑनलाइन आज़माएं! या परीक्षण सूट देखें।

इस कार्यक्रम को भी देखें, जो सभी 1820 संभव 2 डी बाइनरी सरणियों को सूचीबद्ध करता है जिसमें उनके आउटपुट के साथ उनके आउटपुट के साथ-साथ चार बिट सेट होते हैं।

कैसे?

यह पहले इनपुट के सभी चार घुमाव लेता है। फिर यह प्रत्येक के सेट बिट्स को दाईं ओर और फिर यथासंभव नीचे तक स्थानांतरित करता है और परिणामों को बाइनरी नंबरों में परिवर्तित करता है। यह तब प्रत्येक वैध टेट्रोमिनो के न्यूनतम ऐसे प्रतिनिधित्वों की एक सूची में न्यूनतम परिणाम को देखता है और दो मिलान शब्द शब्दकोश zoist+ में अनुक्रमित करने के लिए decremented परिणाम का उपयोग करता है jowl, wजब कोई मैच नहीं मिला।

T€FṀ⁸ṙ€Zµ⁺F - Link 1, shift set bits right & then down : list of lists of bits          
        µ⁺  - perform the following twice, 1st with x=input, then with x=result of that):
T€          -   truthy indexes of €ach
  F         -   flatten into a single list
   Ṁ        -   maximum (the index of the right-most bit)
    ⁸       -   chain's left argument, x
     ṙ€     -   rotate €ach left by that amount
       Z    -   transpose the result
          F - flatten (avoids an € in the main link moving this into here)

ZU$3СǀḄṂ“çc3Ð6'G‘i’ị“¥Çıƭ⁵» - Main link: list of lists of bits (the integers 0 or 1)
   3С                        - repeat this 3 times collecting the 4 results:
  $                           -   last two links as a monad:
Z                             -     transpose
 U                            -     upend (reverse each) -- net effect rotate 90° CW
      Ç€                      - call the last link as a monad for €ach
        Ḅ                     - convert from binary (vectorises)
         Ṃ                    - minimum (of the four results)
          “çc3Ð6'G‘           - code-page indexes = [23,99,51,15,54,39,71]
                              -   ...the minimal such results for l,z,o,i,s,t,j shapes
                   i          - 1-based index of minimum in there or 0 if not found
                    ’         - decrement
                      “¥Çıƭ⁵» - compressed words: "zoist"+"jowl" = "zoistjowl"
                     ị        - index into (1 indexed & modular, so -1 yields 'w',
                              -             0 yields 'l', 1 yields 'z', ...)

---

पिछला तरीका (54 बाइट्स)

Fœr0Ḅ“çc3Ðñ'G‘i
;Z$Ḅ©f“¦µ½¿Æ‘ȯ®¬S>2ȧZU$3СǀṀ’ị“¥Çıƭ⁵»

एक monadic लिंक पूर्णांकों (की एक 2 डी सरणी ले जा रहा 1है और 0रों) और एक छोटा अक्षर लौटने oiszljtसंबंधित tetromino के लिए या wअमान्य है।

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

यह जाँच करता है कि कम से कम तीन खाली लाइनें (पंक्तियाँ + कॉलम) हैं और बिट्स के कुछ पैटर्न किसी भी लाइन में मौजूद नहीं हैं (विशेष रूप से संख्या 5,9,10,11, और 13), ये एक साथ अगले चरण अभ्यस्त उपज का आश्वासन देते हैं झूठी सकारात्मक। यह फ़्लैटेंस और फ़्लोर-बाइनरी को चार चक्करों में से प्रत्येक के बाइनरी नंबर (रूपांतरण से पहले ट्रेलिंग जीरो से छांट कर) में बदल देता है, और संख्याओं की सूची में न्यूनतम परिणाम का उपयोग करता है, जिसके परिणामस्वरूप घटे हुए परिणाम को दो संक्षिप्त शब्द शब्दों में अनुक्रमित किया जाता है। zoist+ jowl, wकोई मैच नहीं होने पर उपज ।

Comments

और मुझे पता था कि हार्डकोडिंग की तुलना में एक बेहतर तरीका था ...

— एरिक आउटगोल्फर

Btw मुझे लगता है कि यह कोड एक संयोग पर निर्भर करता है (क्योंकि, ठीक है, zoistjowlसामान्य रूप से एक स्ट्रिंग के लिए फिट नहीं होगा अन्यथा: पी)

— एरिक आउटगोल्फर

आपका क्या मतलब है "एक संयोग पर निर्भर करता है"? (डिक्शनरी लुकअप केवल एक बाइट को ...Ṁị“LZOISTJWवैसे भी बचाता है)

— जोनाथन एलन

हम्म ... हाँ, मुझे पता था कि यह लंबे समय तक नहीं चलेगा ... btw मुझे लगता है कि तुम चुरा लिया मेरे ZU$3С: पी

— एरिक आउटगोल्फ

मैं पिछले एक को जमा करने के बाद कल एक ही विधि करने की कोशिश कर रहा था लेकिन मुझे लगता है कि मैं थोड़ा थक गया था।

— जोनाथन एलन

Answer 2

पायथन 3 , 124 बाइट्स

def f(n):
 while n&4369<n/n:n>>=1
 while n&15<1:n>>=4
 return'TJLZSIO'["rēȣc63ıGtIJȱᄑ@'̢̑@@@@Ȳq".index(chr(n))%7]

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

एक पूर्णांक n की अपेक्षा करता है एक 4 × 4 बाइनरी मैट्रिक्स का प्रतिनिधित्व करता है। यदि कोई टेट्रोमिनो नहीं पाया जाता है तो फेंकता है।

पंक्ति 2 आकार को दाईं ओर स्लाइड करती है जब तक कि 1 सबसे दाहिने कॉलम में न हो। (4369 0001 0001 0001 0001बाइनरी में है।) 1 पंक्ति के नीचे पंक्ति में होने तक रेखा 3 आकार को कम करती है। साथ में यह बदल जाता है जैसे:

    0 1 0 0        0 0 0 0
    1 1 1 0  into  0 0 0 0
    0 0 0 0        0 0 1 0
    0 0 0 0        0 1 1 1

फिर हम nइस सूची के सूचकांक की तलाश करते हैं :

 [114  275  547   99   54   15   51
  305   71  116  306  561 4369   64
   39  802  785   64   64   64   64
  562  113   23]
#   T    J    L    Z    S    I    O

सूचकांकों के प्रत्येक स्तंभ समान मोडुलो 7 एक टेट्रोमिनो आकार से मेल खाता है। 64 ( @) का उपयोग पैडिंग मान के रूप nमें किया जाता है क्योंकि कोड में इस बिंदु पर 64 नहीं हो सकता है।

एनबी। इसके बजाय 0कंप्यूटिंग द्वारा इनपुट के लिए एक अपवाद फेंक दिया गया n/nहै 1।

Comments

आपका बाइनरी स्ट्रिंग क्यों काम करता है? मैं अजगर 3 में उस के साथ समस्या नहीं थी, टिप्पणियों को देखने के codegolf.stackexchange.com/a/85201/53667

— कार्ल नप्फ़

पायथन सोर्स कोड और टेक्स्ट आउटपुट के लिए डिफ़ॉल्ट एन्कोडिंग के रूप में UTF-8 का उपयोग करता है। लेकिन PPM फाइलें UTF-8 में नहीं पढ़ी जाती हैं । जब आप दौड़ते हैं print("ÿ"), तो जो बाइट्स लिखे जाते हैं c3 bf 0a, वे हैं , नहीं ff 0a, और पीपीएम छवि कचरे में बदल जाती है।

— लिन

Answer 3

एपीएल (डायलॉग) , 95 94 93 89 87 बाइट्स

-2 Zacharý को धन्यवाद

⎕IO←0कई सिस्टम पर डिफ़ॉल्ट की आवश्यकता होती है। तर्क के रूप में बूलियन मैट्रिक्स (किसी भी आकार का!) लेता है। यदि दिए गए बिट्स की संख्या चार नहीं है, और एक खाली लाइन अगर चार दिए गए बिट्स टेट्रोमिनो नहीं बनाते हैं तो कुछ भी नहीं लौटाता है।

{4=+/,⍵:'OIZSJLT'/⍨∨/1∊¨(((2 2)4⍴¨1),(0 1⌽¨⊂K⌽2⊖J),(⍳3)⊖¨⊂J←1,⍪K←3↑1)∘.⍷⍵∘{⌽∘⍉⍣⍵⊢⍺}¨⍳4}

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

इनपुट के सभी चार घुमाव बनाकर काम करता है, फिर प्रत्येक घुमाव में टेट्रोमिनो की तलाश करता है।

{... } अनाम फ़ंक्शन जहां तर्क द्वारा दर्शाया गया है ⍵:

 ,⍵ बहस करना (चपटा करना)

 +/ इसे योग करें

 4= चार उसके बराबर है?

 : यदि ऐसा है, तो (और कुछ नहीं लौटाएं):

  ⍳4 पहले चार four ndices; [0,1,2,3]

  ⍵∘{… }¨ प्रत्येक इनपुट पर निम्न बाएं तर्क के रूप में निम्न फ़ंक्शन को लागू करें

   ⍺ बाएं तर्क यानी इनपुट

   ⊢⍺ कि (अलग उपज ⍵से ⍺)

   ⌽∘⍉⍣⍵ दर्पण और पारगमन (यानी 90 ° घुमाएँ) ⍵बार

  (... )∘.⍷ बाहरी "उत्पाद", लेकिन निम्न सूची और घुमावों का पता लगाएं * का उपयोग करते हुए:

   3↑1 एक से तीन तत्व लें, शून्य के साथ पैडिंग; [1,0,0]

   K← उस के रूप में संग्रहीत करें K

   ⍪ तालिका (कॉलम वेक्टर में बनाएं); [[1],[0],[0]]

   1, एक को रोकना; [[1,1],[1,0],[1,0]]("जे")

   J← के रूप में स्टोर J

   (… )⊖¨⊂ संपूर्ण J को लंबवत रूप से घुमाएं, निम्न चरणों में से प्रत्येक:

    ⍳3 पहले तीन three ntegers;[0,1,2]

   हमारे पास [[[1,1],[1,0],[1,0]],[[1,0],[1,0],[1,1]],[[1,0],[1,1],[1,0]]]("J", "L," T ") है

   (… ), निम्नलिखित सूची प्रस्तुत करें:

    2⊖JJदो चरणों को लंबवत  घुमाएं ; [[1,0],[1,1],[1,0]]( "टी")

    K⌽ क्रमशः 1, 0, और 0 चरणों की पंक्तियों को घुमाएं; [[0,1],[1,1],[1,0]]( "Z")

    0 1⌽¨⊂ पूरे सरणी को लंबवत घुमाएं, कोई समय नहीं और एक बार; [[[0,1],[1,1],[1,0]],[[1,0],[1,1],[0,1]]] ("जेड", "एस")

    (… ), निम्नलिखित सूची प्रस्तुत करें:

     (2 2)4⍴¨1 2 × 2 मैट्रिक्स और 4-तत्व सूची में से प्रत्येक में एक को फिर से खोलें; [[[1,1],[1,1]],[1,1,1,1]]("ओ", "आई")

  1∊¨ प्रत्येक के लिए, एक सदस्य है?

  ∨/ क्षैतिज या कमी (यानी घुमाव के पार; प्रत्येक आकृति के लिए एक बूलियन)

  'OIZSLJT'/⍨ स्ट्रिंग को फ़िल्टर करने के लिए इसका उपयोग करें

* अपने सही तर्क के रूप में एक ही आकार की एक बूलियन सरणी का पता लगाएं, जो बाएं तर्क के समान सभी सबरेज़ के शीर्ष बाएं कोने को दर्शाता है।

Comments

क्या यह काम करेगा? {4=+/,⍵:'OIZSJLT'/⍨∨/1∊¨(((2 2)4⍴¨1),(0 1⌽¨⊂K⌽2⊖J),(⍳3)⊖¨⊂J←1,⍪K←3↑1)∘.⍷⍵∘{⌽∘⍉⍣⍵⊢⍺}¨⍳4}

— ज़ाचारि १०'१

@ Zacharý हाँ, धन्यवाद, किया।

— 19

Answer 4

जावास्क्रिप्ट (ईएस 6), 242 212 172 164 बाइट्स

x=>[...'OISZLJT'].filter((z,y)=>x.match(`^0*(${'99,33825|15,51|2145,195|561,2115|57,1059|135,71|1073'.split`,`[y].replace(/\d+/g,C=x=>x?x%2+C(x>>1)+x%2:'|')})0*$`))

माना जाता था कि सिर्फ गेंद लुढ़कती है, लेकिन मुझे उस ツ \ _ (ツ) _ / just के लिए थोड़ी देर हो गई है

बिट्स की एक स्ट्रिंग लेता है, 0एस ( '0001000110001000000'प्रतिनिधित्व 0001 0011 0010 0000) द्वारा अलग की गई पंक्तियों के साथ और एक सरणी देता है जिसमें टेट्रोमिनो, या कुछ भी नहीं रखने वाले सरणी का प्रतिनिधित्व करता है।

यह tetromino के प्रत्येक घुमाव की जाँच करके यह देखने के लिए काम करता है कि क्या किसी भी बिंदु पर इनपुट में tetromino होता है, जो पूरी तरह से दोनों ओर शून्य से घिरा हुआ है। प्रत्येक टेट्रोमिनो को एक या अधिक बाइनरी संख्याओं द्वारा दर्शाया जाता है:

0 0 0 0   -> 0000 0110 1100 0000
0 1 1 0   -> 0000001100110000000
1 1 0 0   -> 110011
0 0 0 0   -> 51

0 1 0 0   -> 0100 0110 0010 0000
0 1 1 0   -> 0100001100001000000
0 0 1 0   -> 100001100001
0 0 0 0   -> 2145

तो अगर इनपुट एक एस tetromino शामिल जाँच करने के लिए, हम बस यह देखना होगा कि यह या तो की बाइनरी प्रतिनिधित्व होता है 51या 2145केवल के साथ, 0दोनों तरफ रों।

टेट्रोमिनो में से कुछ में 4 झुकाव होते हैं। यदि आप इनमें से द्विआधारी अभ्यावेदन को देखते हैं, तो प्रत्येक में 2 अभ्यावेदन होते हैं, जो अन्य दो का दर्पण मात्र होते हैं। अंतरिक्ष को बचाने के लिए, द्विआधारी प्रतिनिधित्व को पुनरावर्ती Cफ़ंक्शन के साथ आगे और पीछे एक साथ बनाया गया है , जिससे हमें केवल दो झुकावों को रखा जा सकता है और अन्य दो निहित हैं।

---

चारकोल के साथ वैकल्पिक दृष्टिकोण:

x=>[...'OISZLJT'].filter((z,y)=>x.match(`^0*(${[...'÷,êÿ,óî,ûÝ,ëúüÏ,çöïþ,ßýíÞ'.split`,`[y]].map(c=>(C=n=>n?'1e'+(n%4+2)%5-0+C(n>>2):'')(c.charCodeAt())).join`|`})0*$`))

Answer 5

रेटिना , 125 बाइट्स

s`(.*1){5}.*

{s`.*1111.*
I
s`.*111(.{2,4})1.*
$.1
T`234`\LTJ
s`.*11(.{2,4})11.*
$.1
T`2-90`S\OZ4-9
s`.*4.*

O#$`.
$.%`
O#$^`

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले और पूर्णांक से 4 × 4 मैट्रिक्स में बदलने के लिए एक हेडर शामिल है। स्पष्टीकरण:

s`(.*1){5}.*

यदि यह 5 1s है तो इनपुट हटाएं ।

{s`.*1111.*
I

इनपुट के सभी घुमाव देखें (नीचे देखें)। यदि इनपुट में लगातार चार होते हैं 1, तो यह एक है I।

s`.*111(.{2,4})1.*
$.1
T`234`\LTJ

यदि इसमें तीन में 1से एक के 1नीचे अगली पंक्ति में तीन लगातार s प्लस हैं , तो उचित वर्ण के अक्षर में इंटरमीडिएट वर्णों की संख्या को मैप करें।

s`.*11(.{2,4})11.*
$.1

इसी तरह अगली पंक्ति पर 1दो निकटवर्ती 1s के लिए दो आसन्न s के लिए।

T`2-90`S\OZ4-9

लेकिन अन्यथा अप्रयुक्त 0एस का उपयोग करके घुमावों की संख्या की गिनती भी रखें ।

s`.*4.*

और अगर बहुत सारे सड़ांध का प्रदर्शन किया गया है तो छोड़ दें।

O#$`.
$.%`
O#$^`

इस प्रकार इसे घुमाते हुए, सरणी को स्थानांतरित और उल्टा करें।

Answer 6

MATL , 60 बाइट्स

Itt6tIl7tl7H15vHe"4:"G@X!HYa]4$v@BIthYaEqY+4=aa]v'OSZLJTI'w)

इनपुट एक बाइनरी 4 × 4 ऐरे (मैट्रिक्स) है, जिसका उपयोग करके ; पंक्ति विभाजक के रूप में जाता है। Ouput एक पत्र है या बिना टेट्रोमिनो के लिए खाली है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें (एक खाली परिणाम की पहचान करने के लिए आउटपुट में डॉट जोड़ा गया है)।

व्याख्या

कोड 90 डिग्री के चरणों में इनपुट 4 × 4 सरणी के 4 घुमाव बनाता है। प्रत्येक घुमाए गए सरणी को 2 शून्य ऊपर और नीचे के साथ गद्देदार किया जाता है, जो इसे 8 × 4 सरणी में बदल देता है। 4 सरणियों को 32 × 4 सरणी में लंबवत रूप से समतल किया जाता है। इस संक्षिप्त सरणी के भीतर चार घुमाए गए सरणियों को शून्य-गद्दी के लिए "पृथक" धन्यवाद दिया गया है।

7 संभावित पैटर्न में से प्रत्येक को देखने के लिए परीक्षण किया जाता है कि क्या यह 32 × 4 सरणी में मौजूद है। इसके लिए एक लूप का उपयोग किया जाता है। प्रत्येक पैटर्न को दो संख्याओं द्वारा परिभाषित किया गया है, जो बाइनरी में व्यक्त किया गया है उपयुक्त 0/1 मास्क। उदाहरण के लिए, संख्याएँ 3, 6"S" आकार को परिभाषित करती हैं।

2 नंबरों के 7 सेटों को 2 × 7 मैट्रिक्स में व्यवस्थित किया जाता है, जिसमें से लूप प्रत्येक कॉलम को क्रमिक रूप से उठाएगा। मैट्रिक्स को स्टैक के सभी नंबरों को धकेलते हुए, उन्हें वेक्टर में समेटते हुए, और 2-पंक्ति मैट्रिक्स में पुन: आकार देकर परिभाषित किया जाता है। चूँकि "I" आकार को संख्या 15 द्वारा परिभाषित किया गया है, जिसके बाद 0 है, इसे अंत में डालकर 0 को फिर से आकार देने के कार्य से भरा जा सकता है।

मास्क को फिर चार दिशाओं में 3 शून्य के साथ गद्देदार किया जाता है। यह आवश्यक है ताकि इनपुट में अवांछित मूल्यों का पता लगाया जा सके।

यह देखने के लिए कि क्या मास्क 32 × 4 के सरणी में मौजूद है, बाद वाले द्विध्रुवीय रूप में परिवर्तित हो जाता है (अर्थात 0/1 के बजाय 11/1) और मास्क के साथ सजाया जाता है। चूंकि मास्क में 4 होते हैं, इसलिए यदि मिलान परिणाम में कुछ प्रविष्टि 4 के बराबर होती है तो मिलान होता है।

लूप के अंत में, 7 झूठे / सच्चे परिणाम प्राप्त हुए हैं, जिनमें से अधिकांश सच है। यह संभव आउटपुट अक्षरों वाले स्ट्रिंग में इंडेक्स करने के लिए उपयोग किया जाता है।

Answer 7

जेली , 53 बाइट्स

ZL0ẋW⁸tZµ⁺ZU$3С“©©“œ“Ç¿“¦©¦“ƽ‘;Uḃ2$’¤iЀṀị“÷¶Ė¡µỵỤ»

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

पूरा कार्यक्रम। एक 4x4 लेता है। प्रिंट mनहीं तो टेट्रिनो, अन्यथा लोअरकेस प्रिंट करता है।

Comments

क्या ... बिट्स के सरणियों की एक सरणी कानूनी रूप ले रही है? यह मुझे 40 बाइट्स की तरह बचाएगा

— ETHproductions

@ETHproductions आप इनपुट को पूर्णांक के रूप में, या सीधे 4x4 बाइनरी अंकों के 2 डी सरणी या 16 बाइनरी अंकों के फ्लैट सरणी के रूप में ले सकते हैं।

— को आउटगोल्फर एरिक

हुह, मुझे इस सवाल पर ध्यान देने के लिए सही काम करता है ...

— ETHproductions

Answer 8

पर्ल 5 , 197 + 1 (-पी) = 198 बाइट्स

s/(0000)*$//;1while s/(...)0(...)0(...)0(...)0/0${1}0${2}0${3}0${4}/;$_={51,O,15,I,4369,I,54,S,561,S,99,Z,306,Z,547,L,23,L,785,L,116,L,275,J,113,J,802,J,71,J,114,T,562,T,39,T,609,T}->{oct("0b".$_)}

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

इनपुट के रूप में 16 बिट स्ट्रिंग लेता है। इनपुट कुछ भी नहीं है, तो आउटपुट कुछ भी नहीं करता है।

कैसे?

नीचे दिए गए दाएं कोने में इनपुट आकृति को दो प्रतिस्थापन "स्थानांतरित" करते हैं। परिणामी बिट स्ट्रिंग को पूर्णांक में बदल दिया जाता है, फिर मान्य पूर्णांक के हैश में जांचा जाता है।

Answer 9

APL (Dyalog) , 66 बाइट्स

{'TIOJSLZ-'[(¯51 144 64,,∘+⍨12J96 ¯48J64)⍳×/(+/-4×⊢)⍵/,0j1⊥¨⍳4 4]}

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

अर्ग एक बूलियन वेक्टर है।

कंप्यूटर्स के बिंदुओं की गणना उनके गुरुत्वाकर्षण केंद्र के रूप में जटिल संख्याओं (वास्तविक और काल्पनिक भाग ∆x, iply) के रूप में होती है और जटिल संख्याओं को एक साथ गुणा करती है। यह टेट्रोमिनोइन्स के बीच अंतर करने के लिए एक अच्छा पर्याप्त हमलावर है।

Comments

दिलचस्प विधि।

— अरनुलद