22

आप एक टर्मिनल के अंदर रहते हैं जो कि 80 अक्षर चौड़ा है। आप ऊब गए हैं, इसलिए आप डोमिनोज़ खेलने का फैसला करते हैं। नहीं, स्क्रैबल की तरह दिखने वाली बोरिंग किस्म नहीं, एक मजेदार तरीका जहां आप उन्हें एक सेकंड में गिरने के लिए एक घंटा बिताते हैं।

टर्मिनलों में, डोमिनोज़ इस तरह दिखते हैं:

|   upright domino
\   left-tilted domino
/   right-tilted domino
__  fallen domino

जैसा कि हम सभी जानते हैं, अगर एक झुका हुआ डोमिनोज़ एक ईमानदार को छूता है, तो दूसरा डोमिनो भी झुक जाता है। इसका एकमात्र अपवाद यह है कि यदि दो झुके हुए डोमिनोज़ इसे छूते हैं:

|\ --> \\        /| --> //        /|\ --> /|\

अपने टर्मिनल के गुरुत्वाकर्षण स्थिर को समायोजित करें ताकि यह संक्रमण 100 एमएस हो जाए।

यदि एक झुका हुआ डोमिनोज़ दूसरे डोमिनोज़ या टर्मिनल की दीवारों द्वारा समर्थित है, तो इसकी यात्रा समाप्त हो जाती है।

कोई भी झुके हुए डोमिनोज़ में नहीं

\||||____||||/__                /|\    /\    /|\                __\||||____||||/

(80 अक्षर) आगे बढ़ेंगे, चूंकि दो सबसे बाहरी झुके हुए डोमिनोज़ टर्मिनल की दीवारों द्वारा समर्थित हैं और अन्य सभी अन्य डोमिनोज़ द्वारा समर्थित हैं।

हालाँकि, यदि झुकाव दिशा में जगह खाली है, तो डोमिनोज़ नीचे गिर जाता है:

| \\ --> |__\        // | --> /__|

टर्मिनल। गुरुत्वाकर्षण स्थिरांक। तुम समझ गए…

अंत में, बाईं ओर से थोड़ी हवा है, इसलिए दाएं झुके हुए डोमिनोज बाएं झुके हुए लोगों की तुलना में तेजी से गिरते हैं:

|/ \| --> |__\|

कार्य

एक प्रोग्राम / फ़ंक्शन लिखें जो टर्मिनल में डोमिनोज़ खेलने का एक एनीमेशन दिखाता है।

आपके कोड को निम्न कार्य करना चाहिए:

इनपुट से एक स्ट्रिंग पढ़ें, डोमिनोज़ की प्रारंभिक स्थिति का प्रतिनिधित्व करता है।

इस स्ट्रिंग में 80 से अधिक अक्षर नहीं होंगे और केवल ऊपर और खाली स्थानों पर वर्णित डोमिनोज़ शामिल होंगे।
राज्य को प्रिंट करें और 100 एमएस की प्रतीक्षा करें।
ऊपर बताए अनुसार राज्य का रूपांतरण करें।
यदि राज्य बदल गया है, तो 2 पर वापस जाएं।

अतिरिक्त नियम

इनपुट स्ट्रिंग की लंबाई टर्मिनल की चौड़ाई को प्रभावित नहीं करती है; यहां तक कि अगर स्ट्रिंग 80 वर्णों से छोटी है, तो टर्मिनल की दीवारें अभी भी 80 वर्णों से अलग हैं।
हर बार चरण 2 को निष्पादित किया जाता है, राज्य को उसी स्थान पर मुद्रित किया जाना चाहिए, पिछले राज्य को अधिलेखित करना।
चूँकि कुछ भाषाएँ वास्तव में 100 ms प्रतीक्षा करने में असमर्थ हैं , इसलिए 50 और 1000 ms के बीच किसी भी राशि की प्रतीक्षा करने के लिए स्वतंत्र महसूस करें।
मानक कोड-गोल्फ नियम लागू होते हैं।

