22

कुछ प्रेरणा के लिए इस सवाल का धन्यवाद

इस चुनौती में हम एक स्ट्रिंग के रूप में डोमिनोज़ की एक पंक्ति का प्रतिनिधित्व करेंगे |, /और \। आपको इनपुट के रूप में डोमिनोज़ की एक स्ट्रिंग दी जाएगी और आपको यह निर्धारित करना होगा कि जब वे बस गए हैं तो वे क्या दिखते हैं। डोमिनो कैसे गिरते हैं, इसके लिए नियम यहां दिए गए हैं

एक खड़े डोमिनोज़, |एक बाएँ गिरे हुए डोमिनोज़ के बाएँ \, साथ ही एक बाएँ गिरे हुए डोमिनो बन जाएंगे।
एक खड़े डोमिनोज़, |एक सही गिरे हुए डोमिनोज़ के दाईं ओर, एक सही गिरे हुए डोमिनो /बन जाएंगे।
यदि एक खड़े डोमिनोज़ एक बाएँ गिरे हुए \और एक दाएँ गिरे हुए /डोमिनोज़ के बीच है, तो यह खड़ा रहेगा।

इन नियमों को बार-बार लागू किया जाता है जब तक कि व्यवस्था में कोई परिवर्तन नहीं होता है।

यहां एक उदाहरण दिया गया है कि एक एकल इनपुट अपने निष्कर्ष पर कैसे पहुंच सकता है

|||||||\/|||||||\||\|||/||||||\|||||

||||||\\//|||||\\|\\|||//||||\\|||||
|||||\\\///|||\\\\\\|||///||\\\|||||
||||\\\\////|\\\\\\\|||////\\\\|||||
|||\\\\\////|\\\\\\\|||////\\\\|||||
||\\\\\\////|\\\\\\\|||////\\\\|||||
|\\\\\\\////|\\\\\\\|||////\\\\|||||

\\\\\\\\////|\\\\\\\|||////\\\\|||||

आपका कार्य एक इनपुट के अंतिम परिणाम को खोजने और आउटपुट करने वाले कोड को लिखना है। आप मान सकते हैं कि इनपुट हमेशा मान्य है और इसमें कम से कम 2 वर्ण हैं।

यह कोड-गोल्फ है इसलिए उत्तर बाइट्स में कम बाइट के साथ बेहतर स्कोर किए जाएंगे।

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

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

code-golf string dominoes code-golf ascii-art code-golf date error-message code-golf arithmetic date clock code-golf ascii-art kolmogorov-complexity alphabet code-golf math number-theory integer integer-partitions code-challenge test-battery game-of-life optimized-output code-golf decision-problem integer division math number-theory atomic-code-golf code-golf number array-manipulation

— गेहूं का जादूगर
स्रोत

6

बैकस्लैश बच निकले अहो! (क्या हम अन्य प्रतीकों का उपयोग कर सकते हैं?)

— अरनौल्ड

1

@Arnauld नहीं, आपको स्लैश का उपयोग नहीं करना चाहिए।

— गेहूं जादूगर

1

मैं नहीं कर सकता ... यह पता लगाने के लिए कि क्या बचना है और क्या नहीं।

— 16

क्या इनपुट कभी रिक्त स्ट्रिंग या एकल वर्ण होगा?

— दरवाज़े

3

यह मुझे इससे ज्यादा परेशान करता है कि यह `//////// | \ _ जैसी चीजों को स्थिर माना जाता है।

— MooseBoys

13

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

+`(/.\\)|(/)\||\|(\\)
$1$2$2$3$3

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

व्याख्या

+रेटिना बताता है जब तक यह स्ट्रिंग को बदलने के लिए विफल रहता है एक पाश में प्रतिस्थापन को चलाने के लिए। प्रत्येक प्रतिस्थापन एक कदम गिरते डोमिनोज़ की गणना करता है। प्रतिस्थापन वास्तव में एक में तीन प्रतिस्थापन है, लेकिन यह सुनिश्चित करता है कि वे एक साथ होते हैं:

(/.\\)...
$1

यह सिर्फ मैचों /|\(और साथ ही /\\और /\\, लेकिन उन बात नहीं करते हैं) और reinserts यह अपरिवर्तित। इसका उद्देश्य |दोनों पक्षों पर गिरे हुए डोमिनोज़ को छोड़ना है , क्योंकि यह उन मामलों को अन्य दो मामलों में अलग-अलग लुकआउट के साथ शासित करने से कम है।

...(/)\|...
$2$2

