Bạn phải viết một chương trình sẽ xuất mã nguồn

1. Lớn hơn chương trình gốc (nhân vật khôn ngoan)
2. Sẽ in một chương trình khác lớn hơn chính nó khi chạy (tức là chương trình mới cũng là một câu trả lời hợp lệ cho thử thách này)

Đây là môn đánh gôn, vì vậy câu trả lời ngắn nhất sẽ thắng.

GS2 (8636bd8e) , 0 byte

Điều này in một dòng mới, in hai dòng mới, in ba dòng mới, et cetera.

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

H9 + : 1 ký tự

9

Đúng rồi. Một nhân vật. Xuất lời bài hát đến 99 chai bia , đây là một chương trình hợp lệ. Tất cả các dữ liệu không liên quan không được tính, nhưng có rất nhiều 9s trong đó.

Đầu ra của chương trình xuất ra là lời bài hát tới 99 chai bia 59 lần.

Hàm này cho biết số lần lời bài hát được xuất ra nếu bạn chạy nthời gian của chương trình (nếu tính toán của tôi là đúng):

f(n) = 59n-1

GolfScript, 9 ký tự

{.'.~'}.~

Mã này xuất ra:

{.'.~'}{.'.~'}.~

đầu ra nào:

{.'.~'}{.'.~'}{.'.~'}.~

đầu ra nào:

{.'.~'}{.'.~'}{.'.~'}{.'.~'}.~

vân vân

Tôi tin rằng đây là câu trả lời ngắn nhất trong một ngôn ngữ lập trình Turing "hoàn chỉnh" cho đến nay.

Giải trình:

Về cơ bản, mã gốc ở trên là "lớp quine": nó tạo ra một quine bình thường theo sau nó.

Trong GolfScript, bất kỳ khối mã nào theo nghĩa đen (ví dụ {foo}), nếu không bị xáo trộn trên ngăn xếp, là một quine. Do đó, tự nó, {.'.~'}chỉ đơn giản là tự xuất ra, giống như bất kỳ khối mã nào khác.

Phần .~cuối của mã lấy khối mã cuối cùng trên ngăn xếp, sao chép nó và thực thi bản sao. Khi được thực thi, mã .'.~'bên trong khối mã sẽ nhân đôi mục trên cùng trên ngăn xếp (tức là bản sao của chính nó) và nối thêm chuỗi .~.

Vào cuối chương trình, trình thông dịch GolfScript sắp xếp chuỗi và xuất mọi thứ trên ngăn xếp, trong trường hợp này, bao gồm một {.'.~'}khối nhiều hơn trong đầu vào, cộng với chuỗi .~.

Thêm:

Thêm một ]trước một .(để thu thập tất cả các khối mã trên ngăn xếp vào một mảng trước khi chúng được sao chép) làm cho nó tăng theo cấp số nhân:

{].'.~'}.~

đầu ra:

{].'.~'}{].'.~'}.~

đầu ra nào:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

đầu ra nào:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

vân vân

Java 7: 0 ký tự

Lưu dưới dạng tập tin Blank.java. Nếu bạn lưu nó dưới dạng bất kỳ tệp nào khác, hãy thay thế bất kỳ trường hợp nào Blankbằng tên tệp thích hợp.

Sau đó, chạy trong dòng lệnh thông qua biên dịch đầu tiên, sau đó chạy. Nếu biên dịch thất bại, dừng lại.

Tôi liệt kê đây là Java 7 vì nó có thể xuất ra các phiên bản Java khác nhau.

Một vài kết quả đầu ra (xuất ra stderr):

Error: Could not find or load main class Blank

Blank.java:1: error: class, interface, or enum expected
Error: Could not find or load main class Blank
^
Blank.java:1: error: reached end of file while parsing
Error: Could not find or load main class Blank
                                              ^
2 errors

Blank.java:1: error: class, interface, or enum expected
Blank.java:1: error: class, interface, or enum expected
^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                          ^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                                     ^
Blank.java:1: error: as of release 5, 'enum' is a keyword, and may not be used as an identifier
Blank.java:1: error: class, interface, or enum expected
                                          ^
  (use -source 1.4 or lower to use 'enum' as an identifier)
