Giriş

Bu meydan okumada, çok kötü yalancı sayılar kullanarak belirli bir olasılıklı hücresel otomatı simüle edeceğiz . Hücresel otomasyon ikili dizelerde aşağıdaki yerel kural ile tanımlanır. Bir hücrenin sol komşu ve hücre kendisi durumlarına sahip olduğunu varsayalım ave b.

• Eğer min(a,b) == 0o zaman yeni bir devlet, bDİR max(a,b).
• Eğer min(a,b) == 1, o zaman yeni durumu brastgele seçilir {0,1}.

Aşağıdaki resim, bir single'ın 10 adımlı olası evrimini göstermektedir 1.

1
11
101
1111
11001
101011
1111111
10001001
110011011
1010111101

İki komşu kadar Not 1s bazen gelişmeye 1ve bazen 0, ve sınır en parça her zaman 1bu. Göreviniz bu formun hücresel otomat evrimini üretmektir.

Girdiler

Girdileriniz, ngörüntülenecek satır sayısını belirten pozitif bir tamsayı Lve rastgelelik kaynağı olarak kullandığımız boş olmayan bir bit listesidir .

Çıktı

Çıktınız, yukarıdaki şekilde olduğu gibi, zaman adımları 1için tek bir evrenin evrimini gösteren listeler veya 2B bit dizisidir n. 0İstenirse eşit uzunlukta satırlar elde etmek için çıktıyı s ile doldurabilirsiniz , ancak önde 0s olmamalıdır .

Hücresel otomattaki rastgele seçimler listeden çizilmeli ve Ltükendiğinde başlangıca geri dönmelidir. Daha açık bir ifadeyle, çıktı yukarıdan aşağıya, soldan sağa doğru bir zaman formunda bir satırdan geçirilirse, ardışık rasgele seçimler gerektiği Lkadar tekrarlanan listeyi oluşturur .

Misal

Girişlerin n = 7ve olduğunu varsayalım L = [0,1,0]. Daha sonra, hücresel otomat 7 adımda aşağıdaki şekilde gelişir, burada vher rastgele seçimin üzerine bir sağ koyarız :

[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]

Biz işaretlenmiş tüm bitleri okursanız v, aldığımız 01001001, hangi L2.66 kez tekrarladı. Bir sonraki rastgele bit olur 0.

Kurallar ve Puanlama

Tam bir program veya işlev yazabilirsiniz. En düşük bayt sayısı kazanır ve standart boşluklara izin verilmez. Girişlerin ve çıkışların kesin formatı önemsizdir (sebep dahilinde).

Test Durumları

Deterministik versiyon, her rastgele bit 0:

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

Her rastgele bit 1:

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

Yalancı sürümler:

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

Pyth, 33 bayt

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

Çevrimiçi deneyin: Gösteri veya Test Paketi

Açıklama:

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

Retina , 139 bayt

^.
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>

Burada <empty>, sonunda boş bir satır olduğunu gösterir. Her satır ayrı bir dosyaya gider ve #satır besleme (0x0A) ile değiştirilmelidir.

Giriş olmasını bekler nde tekli (olduğu gibi, sıfır yapılmış Tekli ), "yalancı rasgele" dizge ardından, ardından bir boşluk, örneğin 10, [1, 0, 0, 1]olarak okunacak

0000000000 1001

Çıktı meydan okumadaki gibidir, ancak sıfırlarla doldurulur, örn.

1000000000
1100000000
1110000000
1001000000
1101100000
1111110000
1001101000
1101011100
1111111010
1011001111

Bu beklediğimden çok daha zor oldu ...

Python, 142 135 132 131 bayt

133 132 131 bayt versiyonu

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

ikame r[x-1]+r[x]>1ile r[x-1]&r[x]bit seviyesinde operatör edildi ve minimum değeri veren(r[x-1],r[x])

@ThomasKwa n*nyerine n**21 bayt tasarruf önerdiğin için teşekkürler !

-1 bayt için @Shebang teşekkürler