यह मेल खाता है /|और इसे बदल देता है //।

...\|(\\)
$3$3

यह मेल खाता है |\और इसे बदल देता है \\।

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

कह सकते हैं कि मैं देख नहीं आया था। रेटिना निश्चित रूप से नौकरी के लिए एक अच्छा उपकरण है।

— गेहूं जादूगर

@WheatWizard यह हल करने के लिए आसान है, लेकिन शायद अभी भी सभी भागने के साथ क्रिया है और यह कि $1$2$2$3$3गोल्फ भाषाओं को हराया है।

— मार्टिन एंडर

5

पायथन 2 , 115 114 111 108 98 95 बाइट्स

^{-1 बाइट ओवस के लिए धन्यवाद}

a=input()
for i in range(4)*len(a):a=a.replace('//|x||\ \\'[i::4],'/\/x|\/ \\'[3-i::4])
print a

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

— छड़ी
स्रोत

आर-स्ट्रिंग्स का उपयोग करके 114 बाइट्स ।

— ओवंस

आप निकाल सकते हैं b=0;और की घटनाओं की जगह bसे idदो बाइट्स बचाने के लिए!

— लिन

4

वी , 23 बाइट्स

òÓ¯À<!|¨Ü©ü¨¯©|ÜÀ!/±±²²

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

वास्तव में, यह रेटिना के उत्तर के समान है, बस यह बदसूरत दिखता है। रेगेक्स कम्प्रेशन का उपयोग करता है।

Hexdump:

00000000: f2d3 afc0 3c21 7ca8 dca9 fca8 afa9 7cdc  ....<!|.......|.
00000010: c021 2fb1 b1b2 b2                        .!/....

स्पष्टीकरण:

òV को तब तक चलाने के लिए कहता है जब तक स्ट्रिंग नहीं बदलती। बाकी एक संकुचित रेगेक्स है। आइए इसे vim समतुल्य में बदलें ...

:s/\v\/@<!\|(\\)|(\/)\|\\@!/\1\1\2\2/g

:s/                                     " Substitute...
   \v                                   " Turn on magic (use less escaping)
          \|                            " A bar
            (\\)                        " Followed by a captured backslash
       @<!                              " That is not preceded by
     \/                                 " A forward slash
                |                       " OR...
                 (\/)                   " A captured forward slash
                     \|                 " Followed by a bar
                       \\@!             " That is not followed by a backslash
                           /            " Replace this with
                            \1\1        " Pattern 1 twice (will be empty if we matched the second path)
                                \2\2    " Pattern 2 twice (will be empty if we matched the first path)
                                    /g  " Replace every match on this line

— DJMcMayhem
स्रोत

4

SNOBOL4 (CSNOBOL4) , 117 115 112 111 बाइट्स

	D =INPUT
S	D '/|\' ='_'	:S(S)
	E =D
	D '/|' ='//'
	D '|\' ='\\'
	D E	:F(S)
R	D '_' ='/|\'	:S(R)
	OUTPUT =D
END

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

परीक्षण के बजाय परिवर्तनों को देखने के लिए एक दूसरे चर के साथ रोक की स्थिति के लिए विचार के लिए रॉड के अजगर जवाब का श्रेय D '/|' | '|\'।

	D =INPUT		;* read input
S	D '/|\' ='_'	:S(S)	;* replace '/|\' with '_', recursively
	E =D			;* set E to D, this is the while loop
	D '/|' ='//'		;* topple right
	D '|\' ='\\'		;* topple left
	D E	:F(S)		;* if D doesn't match E, goto S
R	D '_' ='/|\'	:S(R)	;* replace '_' with '/|\' (inverse of statement S)
	OUTPUT =D		;* output
END

— ग्यूसेप
स्रोत

3

हास्केल , 114 107 बाइट्स

until=<<((==)=<<)$g
g s=t<$>zip3('|':s)s(tail s++"|")
t(l,'|',r)|l<'0',r/='\\'=l|r=='\\',l>'/'=r
t(_,e,_)=e

इसे ऑनलाइन आज़माएं! पहली पंक्ति एक अनाम फ़ंक्शन को परिभाषित करती है।

स्पष्टीकरण:

until=<<((==)=<<)$gएक फिक्स पॉइंट फ़ंक्शन है ( स्पष्टीकरण के लिए यहां देखें ) जो फ़ंक्शन gको इनपुट स्ट्रिंग पर लागू करता है जब तक कि परिणाम नहीं बदलता है।
zip3('|':s)s(tail s++"|")प्रत्येक डोमिनोज़ के लिए बनाता है, यह स्ट्रिंग में चरित्र है s, पूर्व के साथ एक ट्रिपल और सफल डोमिनोज़, |किनारों पर पैडिंग । जैसे /\|बन जाता है [(|,/,\),(/,\,|),(\,|,|)](बचकर निकल जाना)।
फिर tट्रिपल के केंद्र के टुकड़े की नई स्थिति की गणना करने के लिए फ़ंक्शन को प्रत्येक त्रिक पर लागू किया जाता है।

— Laikoni
स्रोत

2

पर्ल 5 , 39 + 1 ( `-p`) = 40 बाइट्स

s%(?<!/)\|(\\)|(/)\|(?!\\)%$+$+%g&&redo

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

— Xcali
स्रोत

2

प्रोलॉग (एसडब्ल्यूआई) , 132 बाइट्स

+[]-->[].
+[47,124,92|T]-->"/|\\",+T.
+[47,47|T]-->"/|",+T.
+[92,92|T]-->"|\\",+T.
+[X|T]-->[X],+T.
X+Y:- +(N,X,[]),!,(X=N,Y=N;N+Y).

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

यह कार्यक्रम एक विधेय को परिभाषित करता है जो +/2कि सही है यदि दूसरा तर्क पहले के व्यवस्थित संस्करण है। दोनों तर्क चरित्र कोड की सूची हैं।

व्याख्या

यह समाधान डीसीजी का उपयोग करके यह पता लगाने के लिए करता है कि अगला चरण क्या है और फिर बार-बार अगले चरण की गणना करता है जब तक कि अगला कदम वर्तमान चरण के समान ही न हो।

डीसीजी

+[]-->[].
+[47,124,92|T]-->"/|\\",+T.
+[47,47|T]-->"/|",+T.
+[92,92|T]-->"|\\",+T.
+[X|T]-->[X],+T.

कोड की ये पांच पंक्तियाँ DCG (निश्चित क्लाज ग्रामर) नियम को परिभाषित करती हैं जो +कि कार्यक्रम के लिए डोमिनोज़ टॉपिंग के एक चरण की गणना करने के लिए उपयोग किया जाता है। प्रोलॉग में DCGs उस नियम के पहले मामले का पता लगाकर काम करते हैं, जिसके दाहिने हाथ की तरफ स्ट्रिंग से मेल खाती है और उस प्रक्रिया के माध्यम से बाएं हाथ की तरफ नियम का तर्क निर्धारित करती है। यदि कोई मामला मेल नहीं खाता है, तो यह पीछे हट जाएगा और बाद के मामले की कोशिश करेगा।

+[]-->[].

यह रेखा +नियम के आधार मामले का प्रतिनिधित्व करती है । यह बस बताता है कि अगर वर्तमान में कोई डोमिनोज़ नहीं हैं तो अगले चरण में अभी भी कोई डोमिनोज़ नहीं होंगे।

+[47,124,92|T]-->"/|\\",+T.

के बाद से इस कार्यक्रम के चरित्र कोड की सूची के साथ विशेष रूप से संबंधित है यह नोट करना महत्वपूर्ण है कि के लिए चरित्र कोड /, \और |47, 92, और 124 क्रमशः रहे हैं। +नियम का यह मामला /|\स्ट्रिंग को संभालता है ।

+[47,47|T]-->"/|",+T.

यह मामला एक सही गिरने वाले डोमिनोज़ को संभालता है जो कि डोमिनोज़ के ऊपर दस्तक देता है। चूंकि यह मामला संभालने के बाद आता है इसलिए इसका /|\उपयोग उस संभावना के लिए नहीं किया जाएगा।

+[92,92|T]-->"|\\",+T.

बायीं ओर गिरते डोमिनोज के लिए मामले को संभालती है और इसके बाईं ओर डोमिनोज को खटखटाती है।

+[X|T]-->[X],+T.

यह वाइल्डकार्ड मामला है। चूंकि ऊपर वर्णित के अलावा और कुछ भी नहीं बदलता है, इसलिए जब तक इनपुट स्ट्रिंग में पाठ छोड़ दिया जाता है तब तक यह इसे आउटपुट पर कॉपी करेगा जब तक कि यह उपरोक्त मामलों में से किसी से मेल नहीं खाता।

द प्रेडिकेट

X+Y:- +(N,X,[]),!,(X=N,Y=N;N+Y).