Blank.java:1: error: = expected
Blank.java:1: error: class, interface, or enum expected
                                               ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:2: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:3: error: = expected
^
^
Blank.java:3: error: ';' expected
^
 ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
     ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
              ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                   ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                 ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
                                        ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                         ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                                              ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:5: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:6: error: = expected
                                              ^
                                              ^
Blank.java:6: error: ';' expected
                                              ^
                                               ^
Blank.java:7: error: reached end of file while parsing
2 errors
        ^
30 errors

HQ9 +, HQ9 ++ và similars, 2 ký tự

QQ

Đây là đầu ra:

QQQQ

Hồng 27

Một phiên bản sửa đổi rất ít của điều này ( thông qua ):

puts <<3*3,3
puts <<3*3,3
3

Số lần putsin -line được in tăng theo cấp số nhân.

$ ruby quine.rb | ruby | ruby
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
3

$ ruby quine.rb | ruby | ruby | ruby | ruby | ruby | ruby | ruby | wc -l
    3283

Giải tích Lambda - 29

Một thuật ngữ lambda đơn giản

(λu.(u u)(u u))(λu.(u u)(u u))

Giảm thuật ngữ này bằng một sản lượng giảm beta

((λu.(u u)(u u))(λu.(u u)(u u)))((λu.(u u)(u u))(λu.(u u)(u u)))

Và vân vân. Đây là một biến thể đơn giản trên cổ điển (λu.u u)(λu.u u), đó là một nguyên tắc trong phép tính lambda, ứng dụng tự gấp đôi ở đây có nghĩa là chúng ta nhận được gấp đôi sản lượng.

Kịch bản SH, 9

cat $0 $0

Sinh trưởng với tốc độ theo cấp số nhân.

Hoặc là chạy sh whatever.shhoặc đặt nó là thực thi.

Phiên bản Windows có ở đây .

đc 11

Khá đơn giản:

6579792
dfP

Dòng đầu tiên được lặp lại một lần mỗi thế hệ:

$ dc growing_quine.dc
6579792
6579792
dfP

$ dc growing_quine.dc | dc | dc 
6579792
6579792
6579792
6579792
dfP

Dòng cuối cùng bao gồm các hướng dẫn sau: dsao chép giá trị cuối cùng được đặt vào ngăn xếp (6579792) (để chúng tôi có thêm một bản sao mỗi lần chúng tôi chạy nó), fin toàn bộ ngăn xếp (là một bó cùng số đó) và Pin số (6579792) ra dưới dạng luồng byte, hiển thị dưới dạng dfP.

redcode (giải pháp đệ quy)

Đây là mã của chiến binh dễ ghi nhất trong mã đỏ , Imp nổi tiếng:

MOV 0, 1

Khi được thực thi, mã viết một bản sao của lệnh đơn của nó tại địa chỉ tiếp theo trong bộ nhớ; sau đó thực thi nó, v.v.

Con trăn 3 - 55

print(open(__file__).read())
f=lambda:print('f()')
f()

Điều này có thể được thực hiện ngắn hơn bằng cách thay thế __ file__ bằng một tên tệp ký tự duy nhất và lưu tệp như vậy, nhưng tôi cảm thấy câu trả lời này phù hợp hơn với tinh thần của câu hỏi. Sau một lần lặp, nó xuất ra:

print(open(__file__).read())
f=lambda:print('f()')
f()
f()

Smalltalk, 125 61 57

Phiên bản golf trông gần như không thể đọc được vì vậy tôi sẽ giải thích trước (và sử dụng số nhận dạng thực).

Đây là một biến thể của phương pháp tự sửa đổi "kỳ lạ nhất theo cách sản xuất-một-chồng-tràn".

Phương thức in ra một thông điệp xin chào và nguồn hiện tại của nó (chỉ dành cho trình diễn). Sau đó, mã được sửa đổi để xuất ra một chuỗi dài hơn và được cài đặt. Cuối cùng, mã mới được gọi là đệ quy.

Để bảo vệ bản thân khỏi sự trốn chạy ngay lập tức, nó cho phép người dùng xác nhận trong mỗi chu kỳ.

