किसी भी 1D सेलुलर ऑटोमेटन का अनुकरण करें

Question

चुनौती

आपको एक पूरा प्रोग्राम लिखना है जो STDIN से सात नंबर लेता है, और सेलुलर ऑटोमेटन (CA) के दो आयामी इतिहास को STDOUT में प्रिंट करता है। यह कोड गोल्फ है।

इनपुट स्वरूपण इनपुट सात पूर्णांक / स्ट्रिंग्स कॉमा द्वारा अलग किए जाएंगे। पहली संख्या वोल्फ्राम कोड (प्रत्येक नियम का मानक नाम) के अनुसार नियम की संख्या है। दूसरा प्रारंभिक प्रारंभिक कॉन्फ़िगरेशन है। तीसरा और चौथा यह वर्णन करता है कि प्रारंभिक कॉन्फ़िगरेशन के बाईं ओर किस पैटर्न और कितनी बार इसे जोड़ा जाना चाहिए। पैडिंग के रूप में। पाँचवाँ और छठा दाहिने हिस्से के लिए भी ऐसा ही होता है। सिमुलेशन चलाने के लिए पिछली संख्या पीढ़ियों की संख्या है।

तो, इनपुट का एक उदाहरण है 90,11,0,4,0,4,5। यह आपके प्रोग्राम को बताना चाहिए कि आप नियम 90 चला रहे हैं । यह प्रोग्राम को यह भी बताना चाहिए कि आप चाहते हैं कि प्रारंभिक कॉन्फ़िगरेशन 11स्ट्रिंग के 0साथ 4 बार दोनों सिरों पर जोड़ा जाए, इसलिए वास्तविक शुरुआती पैटर्न है 0000110000। यह आपके प्रोग्राम को 5 पीढ़ियों के लिए इस सिमुलेशन को चलाने के लिए भी कहता है।

आउटपुट आपके प्रोग्राम को प्रत्येक पीढ़ी (न्यूलाइन्स द्वारा अलग) कोशिकाओं के पूरे सरणी को प्रिंट करना चाहिए, ताकि आउटपुट सीए का स्पेस-टाइम आरेख हो। प्रत्येक पीढ़ी के लिए, प्रत्येक कोशिका की स्थिति इनपुट के रूप में प्रदान किए गए नियम के अनुसार, इसके राज्य और कोशिकाओं की स्थिति को तत्काल बाईं और दाईं ओर निर्धारित किया जाता है। सिमुलेशन को किनारों के चारों ओर लपेटना चाहिए। मुद्रित पहली चीज जीन के रूप में शुरुआती सरणी होनी चाहिए। 0।

इनपुट 90,11,0,4,0,4,5का परिणाम निम्न आउटपुट में यथासंभव होना चाहिए।

0000110000
0001111000
0011001100
0111111110
1100000011
0110000110

ध्यान दें कि शुरुआती राज्य पांच पीढ़ियों में शामिल नहीं है। यह भी ध्यान दें कि सिमुलेशन किनारों के चारों ओर लपेटता है।

और ज्यादा उदाहरण

इनपुट:

184,1100,01,2,01,1,4

उत्पादन:

0101110001
1011101000
0111010100
0110101010
0101010101

इनपुट:

0,1011,1,0,0,1,2

उत्पादन:

10110
00000
00000

1D CA के काम और वे कैसे गिने जाते हैं, इस बारे में अधिक जानकारी

Comments

अच्छी तरह से नियम 0 सहित एक परीक्षण मामले के लिए किया जाता है।

— पीटर टेलर

मैं मोहित हूँ कि नियम 90 एक Sierpinski गैसकेट है। खासकर जब से मैं एक और कोडगॉल्फ परियोजना के लिए परीक्षण का हिस्सा था ।

— जोश

@JoeFish यह आपकी छवि थी जिसने मुझे इस एक को आज़माने के लिए प्रेरित किया। मैं एक wanted० answer६ जवाब देना चाहता था - २ पक्षियों को मारना - लेकिन इसे शायद स्ट्रिंग ऑपरेशन की आवश्यकता होगी, इसलिए मेरा एमुलेटर इसे (अभी तक) चलाने में सक्षम नहीं होगा।

— लूजर

किसी ने इसे पहले ही कर लिया था: pouet.net/prod.php?which=60478

— luser droog

Answer 1

गोल्फस्क्रिप्ट, 77 73 70 वर्ण

','/)~\(~:?;~~*@@~*@+\+{1&}/]({[.,{.[3<?256+]{2base}/\~=\(+}*])n@)\+}*

@ हॉवर्ड को धन्यवाद, जिन्होंने 4 वर्णों को बचाने का तरीका बताया।

Comments

आप एक स्पष्ट एक बचा सकते हैं 48--> 1&और मुझे लगता है कि तीन और भी। आप )ब्लॉक (काउंटर में वृद्धि नहीं) से पहले छोड़ सकते हैं और इसलिए अंतिम दो पॉप भी बचा सकते हैं।

— हावर्ड

