Làm một cái quine.

Có vẻ dễ phải không? Vâng, quine này phải tự xuất ra cộng với ký tự đầu tiên của nó, sau đó tự xuất ra cộng với ký tự thứ hai, v.v.

Bằng cách này, quine nên trong một vài thế hệ xuất ra hai bản sao.

Ví dụ: Cho phép mã của bạn được x. Chạy nó nên đầu ra x + x[:1]. Chạy chương trình kết quả sẽ xuất ra x + x[:2]và cứ thế ...

Nếu mã của bạn là foobar, chạy này sẽ xuất ra foobarf. Chạy này nên đầu ra foobarfo. Và cứ tiếp tục theo mô hình này:

foobar
foobarf
foobarfo
foobarfoo
foobarfoob
foobarfooba
foobarfoobar
foobarfoobarf

Chương trình của bạn phải dài hơn 2 byte và chỉ phải xuất thêm MỘT ký tự mã riêng cho mỗi lần lặp.

Zsh ,110 108 100 byte

a=`<&0`<<''<<<t;b=${a:0:50};printf $b$b${a:0:-50}
a=`<&0`<<''<<<t;b=${a:0:50};printf $b$b${a:0:-50}

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

Vì vậy, nó là có thể.

Giải trình

a=`<&0`<<''<<<t;       # Set A to everything following this line, until eof or
                       #   an empty line (which never happens before eof) encountered.
                       # A "t" is appended to prevent automatic trimming of newlines.
b=${a:0:50};           # Set B to the first line.
printf $b$b${a:0:-50}  # Print two copies of B and
                       #   A with 50 trailing characters removed.

R, 289 byte

s<-c("s<-", "i=get0('i',ifnotfound=0)+1;p=paste0(s,substr(get0('p',ifnotfound=s),1,i),collapse='');cat(s[1]);dput(s);cat(paste0(s[2],substr(p,1,i)))#")
i=get0('i',ifnotfound=0)+1;p=paste0(s,substr(get0('p',ifnotfound=s),1,i),collapse='');cat(s[1]);dput(s);cat(paste0(s[2],substr(p,1,i)))#

tín dụng cho quine này cho cảm hứng. Chỉ hoạt động nếu chạy trong cùng môi trường R với quine trước đó được chạy.

Alice , 29 byte

4P.a+80pa2*&wdt,kd&w74*,.ok@

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

Ký tự không thể in là 0x18.

Giải trình

Vấn đề với các "câu lệnh Fungeoid dựa trên thông thường là nếu chúng ta lặp lại toàn bộ mã nguồn, thì chúng ta cũng nhận được bổ sung "và chuỗi không còn bao gồm toàn bộ mã nguồn. Tôi cho rằng đó là lý do tại sao câu trả lời hiện có sử dụng gphương pháp gian lận thay thế.

Câu trả lời này không sử dụng "cách tiếp cận dựa trên, nhưng thay vì bao gồm một "trong nguồn, chúng tôi viết nó vào chương trình khi chạy. Theo cách đó, sẽ chỉ có một lần "bất kể chương trình được lặp lại thường xuyên như thế nào (vì chúng tôi chỉ ghi nó vào một tọa độ cụ thể, độc lập với quy mô chương trình).

Ý tưởng chung là sau đó chúng ta tạo ra một đại diện cho toàn bộ mã nguồn trên ngăn xếp, nhưng chỉ quay vòng qua 29 ký tự đầu tiên (tức là độ dài chương trình) với độ dài của vòng lặp được xác định bởi kích thước của mã. Do đó, chúng ta thực sự có thể nối các ký tự tùy ý (ngoại trừ nguồn cấp dữ liệu) sau @và kết quả sẽ luôn là sự lặp lại theo chu kỳ của chương trình cốt lõi, dài hơn một ký tự so với nguồn.

4P   Push 4! = 24. This is the code point of the unprintable, which we're 
     using as a placeholder for the quote.