biên dịch trong Object:

eatMe_alice
   |msg mySource|

   mySource := thisContext method source.

   '**** Hello Alice' printCR.
   '  ---- my current code is:' printCR.
   mySource printCR.
   '  ---------------' printCR.

   (UserConfirmation confirm:'Again? ') ifTrue:[
       Object compile:
            (mySource
                copyReplaceString:'Hello ','Alice'
                withString:'Hello ','Alice !').
       self eatMe_alice
   ]

bắt đầu chương trình bằng cách gửi "eatMe_alice" tới bất kỳ Đối tượng nào; nil sẽ làm:

nil eatMe_alice

Một biến thể tốt đẹp là không gọi mã mới theo cách đệ quy, mà thay vào đó, lặp đi lặp lại, bằng cách thư giãn ngăn xếp cuộc gọi và nhập lại vào phương thức mới. Điều này có lợi thế là không dẫn đến ngoại lệ đệ quy. Để thực hiện việc này, thay thế cuộc gọi đệ quy ("self eatMe_alice") bằng:

thisContext resend

Chơi gôn

Rõ ràng, in ấn và tự gọi điện không được yêu cầu, vì vậy, ngắn nhất (đối với golf) chỉ đơn giản là thêm một nhận xét vào nguồn của riêng tôi và trả lại nó. Là một tác dụng phụ, nó cũng được cài đặt cho cuộc gọi tiếp theo ...

x|s|Object compile:(s:=thisContext method source,'""').^s

Kịch bản SH, 12 8 7

Lưu trữ một tập tin với

sed p *

trong thư mục riêng, trống và chạy từ thư mục này bằng cách sử dụng sh [file]hoặc thiết lập thực thi.

Thay thế cũ với 8 ký tự , nhưng không cần thư mục riêng. Lưu trữ một tập tin với

sed p $0

và chạy bằng cách sử dụng sh [file]hoặc thiết lập thực thi.

Thay thế cũ với 12 ký tự :

sed -i- p $0

Điều này thực sự sẽ xuất ra tệp chương trình, nhưng nơi đầu ra không được chỉ định. Tái tạo chính nó với tốc độ theo cấp số nhân.

JavaScript, 41 , 40 ký tự

function f(){console.log(f+"f(f())")}f()

Lần đầu tiên bạn chạy nó, nó sẽ tự xuất ra cái khác ;f()ở cuối. Các lần chạy tiếp theo của kết quả đầu ra trong mỗi nguồn "đầu vào" được in hai lần.

alertsẽ ngắn hơn console.lognhưng tôi không coi nhiều hộp thoại cảnh báo là đầu ra "trong khi có vẻ hợp lý khi gọi nhiều dòng trong bàn điều khiển là đầu ra.

J , 1 byte

'

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

Rõ ràng, trích dẫn mở cho lỗi rõ ràng:

|open quote
|   '
|   ^
|[-1] /home/runner/.code.tio

Lưu ý rằng, theo bản chất của trình thông dịch J, các lỗi được in thành STDOUT , không phải STDERR.

Khi ở trên được chạy dưới dạng mã, nó sẽ in:

|open quote
|   |   '
|       ^
|[-2] /home/runner/.code.tio

Sau đó

|open quote
|   |   |   '
|           ^
|[-2] /home/runner/.code.tio

vân vân Mỗi khi mã chạy, dòng thứ hai được đệm trái với bốn byte |   , đáp ứng yêu cầu của thử thách này.

J , biến thể quine thích hợp, 25 byte

echo,~'echo,:~(,quote)'''

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

Đầu ra

echo,:~(,quote)'echo,:~(,quote)'

Và sau đó nó tự xuất ra hai lần, trên các dòng riêng biệt:

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

sau đó

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

vân vân

Đầu ra đầu tiên là một biến thể đơn giản của quine J tiêu chuẩn . Phần bổ sung được ,:~nối chính nó theo chiều dọc, trong đó mảng 2D kết quả được in thành hai hàng của cùng một chuỗi.

Windows .BAT, 25

@COPY %~nx0+%~nx0 CON>NUL