@ हावर्ड, धन्यवाद। अंत में वे पॉप पहले पुनरावृत्ति में उपयोगी थे, लेकिन आप सही हैं कि उन्हें समाप्त करना अब समझ में आता है।

— पीटर टेलर

Answer 2

एपीएल (153 अक्षर)

∇ cellularautomaton
  i               ← ⍞
  s               ← (i=',') / ⍳ ⍴i
  (b a x c)       ← {i[s[⍵]↓⍳s[⍵+1]-1]} ¨ ⍳4
  (z x x l x r n) ← ⍎i
  y               ← ⍎ ¨ ⊃ ,/ (l / ⊂a) , b , r / ⊂c
  (n+1) (⊃⍴,y) ⍴ '01'[1+⊃ ,/ y,{({(z ⊤⍨ 8/2)[8 - 2⊥¨ 3 ,/ (⊃⌽⍵),⍵,⊃⍵]}⍣⍵)y} ¨ ⍳n]
∇

और कम पठनीय, थोड़ा छोटा रूप में:

i←⍞⋄s←(i=',')/⍳⍴i⋄b a x c←{i[s[⍵]↓⍳s[⍵+1]-1]}¨⍳4⋄z x x l x r n←⍎i⋄y←⍎¨⊃,/(l/⊂a),b,r/⊂c⋄'01'[1+⊃,/y,{({(z⊤⍨8/2)[8-2⊥¨3,/(⊃⌽⍵),⍵,⊃⍵]}⍣⍵)y}¨⍳n]⍴⍨(1+n),⊃⍴,y

उदाहरण:

      cellularautomaton
26,00110,01,4,10,6,7
0101010100110101010101010
1000000011100000000000001
0100000110010000000000011
0010001101101000000000110
0101011001000100000001101
0000010110101010000011000
0000100100000001000110100
0001011010000010101100010

मुझे यकीन है कि इसमें सुधार की गुंजाइश है (मैंने इस पोस्ट को लिखते समय कुछ बदलाव भी पाया है!), लेकिन इसमें से कुछ में मूलभूत परिवर्तन शामिल हो सकते हैं, और मैं एपीएल को घूरकर नहीं देख सकता। यहाँ इस्तेमाल किया जाने वाला APL का वैरिएंट Dyalog APL है ।

Answer 3

रूबी, 165 159 अक्षर

a=gets.split ?,
b=a.map &:to_i
c=(x=a[2]*b[3]+a[1]+a[4]*b[5]).chars.map &:hex
(0..b[6]).map{puts c*''
c=(1..w=x.size).map{|i|b[0]>>c[i-1]*2+c[i%w]+c[i-2]*4&1}}

संपादित करें: मुझे छोटी वृद्धि के लिए कुछ स्थान मिले।

उदाहरण रन:

> 30,1,0,20,0,20,20
00000000000000000000100000000000000000000
00000000000000000001110000000000000000000
00000000000000000011001000000000000000000
00000000000000000110111100000000000000000
00000000000000001100100010000000000000000
00000000000000011011110111000000000000000
00000000000000110010000100100000000000000
00000000000001101111001111110000000000000
00000000000011001000111000001000000000000
00000000000110111101100100011100000000000
00000000001100100001011110110010000000000
00000000011011110011010000101111000000000
00000000110010001110011001101000100000000
00000001101111011001110111001101110000000
00000011001000010111000100111001001000000
00000110111100110100101111100111111100000
00001100100011100111101000011100000010000
00011011110110011100001100110010000111000
00110010000101110010011011101111001100100
01101111001101001111110010001000111011110
11001000111001111000001111011101100010001

Answer 4

सी, 303 305 301 294 292

305 संपादित करें: उफ़। भूल गए कि calloc()दो आर्गन लगते हैं। यह बड़े इनपुट पर बह रहा था।

301 संपादित करें: आह हा! calloc()अनुरोधित मेमोरी के ब्लॉक आकार को बढ़ाकर 2 और बाइट्स को बचाने के लिए मेरे बू-बू का उपयोग किया।

294 संपादित करें: 300 तोड़ दिया! strcat()एस में से एक को हटा दिया और कुछ छोरों को छोटा किया। अधिकतम मंक का उपयोग करने के लिए समझे, जो उपयोग करने के लिए कहने में उतना ही मजेदार है।

292 संपादित करें: +2मेमोरी आवंटन में जरूरत नहीं थी ।

मैंने बेस विचार के रूप में लुसर ड्रोग के उत्तर का उपयोग किया , लेकिन रैपिंग एल्गोरिथ्म को बदल दिया, साथ ही साथ बहुत सारे ट्विकिंग और स्थिरांक को फैक्टरिंग किया।

r,A,C,n,j;main(){char*s,*p,*t,a[9],b[9],c[9];scanf("%d,%[01],%[01],%d,%[01],%d,%d",&r,b,a,&A,c,&C,&n);for(s=calloc(A+++C,9);A--;)strcat(s,A?a:b);for(;C--;)strcat(s,c);p=strdup(s);for(C=strlen(s);A++<n;puts(s),t=p,p=s,s=t)for(j=C;j--;)p[j]=(1<<(s[j?j-1:C-1]*4+s[j]*2+s[(j+1)%C])-336)&r?49:48;}