उदाहरण

प्रारंभिक अवस्था के लिए
```
 ||\/||
```
निम्नलिखित प्रिंट करें (एक के ऊपर एक):
```
 ||\/||
 |\\//|
 \\\///
__\\//__
```
प्रारंभिक अवस्था के लिए
```
/||||\
```
निम्नलिखित प्रिंट करें
```
/||||\
//||\\
///\\\
```
प्रारंभिक अवस्था के लिए
```
/|||\
```
निम्नलिखित प्रिंट करें
```
/|||\
//|\\
```
प्रारंभिक अवस्था के लिए
```
|/ \|/ \|/ \|/ \|
```
निम्नलिखित प्रिंट करें:
```
|__\|__\|__\|__\|
```

प्रारंभिक अवस्था के लिए (80 वर्ण)

\||||____||||/__                /|\    /\    /|\                __\||||____||||/

निम्नलिखित प्रिंट करें

\||||____||||/__                /|\    /\    /|\                __\||||____||||/

— डेनिस
स्रोत

13

रेटिना , 87 86 85 बाइट्स

1 बाइट बचाने के लिए डेनिस को धन्यवाद।

^.{0,79}$
$0 
:`^
<ESC>c
(`/ | \\
__
/\|(?!\\)
//a
(?<!/)\|\\
\\
$
aaaaa
a
aaaa
(a+)+b|a
<empty>

<ESC>वास्तविक नियंत्रण चरित्र (0x1B) द्वारा प्रतिस्थापित किया जाना चाहिए। <empty>एक खाली अनुरेखण रेखा का प्रतिनिधित्व करता है। फिर आप एक फ़ाइल के साथ उपरोक्त कोड चला सकते हैं-s ध्वज के ।

कोड को एक टर्मिनल की आवश्यकता होती है जो ANSI एस्केप कोड का समर्थन करता है। मैं रेटिना के आउटपुट में लाइन फीड को दबा नहीं सकता हूं इसलिए मुझे पूरे कंसोल को खाली करने की आवश्यकता है<ESC>c हर बार । मैंने रेटिना को चलाने के लिए मोनो का उपयोग करके बैश में कोड का परीक्षण किया है।

व्याख्या

^.{0,79}$
$0

यदि अंतरिक्ष में 80 से कम अक्षर हैं, तो हम एक स्थान को जोड़कर शुरू करते हैं। यह इसलिए ताकि /दाहिने छोर पर अलग से इलाज न किया जाए।

:`^
<ESC>c

अब हम <ESC>cस्ट्रिंग को प्रस्तुत करते हैं, जो टर्मिनल को साफ़ करने के लिए ANSI एस्केप कोड है। तो हर बार स्ट्रिंग मुद्रित होने पर यह टर्मिनल के शीर्ष पर ऐसा करेगा। :`इस प्रतिस्थापन, यानी प्रारंभिक विन्यास का परिणाम बाहर मुद्रित करने के लिए रेटिना निर्देश देता है।

(`/ | \\
__

(`एक पाश शुरू होता है। चूंकि कोई मेल नहीं है ), इसलिए लूप को प्रोग्राम के अंतिम चरण तक जाने के लिए माना जाता है। प्रत्येक पुनरावृत्ति डोमिनोज़ गिरने के एक चरण का अनुकरण करेगी और फिर थोड़ा "सो" जाएगी। यह पहला चरण बदलता है /और \एक स्थान के बगल में होता है __। यह स्वचालित रूप से / \मामले को सही ढंग से संभालता है, क्योंकि मैच ओवरलैप नहीं कर सकते हैं और बाएं से दाएं के लिए खोजे जाते हैं। इसलिए /<sp>मिलान किया जाएगा और __इस तरह से बदल दिया जाएगा कि \मिलान नहीं किया जा सके, और हमें सही मिले __\।

