Máy tự động di động giống như cuộc sống là máy tự động di động tương tự như Trò chơi cuộc sống của Conway, ở chỗ chúng hoạt động trên một lưới vuông lớn vô hạn (về mặt lý thuyết), trong đó mỗi tế bào có chính xác 8 hàng xóm và là một trong 2 trạng thái, cụ thể là sống và chết .

Tuy nhiên, các phiên bản Like-like này khác nhau theo một cách rất quan trọng: các quy tắc cho một ô đã cho trở nên sống động và các quy tắc cho một ô đã cho tồn tại cho thế hệ tiếp theo.

Ví dụ, Game of Life cổ điển sử dụng quy tắc B3/S23, nghĩa là phải mất 3 tế bào sống để sinh ra một tế bào mới và 2 hoặc 3 người hàng xóm còn sống để tồn tại. Đối với thử thách này, chúng tôi sẽ cho rằng hàng xóm không bao gồm chính nó, vì vậy mỗi ô có chính xác 8 hàng xóm.

Nhiệm vụ của bạn là, được đưa ra một cấu hình bắt đầu, quy tắc sinh, quy tắc sinh tồn và số nguyên dương (số lượng thế hệ được chạy), mô phỏng máy tự động giống như cuộc sống bằng cách sử dụng các quy tắc đó cho số lượng thế hệ được cung cấp trong mã ngắn nhất có thể . Cấu hình bắt đầu sẽ là một ma trận vuông / mảng 2 chiều hoặc một chuỗi nhiều dòng, bạn có thể chọn. Những người khác có thể được đưa ra trong bất kỳ định dạng và phương pháp hợp lý.

Ví dụ: nếu quy tắc sinh là 12345678(bất kỳ hàng xóm sống), quy tắc sinh tồn là 2357và cấu hình bắt đầu là

0 0 0 0 0
0 0 0 0 0
0 0 1 0 0
0 0 0 0 0
0 0 0 0 0

hai thế hệ tiếp theo sẽ là

Generation 1:           Generation 2:

0 0 0 0 0               1 1 1 1 1
0 1 1 1 0               1 1 0 1 1
0 1 0 1 0               1 0 1 0 1
0 1 1 1 0               1 1 0 1 1
0 0 0 0 0               1 1 1 1 1

Nếu số lượng thế hệ được đưa ra là 10, thì đầu ra sẽ là thứ gì đó dọc theo dòng

0 1 1 1 0
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
0 1 1 1 0

Bạn không phải xử lý các thay đổi xảy ra bên ngoài giới hạn do ma trận đầu vào đưa ra, tuy nhiên, tất cả các ô bên ngoài ma trận bắt đầu chết. Do đó, ma trận đầu vào có thể là bất kỳ kích thước nào, tối đa giá trị tối đa mà ngôn ngữ của bạn có thể hỗ trợ. Bạn không phải xuất bảng giữa các thế hệ.

Đây là một mã golf để mã ngắn nhất sẽ thắng.

Các trường hợp thử nghiệm

Chúng sử dụng B/Ský hiệu để chỉ ra các quy tắc được sử dụng

B2/S2,, generations = 100cấu hình:

1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0

Đầu ra:

0 0 0 0 0 0 0 0
0 1 0 0 0 0 1 0
1 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0

B1357/S2468,, generations = 12cấu hình:

1 0 1 0 1 0
0 1 1 0 1 0
1 0 0 0 0 0
0 0 0 0 0 1
1 1 1 1 1 0
0 1 1 0 0 1

Đầu ra:

0 1 0 0 0 0
0 1 1 1 1 0
0 1 0 1 1 0
1 1 1 0 0 0
0 0 1 1 1 0
0 1 1 0 0 0

Nếu bạn cần tạo thêm các trường hợp thử nghiệm, bạn có thể sử dụng trình giả lập tuyệt vời này . Hãy chắc chắn để giới hạn kích thước bảng

MATL , 24 23 byte

xx:"tt3Y6Z+1Gm<8M2Gmb*+

Đầu vào là:

