एक अजीब मोटर वाहन लागू करें

Question

मैं सेलुलर ऑटोमेटन के साथ खेल रहा था और मैंने पाया कि कुछ दिलचस्प व्यवहार था। यहां देखिए यह कैसे काम करता है:

यह बायीं से दाईं ओर एक बाइनरी स्ट्रिंग को पढ़ता है, अगर यह अन्य मूल्यों का 1पालन ​​करता है तो यह परिणाम के लिए 2एक 0और पाठ को जारी रखेगा। अगर इसका सामना होता है 0(या 3 से कम मान बचे हैं) तो यह वर्तमान मूल्य और a 1को आगे बढ़ाएगा और पढ़ना जारी रखेगा। स्ट्रिंग के अंत में यह 1परिणाम के लिए एकल जोड़ देगा ।

यहां एक पीढ़ी का काम किया गया उदाहरण है

01011111
^

हम पहले मुठभेड़ करते हैं 0ताकि हम 01अपने परिणाम के लिए संलग्न हों

01011111
 ^
01

अब हमारा सामना होता है 1इसलिए हम एक शून्य को जोड़ते हैं और अगले दो मूल्यों को छोड़ देते हैं

01011111
    ^
010

हम एक और मुठभेड़ करते हैं 1तो हम भी ऐसा ही करते हैं

01011111
       ^
0100

अब हम एक और है 1कूदने के लिए तो हम वर्तमान सेल संलग्न लेकिन पर्याप्त नहीं अंतरिक्ष और एक 1(इस मामले में 11)

01011111
        ^
010011

हम अंत में हैं इसलिए हम एक एकल को जोड़ते हैं 1और इस पीढ़ी को समाप्त करते हैं

01011111
        ^
0100111

कार्य

किसी भी उचित प्रारूप में इनपुट को देखते हुए आपको एक फ़ंक्शन या प्रोग्राम बनाना होगा जो ऑटोमेटन की एक पीढ़ी की गणना करता है।

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

नमूना कार्यान्वयन

यहाँ हास्केल में एक नमूना कार्यान्वयन है (एक फ़ंक्शन को परिभाषित करता है d, लेकिन कार्यक्रम अनिश्चित काल तक प्रिंट करता है):

d('1':_:_:x) = "0" ++ d x
d(a:x) = a:'1':d x
d x = "1"
r x = x:map d(r x)

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

Comments

आपके प्रश्न में आप कहते हैं कि हमारे पास अब एक और 1 है, लेकिन कूदने के लिए पर्याप्त जगह नहीं है इसलिए हम वर्तमान सेल और 1 या 11 को जोड़ते हैं । यह 1 या 11 है?

— caird coinheringaahing

तो फिर अगर हमारे पास 10इसका प्रिंट होना चाहिए 11011? मुझे लगता है कि कुछ और परीक्षण मामले मददगार होंगे

— nmjcman101

@WheatWizard मैं नियमों के बारे में एक स्पष्ट व्याख्या, शायद एक तालिका की सराहना करता हूं

— अलेक्जेंडर - बहाल मोनिका

मुझे विश्वास नहीं होता कि यह वास्तव में एक सेलुलर ऑटोमेटन है, लेकिन मुझे यह कहने के लिए स्वतंत्र महसूस करना चाहिए कि यह क्या है।

— feersum

@ फ़ेर्सम वास्तव में, यह कोशिकाओं की संख्या को संरक्षित नहीं करता है। यह एक परिमित राज्य ट्रांसड्यूसर है ।

— अर्जन जोहान्सन

Answer 1

वी , 26 22 21 बाइट्स

Regexes को मिलाकर 4 बाइट्स के लिए @CowsQuack को धन्यवाद! और @ @rjanJohansen एक और बाइट के लिए कुछ रेगेक्स संयोजनों के साथ।

Ó1../3
Ó./&1
Ó31/0
A1

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

कई बार विकल्प का उपयोग करता है और अंत में एक 1 संलग्न करता है। कुछ भी नहीं फैंसी। मेरे पास एक ऐसा संस्करण है जो वांछित प्रभाव प्राप्त करने के लिए रीमैप 1और 0सम्मिलित मोड में है, लेकिन यह काफी लंबा है।

(एकाधिक प्रतिस्थापन संस्करण: इसे ऑनलाइन आज़माएं! )

Comments

दूसरा और तीसरा Ó1ü0/&1ü\|

— रेग्जेस

@ सहवास की प्रतिभा!

— nmjcman101

इसके Ó./&1बाद भी ऐसा करना कम है Ó31/0।

— अर्जन जोहान्सन

Answer 2

जावास्क्रिप्ट (ईएस 6), 56 बाइट्स

वर्णों के एक सरणी के रूप में इनपुट लेता है। 1यदि कोई रिक्त सरणी दी गई है , तो एक स्ट्रिंग, या संख्या लौटाता है ।

f=([v,...a])=>v?(+v&&a[1]?a.splice(0,2)&&'0':v+1)+f(a):1

डेमो

f=([v,...a])=>v?(+v&&a[1]?a.splice(0,2)&&'0':v+1)+f(a):1

console.log(f([...'01011111']))
console.log(f([...'10']))

एनिमेटेड संस्करण

स्थिर आदानों के उदाहरण: 0101, 010011111

f=([v,...a])=>v?(+v&&a[1]?a.splice(0,2)&&'0':v+1)+f(a):1

