Làm một máy in số nguyên đa năng là tốt và tất cả, nhưng viết một mã duy nhất in nhiều số khác nhau thì rất khó. Sẽ không dễ dàng hơn để tạo một tập lệnh tạo ra một số, nhưng cũng cung cấp cho bạn một tập lệnh mới để có được số tiếp theo?

Thử thách:

Viết mã xuất ra một số nguyên duy nhất Nvà mã thực thi. Mã tiếp theo sẽ xuất ra N+1và một mã có thể xuất ra N+2. Tiếp tục con đường này cho đến khi bạn đạt được N = 15. (Số in cuối cùng phải là 15).

Quy tắc:

• Không có đầu vào (giả sử đầu vào trống).
• Chương trình đầy đủ hoặc chức năng hoặc các định dạng thuận tiện khác được cho phép.
• Mã đầu tiên sẽ xuất ra 1.
• Bạn không thể xuất số không hàng đầu. Tức là bạn không thể in 01cho 1.
• Đầu ra phải ở định dạng N, Code_for_N+1. Lưu ý rằng đầu ra được phân tách bằng dấu phẩy và một khoảng trắng. Mã cho N+1không có dấu ngoặc kép xung quanh. N , Code_for_N+1không được chấp nhận (khoảng trắng phía trước dấu phẩy). Trailing newlines là OK.
• (Các) ký tự đầu tiên của đầu ra phải là số. (Không có không gian hàng đầu, hoặc ans = N).
• Số được in không phải là một phần của mã tiếp theo (mã có thể chứa số này, nhưng bạn không thể lấy số đầu ra làm một phần của mã)
  • Ví dụ: Đầu ra cho N=2có thể là : 2, printer 2. Trong trường hợp này, printer 2là mã cho N=3. Bạn không thể sử dụng toàn bộ đầu ra: 2, printer 2làm mã cho N=3.
• Các tập lệnh có thể bằng các ngôn ngữ khác nhau
• Các kiểu dữ liệu không liên quan (số có thể là một chuỗi), nhưng nó không thể được bao quanh bởi bất cứ thứ gì (dấu ngoặc kép, dấu ngoặc đơn, v.v.).
• Nếu có một mã được xuất ra N=15thì nó phải in STOP!(xem phần thưởng) hoặc không in bất cứ thứ gì (thậm chí không phải là khoảng trắng hoặc dòng mới).
  • Mã cho N=15không thể sập (nhưng xuất ra STDERR là OK).
  • Bạn bị loại nếu mã đầu ra cho N=15bản in 16hoặc bất cứ thứ gì khác (trừ trường hợp tiền thưởng).
• Xây dựng trong điều hành quine không được phép.
• Truy cập tệp nguồn thông qua hệ thống tệp không được phép.

Tiền thưởng:

-10 byte nếu mã in 15 cũng tạo ra mã in " STOP!"

Các ví dụ sử dụng cú pháp Python: (rõ ràng, những điều này sẽ chỉ hoạt động cho các số nguyên được chọn, không phải từ 1 đến 15.)

N = 1
print "1, print 2"
1, print 2

---
N = 15
print 15
15

---
N = 15   (Qualifies for the -10 bytes bonus)
print "15, print 'STOP!'"
15, print 'STOP!'

print 'STOP!'
STOP!

----

N = 15   (Qualifies for the -10 bytes bonus)
print "15, disp('STOP!')"
15, disp('STOP!')        (disp('STOP!') outputs STOP! in MATLAB)

----
N = 15   (This one is not OK. The submission is disqualified)
print "15, print 16"
15, print 16

Luật chơi golf tiêu chuẩn được áp dụng! Mã nhỏ nhất (cho N = 1) tính bằng byte thắng!

Pyth + ///, 15 byte - 10 = 5

