स्यूडोरैंडम सेल्यूलर ऑटोमेटन

Question

परिचय

इस चुनौती में, हम बहुत खराब छद्म आयामी संख्याओं का उपयोग करके एक निश्चित संभाव्य सेलुलर ऑटोमेटन का अनुकरण करेंगे । सेलुलर ऑटोमेटन को निम्नलिखित स्थानीय नियम द्वारा बाइनरी स्ट्रिंग्स पर परिभाषित किया गया है। मान लीजिए कि एक सेल के बाएं पड़ोसी और सेल में ही राज्य aऔर हैं b।

• यदि है min(a,b) == 0, तो नया राज्य bहै max(a,b)।
• यदि min(a,b) == 1, तो का नया राज्य bयादृच्छिक रूप से चुना गया है {0,1}।

निम्न चित्र एकल के संभावित 10-चरणीय विकास को दर्शाता है 1।

1
11
101
1111
11001
101011
1111111
10001001
110011011
1010111101

ध्यान दें कि कैसे दो आसन्न 1s कभी-कभी विकसित होते हैं 1, और कभी-कभी 0सीमा-पार बिट्स हमेशा होते हैं 1। आपका कार्य इस फॉर्म के सेलुलर ऑटोमेटन विकास का उत्पादन करना है।

इनपुट

आपके इनपुट एक सकारात्मक पूर्णांक हैं n, जो प्रदर्शित करने के लिए पंक्तियों की संख्या को दर्शाते हैं, और बिट्स की एक गैर-रिक्त सूची है L, जिसे हम यादृच्छिकता के स्रोत के रूप में उपयोग करते हैं।

उत्पादन

आपका आउटपुट सूची या 2 डी सरणी बिट्स की एक सूची है, जो उपरोक्त चरणों में, समय के चरणों के 1लिए एकल का विकास दर्शाती है n। 0यदि वांछित है, तो आप समान लंबाई की पंक्तियों को प्राप्त करने के लिए आउटपुट के साथ पैड कर सकते हैं , लेकिन अग्रणी 0एस नहीं होना चाहिए ।

सेलुलर ऑटोमेटन में यादृच्छिक विकल्प सूची से खींचा जाना चाहिए L, जब यह समाप्त हो जाता है तो शुरुआत में वापस कूदना चाहिए । अधिक स्पष्ट रूप से, यदि आउटपुट को एक पंक्ति में एक बार के रूप में ऊपर से नीचे, बाएं से दाएं पर लगाया जाता है, तो क्रमिक यादृच्छिक विकल्प सूची Lको आवश्यक रूप से कई बार दोहराया जाएगा ।

उदाहरण

मान लीजिए आदानों हैं n = 7और L = [0,1,0]। फिर सेलुलर ऑटोमेटन 7 चरणों के दौरान निम्नानुसार विकसित होता है, जहां हमने vहर यादृच्छिक विकल्प के ठीक ऊपर रखा है :

[1]

[1,1]
   v
[1,0,1]

[1,1,1,1]
   v v v
[1,1,0,0,1]
   v
[1,1,1,0,1,1]
   v v   v
[1,0,0,1,1,1,1]

यदि हम एक के साथ चिह्नित सभी बिट्स पढ़ते हैं v, तो हम प्राप्त करते हैं 01001001, जो L2.66 बार दोहराया जाता है । अगला रैंडम बिट होगा 0।

नियम और स्कोरिंग

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

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

नियतात्मक संस्करण, हर यादृच्छिक बिट है 0:

Inputs: 10 [0]
Output:
1
11
101
1111
10001
110011
1010101
11111111
100000001
1100000011

हर यादृच्छिक बिट है 1:

Inputs: 6 [1,1]
Output:
1
11
111
1111
11111
111111

छद्म आयामी संस्करण:

Inputs: 10 [0,0,1]
Output:
1
11
101
1111
10101
111111
1010011
11110101
101011111
1111101001

Inputs: 10 [1,0,0,1]
Output:
1
11
111
1001
11011
111111
1001101
11010111
111111101
1011001111

Inputs: 15 [1,1,1,0,0,0]
Output:
1
11
111
1111
10001
110011
1110111
11011001
111111011
1100011111
11100100011
111101100101
1001111101111
11011000111111
101101001011101

Answer 1

पायथ, 33 बाइट्स

jjLk.u++1m?hSde=.<Q1sd.:N2 1tvz]1

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

jjLk.u++1m?hSde=.<Q1sd.:N2 1tvz]1  implicit: Q = input list
    .u                      tvz]1  reduce N=[1] input-1 times by applying
                      .:N2           all substrings of length 2
         m                           map each d of ^ to:
          ?hSd                         if min(d) = 0 then:
               =.<Q1                     rotate Q by one
              e                          and use the last element
                    sd                 else use sum(d) (=max(d))
      ++1                  1         add a 1 at the front and the back
                                   .u gives all intermediate results
 jLk                               join these lists to strings