मुख्य विधेय दो तर्क लेता है, पहला प्रारंभिक डोमिनोज़ सेटअप है, दूसरा व्यवस्थित डोमिनोज़ है। चूंकि यह प्रोलॉग है, दूसरा अनिर्धारित हो सकता है और प्रोग्राम इसकी गणना करेगा। अपने आप में विधेय काफी सरल +(N,X,[])है और डीसीजी को कॉल करता है और इसमें स्टोर करने वाले डोमिनोज के अगले चरण की गणना करता है N। (X=N,Y=N;N+Y)यह जाँच करता है कि डोमिनोज़ का अगला चरण वर्तमान के समान है और यदि यह इसे सेट Yकरता है क्योंकि डोमिनोज़ बस गए होंगे और यदि यह पुनरावृत्ति नहीं करता है, तो डोमिनोज़ के अगले चरण के साथ उसी विधेय को बुला रहा Nहै X।

— 0 '
स्रोत

1

एपीएल (डायलॉग) , 36 बाइट्स

({(↑∘1¨3 ¯3)⍳⊂⍵≠'/|\'}⊃'\/',2⊃⊢)⌺3⍣≡

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

-3 आंशिक रूप से गायों की बोली के लिए धन्यवाद ।

ऐसा लगता है कि ungolfed ... :(

— आउटगोल्फर को एरिक करें
स्रोत

स्टैंसिल बराबर।

— E पर आउटगोल्फ

1

चेहरा , 166 बाइट्स

\|/,cm_/o>AvI[IIcP/+PP|m_/m*/Sl*Im1/11:~-_I|'|?_1-_P|?_1`I-III_|+II|'I.C:1-_I|?_C'|-_P|?_C_|'I-_I|`I?_!'I.C:!'|'|-III+II|'I:C_|-PPP+PPI'I?I~_I-PPP+PP|-**1?*~Sl*Iw*I*>

कमांड लाइन तर्क के रूप में इनपुट लेता है और STDOUT को आउटपुट करता है। यह केवल 94६४ ९ ४ एफ ६ में काम करता है और उस प्रतिबद्ध में बगफिक्स के कारण परे है।

सौंदर्यशास्त्र के लिए लिपटे:

\|/,cm_/o>AvI[IIcP/+PP|m_/m*/Sl*Im1/11:~-_I|'|?_1-_P|?_1`I
-III_|+II|'I.C:1-_I|?_C'|-_P|?_C_|'I-_I|`I?_!'I.C:!'|'|-III
+II|'I:C_|-PPP+PPI'I?I~_I-PPP+PP|-**1?*~Sl*Iw*I*>

और अपुष्ट / टिप्पणी की गई:

\|/,cm_/o>              ( setup )

AvI[II                  ( store input into I )
cP/+PP|m_/              ( store 92, ascii for \, into P, meaning prev char )
m*/Sl*Im1/11            ( store length of input into counter variable * )

( main loop: )
:~

    -_I|'|?_1           ( branch to 1 if the character is not \ )
    -_P|?_1             ( also branch to 1 if the previous character wasn't | )
    `I-III_|+II|'I      ( we have a sequence |\ so prev needs to be toppled )
    .C                  ( jump to C, the "continue" label at end of loop )

    :1
    -_I|?_C             ( branch to C if the character is not | )
    '|-_P|?_C           ( also branch to C if the previous character wasn't / )
    _|'I-_I|`I?_!       ( branch to ! if the next character isn't \ )
    'I.C:!              ( otherwise, skip the next \ and branch to continue )
    '|'|-III+II|'I      ( if all conditions hold we have /|| or /|/ so topple )

    :C
    _|                  ( reset pointer to source )
    -PPP+PPI            ( update prev variable )
    'I                  ( step through data )

?I~

_I-PPP+PP|-**1          ( reset input/prev and decrement counter )
?*~                     ( repeat main loop as many times as there are chars )

Sl*Iw*I*>               ( output final string to stdout )

यहाँ कुछ सूक्ष्म चालें हैं जो कुछ अतिरिक्त बाइट्स को काटती हैं, जैसे कि

चर का नामकरण | और /, जिनके ASCII मूल्यों को कोड में बाद में आत्मनिरीक्षण के माध्यम से पहुँचा जा सकता है
'|मुख्य पाश है, जो वहाँ सेट करने के लिए करने के बजाय कहा जाता है दूसरी पंक्ति पर की पहली पंक्ति पर | मुख्य लूप के दूसरे खंड में उपयोग के लिए सूचक

— Doorknob
स्रोत

1

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

-6 बाइट्स मीक के लिए धन्यवाद

शायद पर्ल के लिए सबसे अच्छा संभव नहीं है, लेकिन यह वही है जो मैं साथ आ सकता हूं।

0while(s/(?<!\/)\|(?=(\\))|(?<=(\/))\|(?!\\)/$1$2/g)

व्याख्या

while(
  s/
    (?<!\/)\|(?=(//)) # If there's a | that precedes a \ but doesn't follow a /, capture /
      | # Or
    (?<=(\/))\|(?!//)/ # If there's a | that follows a / doesn't precede a \, capture /
  /$1$2/ # Replace all | with capture group 1 or 2, as one of the two will always be empty
  g # Repeat as much as possible for this string
)

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

— जेफ्री एच।
स्रोत

-pके बजाय के -aलिए की जरूरत समाप्त print;; whileएक डमी एक्सप्रेशन (जैसे 0) के लिए एक प्रत्यय के रूप में उपयोग करने से एक और 2 बाइट्स

— बचेंगे

धन्यवाद @ मिक, मैं उन चालों को नहीं जानता था। मुझे यह भी पता चलता है कि मैं कुछ बाइट्स को बचाने के लिए regex को कुछ और के साथ सीमांकित कर सकता हूं। बाद में मिल सकता है।

— जेफ्री एच।

1

पर्ल 5 , 44 (कोड) + 1 ( `-p`) = 45 बाइट्स

1while s,(/)\|(?!\\)|(?<!/)\|(\\),$1$1$2$2,g

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

व्याख्या

1while s,                        ,        ,g   while anything found substitute globally
         (/)\|(?!\\)              $1$1         /| that is not followed by \ to //
                    |                          or
                     (?<!/)\|(\\)     $2$2     |\ that is not preceded by / to \\

— mik
स्रोत

1

क्लीन , 98 बाइट्स

import StdEnv
$['/|':t]=['//': $t]
$['|\\':t]=['\\\\': $t]
$[h:t]=[h: $t]
$e=e
f=until(\e=e== $e)$

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

— Οurous
स्रोत

0

रूबी , 83 बाइट्स

तकनीकी रूप से आसान है 9.times, या यहाँ तक कि 999.timesलेकिन मुझे सस्ते होने का मन नहीं है :)

अभी भी विशाल गोल्फ की क्षमता है। (नोट: इससे y while undoneकहीं अधिक लंबा है x.size.times)

->x{x.size.times{x.gsub! /\/\|\\?|\|\\/,'/|\\'=>'/|\\','/|'=>'//','|\\'=>'\\\\'}
x}

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

— Unihedron
स्रोत

0

आर , 114 बाइट्स

function(d){g=gsub
for(i in 1:nchar(d))d=g("/|","//",g("|\\","\\\\",g("/|\\","_",d,f=T),f=T),f=T)
g("_","/|\\",d)}

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

एक बची हुई स्ट्रिंग लौटाता है।

— ग्यूसेप
स्रोत

0

सी (जीसीसी) , 183 बाइट्स

D,i;f(char*S){char*s=malloc(-~strlen(S));for(D=1;D--;strcpy(S,s))for(strcpy(s,S),i=0;s[i];i++)s[i]>92&&(S[-~i]==92&&S[~-i]!=47&&(s[i]=92,D=1)||S[~-i]==47&&S[-~i]!=92&&(s[i]=47,D=1));}

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

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

कुछ डोमिनोज़ टॉप करें!

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

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

व्याख्या

पायथन 2 , 115 114 111 108 98 95 बाइट्स

वी , 23 बाइट्स

SNOBOL4 (CSNOBOL4) , 117 115 112 111 बाइट्स

हास्केल , 114 107 बाइट्स

स्पष्टीकरण:

पर्ल 5 , 39 + 1 ( -p) = 40 बाइट्स

प्रोलॉग (एसडब्ल्यूआई) , 132 बाइट्स

व्याख्या

डीसीजी

द प्रेडिकेट

एपीएल (डायलॉग) , 36 बाइट्स

चेहरा , 166 बाइट्स

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

व्याख्या

पर्ल 5 , 44 (कोड) + 1 ( -p) = 45 बाइट्स

व्याख्या

क्लीन , 98 बाइट्स

रूबी , 83 बाइट्स

आर , 114 बाइट्स

सी (जीसीसी) , 183 बाइट्स

पर्ल 5 , 39 + 1 ( `-p`) = 40 बाइट्स

पर्ल 5 , 44 (कोड) + 1 ( `-p`) = 45 बाइट्स