s = '1';
setInterval(_=>o.innerHTML=s=''+f([...s]), 200)

<input oninput="s=this.value" value="1" />
<pre id=o style="font-size:32px"></pre>

Answer 3

पायथन 2 , 88 बाइट्स

I,r=input(),[]
while I:a=I[0]and len(I)>2;b=a<1;r+=[I[0]]*b+[+b];I=I[a*2+1:]
print r+[1]

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

Answer 4

पायथन 2 , 89 बाइट्स

x=input()
y=0
k=[]
while x[y:]:v=1-x[y]*(y<len(x)-2);k+=[x[y]]*v+[v];y+=3-2*v
print k+[1]

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

-4 बाइट्स धन्यवाद रॉड
-6 बाइट्स के लिए धन्यवाद, धन्यवाद
-1 बाइट माइकस्टेपिक के लिए

Comments

[0]if v else[x[y],1]के रूप में फिर से लिखा जा सकता है [[x[y],1],[0]][v], लेकिन आप 19 बाइट में 96 बाइट्सv

— रॉड

90 बाइट्स

— ओव्स

पायथन 2 में प्रिंट स्टेटमेंट के लिए कोष्ठकों की आवश्यकता नहीं होती है, इसलिए आप एक बाइट बचा सकते हैं

— micsthepick

Answer 5

स्विफ्ट 3 , 147 बाइट्स

-1 @ Mr.Xcoder को धन्यवाद

func g(i:[Int]){var r=[Int]();var s=ArraySlice(i);while let e=s.popFirst(){if 0<e&&2<s.count{r+=[0];s=s.dropFirst(2)}else{r+=[e,1]}};print(r+[1])}

मुद्रण के बजाय मान लौटाया गया:

func iterate(state: [Int]) -> [Int] {
    var result = [Int]()

    var inputSlice = ArraySlice(state)

    while let element = inputSlice.popFirst() {
        if 0 < element && 2 < inputSlice.count { 
            result += [0]
            inputSlice = inputSlice.dropFirst(2)
        }
        else {
            result += [element, 1]
        }

        //debugPrint(result.map(String.init).joined(separator: ""))
    }

    return result + [1]
}

Comments

आप बदल सकते हैं 3<=s.countके साथ 2<s.countके लिए -1 बाइट्स ।

— श्री एक्सकोडर

@ Mr.Xcoder धन्यवाद! मैं इसके बजाय 1इनपुट में एस का पता लगा सकता हूं0 < elementelement == 0

— अलेक्जेंडर - मोनिका

Answer 6

अजगर २ , 81 बाइट्स

इनपुट और आउटपुट दोनों लिस्ट हैं (धन्यवाद एग्री द आउटग्राफर)

def f(Z):return Z and((1>Z[0]or 3>len(Z))and[Z[0],1]+f(Z[1:])or[0]+f(Z[3:]))or[1]

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

कुछ मामले

[0,1,0,1,1,1,1,1] --> [0,1,0,0,1,1,1]
[0] ----------------> [0,1,1]
[1] ----------------> [1,1,1]
[] -----------------> [1]
[0,1] --------------> [0,1,1,1,1]
[1,0] --------------> [1,1,0,1,1]

पायथन 2 , 85 बाइट्स

इनपुट और आउटपुट दोनों तार हैं (प्रारंभिक समाधान)

def f(Z):return Z and(('0'==Z[0]or 3>len(Z))and Z[0]+'1'+f(Z[1:])or'0'+f(Z[3:]))or'1'

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

कुछ मामले

'01011111'--> 0100111
'0'---------> 011
'1'---------> 111
''----------> 1
'01'--------> 01111
'10'--------> 11011

स्पष्टीकरण यह सरल रूप से एक पुनरावर्ती विधि का एक गोल्फ है।

Comments

सूचियों का उपयोग कम है।

— एरिक आउटगॉल्फ जूल

@EriktheOutgolfer धन्यवाद :)

— mdahmoune

ओह, और आप 1>Z[0]इसके बजाय कर सकते हैं 0==Z[0]।

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

Answer 7

पर्ल 5 , 62 + 2 ( -F) = 64 बाइट्स

$r.=$F[$i]&&$i+2<@F&&($i+=2)?0:"$F[$i]1";++$i<@F&&redo;say$r.1

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

Answer 8

स्काला , 131 + 29 = 160 बाइट्स

यह स्ट्रिंग aके पैरामीटर के रूप में एक फ़ंक्शन के अंदर है और आउटपुट को स्ट्रिंग के रूप में वापस करता है।

var s=""
var k=0
for(c<-0 to a.length-1)breakable{if(k>0){k-=1
break}
if(a(c)==49&c<a.length-3){s+="0"
k+=2}else s+=a(c)+"1"}
s+"1"

मुझे करना है import util.control.Breaks._, इसलिए मुझे उन 28 बाइट्स के साथ एक अनुगामी लाइनफीड जोड़ने की आवश्यकता है।

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

Answer 9

सी # (.NET कोर) , 108 बाइट्स

n=>{var t="";for(int i=0,b=n.Length;i<b;){if(n[i]>'0'&i+2<b){t+="0";i+=3;}else t+=n[i++]+"1";}return t+"1";}

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

इनपुट एक स्ट्रिंग के रूप में लिया जाता है, और एक स्ट्रिंग आउटपुट के रूप में दिया जाता है।