Một quine 1-up là một chương trình rất giống với một quine. Một điểm khác biệt chính là thay vì tự in một lần, khi n bản sao của chương trình được nối, kết quả sẽ in chương trình gốc n + 1 lần.

Thí dụ

Nếu chương trình của bạn là Abc123:

Abc123  ->  Abc123Abc123
Abc123Abc123  ->  Abc123Abc123Abc123
Abc123Abc123Abc123  -> Abc123Abc123Abc123Abc123

Thử thách

Thách thức của bạn là tạo ra một câu hỏi ngắn hạn hợp lệ ngắn nhất trong bất kỳ ngôn ngữ nào. Các quy tắc quine thông thường được áp dụng, vì vậy bạn có thể không:

• Gửi chương trình trống.
• Trực tiếp hoặc gián tiếp đọc ¹ mã nguồn.
• Sử dụng quining tích hợp.

Đây là mã golf, vì vậy mã ngắn nhất tính bằng byte thắng.

^{1 Điều này không bao gồm việc sử dụng chuỗi hoặc mã mã cứng như một phần của chương trình của bạn.}

GolfScript, 12 byte

{`'.~'+:n}.~

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

Giải trình

Điều này kết hợp các ý tưởng từ quine GolfScript tiêu chuẩn:

{'.~'}.~

Và câu hỏi được phát hiện gần đây của tôi :

":n`":n`

Ý tưởng chính là một lần nữa để sử dụng nđược in ngầm vào cuối chương trình để có được bản sao bổ sung của quine. Vì việc gán biến không thay đổi bất cứ điều gì khi nó được thực hiện lại trong các bản sao tiếp theo, nên điều này sẽ chỉ thêm một bản sao. Đây là một sự cố về mã:

{        # Standard quine framework. This pushes the block, duplicates it and runs the
         # second copy, such that it can process the first copy to create a quine.
  `      # Convert the block to its string representation.
  '.~'+  # Append the string '.~' to make a complete quine. This is simply left on the
         # stack to be printed at the end.
  :n     # Store the string in n such that one more copy is printed at the end.
}.~

GolfScript, 12 byte

{: ".~"][}.~

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

Cách mã nguồn hoạt động

{: ".~"][}.~

{        }    Define and push a code block.
          .~  Push a copy and execute it.
 :            Save the code block in the space character.
              Every subsequent space will now execute the code block.
   ".~"       Push that string.
       ]      Wrap everything up to the last [ in an array.
        [     Set a new array marker.

Nếu mã nguồn trên được thực thi một lần, ngăn xếp sẽ kết thúc là

["" {: ".~"]} ".~"]

trong đó chuỗi trống ở đầu tương ứng với trạng thái ban đầu của ngăn xếp (đầu vào trống).

Hai bản sao của mã nguồn sẽ để lại trạng thái cuối cùng là

["" {: ".~"]} ".~"] [{: ".~"]} ".~"]

ba bản sao trạng thái cuối cùng của

["" {: ".~"]} ".~"] [{: ".~"]} ".~"] [{: ".~"]} ".~"]

vân vân

Chuyện gì xảy ra tiếp theo

Sau khi thực thi mã nguồn, trình thông dịch thực hiện như sau.

1. Nó bao bọc toàn bộ ngăn xếp trong một mảng và đẩy mảng đó lên ngăn xếp.

   Đối với hai bản sao của mã nguồn, ngăn xếp hiện chứa

   ["" {: ".~"][} ".~"] [{: ".~"][} ".~"] [["" {: ".~"][} ".~"] [{: ".~"][} ".~"]]
   

2. Nó thực hiện putsvới ý định in ngăn xếp được bọc, theo sau là một dòng cấp.

   putsđược định nghĩa là {print n print}, vì vậy nó làm như sau.

   1. printin bản sao được đóng gói của ngăn xếp mà không kiểm tra nó (nghĩa là không chuyển đổi nó thành biểu diễn chuỗi của nó). Điều này gửi

      {: ".~"][}.~{: ".~"][}.~
      

      (mã nguồn) thành STDOUT và bật bản sao ngăn xếp từ đầu ngăn xếp.

      Bây giờ ngăn xếp chứa

      ["" {: ".~"][} ".~"] [{: ".~"][} ".~"]
      

   2. thực thi khối mã chúng ta đã xác định trước đó.

      :bắt đầu bằng cách lưu [{: ".~"][} ".~"]vào ký tự khoảng trắng, sau đó ".~"tự đẩy, ]bọc ".~"trong một mảng và [đặt một điểm đánh dấu mảng mới.

   3. n đẩy một chuỗi bao gồm một dòng đơn.

      Bây giờ ngăn xếp chứa

      ["" {: ".~"][} ".~"] [{: ".~"][} ".~"] [".~"] "\n"
      

   4. được thực hiện một lần nữa. Tuy nhiên, nó đã được xác định lại khi chúng tôi gọi nó lần đầu tiên và bây giờ có chứa một mảng, không phải là một khối mã.

      Trong thực tế, nó đẩy [{: ".~"][} ".~"], rời khỏi ngăn xếp như

      ["" {: ".~"][} ".~"] [{: ".~"][} ".~"] [".~"] "\n" [{: ".~"][} ".~"]
      

   5. Cuối cùng, printin mục ngăn xếp trên cùng mà không kiểm tra nó, gửi

      {: ".~"][}.~
      

      đến STDOUT, tăng 1 mã nguồn.

Javascript ES6 (REPL), 55 byte

var a=-~a;$=_=>`var a=-~a;$=${$};$();`.repeat(a+1);$();

Đã lưu 2 byte nhờ @ user81655!

Giải trình

Đây là khung quine tiêu chuẩn:

$=_=>`$=${$};$()`;$()

Bạn sẽ có thể thấy khung này trong trình. Giải thích thêm dưới đây.

var a=-~a;

Đây là bộ đếm, được mặc định là 1. Về cơ bản, nó cho chúng ta biết bao nhiêu lần lặp lại quine và gia tăng cùng một lúc.

$=_=>`var a=-~a;$=${$};$();`.repeat(a+1);$();

Đây là phần quine. Về cơ bản, chúng tôi lặp lại chuỗi quine bằng bộ đếm + 1. Các cuộc gọi chức năng tiếp theo sẽ ghi đè đầu ra.

CJam, 14 byte

{"_~"]-2>_o}_~

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

Làm thế nào nó hoạt động

{"_~"]-2>_o}_~

{          }    Define a code block and push it on the stack.
            _~  Push and execute a copy of it.
 "_~"           Push that string.
     ]          Wrap the entire stack in an array.
      -2>       Discard all but the last two elements (block and string).
         _o     Push and print a copy of that array.

Sau khi bản sao cuối cùng của chương trình được thực thi, mảng chứa khối và chuỗi vẫn nằm trên ngăn xếp, do đó, nó được in ngầm.

Groovy, 83 byte

s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//

Có một nhúng và không có dòng mới. Bản in này:

s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//

Hàm f()in một bản sao của quine. Chương trình ban đầu gọi nó hai lần. Dòng đầu tiên của mã được nối thêm trở thành một nhận xét và chỉ có cuộc gọi thứ hai f()được thực hiện.

Ruby, 43 byte

1;s="1;s=%p;$><<s%%s*n=2-0";$><<s%s*n=2-0

Chính nó, điều này in chính nó 2-0hoặc 2thời gian. Khi được nối với một bản sao khác của chính nó, câu lệnh in cuối cùng trông như thế $><<s%s*n=2-01, nghĩa là nó tự xuất ra chỉ một lần ( 01là bát phân 1). Vì vậy, chỉ có bản sao cuối cùng của chuỗi in hai lần, những người khác in một lần.

Việc gán nội tuyến nchỉ là để có được thứ tự các hoạt động chính xác; trạng thái không thực sự được truyền từ bản này sang bản khác.

NodeJS, 63 61 60 55 byte

điều này cũng sẽ hoạt động trong JavaScript (ES6) nếu bạn xem xét nhiều thông điệp trên bảng điều khiển được phân tách bằng dòng mới (không yêu cầu REPL)

Đã lưu 2 byte nhờ @ dev-null

(f=_=>(t=_=>console.log(`(f=${f})()`)||(_=>t))(t()))()

lưu ý rằng có một dòng mới ở cuối mã.

Đây là một điều thú vị, chắc chắn là một trong những mục yêu thích của tôi cho trang web này cho đến nay.

Tôi khá tự tin rằng điều này không thể được đánh gôn nhiều hơn nữa. (có thể là printchức năng của SpiderMonkey ...)

Giải trình

//FIRST ITERATION
            console.log(`(f=${f})()`)                   //logs to the console a quine of the source code using function f's toString()
                                     ||                 //causes the expression to evaluate to the second part, since console.log's return value is falsy
                                       (_=>t)           //a function that returns function t when called
       t=_=>                                            //defines function t to be the code above. When called, t will log a quine and then return a function that returns t.
      (                                      )(t())     //call t twice. (one call is done via the t() as an ignored parameter) This will print the quine twice.
 f=_=>                                                  //define f as the above code.
(                                                  )()  //call function f with no arguments. this results in a function returning t. (the result of calling t once)
                                                        //this newline is to compensate for console.log's behavior of adding a newline to its output
//SECOND ITERATION
(                                                  )    //call the function that returns t that was returned from the first iteration. This expression will result in whatever that function returns, which is t.
 f=_=>(t=_=>console.log(`(f=${f})()`)||(_=>t))(t())     //this part evaluates to a function, which is passed as a parameter to the function that returns t, that ignores its parameter.
                                                    ()  //call whatever the last expression returned, which is the function t, with no parameters. This will print the quine once.
                                                        //this call will result in a function returning t, just like from the first iteration, so we can add on more iterations at will.

Ruby, 55 byte

n||=2;s="n||=2;s=%p;$><<(s%%s)*n;n=1;";$><<(s%s)*n;n=1;

Không có gì rất thú vị ở đây, nó chỉ là một viên đá ruby ​​bình thường với một quầy.

JavaScript (ES6), 164 byte

console.log((`+String.fromCharCode(96)).repeat(window.a||(a=3,5)).slice(67,-14))
console.log((`+String.fromCharCode(96)).repeat(window.a||(a=3,5)).slice(67,-14))

Hoạt động trong bất kỳ trang thử nghiệm hoặc bảng điều khiển JS nào trong Firefox, giả sử rằng khoảng trống giữa hai thông báo bảng điều khiển được tính là một dòng mới.

Perl 6 , 58 53 byte

Cảm ơn Jo King cho -5 byte.

<say "<$_>~~.EVAL for 0..!.++;">~~.EVAL for 0..!.++;

Dựa trên câu chuyện của Jo King .

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

Japt, 40 byte

Oo("+Q ²pT°?1:2 é4;POo("+Q ²pT°?1:2 é4;P

Kiểm tra nó trực tuyến! Giải thích sắp tới.

Y

Không biên dịch, 6 byte

UCn*px

Y là một headcannon mà tôi đã có một thời gian, và điều này đã truyền cảm hứng cho tôi để viết nó. Nó được tạo ra cho những thách thức trong đó trình tự là chìa khóa, chẳng hạn như điều này. Mã được chia thành các liên kết bởi các ký tự "nút". Trong trường hợp này, mã của chúng tôi được đặt vào hai chuỗi (ban đầu), với nút là C.

U  C  n* px
1  N    2

Ughi lại một chuỗi siêu việt, tức là một chuỗi kéo dài các liên kết. Nó ghi lại cho đến khi nó gặp người khác U. Nếu a Ukhông được đáp ứng ở cuối chuỗi, nó sẽ quấn quanh. Ngoài ra, Uđược bao gồm trong chuỗi theo mặc định. Sau khi ghi lại chuỗi, chúng tôi tiến hành nút C, nó chỉ di chuyển chúng tôi đến liên kết tiếp theo.

nđẩy số chuỗi. Đối với trường hợp cơ sở của chúng tôi, điều này 2. Đối với một chuỗi các Kchuỗi, có K+2các chuỗi, vì có Kcác nút.*là chuỗi repittion. pin toàn bộ ngăn xếp (trong trường hợp này là một chuỗi) và xchấm dứt chương trình.

Trong một văn bản:

UCn*px
U..... record that string
 C     next link
  n*   repeat that string twice.
    px print and terminate

UCn*pxUCn*pxUCn*px
U.....U            record string
 C                 next link
  n*               repeat that string four times (three Cs)
    px             print and terminate

Hãy thử nó ở đây!

Brachylog , 20 byte

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

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

Sửa đổi từ quine này.

⊥                       Fail,
 ∨                      or
                w       print
  "⊥∨~kgjw₃w₅"          "⊥∨~kgjw₃w₅"
                 ₃      formatted
              gj        with itself;
                 ₃w₅    print it again at the end of the program if this route succeeds.

Khi điều này được kết hợp với chính nó, mọi tuyến đường ngoại trừ lần thất bại cuối cùng và chương trình chuyển sang kế tiếp, thực hiện từng bước w₃và quay lại quá khứ w₅ngoại trừ lần cuối cùng.

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

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

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

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

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

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