Sinh trưởng với tốc độ theo cấp số nhân.

Phiên bản SH tương đương tại đây .

mặt lưới, 11 byte, không biên dịch

"'34'coo1o;

Đây là khung quine tiêu chuẩn, ngoại trừ một phần bổ sung 1được in sau mỗi lần lặp. Hãy thử trực tuyến!

Đầu ra đầu tiên:

"'34'coo1o;
"'34'coo1o;1
"'34'coo1o;11
"'34'coo1o;111

Kính hiển vi II, 6 byte

Không biên dịch, ngôn ngữ hoãn thách thức.

"qp"qp

Lặp lại đầu tiên thêm một phần bổ sung qpvào cuối và mỗi lần lặp kế tiếp sẽ thêm một bản sao bổ sung của chương trình gốc này vào đầu.

Bùa mê , 6 byte

"'<S@>

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

Điều này thật kỳ lạ. Tất cả những gì tôi phải làm là xóa một ~từ câu hỏi ban đầu được tìm thấy bởi Jo King .

Mỗi lần chạy bổ sung sẽ nối thêm một lần nữa <vào cuối, ví dụ:

"'<S@><<<<<<<<<

Tất cả đều không làm gì cả.

EcmaScript 6 (51 byte):

(_=x=>'(_='+_+Array(x++).join(','+_)+')('+x+')')(2)

Nó tạo ra một phiên bản dài hơn của chính nó, có thể tạo ra một phiên bản dài hơn của chính nó, có thể tạo ra một phiên bản dài hơn của chính nó, v.v ...

PHP, 38

<?echo fgets(fopen(__FILE__,'r')).';';

Nó sẽ thêm một dấu chấm phẩy ở mỗi lần chạy.

ECMAScript 6 (38 ký tự)

(f=_=>'(f='+f+')();(f='+f+')();')();

Đầu ra nào:

(f=_=>'(f='+f+')();(f='+f+')();')();(f=_=>'(f='+f+')();(f='+f+')();')();

Biên tập

Bạn có thể làm (28 ký tự):

(f=_=>'(f='+f+')();'+f())();

Tuy nhiên, nó sẽ lặp lại vô tận và không bao giờ trả lại bất cứ điều gì ... nhưng điều này có thể được giải quyết bằng cách làm một cái gì đó như thế này (42 ký tự):

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);

Sẽ xuất ra:

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(2);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(1);

Lisp thông thường, 16 ký tự

(print `(or ,-))

Cấp, nó chỉ tương tác, nhưng có thể tham chiếu biểu mẫu cấp cao nhất hiện tại có lẽ là cách tốt nhất để giảm thiểu một chương trình không tầm thường đáp ứng đặc điểm kỹ thuật.

Những gì sẽ thực sự thú vị là những gì thổi lên nhanh nhất. Có lẽ một cái gì đó như

(print `(progn ,@(loop repeat (length -) collect -)))

Julia, 66 ký tự

x="print(\"x=\$(repr(x))\\n\$x;\"^2)";print("x=$(repr(x))\n$x;"^2)

Đầu ra (134 ký tự):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Kết quả thực hiện kết quả (268 ký tự):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

kết quả tiếp theo (536 ký tự):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Kết quả tiếp theo (1072 ký tự):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Tôi hy vọng điều này là theo các quy tắc.

Nó tạo ra đầu ra lớn hơn và chính đầu ra là mã nguồn hợp lệ tạo ra đầu ra lớn hơn một lần nữa.

05AB1E, 15 byte, không lọc

0"DÐ34çý"DÐ34çý

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

In 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
mà in 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
vv

Evoloop, hình chữ nhật 9 × 9 (81 ô)

Máy tự động di động Evoloop đi kèm với Golly hỗ trợ các mẫu tự sao chép theo cách "giống như quine". Cụ thể, mỗi mẫu này chứa một "chương trình"; một mô hình tự tái tạo bằng cách trước tiên thực hiện chương trình (tạo ra "cơ thể" của con gái), và sau đó bằng cách sao chép chương trình vào con gái.