pPt`S15", STOP!

Điều này in 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, STOP!trong Pyth, bằng cách lấy range(1,15+1)và tước bỏ dấu ngoặc bắt đầu và kết thúc, và in nó ngay lập tức theo sau ", DỪNG LẠI!".

Mười bốn chương trình tiếp theo nằm trong ///, chương trình này trực tiếp xuất ra tất cả các chương trình không chứa /hoặc \. Vì vậy, chương trình thứ hai

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

cho 2và chương trình thứ ba 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15. Chương trình áp chót 15, STOP!, in 15, STOP!, vì vậy chương trình cuối cùng là vừa STOP!.

JavaScript, 131238 - 10 = 131228 byte

Cách tiếp cận ngây thơ hóa ra tồi tệ hơn dự kiến. Nhìn nhận lại tôi nên mong đợi nó. Nhưng tôi nghĩ dù sao tôi cũng sẽ chia sẻ nó. Mã đầy đủ ở đây.

Ý tưởng: Lặp đi lặp lại và thêm N-1, ...

alert("14,alert(\"15, alert(\\\"STOP!\\\")\")")

CJam, 26 25 24 byte

1{", "2$)@"_~"](_F<@*}_~

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

Các chương trình tiếp theo chỉ đơn giản là tăng số đầu tiên. Điều này chạy chương trình 16 lần.

Hoặc với phần thưởng cho cùng số điểm:

1{", "\2$)_G<\@`+"_~"+"STOP!"`?}_~

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

Các chương trình tiếp theo chỉ đơn giản là tăng số đầu tiên. Điều này chạy chương trình 16 lần.

Giải pháp thay thế cho phần thưởng:

1{", "\2$)Gmd@`+"_~"+"STOP!"`\?}_~

JavaScript (ES6), 62 61 byte - 10 điểm thưởng = 51 điểm

_=>"1, "+(f=n=>`_=>"`+(n<16?n+`, "+(${f(n+1)})`:`STOP!"`))(2)

Giải trình

Một giải pháp không đọc mã nguồn của chính nó và cũng không dài một cách lố bịch.

Chương trình đầu tiên xây dựng tất cả 15 chương trình khác và lồng chúng vào nhau bằng hàm đệ quy. Tôi giải quyết vấn đề dấu gạch chéo ngược bằng cách tự lồng các hàm (sau đó được truyền thành chuỗi trong đầu ra) chứ không phải chuỗi.

_=>
  "1, "                // print the first number
  +(f=n=>`_=>"`+(      // f = recursive function for printing program N
    n<16?              // for programs 2 - 15:
      n+`, "+(${       // add N to the output of the nested function
        f(n+1)         // nest the code of program N + 1
      })`
    :`STOP!"`          // program 16 just outputs "STOP!" for the bonus
  ))(2)                // start from program 2

Kiểm tra

var nextProgram = '_=>"1, "+(f=n=>`_=>"`+(n<16?n+`, "+(${f(n+1)})`:`STOP!"`))(2)',
    n = 1;
while(nextProgram) {
  result.textContent += "Program " + n++ + ": " + nextProgram + "\n";
  var output = eval("(" + nextProgram + ")()");
  result.textContent += "   Output: " + output + "\n\n";
  var index = output.indexOf(",");
  nextProgram = index > 0 ? output.substr(index + 2) : null;
}

<pre id="result"></pre>

Matlab, 226 212 - 10 = 202 byte

Cảm ơn @StewieGriffin cho một vài byte =)

'awFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)

Phần đầu tiên là một chuỗi đại diện cho dòng thứ hai (bên dưới), mã thực tế (chỉ được thay đổi bởi 9). Trong Matlab, các chuỗi là ma trận chứa đầy các ký tự, vì vậy bạn có thể dễ dàng thực hiện các ca bằng cách chỉ cần thêm / trừ một vô hướng. Vì vậy, chương trình chỉ in ra cùng một chuỗi * một lần nữa, cộng với cùng một chuỗi nhưng đã thay đổi dẫn đến mã.

* Không hoàn toàn: byte đầu tiên là bộ đếm cần được tăng lên trong mỗi lần lặp.

Trò lừa bịp với chuỗi đã bị đánh cắp một cách đáng xấu hổ từ đây.

'awFjw|Dro)w1:26B?G:>DwF0\}xy*0Dnu|nDwFdw~v;|}{1w1:26B?2505)05<B5w1:24:5w1;Cnwm25<B5>B5w1;Cnwm26B500fDnwmDmr|y1w2';
n=ans;if n(1)-96>15;n='Stop!';else;n=[num2str(n(1)-96),', ',39,n(1)+1,n(2:end),39,59,n(2:end)-9,''];end;disp(n)

Ở đây một vài dòng cuối cùng của chuỗi được sao chép từ bàn điều khiển:

>> 'mwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
13, 'nwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'nwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
14, 'owFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'owFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
15, 'pwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'pwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
STOP!

JavaScript, 50 47 44 42 44 ^* byte

a=_=>(x=1)+(x<15?", a="+a:"").replace(x,x+1)

Đó là một chức năng trích xuất cơ thể của chính nó (chỉ a) và thay thế trong đó. Lấy phần thân hàm là một tính năng tích hợp sẵn của JavaScript, mặc dù không rõ ràng là một toán tử quine (nếu nó không hợp lệ, sẽ xóa câu trả lời).

a=_=>(x=1)+(x<15?", a="+a:"").replace(x,x+1);
alert(a());

Trong trường hợp nó không hoạt động được nhúng đúng ở đó (vì đối với tôi nó không hoạt động), bạn có thể xem một ví dụ ở đó .

