पायथन 2.6+ - 334 322 316 वर्ण
397 368 366 अक्षर असम्बद्ध
exec'xÚEPMO!½ï¯ i,P*Ýlš%ì‰=‰Ö–*†þz©‰:‡—Lò¾fÜ”bžAù,MVi™.ÐlǃwÁ„eQL&•uÏÔ‹¿1O6ǘ.€LSLÓ’¼›î”3òšL¸tŠv[ѵl»h;ÁºŽñÝ0Àë»Ç‡ÛûH.ª€¼âBNjr}¹„V5¾3Dë@¼¡•gO. ¾ô6 çÊsÃЮürÃ1&›ßVˆùZ`Ü€ÿžcx±ˆ‹sCàŽ êüRô{U¯ZÕDüE+³ŽFA÷{CjùYö„÷¦¯Î[0þøõ…(Îd®_›â»E#–Y%’›”ëýÒ·X‹d¼.ß9‡kD'.decode('zip')
सिंगल न्यूलाइन की आवश्यकता है, और मैंने इसे एक चरित्र के रूप में गिना है।
ब्राउज़र कोड-पेज मुंबो जंबो इस कोड की एक सफल कॉपी-एंड-पेस्ट को रोक सकता है, इसलिए आप वैकल्पिक रूप से इस कोड से फ़ाइल उत्पन्न कर सकते हैं:
s = """
23 63 6F 64 69 6E 67 3A 6C 31 0A 65 78 65 63 27 78 DA 45 50 4D 4F 03 21
10 BD EF AF 20 69 2C 50 2A 02 DD 6C 9A 25 EC AD 07 8D 89 07 3D 89 1C D6
96 2A 86 05 02 1B AD FE 7A A9 89 3A 87 97 4C F2 BE 66 DC 94 62 9E 41 F9
2C 4D 56 15 69 99 0F 2E D0 6C C7 83 77 C1 16 84 65 51 4C 26 95 75 CF 8D
1C 15 D4 8B BF 31 4F 01 36 C7 98 81 07 2E 80 4C 53 4C 08 D3 92 BC 9B 11
EE 1B 10 94 0B 33 F2 9A 1B 4C B8 74 8A 9D 76 5B D1 B5 6C BB 13 9D 68 3B
C1 BA 8E F1 DD 30 C0 EB BB C7 87 DB FB 1B 48 8F 2E 1C AA 80 19 BC E2 42
4E 6A 72 01 7D B9 84 56 35 BE 33 44 8F 06 EB 40 BC A1 95 67 4F 08 2E 20
BE F4 36 A0 E7 CA 73 C3 D0 AE FC 72 C3 31 26 9B DF 56 88 AD F9 5A 60 DC
80 FF 9E 63 78 B1 88 8B 73 43 E0 8E A0 EA FC 52 F4 7B 55 8D AF 5A 19 D5
44 FC 45 2B B3 8E 46 9D 41 F7 7B 43 6A 12 F9 59 F6 84 F7 A6 01 1F AF CE
5B 30 FE F8 F5 85 28 CE 64 AE 5F 9B E2 BB 45 23 96 59 25 92 9B 94 EB FD
10 D2 B7 58 8B 64 BC 2E DF 39 87 6B 44 27 2E 64 65 63 6F 64 65 28 27 7A
69 70 27 29
"""
with open('golftris.py', 'wb') as f:
f.write(''.join(chr(int(i, 16)) for i in s.split()))
परिक्षण
intetris
[]
[]
[]
[]
[# # #]
[## ######]
[==========]
T2 Z6 I0 T7
न्यूलाइन्स को यूनिक्स-स्टाइल (केवल लाइनफीड) होना चाहिए। अंतिम पंक्ति पर एक अनुगामी न्यूलाइन वैकल्पिक है।
परीक्षा करना:
> अजगर golftris.py <intetris
[]
[]
[]
[# ###]
[# ###]
[##### ####]
[==========]
10
यह कोड मूल कोड को खोल देता है , और इसके साथ निष्पादित करता है exec। यह विघटित कोड 366 वर्णों का होता है और इस तरह दिखता है:
import sys
r=sys.stdin.readlines();s=0;p=r[:1];a='[##########]\n'
for l in r.pop().split():
n=int(l[1])+1;i=0xE826408E26246206601E>>'IOZTLSJ'.find(l[0])*12;m=min(zip(*r[:6]+[a])[n+l].index('#')-len(bin(i>>4*l&31))+3for l in(0,1,2))
for l in range(12):
if i>>l&2:c=n+l/4;o=m+l%4;r[o]=r[o][:c]+'#'+r[o][c+1:]
while a in r:s+=10;r.remove(a);r=p+r
print''.join(r),s
न्यूलाइन्स की आवश्यकता होती है, और प्रत्येक एक पात्र होता है।
इस कोड को पढ़ने का प्रयास न करें। चर नामों को उच्चतम संपीड़न की तलाश में यादृच्छिक रूप से चुना जाता है (विभिन्न चर नामों के साथ, मैंने संपीड़न के बाद 342 वर्णों के रूप में देखा)। एक और अधिक समझने योग्य संस्करण इस प्रकार है:
import sys
board = sys.stdin.readlines()
score = 0
blank = board[:1]
full = '[##########]\n'
for piece in board.pop().split():
column = int(piece[1]) + 1
bits = 0xE826408E26246206601E >> 'IOZTLSJ'.find(piece[0]) * 12
drop = min(zip(*board[:6]+[full])[column + x].index('#') -
len(bin(bits >> 4 * x & 31)) + 3 for x in (0, 1, 2))
for i in range(12):
if bits >> i & 2:
x = column + i / 4
y = drop + i % 4
board[y] = board[y][:x] + '#' + board[y][x + 1:]
while full in board:
score += 10
board.remove(full)
board = blank + board
print ''.join(board), score
क्रुक्स तीन क्रिप्टिक लाइनों में है मैंने कहा कि मैं समझाता हूं।
टेट्रोमिनो का आकार वहां हेक्साडेसिमल संख्या में एन्कोडेड है। प्रत्येक टेट्रोनिमो को कोशिकाओं के 3x4 ग्रिड पर कब्जा करने के लिए माना जाता है, जहां प्रत्येक कोशिका या तो रिक्त होती है (एक स्थान) या पूर्ण (एक संख्या चिह्न)। प्रत्येक टुकड़ा को 3 हेक्साडेसिमल अंकों के साथ एन्कोड किया गया है, प्रत्येक अंक एक 4-सेल कॉलम का वर्णन करता है। कम से कम महत्वपूर्ण अंक बाएं-सबसे स्तंभों का वर्णन करते हैं, और प्रत्येक अंक में सबसे कम महत्वपूर्ण बिट प्रत्येक स्तंभ में शीर्ष-सबसे सेल का वर्णन करता है। यदि बिट 0 है, तो वह सेल रिक्त है, अन्यथा यह '#' है। उदाहरण के लिए, I tetronimo के रूप में एन्कोड किया गया है 00F, सबसे कम-संख्या वाले चार बिट्स के साथ बाएं-सबसे कॉलम में चार नंबर चिह्नों को एनकोड करने के लिए सेट किया गया है, और T है131, बाईं और दाईं ओर शीर्ष बिट सेट के साथ, और शीर्ष दो बिट्स मध्य में सेट हैं।
पूरे हेक्साडेसिमल संख्या को फिर एक बिट बाईं ओर शिफ्ट किया जाता है (दो से गुणा)। यह हमें नीचे-सबसे थोड़ा अनदेखा करने की अनुमति देगा। मैं समझाता हूँ कि एक मिनट में क्यों।
तो इनपुट से वर्तमान टुकड़ा दिया जाता है, हम सूचकांक को इस हेक्साडेसिमल संख्या में खोजते हैं, जहां 12 बिट्स यह बताते हैं कि यह आकार शुरू है, फिर इसे नीचे शिफ्ट करें ताकि bitsचर के 1-12 (स्किपिंग बिट 0) बिट्स वर्तमान टुकड़े का वर्णन करें।
यह dropनिर्धारित करने के लिए कि ग्रिड के ऊपर से कितनी पंक्तियाँ आती हैं, टुकड़ा दूसरे टुकड़े पर उतरने से पहले गिर जाएगा। पहली पंक्ति को पता चलता है कि खेल के मैदान के प्रत्येक स्तंभ के शीर्ष पर कितनी खाली कोशिकाएँ हैं, जबकि दूसरी टुकड़ा के प्रत्येक स्तंभ में सबसे कम कब्जे वाली कोशिका को खोजती है। zipसमारोह जहां प्रत्येक टपल के होते हैं tuples की एक सूची, रिटर्न n वें इनपुट सूची में प्रत्येक आइटम से सेल। इसलिए, नमूना इनपुट बोर्ड का उपयोग करके, zip(board[:6] + [full])वापस आ जाएगा:
[
('[', '[', '[', '[', '[', '[', '['),
(' ', ' ', ' ', ' ', ' ', ' ', '#'),
(' ', ' ', ' ', ' ', '#', '#', '#'),
(' ', ' ', ' ', ' ', ' ', '#', '#'),
(' ', ' ', ' ', ' ', ' ', ' ', '#'),
(' ', ' ', ' ', ' ', ' ', '#', '#'),
(' ', ' ', ' ', ' ', ' ', '#', '#'),
(' ', ' ', ' ', ' ', '#', '#', '#'),
(' ', ' ', ' ', ' ', ' ', '#', '#'),
(' ', ' ', ' ', ' ', ' ', '#', '#'),
(' ', ' ', ' ', ' ', '#', '#', '#'),
(']', ']', ']', ']', ']', ']', ']')
]
हम उपयुक्त कॉलम के अनुरूप इस सूची से टपल का चयन करते हैं, और कॉलम में पहले का इंडेक्स पाते हैं '#'। यही कारण है कि हमने कॉल करने से पहले एक "पूर्ण" पंक्ति जोड़ दी zip, ताकि indexकॉलम अन्यथा रिक्त होने पर एक समझदार रिटर्न (अपवाद को फेंकने के बजाय) होगा।
फिर '#'टुकड़े के प्रत्येक कॉलम में सबसे कम खोजने के लिए , हम उस कॉलम का वर्णन करने वाले चार बिट्स को शिफ्ट और मास्क करते हैं, फिर binफ़ंक्शन का उपयोग करके उन्हें एक स्ट्रिंग और शून्य में बदल देते हैं। binसमारोह केवल महत्वपूर्ण बिट देता है, इसलिए हम केवल इस स्ट्रिंग की लंबाई की गणना की जरूरत सबसे कम कब्जे वाले सेल (सबसे महत्वपूर्ण सेट बिट) खोजने के लिए। binसमारोह भी पहले जोड़ता '0b'है, तो हम है कि घटाना है। हम कम से कम महत्वपूर्ण बिट को भी अनदेखा करते हैं। यही कारण है कि हेक्साडेसिमल संख्या बाईं ओर एक बिट स्थानांतरित होती है। यह खाली स्तंभों के लिए है, जिनके स्ट्रिंग निरूपण में केवल शीर्ष सेल पूर्ण (जैसे T टुकड़ा) वाले स्तंभ के समान लंबाई होगी ।
उदाहरण के लिए, के स्तंभों मैं tetromino, के रूप में, जैसा कि पहले उल्लेख कर रहे हैं F, 0और 0। bin(0xF)है '0b1111'। की अनदेखी करने के बाद '0b', हमारे पास 4 की लंबाई है, जो सही है। लेकिन bin(0x0)है 0b0। की अनदेखी करने के बाद '0b', हमारे पास अभी भी '1' की लंबाई है, जो गलत है। इसका हिसाब रखने के लिए, हमने अंत में एक अतिरिक्त बिट जोड़ा है, ताकि हम इस महत्वहीन बिट को अनदेखा कर सकें। इसलिए, +3कोड '0b'में शुरुआत में अतिरिक्त लंबाई और अंत में महत्वहीन बिट के लिए खाता है ।
यह सब तीन स्तंभों ( (0,1,2)) के लिए एक जनरेटर अभिव्यक्ति के भीतर होता है , और हम तीन minपंक्तियों में से किसी को छूने से पहले टुकड़ा को छोड़ने के लिए अधिकतम पंक्तियों को खोजने के लिए परिणाम ले सकते हैं।
बाकी को कोड पढ़कर समझना बहुत आसान होना चाहिए, लेकिन forइन असाइनमेंट के बाद लूप इस टुकड़े को बोर्ड में जोड़ता है। इसके बाद, whileलूप पूरी पंक्तियों को हटा देता है, उन्हें शीर्ष पर खाली पंक्तियों के साथ बदल देता है, और स्कोर को लंबा करता है। अंत में, बोर्ड और स्कोर आउटपुट पर प्रिंट किए जाते हैं।