j                                  print each string on a line

Answer 2

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

^.
1

 00:0 01:1 10:1 11:
(m`^(..)((\S*)(?<=0) .*)
$1$3#$1!$2
+m`(?<=^(?<-2>.)*(..).*?#(.)*.)\d!(.)(.*\1:)(.)(\d*)
$5$3!$4$6$5
)`!0
0
 .+
<empty>

जहां <empty>इंगित करता है कि एक अनुगामी खाली रेखा है। प्रत्येक पंक्ति एक अलग फ़ाइल में जाती है और उसे #लाइनफ़ीड (0x0A) से प्रतिस्थापित किया जाना चाहिए।

उम्मीद इनपुट होने के लिए nमें एकल (शून्य से बना, के रूप में एकल ), फिर एक रिक्ति, "छद्म यादृच्छिक" स्ट्रिंग हो, जैसे 10, [1, 0, 0, 1]के रूप में पढ़ा की जाएगी

0000000000 1001

आउटपुट चुनौती के रूप में है, लेकिन शून्य के साथ गद्देदार, जैसे

1000000000
1100000000
1110000000
1001000000
1101100000
1111110000
1001101000
1101011100
1111111010
1011001111

मुझे उम्मीद थी कि यह रास्ता पेचीदा था ...

Answer 3

पायथन, 142 135 132 131 बाइट्स

133 132 131 बाइट संस्करण

f=input;n=f();L=f()*n*n;r=[1];i=1
while i<=n:print r;r=[L.pop(0)if r[x-1]&r[x]else r[x-1]+r[x]for x in range(1,i)];r=[1]+r+[1];i+=1

r[x-1]+r[x]>1द्वारा प्रतिस्थापित किया r[x-1]&r[x]गया था बिटकॉइन ऑपरेटर और पैदावार में न्यूनतम मूल्य देता है(r[x-1],r[x])

n*nइसके बजाय सुझाव देने के लिए धन्यवाद @ThomasKwa n**21 बाइट बचाता है!

धन्यवाद @ बाइट -1 बाइट के लिए

135 बाइट संस्करण

f=input;n=f();L=f()*n**2;r=[1];i=1
while i<=n:print r;r=[L.pop(0)if r[x-1]+r[x]>1 else r[x-1]+r[x]for x in range(1,i)];r=[1]+r+[1];i+=1

@ -7 बाइट्स के लिए @Cole का धन्यवाद:

min(r[x-1],r[x])->r[x-1]+r[x]>1

max(r[x-1],r[x])->r[x-1]+r[x]

142 बाइट संस्करण

f=input;n=f();L=f()*n**2;r=[1];i=1
while i<=n:print r;r=[L.pop(0)if min(r[x-1],r[x])else max(r[x-1],r[x])for x in range(1,i)];r=[1]+r+[1];i+=1

@ जकुबे के उत्तर के करीब भी नहीं लेकिन मुझे इस पर बहुत मज़ा आया और कोडिंग की।

दो इनपुट की अपेक्षा करता है: पहला इनपुट पंक्तियों की संख्या है और दूसरा इनपुट छद्म आयामी स्रोत सूची है । यह एक के बाद एक पंक्ति कंसोल पर प्रिंट करता है, प्रत्येक नई लाइन पर।

उदाहरण के तौर पे:

10 # This is input
[0] # This is input
[1] <- First output row
[1, 1]
[1, 0, 1]
[1, 1, 1, 1]
[1, 0, 0, 0, 1]
[1, 1, 0, 0, 1, 1]
[1, 0, 1, 0, 1, 0, 1]
[1, 1, 1, 1, 1, 1, 1, 1]
[1, 0, 0, 0, 0, 0, 0, 0, 1]
[1, 1, 0, 0, 0, 0, 0, 0, 1, 1]

अब यह कैसे काम करता है, इस पर संक्षिप्त विवरण के लिए:

f=input;n=f();L=f()*n*n;r=[1];i=1 First we define the input() function as f 
                                   for saving bytes as we have to call it twice.
                                   Then L is defined as a list made of the 
                                   pseudorandom numbers in their order *many* times 
                                   (were *many* is an upperbound of the canges that 
                                   could be done); r as the first row and i as the row 
                                   counter.

while i<=n:print r                 A while loop that exits when the nth row has been 
                                   calculated and the printing of the actual row.

r=[L.pop(0)if r[x-1]&r[x] else r[x-1]+r[x] for x in range(1,i)];r=[1]+r+[1];i+=1
     ^           ^                 ^                         ^
     |           |                 |Same as max(r[x-1],r[x]) | from 2nd to last element
     |           | Same as min(r[x-1],r[x]) (0->False;1->True)                
     | get random bit from pseudorandom list    

यहाँ ट्रिक यह है कि हम जानते हैं कि बिट लिस्ट हमेशा शुरू और समाप्त होगी 1क्योंकि पहले और आखिरी एलिमेंट्स को ऐनक के कारण कभी भी संशोधित नहीं किया जाता है। सवाल का। यही बयान का कारण है [1]+r+[1]।

लेकिन अगर rइसे इनिशियलाइज़ किया जाता है [1], तो पहली पंक्ति में कोई बदलाव नहीं होता है और फिर हम जोड़ते [1]+r+[1]हैं कि दूसरी पंक्ति कैसे आती है [1,1,1]?

यह तथ्य यह है कि पहली यात्रा पर की वजह से है i=1तो range(1,i)रिटर्न एक खाली सूची और, एक परिणाम के रूप forसूची समझ में पुनरावृति करने के लिए कुछ भी नहीं होने से अधिक rएक खाली सूची तो बन जाता है [1]+r+[1]=[1,1]। यह सिर्फ पहली यात्रा पर होता है जो हमारे लिए सिर्फ आदर्श है!

पुनश्च: यह कैसे और अधिक गोल्फ के बारे में कोई सुझाव देने के लिए स्वतंत्र महसूस करें।

Comments

यदि मुझे चुनौती सही ढंग से समझ में नहीं आती है तो मेरी क्षमा याचना, लेकिन क्या आप इसके min(a,b)साथ a+b>1और max(a,b)साथ नहीं बदल सकते a+b? मुझे लगता है कि आपको शायद 1-> के पहले मामले को संभालने के लिए कुछ करना होगा 11(मुझे लगता है कि आप ऐसा कर सकते हैं L=[1]+f()..., या सामने के 1 को सम्मिलित करने का कोई तरीका ढूंढ सकते हैं Lक्योंकि वह हमेशा दूसरी पंक्ति के लिए 1 पॉप करेगा)

— कोल

@ पूरे सौभाग्य से कार्यक्रम के बाकी हिस्सों में कोई बदलाव नहीं किया जाना चाहिए क्योंकि परिवर्तन केवल बिट्स की एक जोड़ी के न्यूनतम और अधिकतम मूल्यों को जानने के तरीके को प्रभावित करते हैं।

— आयोनेस

आपने याद किया कि आप यहां एक स्थान हटा सकते हैं: r[x-1]&r[x] else:)

— केड

क्या n ** 2 -> n * n काम करेगा?

— २.१

@ थोमस तुम सही हो!

— Ioannes

Answer 4

MATLAB, 146 143 138

(ऑनलाइन ओक्टेव पर भी काम करता है, लेकिन आपको फ़ाइल में फ़ंक्शन को बचाने के लिए साइन इन करना होगा)।

function o=c(n,L);o=zeros(n);o(:,1)=1;for i=2:n;for j=2:i;a=o(i-1,j-1);b=o(i-1,j);c=a|b;d=a&b;c(d)=L(d);L=circshift(L,-d);o(i,j)=c;end;end

फ़ंक्शन एक इनपुट लेता है nऔर L, और एक सरणी oदेता है जिसमें आउटपुट होता है।

इनपुट मानों के लिए, nएक स्केलर है, और Lएक कॉलम वेक्टर है, जिसे प्रारूप में निर्दिष्ट किया जा सकता है [;;;]। आप जो दिखाते हैं, वह बिलकुल नहीं है, लेकिन आप कहते हैं कि यह कारण के भीतर लचीला है और ऐसा लगता है।

आउटपुट को n x n0 और 1 के सरणी वाले स्वरूप के रूप में स्वरूपित किया गया है ।

और एक स्पष्टीकरण:

function o=c(n,L)
%Create the initial array - an n x n square with the first column made of 1's
o=zeros(n);o(:,1)=1;
%For each row (starting with the second, as the first is done already)
for i=2:n;
    %For each column in that row, again starting with the second as the first is done
    for j=2:i;
        %Extract the current and previous elements in the row above
        a=o(i-1,j-1); %(previous)
        b=o(i-1,j);   %(current)
        %Assume that min()==0, so set c to max();
        c=a|b;
        %Now check if min()==1
        d=a&b;
        %If so, set c to L(1)
        c(d)=L(d);
        %Rotate L around only if min()==1
        L=circshift(L,-d);
        %And store c back to the output matrix
        o(i,j)=c;
    end;
end

---

अपडेट: मैं कुछ बाइट्स को बचाने के लिए if-else स्टेटमेंट को ऑप्टिमाइज़ करने में कामयाब रहा। इनपुट प्रारूप एक बार फिर कॉलम वेक्टर में बदल गया है।

Answer 5

हास्केल, 153 149 बाइट्स

j[_]o l=(l,o)
j(a:u@(b:c))o q@(l:m)|a*b==0=j u(o++[a+b])q|1<2=j u(o++[l])m
k(r,a)=fmap((1:).(++[1]))$j a[]r
n%l=map snd$take n$iterate k(cycle l,[1])

%बिट लिस्ट की सूची देता है। उपयोग उदाहरण:

> 10 % [1,0,0,1] 
[[1],[1,1],[1,1,1],[1,0,0,1],[1,1,0,1,1],[1,1,1,1,1,1],[1,0,0,1,1,0,1],[1,1,0,1,0,1,1,1],[1,1,1,1,1,1,1,0,1],[1,0,1,1,0,0,1,1,1,1]]

ओ प्यारे! यादृच्छिक सूची को Lचारों ओर ले जाने से शुद्ध दर्द होता है। देखते हैं कि क्या यह छोटा हो सकता है।

Answer 6

सी #, 152 बाइट्स

यहां कुछ खास नहीं है। फ़ंक्शन एक 2 डी सरणी देता है जहां पहली रैंक लाइन है और दूसरी कॉलम है।

स्पष्टता के लिए प्रस्तुत और नई लाइनें:

int[,]F(int n,int[]l){
    var o=new int[n,n];
    for(int y=0,x,i=0,m;y<n;y++)
        for(o[y,x=0]=1;x++<y;)
            o[y,x]=(m=o[y-1,x-1]+o[y-1,x])<2?m:l[i++%l.Length];
    return o;
}

Answer 7

टीआई-बेसिक, 106 94 87 86 87 बाइट्स

Prompt N,B
"∟B(1+remainder(𝑛,dim(∟B→u
{1
For(I,1,N
Disp Ans
augment({0},Ans)+augment(Ans,{0
Ans and Ans≠2+seq(u(𝑛-(Ans(X)<2)+2dim(∟B)),X,1,dim(Ans
End

TI-BASIC के पास वेतन वृद्धि ऑपरेटर नहीं है, है ना? खैर, यह करता है। समीकरण चर u, जिसे आमतौर पर अनुक्रमों के साथ उपयोग किया जाता है, में एक अस्पष्ट विशेषता होती है: जब uएक तर्क के साथ कहा जाता है, तो चर 𝑛उस तर्क से एक से अधिक पर सेट होता है। सशर्त वेतन वृद्धि इस पर निर्भर करती है। (मैं लंबे समय से इसका इस्तेमाल करने का इंतजार कर रहा हूं।)

ठीक से काम करने के लिए सूची अनुक्रमण के लिए, 𝑛इसका डिफ़ॉल्ट मान 0 𝑛Minहोना चाहिए , और इसका डिफ़ॉल्ट 1 होना चाहिए, इसलिए इसे चलाने से पहले अपने कैलकुलेटर की रैम को साफ़ करें या उन मानों को मैन्युअल रूप से सेट करें।

augment({0},Ans)+augment(Ans,{0दो आसन्न तत्वों की रकम की सूची की गणना करता है, इसलिए यह 0, 1s और 2s की सूची लौटाएगा। फिर जादू इस लाइन पर है:

Ans and Ans≠2+seq(u(𝑛-(Ans(X)≠2)+dim(∟B)),X,1,dim(Ans

Ans and                 ;set 0s to 0
Ans≠                    ;set to 0 all sums that equal...
2+
  seq(...,X,1,dim(Ans   ;execute for each element of the list
      u(                ;return this element in list of bits (looping)        
        𝑛               ;current location in the list
        -(Ans(X)≠2)+    ;subtract 1 if the element isn't 2
        2dim(∟B)        ;Add twice the dimension of the list
                           ;(because n<nMin on the first iteration, it's out of the domain
                           ;this prevents an error)
       )                      ;set n to one greater than that value
                              ;i.e. increment if element≠2
                        ;Will equal Ans(X) iff Ans(X)=2 and the bit read false

इस पंक्ति का परिणाम यह होगा कि सूची तत्व 0 हैं यदि वे 0 थे या यदि वे 2 थे और बिट रीड 0 था।

Result of above line
n \ u |  0  |  1
0        0     0

परीक्षण का मामला:

N=?7
B=?{0,1,0
             {1}
           {1 1}
         {1 0 1}
       {1 1 1 1}
     {1 1 0 0 1}
   {1 1 1 0 1 1}
 {1 0 0 1 1 1 1}
            Done