^{* - có vẻ như đoạn trích tạo ra kết quả mà không a=thực hiện các cuộc gọi tiếp theo}

Python 2.7.10, 196 92 - 10 = 82 byte

Ôi !!! Đây là niềm vui Bây giờ ngắn hơn nhiều. : P

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)if n!=15else"STOP!"';print n,a%(n+1,a)if n!=15else"STOP!"

Giải trình:

Tôi bắt đầu với điều này:

a='a=%r;print a%%a';print a%a

Đó chỉ là một câu đố đơn giản. Đây là với một bộ đếm được thêm vào:

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)';print n,a%(n+1,a)

nlà một biến đếm được in ở đầu. Sau đó, khi nó inn= một phần, nó thay thế n+1cho%d . Vì vậy, từ đây nó sẽ đếm lên vô hạn.

Và đây là phiên bản cuối cùng. Nó thêm một mệnh đề if dừng ở 15 và in "DỪNG!" cũng.

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)if n!=15else"STOP!"';print n,a%(n+1,a)if n!=15else"STOP!"

Mã cũ:

a= ['if num==15:print"STOP!!!";exit()','print num','print"a=",a','print"num=",num+1', 'for s in a:print s']
num= 1
print num
if num==15:print"STOP!!!";exit()
print"a=",a
print"num=",num+1
for s in a:print s

Không bao giờ chiến thắng, nhưng vui vẻ. : P Bây giờ ngắn hơn nhiều, mặc dù tôi vẫn không có cơ hội. : P

PowerShell, (215-10) = 205 197 167 106 104 103 byte

$d='$c=(,1*{2}).count;$d={0}{1}{0};(("$c, $d"-f[char]39,$d,($c+1)),$c)[$c-eq15]';"1, $d"-f[char]39,$d,2

_{(Nếu công cụ duy nhất của bạn là PowerShell, mọi vấn đề trông giống như một cái đinh. Đợi ...)}

Về cơ bản, chúng ta bắt đầu với việc thiết $dbằng một chuỗi lớn ole-dài của một almost- Quine của mã gốc. Nó ra 1và sau đó $dvới các nhà điều hành định dạng -fđể cư một cách chính xác {0}, {1}, {2}đứng-ins, incrementing {2}số trong,1*{2} phần bởi một mỗi lần.

Các ,x*yhoạt động trong PowerShell tạo ra một mảng mới của ymặt hàng, mỗi trong số đó là tương đương x. Ví dụ, ,2*3tương đương với @(2,2,2).

Điều này có nghĩa, đầu ra đầu tiên sẽ là 1, $c=(,1*2).length;$d=(etc...), do đó, khi mã thứ hai được thực thi, $csẽ bằng số đếm của mảng @(1,1), hoặc 2, v.v. Lưu ý rằng $ckhông được sử dụng như một biến trong mã gốc, chỉ trong các lần chạy tiếp theo.

Dừng khi nó in 15 bằng cách tính toán đơn giản $cbằng 15và sau đó lập chỉ mục vào một mảng, phần tử thứ 0 $c, $dnhư được mô tả ở trên, phần còn lại chỉ là 15. Vì vậy, khi $c15 tuổi, nó sẽ xuất ra 15và không có gì khác. Không đủ điều kiện nhận thưởng, vì "15, {0}STOP!{0}"5 ký tự quá dài để -10 đáng giá.

Yêu cầu thiết bị đầu cuối PowerShell có chiều rộng> ~ 150. Hoặc để bạn tự xóa phần ngắt dòng bổ sung (thiết bị đầu cuối sẽ chèn một cách hữu ích vào gói đầu ra) khi sao chép-dán mã. Hoặc để bạn nắm bắt đầu ra thành một biến và sau đó thực hiện lại biến đó. V.v.

_{Chỉnh sửa 1 - Đã lưu một số byte bằng cách xóa "STOP!" từ ngữ.
Chỉnh sửa 2 - Durr, không sử dụng .length mỗi lần, chỉ cần gọi một lần
Chỉnh sửa 3 - Không cần phải là một câu hỏi, vì vậy lần chạy ban đầu có thể ngắn hơn rất nhiều
Chỉnh sửa 4 - Thay đổi từ sử dụng chuỗi sang mảng để tính toán $c, đã lưu hai byte. Tôi khá chắc chắn rằng điều này gần như tối ưu cho phương pháp này.
Chỉnh sửa 5 - Đã lưu một byte khác bằng cách đếm trực tiếp đẳng thức thay vì sửa đổi}

JavaScript, 79 - 10 = 69 byte

