หุ่นยนต์เคลื่อนที่คล้ายชีวิตเป็นหุ่นยนต์อัตโนมัติที่คล้ายกับเกมแห่งชีวิตของคอนเวย์ซึ่งทำงานบนกริดขนาดใหญ่ (ในทางทฤษฎี) โดยที่แต่ละเซลล์มี 8 เพื่อนบ้านอย่างแน่นอนและเป็นหนึ่งใน 2 สถานะคือมีชีวิตและตาย .

อย่างไรก็ตามเวอร์ชัน Like-like เหล่านี้มีความแตกต่างกันในวิธีการที่สำคัญ: กฎสำหรับเซลล์ที่กำหนดให้มีชีวิตอยู่และกฎสำหรับเซลล์ที่กำหนดให้อยู่รอดในรุ่นต่อไป

ตัวอย่างเช่น Game of Life คลาสสิคใช้กฎB3/S23ซึ่งหมายความว่าจะต้องใช้เซลล์ที่มีชีวิต 3 เซลล์เพื่อสร้างเซลล์ใหม่และทั้ง 2 หรือ 3 เพื่อนบ้านที่มีชีวิตอยู่รอด สำหรับความท้าทายนี้เราจะสมมติว่าเพื่อนบ้านไม่รวมตัวมันเองดังนั้นแต่ละเซลล์มี 8 เพื่อนบ้านอย่างแน่นอน

งานของคุณคือกำหนดค่าเริ่มต้นกฎการเกิดกฎการเอาชีวิตรอดและจำนวนเต็มบวก (จำนวนรุ่นที่จะทำงาน) จำลองหุ่นยนต์เสมือนชีวิตโดยใช้กฎเหล่านั้นสำหรับจำนวนรุ่นที่กำหนดในรหัสสั้นที่สุดเท่าที่จะทำได้ . การกำหนดค่าเริ่มต้นจะเป็นอาร์เรย์เมทริกซ์จตุรัส / 2 มิติหรือสตริงหลายบรรทัดคุณสามารถเลือกได้ ผู้อื่นอาจได้รับในรูปแบบและวิธีการที่สมเหตุสมผล

ตัวอย่างเช่นถ้ากฎการเกิดคือ12345678(เพื่อนบ้านที่มีชีวิต) กฎการเอาชีวิตรอด2357และการกำหนดค่าเริ่มต้นคือ

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

อีกสองชั่วอายุคนจะเป็น

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

หากจำนวนรุ่นที่ได้รับคือ 10 เอาต์พุตจะเป็นบางสิ่งตามแนวของ

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/Sสัญลักษณ์เพื่อระบุกฎที่ใช้

B2/S2,, generations = 100การกำหนดค่า:

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

เอาท์พุท:

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 = 12การกำหนดค่า:

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

เอาท์พุท:

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

หากคุณต้องการสร้างกรณีทดสอบเพิ่มเติมคุณสามารถใช้ตัวจำลองที่ยอดเยี่ยมนี้ได้ โปรดตรวจสอบให้แน่ใจว่าได้ จำกัด ขนาดกระดาน

MATL , 24 23 ไบต์

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

อินพุตคือ:

• อาเรย์กับกฎการเกิด
• อาเรย์กับกฎการเอาชีวิตรอด
• จำนวนรุ่น
• เมทริกซ์ที่มีการกำหนดค่าเซลล์เริ่มต้นโดยใช้;เป็นตัวคั่นแถว

ลองออนไลน์! หรือดูกรณีทดสอบ: 1 ,2

ในอีกไม่กี่ไบต์เพิ่มเติมที่คุณสามารถดูวิวัฒนาการในศิลปะ ASCII

คำอธิบาย

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

ภาษา Wolfram (Mathematica) , 144 122 ไบต์

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

ลองออนไลน์!

ตัวอย่างการใช้งาน:

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

ใช้กริดสุ่ม 10x10 เป็นจุดเริ่มต้นรอดชีวิตด้วย 2 หรือ 3 เพื่อนบ้านเกิดกับ 3 เพื่อนบ้านผลการพล็อตที่ 5 ซ้ำ

R , 256 ไบต์

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

ลองออนไลน์!

น่าเศร้านี่ดูไม่เหมือนกอล์ฟอย่างที่ฉันหวังไว้

อินพุต : เมทริกซ์ R และพารามิเตอร์ความท้าทาย เอาท์พุท : เมทริกซ์หลังจากรุ่น R

อัลกอริทึมรองเมทริกซ์ด้วยศูนย์เพื่อจัดการกับขอบเขต จากนั้นซ้ำ: 1) มันใช้กฎการเกิดและ 2) มันฆ่าเซลล์ที่มีอยู่ก่อนที่ไม่ผ่านกฎการอยู่รอด การแพ็ดดิ้งจะถูกลบออกเมื่อส่งคืน

Python 2 , 156 149 146 bytes

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

ลองออนไลน์!

ใช้อินพุต:

• Rüles: กฎเป็นรายการของ[birth,survial] stringเช่น. ( ['135','246'])
• generations: int
• cการกำหนดค่า: อาร์เรย์ 2D ของ1/0หรือTrue/False

ส่งคืนอาร์เรย์ 2d ของ True/False