संभव टेट्रिस क्रम

Question

आधिकारिक टेट्रिस एल्गोरिथ्म द्वारा टेट्रिस टुकड़ों की एक रन जेनरेट की जा सकती है या नहीं यह जानने के लिए कोड लिखें। सबसे कम बाइट्स जीतता है।

---

आधिकारिक टेट्रिस गेम एक विशेष तरीके से गिरने वाले टुकड़ों के अनुक्रम को उत्पन्न करते हैं। सात टुकड़े IJLOSTZएक यादृच्छिक क्रम में गिराए जाते हैं, फिर एक और यादृच्छिक क्रमांकन गिराया जाता है, और इसी तरह।

JTLOISZ STJOLIZ LISJOTZ ...

इस उदाहरण में टुकड़ों का सन्निहित भाग है

SZSTJOLIZLIS

ध्यान दें कि यह 7. के समूह की सीमाओं के पार कट जाता है, लेकिन टुकड़ों का भाग

SZOTLZSOJSIT

किसी भी टेट्रिस अनुक्रम का विकल्प नहीं हो सकता है, इसलिए इसे आधिकारिक टेट्रिस गेम में कभी नहीं देखा जा सकता है।

---

इनपुट: पत्रों का एक गैर-रिक्त स्ट्रिंग IJLOSTZ।

आउटपुट: इनपुट के अनुक्रम या विकल्प के लिए एक सत्य या गलत मूल्य, जो आधिकारिक Tetris रैंडम जेनरेटर द्वारा उत्पन्न किया जा सकता है, यानी सात अक्षरों के क्रमपरिवर्तन का एक संयोजन।

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

सच:

T
JJ                        (unique breakdown: J J)
JTJ                     (possible breakdown: JT J)
LTOZIJS
SZSTJOLIZLIS            (possible breakdown: SZ STJOLIZ LIS)
JTLOISZSTJOLIZLISJOTZ   (possible breakdown: JTLOISZ STJOLIZ LISJOTZ)  
LIJZTSLIJZTS              (unique breakdown: LIJZTS LIJZTS)

असत्य:

SZOTLZSOJSIT
ZZZ
ZIZJLJ
ZJLJLZITSOTLISOJT
JTLOISZSTJOLIZLISJOTZLJTSZLI
IOJZSITOJZST
LIJZTSLIJZTSL

लीडरबोर्ड

मार्टिन ब्यटनर के सौजन्य से ।