135 baytlık sürüm

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 bayt için @Cole'a teşekkürler:

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

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

142 baytlık sürüm

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

@ Jakube cevap bile yakın değil ama kodlama ve bu bir golf eğlenceli bir sürü vardı.

İki giriş bekler: ilk giriş satır sayısı ve ikinci giriş yalancı kaynak kaynak listesidir . Konsolda her biri yeni bir satıra arka arkaya yazdırır.

Örnek olarak:

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]

Şimdi nasıl çalıştığına dair kısa bir açıklama için:

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    

Buradaki hile, bit listesinin her zaman ile başlayıp biteceğini bildiğimiz 1için, ilk ve son elemanlar teknik özellikler nedeniyle asla değiştirilmez. sorunun. İfadenin nedeni budur [1]+r+[1].

Ama eğer rilklendirilirse [1], ilk satırda hiçbir değişiklik olmaz ve sonra [1]+r+[1]ikinci satırın nasıl gelmediğini ekleriz [1,1,1]?

Bunun nedeni birinci tekrar gerçeğine olduğunu i=1böylece range(1,i)bir sonucu olarak, döner boş liste ve foryineleme için hiçbir şey olan liste anlama üzerinde röylesine boş bir liste haline gelir [1]+r+[1]=[1,1]. Bu sadece bizim için ideal olan ilk yinelemede olur!

Not: Nasıl daha fazla golf oynayabileceğiniz konusunda önerilerde bulunmaktan çekinmeyin.

MATLAB, 146 143 138

(Ayrıca çevrimiçi Octave üzerinde çalışır, ancak işlevi bir dosyaya kaydetmek için oturum açmanız gerekir).

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

İşlev, bir girdi alır nve L, bir dizi döner oçıktısını içerir.

Giriş değerleri için, nbir skalerdir ve Lformatta belirtilebilen bir sütun vektörüdür [;;;]. Gösterdiğiniz şey tam olarak değil, ama mantıklı bir şekilde esnek olduğunu söylüyorsunuz ve bu öyle görünüyor.

Çıktı, 0'lar ve n x n1'ler içeren bir dizi olarak biçimlendirilir .

Ve bir açıklama:

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

Güncelleme: Birkaç bayt kaydetmek için if-else deyimini optimize etmeyi başardım. Giriş biçimi bir kez daha sütun vektörüne dönüştü.

Haskell, 153149 bayt

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])

%bit listelerinin bir listesini döndürür. Kullanım örneği:

> 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]]

Ah hayatım! Rasgele listeyi taşımak Lsaf acıdır. Bakalım bu daha kısa olabilir mi?

C #, 152 bayt

Burada özel bir şey yok. İşlev, birinci sıralamanın satır ve ikincisinin sütun olduğu bir 2D dizi döndürür.

Netlik için girintili ve yeni satırlar:

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;
}

TI-BASIC, 106 94 87 86 87 bayt

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'in bir artış operatörü yok, değil mi? Şey, öyle. uNormalde sekanslarla kullanılan denklem değişkeni belirsiz bir özelliğe sahiptir: ubir argümanla çağrıldığında, değişken 𝑛bu argümandan daha büyük bir değere ayarlanır. Koşullu artış buna bağlıdır. (Uzun süredir kullanmayı bekliyorum.)

Liste indekslemesinin düzgün çalışması 𝑛için varsayılan değeri 0 olmalı ve varsayılan değeri 𝑛Min1 olmalıdır, bu yüzden çalıştırmadan önce hesap makinenizin RAM'ini temizleyin veya bu değerleri manuel olarak ayarlayın.

augment({0},Ans)+augment(Ans,{0iki bitişik öğenin toplamlarının listesini hesaplar, böylece 0s, 1s ve 2s listesini döndürür. Sonra sihir bu çizgide:

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

Bu satırın sonucu, liste öğelerinin 0 olsaydı veya 2 olsaydı ve okunan bit 0 ise 0 olur.

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

Test durumu:

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