Những điều trên áp dụng cho thiết bị tự động di động "Langton's Loops" nổi tiếng hơn cũng như Evoloop, nhưng Evoloop có một điểm khác biệt thú vị, đó là dễ dàng tạo ra một mô hình phát triển trong mỗi thế hệ kế tiếp.

( Theo tôi, thú vị hơn nhiều , đó là sự thật rằng Evoloop là một máy tự động di động đơn giản có chứa các mô hình tự sinh sản và phát triển theo cách rất giống cuộc sống! Tôi nghĩ rằng máy tự động di động duy nhất được biết đến là Evoloop và hậu duệ của nó Tuy nhiên, một thiếu sót của Evoloop là có một bộ gen "tốt nhất" đặc biệt, sự tiến hóa cuối cùng luôn hội tụ đến bộ gen này.)

Bây giờ, có hai thiếu sót cho trình này. Một là không rõ "đầu ra" của thiết bị tự động di động là gì. Nhưng tôi nghĩ rằng một máy tự động tự tái tạo là "đủ gần" để trở thành một quine; Nó chắc chắn không kém phần thú vị! Một thiếu sót khác là những mẫu này không chỉ tạo ra một bản sao của chính chúng; mỗi bản sao của mẫu ban đầu cố gắng tạo ra vô số bản sao của chính nó và các bản sao này cuối cùng tương tác với nhau theo cách phá hoại. Vì vậy, tôi nghĩ rằng tôi đã đáp ứng các yêu cầu của thử thách này về mặt tinh thần, nhưng không phải bằng thư.

Nếu không có thêm rắc rối, mô hình là:

022222220
270170172
212222202
202000212
272000272
212000202
202222212
271041032
022222250

Đây là mẫu một lần nữa, trong một định dạng có thể được sao chép và dán vào Golly:

x = 9, y = 9, rule = Evoloop
.7B$BG.AG.AGB$BA5B.B$B.B3.BAB$BGB3.BGB$BAB3.B.B$B.5BAB$BGA.DA.CB$.6BE
!

Được rồi, nhưng nó trông như thế nào? Nó trông như thế này:

Trong hình ảnh động ở trên, bạn có thể thấy mô hình ban đầu tạo ra một cô con gái lớn hơn, tạo ra một cháu gái lớn hơn, sau đó là cháu gái lớn hơn, và cuối cùng là một cháu gái lớn thậm chí còn lớn hơn bắt đầu xây dựng một cháu gái lớn thứ ba thậm chí còn lớn hơn cháu gái. Nếu bạn chạy mô hình này trong một thời gian dài, nó sẽ tiếp tục như thế này mãi mãi (hoặc có lẽ cuối cùng chúng sẽ bị các sinh vật tiến hóa vượt qua, có khả năng sinh sản nhanh hơn nhiều; tôi không chắc chắn).

PIN, 26

Đặt mã này vào bất kỳ tệp .bat nào và nó sẽ tiếp tục thực thi (trong một vòng lặp vô hạn) và tệp cũng sẽ phát triển.

echo echo %0 ^>^> %0 >> %0

PYG (6)

P(Q,Q)

In mã nguồn riêng của nó, được phân tách bằng dòng mới. Thế hệ thứ hai sẽ là

P(Q,Q)
P(Q,Q)

và kể từ đó trở đi.

DẦU , 83 byte

0
0
1
1
1
4
1
11
4
1
11
1
2
2
1
12
18
10
18
1
32
22
1
18
26
4
26
8
18
11
6
17
4
26

Đầu tiên, nó in hai dòng có số 0 trong đó và sau đó so sánh mỗi dòng với dòng 1, nếu chúng bằng nhau (đó là trường hợp khi tệp bị cạn kiệt), chúng tôi sẽ in những gì trong ô 26. Kết quả đầu ra sẽ trông giống tương tự, ngoại trừ với một bổ sung 33, mà không làm gì cả. Lần tới, một dòng khác sẽ được thêm vào, v.v.

Giúp tôi với, WarDoq! , 1 byte.

H

In Hello, World!.

Các ký tự khác ngoài H là mã nguồn hợp lệ (và an toàn) (in các biến thể khác của Hello World).