সিউডোরান্ডম সেলুলার অটোমেটন

Question

ভূমিকা

এই চ্যালেঞ্জের মধ্যে আমরা খুব খারাপ সিডোডোরডম সংখ্যা ব্যবহার করে একটি নির্দিষ্ট সম্ভাব্য সেলুলার অটোমেটন অনুকরণ করব । সেলুলার অটোমেটন নিম্নলিখিত স্থানীয় নিয়মে বাইনারি স্ট্রিংগুলিতে সংজ্ঞায়িত হয়। ধরুন যে কোনও কক্ষের বাম প্রতিবেশী এবং সেলে নিজেই রয়েছে রাজ্যগুলি aএবং b।

• তাহলে min(a,b) == 0, তারপর নতুন রাষ্ট্র bহয় max(a,b)।
• যদি min(a,b) == 1, তবে নতুন রাষ্ট্রের bথেকে এলোমেলোভাবে নির্বাচন করা হয় {0,1}।

নিম্নলিখিত চিত্রটি একটি একক সম্ভাব্য দশ-ধাপ বিবর্তন দেখায় 1।

1
11
101
1111
11001
101011
1111111
10001001
110011011
1010111101

দুটি সংলগ্ন কীভাবে 1কখনও কখনও বিকাশ হয় 1এবং কখনও কখনও 0এবং সীমান্তের সর্বাধিক বিটগুলি সর্বদা 1এস Note আপনার কাজটি এই ফর্মটির সেলুলার অটোমেটনের বিবর্তন তৈরি করা produce

ইনপুট

আপনার ইনপুটগুলি একটি ধনাত্মক পূর্ণসংখ্যা 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মধ্যে ইউনারী (শূন্যর তৈরী হিসেবে একক ), একটি স্থান দ্বারা অনুসরণ, "সিউডো-রেণ্ডম" STRING দ্বারা অনুসরণ, যেমন 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পরিবর্তে পরামর্শের জন্য n**2যা 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

-২ বাইটের জন্য @ কোলকে ধন্যবাদ:

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] । এটি কেবল প্রথম পুনরাবৃত্তির ক্ষেত্রে ঘটে যা আমাদের জন্য আদর্শ!

PS: কীভাবে এটি আরও গল্ফ করা যায় সে সম্পর্কে কোনও পরামর্শ দিতে বিনা দ্বিধায়

Comments

আমি ক্ষমা চাচ্ছি আমি সঠিকভাবে চ্যালেঞ্জ বুঝতে পারছি না, কিন্তু আপনি প্রতিস্থাপন করতে পারবেন না min(a,b)সঙ্গে a+b>1এবং max(a,b)সঙ্গে a+b? আমি বুঝতে পেরেছিলাম 1-> এর প্রথম প্রথম কেসটি হ্যান্ডেল করার জন্য আপনাকে সম্ভবত কিছু করতে হবে11 (আমি মনে করি আপনি কাজ করতে পারে L=[1]+f()..., অথবা সামনে 1 সন্নিবেশ করতে কিছু উপায় খুঁজে বের Lকারণ যে সবসময় দ্বিতীয় লাইন 1 পপ হবে)

— কোল

@ কোল ভাগ্যক্রমে প্রোগ্রামের বাকী অংশে কোনও পরিবর্তন আনতে হবে না কারণ পরিবর্তনগুলি কেবল এক জোড়া বিটের নূন্যতম এবং সর্বাধিক মান জানার উপায়কে প্রভাবিত করে।

— Ioannes

আপনি মিস করেছেন যে আপনি এখানে একটি জায়গা সরিয়ে ফেলতে পারেন: r[x-1]&r[x] else:)

— কেড

N ** 2 -> n * n কাজ করবে?

— lirtosiast

@ থমাস আপনি ঠিক বলেছেন!

— আইওননেস

Answer 4

ম্যাটল্যাব, 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-অন্য বিবৃতিটি অপ্টিমাইজ করতে সক্ষম হয়েছি। ইনপুট ফর্ম্যাটটি আবার কলাম ভেক্টরে ফিরে এসেছে।

Answer 5

Haskell,, 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 বাইট

এখানে বিশেষ কিছু নেই। ফাংশনটি 2D অ্যারে প্রদান করে যেখানে প্রথম র‌্যাঙ্কটি লাইন এবং দ্বিতীয়টি কলাম।

স্বচ্ছতার জন্য যুক্ত এবং নতুন লাইন:

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

টিআই-বেসিকের ইনক্রিমেন্ট অপারেটর নেই, তাইনা? ভাল, এটা সাজানোর। সমীকরণের ভেরিয়েবল u, সাধারণত সিকোয়েন্সগুলির সাথে ব্যবহৃত হয় তার একটি অস্পষ্ট বৈশিষ্ট্য থাকে: যখন uআর্গুমেন্টের সাথে ডাকা হয়, ভেরিয়েবল𝑛 তর্কটির চেয়ে বড়তে সেট করা হয়। শর্তসাপেক্ষ বৃদ্ধি এই উপর নির্ভর করে। (আমি এটি দীর্ঘকাল ধরে ব্যবহার করার অপেক্ষায় ছিলাম))

সঠিকভাবে কাজ করতে তালিকার সূচিকাগুলির জন্য 𝑛অবশ্যই এটির 0 এর ডিফল্ট মান হতে 𝑛Minহবে এবং এটির ডিফল্ট 1 হওয়া উচিত, সুতরাং আপনার ক্যালকুলেটরটির র‌্যাম সাফ করুন বা এগুলি চালানোর আগে মানগুলি নিজেই সেট করুন।

augment({0},Ans)+augment(Ans,{0দুটি সংলগ্ন উপাদানের যোগফলের তালিকা গণনা করে, তাই এটি 0, 1 এবং 2 এর তালিকা প্রদান করবে। তাহলে যাদুটি এই লাইনে রয়েছে:

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