Cuộc sống kỳ lạ của một tổ ong

Các nhà nghiên cứu gần đây đã phát hiện ra một đàn ong thú vị sống trong một cánh đồng tổ ong vô tận:

Mỗi tế bào có thể nuôi một con ong hoặc không. Trên thực tế, cuộc sống của những sinh vật đó có vẻ hơi ... hỗn loạn. Có thể tính toán rằng một thuộc địa luôn bắt đầu với mẫu sau:

_{(Bee vẽ bởi Emmanuel Boutet trên Wikimedia Commons . Hình ảnh tổ ong-and-ong này do đó được phát hành theo CC-BY-SA . Càu nhàu )}

Sau đó, vòng đời của ong được chia thành các thế hệ được gọi là. Mỗi thế hệ ong cũ chết và những con mới nở và nó chủ yếu phụ thuộc vào hàng xóm của tế bào của chúng:

• Nếu một con ong có ít hơn hai người hàng xóm, nó sẽ chết vì cô đơn.
• Nếu một con ong có nhiều hơn ba người hàng xóm, nó sẽ chết vì quá đông.
• Nếu một tế bào có hai, ba hoặc bốn con ong sống trong các tế bào lân cận thì một con ong mới nở ở đó trong thế hệ tiếp theo.

Những con ong chết không chết cho đến khi kết thúc một thế hệ nên chúng vẫn ảnh hưởng đến các tế bào xung quanh có thể nở ra những con ong ở thế hệ tiếp theo.

Bây giờ chúng ta biết làm thế nào một thuộc địa như vậy hoạt động, chúng ta có thể mô phỏng nó thông qua bất kỳ số lượng thế hệ.

Đầu vào

Đầu vào là một số N duy nhất , được đưa ra trên đầu vào tiêu chuẩn, được kết thúc bằng ngắt dòng. 0 ≤ N 150. Đây là số lượng thế hệ để mô phỏng.

Đầu ra

Đầu ra là một số duy nhất, trên đầu ra tiêu chuẩn và tùy ý theo sau là ngắt dòng đơn, đại diện cho số lượng ong sống sau N thế hệ.

Đầu ra bổ sung về lỗi tiêu chuẩn được bỏ qua.

Đầu vào mẫu

0
5
42
100

Đầu ra mẫu

6
44
1029
5296

Điều kiện chiến thắng

Mã ngắn nhất sẽ thắng, như thông lệ trong golf. Trong trường hợp hòa, giải pháp trước đó thắng.

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

Có hai tập lệnh kiểm tra, chứa các trường hợp kiểm thử giống hệt nhau:

• bash
• PowerShell

Yêu cầu trong cả hai trường hợp : <test script> <my program> [arguments], ví dụ ./test ruby beehive.rbhoặc ./test.ps1 ./beehive.exe.

Tôi biết chỉ có 22 bài kiểm tra thay vì 151 (chủ yếu vì các giải pháp thường khá chậm). Xin vui lòng không nhúng các trường hợp thử nghiệm chính xác thay vì giải quyết nhiệm vụ. Các tập lệnh này là một thuận tiện để bạn kiểm tra xem một thay đổi có còn khiến chương trình hoạt động chính xác hay không; không phải là bạn có thể điều chỉnh mã của mình cho các trường hợp thử nghiệm cụ thể.

Một lưu ý khác

Nhiệm vụ này là một phần của cuộc thi golf được tổ chức tại trường đại học của tôi trong năm 2011-W24. Điểm số và ngôn ngữ của các thí sinh của chúng tôi như sau:

• 336 - C
• 363 - C
• 387 - C
• 389 - Haskell
• 455 - C

Giải pháp của chúng tôi là

• 230 - Ruby

Ruby, 181 163 153 146 ký tự

h=[0]*4e4
[0,-200,201,202,2,3].map{|i|h[i]=1}
gets.to_i.times{h=h.map{[g=1,200,201].map{|x|g+=h[x]+h[-x]};g>5-h.rotate![-1]||g<3?0:1}}
p h.count 1

Việc triển khai này tuân theo cách tiếp cận tiêu chuẩn bằng cách sử dụng một mảng h(kích thước 200x 200phẳng), trong đó mỗi phần tử là 0(không có ong) hoặc 1(bao gồm ong). Mảng [0,-200,201,202,2,3]mô tả vị trí ban đầu của ong (liên quan đến bất kỳ ô ban đầu nào).

Đầu vào và đầu ra như được chỉ định ở trên, vượt qua tất cả các trường hợp thử nghiệm được xác định.

Chỉnh sửa 1: thay đổi trở lại thành giải pháp gói thay vì chuyển đổi "không gian bổ sung" (ngắn hơn trong phiên bản trung gian nhưng giờ dài hơn vài ký tự).

Chỉnh sửa 2: loại bỏ biếnb hoàn toàn .

Chỉnh sửa 3: cảnh báo: chỉnh sửa này làm cho chương trình chậm khủng khiếp. Do đó, tôi đã giảm kích thước xuống còn 200 kích thước vẫn đủ cho tối đa 150 lần lặp. Thay vì lập chỉ mục cho mảng bằng một biến, chúng tôi liên tục xoay mảng về phía trước. Thiết kế không thực sự tốt, nhưng bây giờ chúng tôi đáng kể dưới 150.

Con trăn, 152 ký tự

P=[0,2,3,1j,1+1j,1-1j]
for i in' '*input():Q=[p+d for d in(1,-1,1j,-1j,1j-1,1-1j)for p in P];P=set(p for p in Q if 1<Q.count(p)<5-(p in P))
print len(P)

Giải pháp này theo dõi các vị trí ong với một bộ số phức. Nó khá chậm vì vòng lặp bên trong là bậc hai về số lượng ong. Tôi đã thử nghiệm tới 50 và nó hoạt động.

Python, 171 169 158 ký tự

w=300
s=w*w
x=[0]*297
h=[1,1,0]+x+[1,0,1,1]+x+[1]+x*s
exec('h=[1<sum(h[(i+x)%s]for x in[-1,-w-1,-w,1,w+1,w])<5-h[i]for i in range(s)];'*input())
print sum(h)

Tôi mô hình thế giới dưới dạng mảng 300 * 300 = 900000 1D ( hthực sự lớn hơn, nhưng kết thúc không được sử dụng), trong đó một con ong là 1 và trống là 0. Kích thước 300 là tốt vì hầu hết sự tăng trưởng sẽ là 2 trong mỗi chiều cho mỗi thế hệ, và không có hơn 150 thế hệ.

Đây là một phiên bản hơi vô căn cứ và nhận xét:

w=300 # width and height of the world
s=w*w
# create initial grid
l=[1,1]+[0]*298+[1,0,1,1]+[0]*297+[1]+[0]*s

for k in range(input()):
  h=l[:]

  for i in range(s):

    # for each point, compute the number of neighbors
    n=sum(map(lambda x:h[(i+x)%s],[-1,-w-1,-w,1,w+1,w]))

    # if that number verifies the conditions, put 1 here, if not put 0
    l[i]=1<n<5-h[i]

print sum(l)