r,A,C,n,j;
main(){
    char*s,*p,*t,a[9],b[9],c[9];
    scanf("%d,%[01],%[01],%d,%[01],%d,%d",&r,b,a,&A,c,&C,&n);
    for(s=calloc(A+++C,9);A--;)
        strcat(s,A?a:b);
    for(;C--;)
        strcat(s,c);
    p=strdup(s);
    for(C=strlen(s);A++<n;puts(s),t=p,p=s,s=t)
        for(j=C;j--;)
            p[j]=(1<<(s[j?j-1:C-1]*4+s[j]*2+s[(j+1)%C])-336)&r?49:48;
}

Comments

आप इसे शुरू करना भूल गए C,A,! :)

— लूसर डॉग

स्मृति के भार के लिए, किस बारे में brk()? तब p=s+C+1;कहीं।

— लूजर

+1 फिर से उपयोग करने के लिए +++!

— लूज़र ने

Haha! सभी बदलें %[01]करने के लिए %s! -9 (... कई साल बाद)

— लूसर

@luserdroog यह काम नहीं करता है क्योंकि% s लालची है और अल्पविराम और अन्य अंकों को भी खाता है।

— जोफिश

Answer 5

सी (487 484 रिक्त स्थानों के साथ 418)

* जोफिश की मदद से 66 गिरा

C,A,r,n,j;main(){char*s,*p,*t,a[9],b[9],c[9];
    scanf("%d,%[01],%[01],%d,%[01],%d,%d",&r,b,a,&A,c,&C,&n);
    s=malloc(strlen(a)*A+strlen(b)+strlen(c)*C+3);*s=0;
    strcat(s,"0");
    for(;A--;)strcat(s,a);
    strcat(s,b);
    for(;C--;)strcat(s,c);
    strcat(s,"0");
    p=malloc((C=strlen(s)-1)+2);
    for(;n--;){
    *s=s[C-1];
    s[C]=0;
    puts(s+1);
    s[C]=s[1];
    for(j=1;s[j+1];j++)
        p[j]=(1<<(s[j-1]-48)*4+(s[j]-48)*2+s[j+1]-48)&r?49:48;
    t=p;p=s;s=t;
    }
    s[C]=0;
    puts(s+1);
}

टाइपप्रति

josh @ Z1 ~
$ म
सावधान करना
cc ca.c -o ca
ca.c: 1: 1: चेतावनी: डेटा परिभाषा का कोई प्रकार या संग्रहण वर्ग नहीं है
ca.c: फ़ंक्शन 'मेन' ​​में:
ca.c: 2: 5: चेतावनी: अंतर्निहित फ़ंक्शन 'स्कैनफ़' की असंगत निहित घोषणा
ca.c: 3: 7: चेतावनी: अंतर्निहित कार्य 'मॉलॉक' की असंगत निहित घोषणा
ca.c: 3: 14: चेतावनी: अंतर्निहित फ़ंक्शन 'strlen' की असंगत निहित घोषणा
ca.c: 4: 5: चेतावनी: अंतर्निहित फ़ंक्शन 'असंगत' की असंगत निहित घोषणा

josh @ Z1 ~
$ गूंज 90,11,0,4,0,4,5,5 | सीए
-बाश: सीए: कमांड नहीं मिला

josh @ Z1 ~
$ गूंज 90,11,0,4,0,4,5,5 | ।/सीए
0000110000
0001111000
0011001100
0111111110
1100000011
0110000110

Comments

अच्छा लगा। आप अपने intचरों को वैश्विक बनाकर और हटाने के लिए काफी कुछ बाइट्स दाढ़ी कर सकते हैं #include: r,A,B,C,n,i,j; main(){char *s...

— जोश

अपने forछोरों में एक गुच्छा को बचाएं :for(;A--;)strcat(s,a);

— जोश

और फिर से उपयोग करें Aऔर Cबाद में इसलिए आपको घोषित iया बिल्कुल भी नहीं करना है B। p=malloc((C=strlen(s))+1); --C; strcpy(p,s); for(A=0;A<n;A++){क्षमा करें, मैं अब रुक जाऊँगा :)

— जोश

ठीक है, मैंने झूठ बोला, एक और। को नष्ट करने से 2 बाई से छुटकारा --C;: p=malloc((C=strlen(s)-1)+2);। मुझे लगता है कि पहली बार में गोल्फिंग कोड इसके साथ आने से ज्यादा मजेदार है!

— जोश

मुझे इस बारे में निश्चित नहीं था कि #includeचूँकि scanfचर-अचर है। लेकिन यह शायद ठीक है क्योंकि यह केवल एक बार कहा जाता है। ... मेरी पुरानी मशीन कल मर गई, और मैं अभी भी सिग्विन स्थापित कर रहा हूं। जैसे ही मैं इसका परीक्षण करूंगा, मैं उन परिवर्तनों को शामिल कर लूंगा। धन्यवाद!

— लूसर ड्रॉग