/\|(?!\\)
//a

यह बदल जाता है /|में //प्रदान की कोई है \उसके बगल में। हम aइस तरह के एक append कि इस नए /अगले चरण के साथ गड़बड़ नहीं करता है (जो अभी तक इस परिवर्तन के बारे में "पता नहीं" नहीं होना चाहिए)।

(?<!/)\|\\
\\

विपरीत स्थिति: बारी |\में \\प्रदान की कोई है /उसके बगल में। हमें aयहां डालने की आवश्यकता नहीं है, क्योंकि हम सिमुलेशन के इस चरण के साथ काम कर रहे हैं।

अब सोने वाला हिस्सा ...

$
aaaaa

aकोड के अंत में 5 और एस लागू करता है।

a
aaaa

प्रत्येक aको 4 aएस में बदल देता है , इसलिए हम aअंत में 20 एस प्राप्त करते हैं।

(a+)+b|a
<empty>

अब मज़ेदार हिस्सा ... भयावह बैकट्रैकिंग की मदद से हम थोड़ा सोते हैं । (a+)+समूह की पुनरावृत्ति के बीच मिलान को विभाजित करने के तरीकों की एक घातीय राशि है । क्योंकि bमैच के विफल होने के कारण, इंजन पीछे हट जाएगा और उन संयोजनों में से हर एक को तय करने से पहले कोशिश करेगा कि (a+)+bमैच नहीं हो सकता। बीस के लिएaअंत एस के लिए जो आधे सेकंड की तरह कुछ लेता है।

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

लूप पुनरावृत्ति के अंत में स्ट्रिंग को छोड़ता है। यहाँ यह काम आता है कि मैंने रेटिना में लूप के मुद्रण व्यवहार को अभी तक ठीक नहीं किया है। वर्तमान में, प्रत्येक चरण के लिए केवल एक ध्वज है, जो कहता है कि "प्रिंट करें" या "प्रिंट न करें"। कार्यक्रम में अंतिम चरण को छोड़कर डिफ़ॉल्ट "प्रिंट नहीं" है, जो "प्रिंट" करने के लिए डिफ़ॉल्ट है। लेकिन मंच को लूप किया जाता है, इसका मतलब है कि यह वास्तव में प्रत्येक पुनरावृत्ति पर वर्तमान स्ट्रिंग को प्रिंट करता है। आम तौर पर, यह वास्तव में कष्टप्रद है, और आपको लगभग हमेशा एक अतिरिक्त खाली चरण को अंत में शामिल करने की आवश्यकता होती है यदि आप केवल अंतिम परिणाम चाहते हैं, लेकिन यहां यह मुझे चार बाइट्स बचाने की अनुमति देता है।

— मार्टिन एंडर
स्रोत

6

जावास्क्रिप्ट (ईएस 6), 206 148 129 158 बाइट्स

मैं अंत में इसे एक नीचले बिंदु पर ले जाऊंगा, लेकिन यह कंसोल को साफ़ नहीं करेगा या एक अतिरिक्त स्थान को नहीं बढ़ाएगा; इन समस्याओं को अब ठीक कर दिया गया है।

c=console;d=s=>{c.clear(s[79]||(s+=' ')),c.log(s),t=s[R='replace'](/\/ | \\/g,'__')[R](/\/\|/g,'//a')[R](/\|\\/g,'\\\\')[R](/a/g,'');t!=s&&setTimeout(d,99,t)}

वैकल्पिक 153 बाइट संस्करण जो Node.JS में काम करना चाहिए:

d=s=>{s[79]||(s+=' '),console.log("\033c"+s),t=s[R='replace'](/\/ | \\/g,'__')[R](/\/\|/g,'//a')[R](/\|\\/g,'\\\\')[R](/a/g,'');t!=s&&setTimeout(d,99,t)}

IMHO, यह खेलने के लिए काफी मजेदार है। यहां एक HTML संस्करण आज़माएं:

कोड स्निपेट दिखाएं

output=document.getElementById("output"),console.log=a=>output.innerHTML=a;
d=s=>{s[79]||(s+=' ');console.log(s),t=s[R='replace'](/\/ | \\/g,'__')[R](/\/\|/g,'//a')[R](/\|\\/g,'\\\\')[R](/a/g,'');t!=s&&setTimeout(d,99,t)}
s=n=>{n=n||15,r='';for(i=0;i<n;i++)r+=(i%2?'|'.repeat(Math.random()*16|0):'\\ /'[Math.random()*3|0].repeat(Math.random()*3+1|0));return r} // randomizer
input=document.getElementById("input");
input.addEventListener("keydown",e=>e.keyCode==13?(e.preventDefault(),d(input.value)):0);

<p>Enter your dominoes here:</p>
<textarea id="input" rows="1" cols="80">|||\ |||\ /|\ /||||||||\ /|||| /|||</textarea>
<button id="random" onclick="input.value=s()">Randomize</button><button id="run" onclick="d(input.value)">Run</button>
<p>Result:</p>
<pre id="output"></pre>

स्निपेट का विस्तार करें

वहाँ शायद गोल्फ के लिए एक अच्छा सा और कमरा है। सुझावों का स्वागत है!

— ETHproductions
स्रोत

चल रहे डेमो के लिए +1 जो मेरे समय का 10 मिनट बर्बाद करता है, और रैंडमाइज़र फ़ंक्शन के लिए +1। हालांकि, डेनिस का उल्लेख है, यह पहले परीक्षण के मामले के लिए विफल रहता है। कोशिश करो /या /|आप देखेंगे कि टाइल को सभी तरह से गिरना नहीं चाहिए जैसा कि इसे करना चाहिए।

— dberm22

@ डेनिस इन समस्याओं को इंगित करने के लिए धन्यवाद। मुझे विश्वास है कि मैंने अब दोनों को ठीक कर लिया है।

— ETHproductions

नोड वसा तीर के बारे में खुश नहीं है, लेकिन यह अन्यथा ठीक काम करता है। आप \0333 बाइट की बचत करके शाब्दिक ESC बाइट को बदल सकते हैं ।

— डेनिस

2

पर्ल 5, 154 146

2 रीगेक्स के बीच राज्य को बनाए रखने के लिए एक अस्थायी चरित्र का उपयोग करना था।
जोखिम से निपटने के लिए कुछ ऐसा / | | | \ / के बजाय / / \ / के रूप में अंत होगा / | \ _।

$_=substr(pop.' ',0,80);$|++;while($}ne$_){print"$_\r";$}=$_;s@ \\|/ @__@g;s@/\|(?=[^\\])@/F@g;s@([^/])\|\\@$1\\\\@g;tr@F@/@;select($\,$\,$\,0.1)}

परीक्षा

$ perl dominos.pl '|\ |\/|||\/|'
|\__\//|\\/__

— LukStorms
स्रोत

1

यदि आप स्लैश के अलावा किसी सीमांकक का उपयोग करते हैं तो आप कई बैकस्लैश को समाप्त कर सकते हैं - जैसे कि s, \\|/ ,__,gइसके बजाय s/ \\|\/ /__/g।

— हॉब्स

अच्छा सुझाव। उस चाल के बारे में भूल गए। और कुछ बाइट्स अतिरिक्त को नकारात्मक सेट का उपयोग करके काट दिया गया।

— लुक्स्टॉर्म्स

2

ईएस 6 , 220 218 195 बाइट्स

minified

f=d=>{var e,c=console;if(!d[79])d+=' ';c.clear();c.log(d);e=d;d=d[R='replace'](/\/\|\\/g,'a')[R](/\/ | \\/g,'__')[R](/\/\|/g,'//')[R](/\|\\/g,'\\\\')[R]('a','/|\\');if(e!=d)setTimeout(f,100,d);};