.a+  Duplicate it and add 10, to get 34 = '"'.
80p  Write '"' to cell (8,0), i.e. where the first unprintable is.
    Placeholder, becomes " by the time we get here, and pushes the code
     points of the entire program to the stack. However, since we're already
     a good bit into the program, the order will be messed up: the bottom
     of the stack starts at the 24 (the unprintable) followed by all 
     characters after it (including those from extraneous repetitions). Then 
     on top we have the characters that come in front of the `"`. 
     So if the initial program has structure AB, then any valid program has
     the form ABC (where C is a cyclic repetition of the initial program),
     and the stack ends up holding BCA. We don't care about C, except to
     determine how big the program is. So the first thing we need to do is
     bring B to the top, so that we've got the initial program on top of
     the stack:
a2*  Push 10*2 = 20.
&w   Run the following section 21 times, which is the length of B.

  dt,  Pull up the value at the bottom of the stack.

k    End of loop.
d&w  Run the following section D+1 times, where D is the length of ABC.

  74*  Push 28, one less than the number of characters in AB.
  ,    Pull up the 29th stack element, which is the next character to print.
  .o   Print a copy of that character.

k    End of loop.
@    Terminate the program.

Perl 5 , 83 byte (bao gồm cả dòng mới)

$_=q($/=$;;$_="\$_=q($_);eval
__END__
".<DATA>;print$_,/(.).{82}\z/s);eval
__END__

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

Mã __DATA__thông báo ol 'tốt giúp dễ dàng nối thêm một chuỗi tùy ý vào bất kỳ chương trình Perl nào, mà chương trình chính sau đó có thể truy cập thông qua <DATA>xử lý tệp (và thực tế sử dụng __END__, điều tương tự để tương thích ngược, thay vì __DATA__tiết kiệm thêm hai byte) .

Lưu ý rằng chương trình này không đọc mã nguồn của riêng nó mà chỉ đọc dữ liệu đầu vào bổ sung vào nguồn của nó sau __END__mã thông báo. Trong thực tế, __END__mã thông báo và mọi thứ sau khi nó hoạt động giống như một chuỗi ký tự được kết thúc bằng đầu cuối.

Cũng lưu ý rằng, để đáp ứng chính xác thông số kỹ thuật, chương trình này phải kết thúc bằng một dòng mới. Nếu không, dòng mới thực sự sẽ tự động được nối thêm sau lần thứ hai __END__, nhưng sau đó đầu ra lặp đầu tiên sẽ không chính xác bằng mã cộng với byte đầu tiên của nó nữa.

Befunge-98 , 30 byte

0>:#;0g:840#;+*#1-#,_$a3*%0g,@

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

Tôi đã thử sử dụng Befunge-98, sử dụng một quine chấm dứt không gian, cũng tính xem có bao nhiêu ký tự đã được xuất ra. Tuy nhiên có sử dụng glệnh.

PHP, 146 byte

ob_start(function($s){return($u=substr($s,0,73)).$u.substr($s,0,-72);})?>ob_start(function($s){return($u=substr($s,0,73)).$u.substr($s,0,-72);})?>

Nó nên được chạy bằng cách sử dụng -rtrong dòng lệnh.

Bùa mê , 61 byte

803X4+kw.'.q}͍}͍}͍}͍}͍}͍}͍}͍}͍::l͍5X-:}-$:l͍{-1--@

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

Sử dụng một cách tiếp cận tương tự như câu trả lời của Alice: phản xạ viết "lệnh chuỗi vào mã để chỉ có một. Phần còn lại có rất nhiều thao tác chuỗi và ngăn xếp để khôi phục chương trình gốc, cần bao nhiêu byte bổ sung và in các khối cần thiết.

Các }͍chuỗi quay đại diện chuỗi trong bộ nhớ xung quanh sao cho 803X4+kwxuất hiện ở đầu thay vì ở cuối, do vị trí của "và không có một cách dễ dàng hơn trong việc xử lý hoạt động này mà không cần phải tính toán rất nhiều con số lúng túng .

Mặc dù chương trình ban đầu là 61 byte , độ dài chuỗi của nó chỉ là 50, rất dễ xây dựng 5Xvà điều trùng hợp là điều này không cần phải được đệm ra sau khi chứa tất cả các chức năng cần thiết (ví dụ: chương trình 49 độ dài sẽ dễ dàng hơn để mã hóa như 50với một byte đệm hơn là mã hóa một chữ 49, trong khi 51sẽ được mã hóa thành 5X3+hoặc 53, phải tính đến các byte thừa của chính nó).