s='STOP!';for(i=15;i;){s=i--+',alert("'+s.replace(/[\\"]/g,"\\$&")+'")'};alert(s)

Không sử dụng Function.prototype.toStringtheo bất kỳ cách nào cả.

Befunge, 57 - 10 = 47 byte

1:'!`'#*j:.',,1+:9`''*'0++,1#;:0g:48*`j@,1+;"!POTS",,,,,@

Điều này là tuyệt vời. Hãy thử nó ở đây .

Hàng loạt, 73 + 5 - 10 = 68 byte

@set a=STOP!
@for /l %%a in (15,-1,1)do @set a=%%a, @echo !a!
@echo %a%

Yêu cầu CMD /V:ONvì vậy tôi đã thêm 5 byte cho điều đó.

Python 2.7, 107 ký tự

Bằng cách sử dụng đệ quy và không viết một quine, tôi nghĩ rằng tôi có thể tiết kiệm rất nhiều, đó là sự thật, nhưng không đủ tốt. Mặc dù không phải là người chiến thắng, tôi nghĩ cách tiếp cận này rất thú vị để chia sẻ.

Tôi bắt đầu bằng cách tạo một chuỗi cho N = 4, thoát khỏi ký tự \và "ký tự.

print "1, print \"2, print \\\"3, print \\\\\\\"4, print \\\\\\\\\\\\\\\"STOP!\\\\\\\\\\\\\\\"\\\\\\\"\\\"\""

Sau đó, tôi đã tạo ra một hàm lambda tạo ra chuỗi này, dựa trên chỉ mục bắt đầu và chỉ mục dừng, sử dụng đệ quy. Đây chính là nó:

l=lambda n,m:str(n)+", print "+"\\"*(2**(n-1)-1)+"\""+l(n+1,m)+"\\"*(2**(n-1)-1)+"\"" if n<m else "STOP!"

Sử dụng nó như thế này:

print l(1,15)

Đầu ra: [32902 ký tự, quá dài để xử lý]

Vì vậy, có vẻ như cách tiếp cận phức tạp kolmogorov của tôi không thành công ;-)

SMBF , 28 byte

\x10đại diện cho một byte bằng chữ (giá trị thập phân 16). Số nguyên là đầu ra dưới dạng một số nguyên (byte). Vì vậy, đầu ra ký tự đầu tiên là \x01. Chương trình sau đó in ",". Khi in nguồn riêng của nó, nó in thêm +vào lúc đầu.

+.<-<<.>.>[[<]>.[.>]<[-]], \x10

Giải trình:

+.                                  Increment number and print
  <-                                Pre-decrement loop counter
    <<.>.>                          Print comma and space from own source
          [             ]           Only execute if loop counter != 0
           [<]>.                    Move to left of source, then print `+`
                [.>]                Print entire source.
                    <[-]            Zero out the loop counter so this program halts.
                         , \x10     The comma, space, and loop counter used earlier.
                                    Input is empty, so `,` doesn't do anything.

Lưu ý rằng bạn không thể chạy cái này trong một trình thông dịch tiêu chuẩn bởi vì nó yêu cầu một chữ hex trong đầu vào. Bạn cũng cần một thiết bị đầu cuối đặc biệt để đầu ra hex hoạt động chính xác.

Bash, 78 74 73 - 10 = 63 byte (Ví dụ: không thể thắng)

p='if(($((++a>15))));then unset a p;fi;echo ${a-STOP\!}${p+, $p}';eval $p

Đến muộn, nhưng thấy bash chưa được thử nên đã cho nó đi. Thử thách vịnh đầu tiên và câu đố giống như quine. Họ rất vui!

Giải trình:

Điều này hoạt động vì acác bước từ 1 đến 15 và sau đó là unsetcùng với p. Tập lệnh (được lưu trữ p) in cả hai ra nếu chúng setvà "DỪNG!" nếu không thì. Ban đầu unset alà set0 vì nó xuất hiện trong một mở rộng số học.

, 30 ký tự / 47 byte (không cạnh tranh)

⟮a=1)+(a<ḏ?⬬+ⒸⅩ222+ᶈ0:⬯)ē(a,⧺a

Try it here (Firefox only).

Cuối cùng cũng tìm thấy một câu hỏi đúng đắn về ol.

Giải trình

Đây là câu hỏi thực sự mà tôi đã sử dụng: ⟮ⒸⅩ222+ᶈ0

Bạn thấy nó trong câu trả lời của tôi? Hy vọng, bạn sẽ có thể mở rộng từ đó.

Keg + PHP, 19-10 = 10 byte

ï_(. \,,,)\!POTS(,

Đếm từ 1 đến 15 rồi dừng lại. TIO

Keg, 13 byte

ï_(. \,,,).