अधिक पठनीय

f=d=> {
    var e,
    c=console;
    if(!d[79])
        d+=' ';
    c.clear();
    c.log(d);
    e=d;
    d = d[R='replace'](/\/\|\\/g, 'a')  //Substitute '/|\' with 'a' so it doesn't get replaced
        [R](/\/ |  \\/g, '__')     //Replace '/ ' and ' \' with '__'
        [R](/\/\|/g, '//')    //Replace '/|' with '//'
        [R](/\|\\/g, '\\\\')  //Replace '|\' with '\\'
        [R]('a', '/|\\');     //Put '/|\' back
    if(e!=d)
        setTimeout(f,100,d);
};

— user3000806
स्रोत

2

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! 1. मुझे यकीन नहीं है कि आप ES6 नोटेशन का उपयोग क्यों कर रहे हैं। () = > {और }()बस अपने कोड से हटाया जा सकता है। 2. मुझे नहीं लगता कि अलर्ट बॉक्स किसी एनीमेशन के लिए स्वीकार्य आउटपुट प्रारूप हैं। आप या तो अपने जेएस को HTML में एम्बेड कर सकते हैं या आवश्यक बदलाव कर सकते हैं ताकि यह कमांड लाइन से काम करे। 3. किसी भी स्थिति में, आपके कोड को लगभग प्रतीक्षा करनी होगी। एक राज्य और अगले मुद्रण के बीच 100 एमएस।

— डेनिस

2

PPCG में आपका स्वागत है! मेरा सुझाव है कि इस पोस्ट और इस पोस्ट की जाँच करें ताकि आपकी गोल्फ को बेहतर बनाया जा सके।

— jrich

सुझाव और गोल्फ युक्तियाँ के लिंक के लिए धन्यवाद। यह अभी भी थोड़ा लंबा है, लेकिन मैंने इसे थोड़ा छोटा किया और टाइमर को जोड़ा। मैं और अधिक गहराई से युक्तियों से गुजरूंगा और देखूंगा कि मैं क्या छोटा कर सकता हूं।

— user3000806

1

यह अब एक टर्मिनल में काम करना चाहिए, लेकिन यह अभी भी पुराने पर अद्यतन स्थिति को मुद्रित नहीं करेगा। लिनक्स पर, आप console.log("^[c"+d)इसके बजाय कॉल करके ठीक कर सकते हैं , जहां ^[ESC वर्ण (एक बाइट) है।

— डेनिस

1

यदि आप पहले .replaceको बदलते हैं [R='replace'], तो प्रत्येक को बाद में [R], यह काफी नीचे कट जाएगा। आप setTimeout(f,100,d)वर्तमान सेटअप की जगह का उपयोग करके कुछ बाइट्स भी बचा सकते हैं ।

— ETHproductions

2

सी #, 335 बाइट्स

भाषा का कोई बड़ा विकल्प नहीं।

मैंने दो अंकों की संख्या का चयन करने के लिए 50 और 1000 के बीच की अनुमति में देरी का दुरुपयोग किया।

स्पष्टता के लिए नई लाइनें और इंडेंटेशन जोड़ा गया:

namespace System.Threading{
    class P{
        static void Main(string[]z){
            var c=@"/|\,/|\,/|,//,|\,\\,/ ,__, \,__".Split(',');
            for(string a=z[0].PadRight(80),b="";a!=b;){
                Console.Clear();
                Console.Write(b=a);
                Thread.Sleep(99);
                a="";
                for(int i,j;(i=a.Length)<80;)
                    a+=(j=Array.FindIndex(c,d=>b.Substring(i).StartsWith(d)))%2==0
                        ?c[j+1]
                        :b.Substring(i,1);
            }
        }
    }
}

— हाथ-ए-खाना
स्रोत

1

PHP, 175 बाइट्स

$i=sprintf("%-80s",$argv[1]);$p='preg_replace';do{echo($o=$i)."\r";$i=$p('(/\|\\\\(*SKIP)(?!)|(?|(/)\||\|(\\\\)))','$1$1',$p('(/ | \\\\)','__',$i));usleep(1e5);}while($i!=$o);

संयुक्त राष्ट्र के न्यूनतम किया गया:

$input = sprintf("%-80s",$argv[1]);
do {
  echo $input."\r";
  $old = $input;
  $input = preg_replace('(/ | \\\\)','__',$input);
  $input = preg_replace('(/\|\\\\(*SKIP)(?!)|(?|(/)\||\|(\\\\)))','$1$1',$input);
  usleep(100000);
}
while( $input != $old);

मूल रूप से रेगेक्स गोल्फ। पहले किसी भी गिरने वाले डोमिनोज़ को समतल करता है, जिसमें स्थान है (और बाएं से दाएं मिलान के आदेश के कारण, "हवा" चल रही है)। फिर बदसूरत हिस्सा आता है (आप शाप देते हैं!)

मैच /|\ , फिर उसे छोड़ें।
मिलान करें (/)|और बदलें//
मिलान करें |(\)और बदलें\\

इससे डोमिनोज गिर जाते हैं। अंत में, बस अगले चरण के लिए 100ms प्रतीक्षा करें।

()Regex पर सीमांकक के रूप में उपयोग करने का मतलब है कि /भागने की आवश्यकता नहीं है, जो न्यूनतम मदद करता है!

— नीट द डार्क एबसोल
स्रोत

आपको 100 की बजाय 50ms का इंतजार करने की अनुमति है, 1 char की बचत?) क्या PHP 10 ^ 5 की अनुमति देता है?