• Mảng có quy tắc sinh
• Mảng với quy tắc sinh tồn
• Số lượng thế hệ
• Ma trận với cấu hình ô ban đầu, sử dụng ;như dấu tách hàng.

Hãy thử trực tuyến! Hoặc xem các trường hợp thử nghiệm: 1 , 2 .

Đối với một vài byte nữa, bạn có thể thấy sự phát triển trong nghệ thuật ASCII .

Giải trình

xx      % Take two inputs implicitly: birth and survival rules. Delete them
        % (but they get copied into clipboard G)
:"      % Take third input implicitly: number of generations. Loop that many times
  tt    %   Duplicate twice. This implicitly takes the initial cell configuration
        %   as input the first time. In subsequent iterations it uses the cell 
        %   configuration from the previous iteration
  3Y6   %   Push Moore neighbourhood: [1 1 1; 1 0 1; 1 1 1]
  Z+    %   2D convolution, maintaining size
  1G    %   Push first input from clipboard G: birth rule
  m     %   Ismember: gives true for cells that fulfill the birth rule
  <     %   Less than (element-wise): a cell is born if it fulfills the birth rule
        %   *and* was dead
  8M    %   Push result of convolution again, from clipboard M
  2G    %   Push second input from clipboard G: survival rule
  m     %   Ismember: gives true for cells that fulfill the survival rule
  b     %   Bubble up the starting cell configuration
  *     %   Multiply (element-wise): a cell survives if it fulfills the survival
        %   rule *and* was alive
  +     %   Add: a cell is alive if it has been born or has survived, and those
        %   are exclusive cases. This produces the new cell configuration
        % Implicit end loop. Implicit display

Ngôn ngữ Wolfram (Mathicala) , 144 122 byte

CellularAutomaton[{Tr[2^#&/@Flatten@MapIndexed[2#+2-#2[[1]]&,{#2,#3},{2}]],{2,{{2,2,2},{2,1,2},{2,2,2}}},{1,1}},#,{{#4}}]&

Hãy thử trực tuyến!

Ví dụ sử dụng:

%[RandomInteger[1, {10, 10}], {2, 3}, {3}, 5]

sử dụng lưới ngẫu nhiên 10 x 10 khi bắt đầu, tồn tại với 2 hoặc 3 hàng xóm, sinh ra với 3 hàng xóm, kết quả cốt truyện ở 5 lần lặp.

R , 256 byte

function(x,B,S,r){y=cbind(0,rbind(0,x,0),0)
n=dim(y)[1]
z=c(1,n)
f=function(h){w=-1:1
b=h%%n+1
a=(h-b+1)/n+1
'if'(a%in%z|b%in%z,0,sum(x[w+b,w+a])-x[b,a])}
while(r){x=y
for(i in 1:n^2){u=f(i-1)
y[i]=u%in%B
y[i]=(y[i]&!x[i])|(x[i]&(u%in%S))}
r=r-1}
y[-z,-z]}

Hãy thử trực tuyến!

Đáng buồn thay, điều này không giống như chơi golf như tôi hy vọng.

Đầu vào : một ma trận R và các tham số thách thức. Đầu ra : ma trận sau các thế hệ R.

Thuật toán đệm ma trận với các số không để xử lý các ranh giới. Sau đó, lặp đi lặp lại: thứ 1) nó áp dụng quy tắc Sinh và thứ 2) nó giết chết các ô tồn tại trước đó không vượt qua quy tắc Sinh tồn. Đệm được loại bỏ khi trở về.

Python 2 , 156 149 146 byte

lambda R,g,c:g and f(R,g-1,[[`sum(sum(l[y+y/~y:y+2])for l in c[x+x/~x:x+2])-c[x][y]`in R[c[x][y]]for y,_ in e(c)]for x,_ in e(c)])or c
e=enumerate

Hãy thử trực tuyến!

Đưa đầu vào:

• Rules: [birth,survial]quy tắc như danh sách string. ví dụ. ( ['135','246'])
• gliệt kê: int
• configuration: mảng 2D vuông của 1/0hoặcTrue/False

Trả về mảng 2d của True/False