function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/55689/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(e){answers.push.apply(answers,e.items);if(e.has_more)getAnswers();else process()}})}function shouldHaveHeading(e){var t=false;var n=e.body_markdown.split("\n");try{t|=/^#/.test(e.body_markdown);t|=["-","="].indexOf(n[1][0])>-1;t&=LANGUAGE_REG.test(e.body_markdown)}catch(r){}return t}function shouldHaveScore(e){var t=false;try{t|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(n){}return t}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading);answers.sort(function(e,t){var n=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0],r=+(t.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0];return n-r});var e={};var t=1;answers.forEach(function(n){var r=n.body_markdown.split("\n")[0];var i=$("#answer-template").html();var s=r.match(NUMBER_REG)[0];var o=(r.match(SIZE_REG)||[0])[0];var u=r.match(LANGUAGE_REG)[1];var a=getAuthorName(n);i=i.replace("{{PLACE}}",t++ +".").replace("{{NAME}}",a).replace("{{LANGUAGE}}",u).replace("{{SIZE}}",o).replace("{{LINK}}",n.share_link);i=$(i);$("#answers").append(i);e[u]=e[u]||{lang:u,user:a,size:o,link:n.share_link}});var n=[];for(var r in e)if(e.hasOwnProperty(r))n.push(e[r]);n.sort(function(e,t){if(e.lang>t.lang)return 1;if(e.lang<t.lang)return-1;return 0});for(var i=0;i<n.length;++i){var s=$("#language-template").html();var r=n[i];s=s.replace("{{LANGUAGE}}",r.lang).replace("{{NAME}}",r.user).replace("{{SIZE}}",r.size).replace("{{LINK}}",r.link);s=$(s);$("#languages").append(s)}}var QUESTION_ID=45497;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/;var NUMBER_REG=/\d+/;var LANGUAGE_REG=/^#*\s*((?:[^,\s]|\s+[^-,\s])*)/

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet type=text/css href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=answer-list><h2>Leaderboard</h2><table class=answer-list><thead><tr><td></td><td>Author<td>Language<td>Size<tbody id=answers></table></div><div id=language-list><h2>Winners by Language</h2><table class=language-list><thead><tr><td>Language<td>User<td>Score<tbody id=languages></table></div><table style=display:none><tbody id=answer-template><tr><td>{{PLACE}}</td><td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table><table style=display:none><tbody id=language-template><tr><td>{{LANGUAGE}}<td>{{NAME}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table>

Answer 1

पायथ, 16 15 बाइट्स

sm*F.{Mc+>Gdz7T

झूठे के लिए प्रिंट 0, सच के लिए एक सकारात्मक पूर्णांक।

Answer 2

CJam, 23 20 16 बाइट्स

q7{\+_7/_Lf|=},&

4 बाइट शेविंग के लिए Sp3000 को क्रेडिट!

यह अंकों के एक झुंड को सत्य मान के रूप में या मिथ्या मूल्य के रूप में कुछ भी नहीं छापता (मुद्रण से पहले ये वास्तव में एक गैर-रिक्त या रिक्त सूची हैं, जो वास्तव में सत्य और सीजेएम में मिथ्या हैं)।

इसका परीक्षण यहां करें।

व्याख्या

यह सिर्फ इनपुट के सभी 7 संभावित विभाजन को विखंडू में जाँचता है।

q      e# Read the input
7{     e# Select the numbers from 0 to 6 for which the following block is true.
  \+   e#   Prepend the number to the input. This shifts the string by one cell
       e#   without adding non-unique elements.
  _7/  e#   Make a copy and split into chunks of 7.
  _Lf| e#   Remove duplicates from each chunk.
  =    e#   Check if the last operation was a no-op, i.e. that there were no duplicates.
},
&      e# The stack now contains the input with [6 5 ... 1 0] prepended as well as a list
       e# of all possible splittings. We want to get rid of the former. To do this in one
       e# byte we take the set intersection of the two: since we've prepended all the
       e# integers to the list, this will always yield the list of splittings.

Answer 3

रेटिना , 61 55 बाइट्स

^((.)(?<!\2.+))*((){7}((?<-4>)(.)(?!(?<-4>.)*\4\6))*)*$

चूँकि यह केवल एक एकल रेगीक्स है, रेटिना मैच मोड में चलेगा और इसमें पाए जाने वाले मैचों की संख्या की रिपोर्ट करेगा, जो 1मान्य अनुक्रमों के लिए होगा और 0अन्यथा। यह गोल्फ की भाषाओं की तुलना में प्रतिस्पर्धी नहीं है, लेकिन मैं इसके साथ काफी खुश हूं, यह देखकर मैंने 260 बाइट्स के राक्षस के साथ शुरुआत की।

व्याख्या

^((.)(?<!\2.+))*

यह बिट चर लंबाई के अनूठे अक्षरों के एक उपसर्ग का उपभोग करता है, अर्थात यह संभावित रूप से अधूरे अग्रणी चंक से मेल खाता है। लुकबाइंड यह सुनिश्चित करता है कि इस बिट में मिलान किया गया कोई भी अक्षर पहले स्ट्रिंग में दिखाई नहीं दिया है।

अब शेष इनपुट के लिए, हम वर्णों को दोहराए बिना 7 के विखंडन का मिलान करना चाहते हैं। हम इस तरह के एक कबाड़ का मिलान कर सकते हैं:

(.)(?!.{0,5}\1)(.)(?!.{0,4}\2)(.)(?!.{0,3}\3)...(.)(?!.?\5).

यानी हम एक ऐसे चरित्र से मेल खाते हैं जो अन्य 6 वर्णों के लिए प्रकट नहीं होता है, फिर वह जो अन्य 5 वर्णों के लिए प्रकट नहीं होता है और इसी तरह। लेकिन इसके लिए काफी भयानक कोड पुनरावृत्ति की आवश्यकता होती है, और हमें एक अनुगामी (संभावित रूप से अधूरा) अलग से मिलान करना होगा।

बचाव के लिए समूहों को संतुलित करना! मैच करने का एक अलग तरीका

(.)(?!.{0,5}\1)

एक कैप्चर स्टैक पर 5 खाली मैचों को पुश करना है और इसे खाली करने का प्रयास करना है:

(){5}(.)(?!(?<-1>.)*\2)

*कम से कम शून्य पुनरावृत्ति की अनुमति देता है {0,5}, और क्योंकि हमने पांच कैप्चर को धकेल दिया है, यह 5 बार से अधिक पॉप करने में सक्षम नहीं होगा। यह इस पैटर्न के एकल उदाहरण के लिए लंबा है, लेकिन यह बहुत अधिक पुन: प्रयोज्य है। चूँकि हम नकारात्मक लुकअप में पॉपिंग कर रहे हैं , यह लुकहेड पूरा होने के बाद वास्तविक स्टैक को प्रभावित नहीं करता है। इसलिए लुकहेड के बाद, हमें स्टैक पर अभी भी 5 तत्व मिले हैं, कोई फर्क नहीं पड़ता कि अंदर क्या हुआ। इसके अलावा, हम बस प्रत्येक लुकहेड से पहले स्टैक से एक तत्व को पॉप कर सकते हैं, और कोड को एक लूप में चला सकते हैं, स्वचालित रूप से लुकहेड की चौड़ाई को 5 से घटाकर 0. करने के लिए। ताकि वास्तव में लंबे समय तक वास्तव में छोटा किया जा सके

(){7}((?<-1>)(.)(?!(?<-1>.)*\1\3))*

(आप दो अंतर देख सकते हैं: हम 5 के बजाय 7 धक्का दे रहे हैं। एक अतिरिक्त कब्जा है क्योंकि हम प्रत्येक पुनरावृत्ति से पहले पॉप करते हैं, इसके बाद नहीं। दूसरा वास्तव में आवश्यक है ताकि हम स्टैक से 7 बार पॉप कर सकें (जब से हम चाहते हैं) लूप को 7 बार चलाने के लिए), हम लुकहैड के अंदर उस ऑफ-बाय-वन एरर को यह सुनिश्चित करके ठीक कर सकते हैं कि \1स्टैक पर अभी भी कम से कम एक एलिमेंट बाकी है।)

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

^((.)(?<!\2.+))*((){7}((?<-4>)(.)(?!(?<-4>.)*\4\6))*)*$