— ब्लूकैक्टी

1

पोसिक्स शेल + सेड, 144

sed 's/^.\{1,79\}$/& /;s/.*/printf '"'&\\r'"';sleep .1/;h;:;s,/|\\,/:\\,g;s,\(/ \| \\\),__,g;s,/|,//,g;s,|\\,\\\\,g;H;t;x;y/:/|/;s/\\/\\\\/g'|sh

यह दो भागों में है। डोमिनोज़ को टॉप करने का मुख्य कार्य मानक sedपैटर्न प्रतिस्थापन है, जो लाइनों को अंतरिक्ष में जमा करता है। हम अस्थायी रूप से बारी /|\में /:\बचाने के लिए, अंत में ठीक हो।

s/^.\{0,79\}$/& /
h

:
s,/|\\,/:\\,g
s,\(/ \| \\\),__,g
s,/|,//,g
s,|\\,\\\\,g
H
t

x
y/:/|/

जबसे sed मुझे देरी डालने का कोई तरीका नहीं मिला है (मैंने टर्मोफ़ / टर्मकैप में देखा, लेकिन कोई मानक तरीका नहीं खोज पाया), मैं प्रत्येक में प्रवेश करता हूंprintf "...\r"; sleep .1 को प्रत्येक 100ms पर एक लाइन प्रिंट करने के लिए । मैं वास्तव में यह पहली बार करता हूं, जब हमारे पास सिर्फ एक पंक्ति होती है, क्योंकि कमांड के पात्रों को टॉपिंग के किसी भी विकल्प से नहीं छुआ जाएगा।

सभी पर्यावरण में सेट के साथ परीक्षण dashऔर GNU का उपयोग कर ।coreutilsPOSIXLY_CORRECT

— टोबी स्पाईट
स्रोत

डोमिनोज की तरह उन्हें देखो

कार्य

अतिरिक्त नियम

उदाहरण

रेटिना , 87 86 85 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 206 148 129 158 बाइट्स

पर्ल 5, 154 146

परीक्षा

ईएस 6 , 220 218 195 बाइट्स

सी #, 335 बाइट्स

PHP, 175 बाइट्स

पोसिक्स शेल + सेड, 144