โปรแกรมที่พิมพ์โปรแกรม

13

ท้าทาย

เป้าหมายของคุณคือการเขียนโปรแกรมที่พิมพ์โปรแกรมอื่น โปรแกรมที่พิมพ์นั้นควรพิมพ์โปรแกรมอื่นและโปรแกรมใหม่ควรพิมพ์โปรแกรมอื่นจนกว่าจะสิ้นสุด

กฎระเบียบ

  1. แต่ละโปรแกรมต้องน้อยกว่า 256 ไบต์ (หากจำเป็นต้องเปลี่ยนแปลงให้แสดงความคิดเห็น)
  2. โปรแกรมสุดท้ายจะต้องเป็นโปรแกรมเปล่า
  3. จะต้องมีจำนวน จำกัด ของโปรแกรมดังนั้นโปรแกรมไม่สามารถเป็นควิน
  4. โปรแกรมทั้งหมดจะต้องทำงานในภาษาเดียวกัน
  5. ไม่อนุญาตให้ป้อนข้อมูล
  6. โปรแกรมที่ชนะคือโปรแกรมที่พิมพ์โปรแกรมได้มากที่สุดโดยนับตัวเอง

โชคดี!

code-challenge  code-generation 
— เต่า
แหล่งที่มา
คะแนนสูงสุดหรือ2^2048 3.2317e616
— orlp
เพื่อให้ง่ายต่อการเปรียบเทียบคะแนนขนาดใหญ่โปรดรวมการประมาณคะแนนของคุณในรูปแบบa*10^bที่1<=a<10และbเป็นจำนวนธรรมชาติ
— ข้อบกพร่อง
2
จริงๆแล้วการคำนวณครั้งก่อนของฉันผิด สมมติว่าโปรแกรมจะต้องอยู่ในไบต์คะแนนเป็นไปได้สูงสุดคือ<เลขที่ยาวเกินไปสำหรับความคิดเห็น>1.2673e614หรือ
— orlp

คำตอบ:

20

CJam, 4.56 × 10 526โปรแกรม

2D#2b{"\256b_(256b:c'\s`_:(er`":T~{;38'ÿ*`{:T~{;63'ÿ*`{:T~{;88'ÿ*`{:T~{;114'ÿ*`{:T~{;140'ÿ*`{:T~{;166'ÿ*`{:T~{;192'ÿ*`{:T~{;219'ÿ*`{Q?\"_~"}s(\T}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}s(\T`}?\"_~"}_~

คะแนนที่แน่นอน: 254 219 + 254 192 + 254 166 + 254 140 + 254 114 + 254 88 + 254 63 + 254 63 + 254 38 + 254 13 + 3

โปรแกรมทั้งหมดจะต้องได้รับการบันทึกโดยใช้การเข้ารหัส ISO-8859-1 เพื่อให้สอดคล้องกับขีด จำกัด ขนาดไฟล์

ขอบคุณ@ChrisDrostที่ชี้จุดบกพร่องและแนะนำวิธีการทำรัง

ลองใช้ออนไลน์ในล่าม CJam

254 219 + 2 ≈ 4.56 × 10 526โปรแกรม

ส่วนแบ่งสายของคะแนนสามารถทำได้โดยต่อไปนี้โปรแกรมที่ง่ายมาก1

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ"
{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

การรันโปรแกรมนี้จะสร้างโปรแกรม

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ"
{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

และหลังจาก254 219 -การทำซ้ำอีก1รายการโปรแกรม

{\256b_(256b:c'\s`_:(er`Q?\"_~"}_~

โปรแกรมที่ไม่ว่างล่าสุดนี้ออกโดยมีข้อผิดพลาด2และไม่พิมพ์อะไรเลย (โปรแกรมเปล่า)

มันทำงานอย่างไร

สมมติว่าสตริงอยู่ในสแต็กแล้ว

{      e# Push a code block.
  \    e# Swap the string on top of the code block.
       e# This will cause a runtime error if there is no string on the stack.
  256b e# Convert the string (treated as a base-256 number) to integer (I).
  _(   e# Copy the integer and decrement the copy.
  256b e# Convert the integer into the array of its base-256 digits.
  :c   e# Cast each base-256 digit to character. Converts from array to string.
  '\s  e# Push a string that contains a single backslash.
  `    e# Push its string representation, i.e., the array ['" '\ '\ '"].
  _:(  e# Push a copy and decrement each character. Pushes ['! '[ '[ '!].
  er   e# Perform transliteration to replace "s with !s and \s with [s.
       e# This skips characters that require escaping.
  `    e# Push its string representation, i.e., surround it with double quotes.
  Q    e# Push an empty string.
  ?    e# Select the first string if I is non-zero, the empty string otherwise.
  \    e# Swap the selected string with the code block.
  "_~" e# Push that string on the stack.
}      e#
_~     e# Push a copy of the code block and execute it.
       e# The stack now contains the modified string, the original code block
       e# and the string "_~", producing an almost exact copy of the source.

254 192 ≈ 5.35 × 10 461โปรแกรมเพิ่มเติม

นี่คือสิ่งที่ได้รับบ้าเล็กน้อย

โปรแกรมแรกสามารถบีบอัดได้สูง โดยการเขียนโปรแกรมที่คล้ายกันที่แทนของโปรแกรมที่ว่างเปล่าในที่สุดผลิตโปรแกรมแรกจากส่วนข้างต้นเราสามารถปรับปรุงคะแนนจาก254 192โปรแกรม3

โปรแกรม

"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ"
{"\256b_(256b:c'\s`_:(er`":T~{;219'ÿ*`{Q?\"_~"}s(\T}?\"_~"}_~

คล้ายกับโปรแกรมแรกของส่วนก่อนหน้าและเรียกใช้อดีตและเอาท์พุทของมันสำหรับการทำซ้ำ254 192ผลิตหลัง

สมมติว่าสตริงอยู่ในสแต็กแล้ว:

{                           e# Push a code block.
  "\256b_(256b:c'\s`_:(er`" e# Push that string on the stack.
                            e# The characters inside it behave exactly as
                            e# they did in the previous section.
  :T~                       e# Save the string in T and evaluate it.
  {                         e# If the integer I is non-zero, keep the generated
                            e# string; else:
    ;                       e#   Pop the code block from the stack.
    219'ÿ*`                 e#   Push a string of 219 ÿ's (with double quotes).
    {Q?\"_~"}               e#   Push that block on the stack.
    s                       e#   Push its string representation.
    (\                      e#   Shift out the { and swap it with the tail.
    T                       e#   Push T.
  }?                        e#
  \                         e# Swap the selected string with the code block
                            e# or T with the tail of the code block.
  "_~"                      e# Push that string on the stack.
}                           e#
_~                          e# Push a copy of the code block and execute it.

โปรแกรม Moar

โปรแกรมแรกของส่วนก่อนหน้านี้ยังคงสามารถบีบอัดได้สูงดังนั้นเราจึงสามารถใช้วิธีการที่คล้ายกันและเขียนโปรแกรมที่หลังจากทำซ้ำ254 166โปรแกรมผลิตโปรแกรมดังกล่าวข้างต้น

ทำซ้ำเทคนิคนี้ซ้ำแล้วซ้ำอีกจนกว่าเราจะถึงขีด จำกัด 255 ไบต์เราสามารถเพิ่มจำนวน254 166 + 254 140 + 254 114 + 254 88 + 254 88 + 254 63 + 254 38 + 254 13 + 1 ≈ 1.59 × 10 399โปรแกรมไป ของส่วนก่อนหน้า

1 เพิ่มบรรทัดใหม่เพื่อความชัดเจน
2 ตามฉันทามติเกี่ยวกับ Metaนี้ได้รับอนุญาตโดยค่าเริ่มต้น
3 หรือ 0.000000000000000000000000000000000000000000000000000000000000000000000012%

— เดนนิส
แหล่งที่มา
ขอให้เรายังคงอภิปรายนี้ในการแชท
— Dennis
5

JavaScript, 1,000 โปรแกรม

x=999;
q=";alert(x=999?`q=${JSON.stringify(q)+q}`.split(x).join(x-1):``)";
alert(
    x ? `x=999;q=${JSON.stringify(q)+q}`.split(x).join(x-1) // basically .replaceAll(x, x-1)
      : ``
)

ไม่ว่าจะเป็นสิ่งที่ถูกต้องขึ้นอยู่กับวิธีการเข้าใจกฎข้อที่สาม

— Ypnypn
แหล่งที่มา
มันไม่ได้เป็นเทคนิคในการ quine เพราะมันพิมพ์ออกมาแก้ไขรหัสแหล่งที่มาของตัวเองมากกว่าสำเนาที่เหมือนกัน มันใช้เทคนิคคล้ายควินๆอย่างเห็นได้ชัด ฉันคิดว่าเราต้องการคำชี้แจงจาก @TheTurtle
— JohnE
5
@JohnE และ Ypnypn นี่คือสิ่งที่ฉันจินตนาการ วิธีนี้ใช้ได้ผล
— The Turtle
6
คุณยังคงต่ำกว่าขีดจำกัดความยาวของรหัส ทำไมคุณไม่เปลี่ยน 999 เป็นสิ่งที่ใหญ่กว่า
— DankMemes
4

Ruby, 1.628 × 10 ^ 237 โปรแกรม

a=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;_="a=%#x-1;_=%p;puts _%%[a,_]if a";puts _%[a,_]if a

วิธีการเดียวกับคำตอบ Perl ของฉัน แต่เนื่องจาก Ruby จัดการกับ ints ขนาดใหญ่อยู่แล้วจึงง่ายต่อการจัดเก็บเป็น hex

โปรแกรม Ruby, 9.277 × 10 ^ 90

a=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;b=0xf;(b<1)&&(a-=1)&&b=eval('0x'+'f'*(74-("%x"%a).length));_="a=%#x;b=%#x;(b<1)&&(a-=1)&&b=eval('0x'+'f'*(74-('%%x'%%a).length));_=%p;puts _%%[a,b-1,_]if a";puts _%[a,b-1,_]if a

ดังนั้นความพยายามนี้จึงเป็นรูปแบบที่แตกต่างกันเล็กน้อยในลักษณะที่คล้ายกับควินท์ก่อนหน้านี้ แต่เนื่องจากฟังก์ชั่นพิเศษทั้งหมดฉันไม่ได้รับหมายเลขที่สูงใกล้เคียงกับที่อื่น ๆ ... น่าสนใจที่จะลองวิธีอื่น!

— เฮสติ้งส์ Dom
แหล่งที่มา
2

C, 2.2 * 10 ^ 177 โปรแกรม

#define S(s)char*q=#s,n[]="#####################################################################################################";i;s
S(main(){while(n[i]==91)n[i++]=35;i==101?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})

มันไม่สมบูรณ์แบบ แต่ค่อนข้างดี ฉันหมายความว่ามัน255ยาวจริง ๆ ไบต์และสร้างโปรแกรมที่มีความยาวเท่ากัน คุณอาจจะทำเรื่องยุ่งยากมากขึ้นเพื่อให้ได้โปรแกรมเพิ่มขึ้นบ้าง แต่ฉันจะทิ้งไว้เหมือนตอนนี้

โปรแกรมนี้ใช้ C quine ง่าย ๆ นอกจากนี้ยังมีอัลกอริทึมการนับที่ค่อนข้างง่ายซึ่งนับผ่านค่าที่เป็นไปได้ทั้งหมดของอาร์เรย์อาnร์ค nเรามีโปรแกรมมากเท่าที่พีชคณิตของสตริง

ช่วงถ่านถูก จำกัด ไว้ที่ช่วงจาก#(= 35) ถึง[= (91) นั่นเป็นเพราะฉันไม่ต้องการสิ่งใด"หรือ\ในสตริงเพราะพวกเขาจำเป็นต้องหลบหนี

รุ่นโปรแกรมจะสิ้นสุดลงเมื่อค่าทั้งหมดในอาร์เรย์ถ่านมีn [จากนั้นจะแสดงผลลัพธ์ของโปรแกรมจำลองอย่างง่ายmain(){}ซึ่งไม่มีผลอะไรเลย

#define  S(s) char *q = #s; /* have the source as a string */ \
char n[] = "#####################################################################################################"; \ 
int i; \
s /* the source itself */
S(main() {
    while(n[i]=='[') /* clear out highest value, so next array element be incremented */
        n[i++]='#'; 
    i==101 /* end of array reached? output dummy program */
        ? q = "main(){}"
        : n[i]++; /* count one up in the whole array */
    printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)", n, q);
})

เป็นการสาธิตว่ามันควรใช้งานได้ฉันเพิ่งเปลี่ยนขีด จำกัด ดังนั้นเฉพาะอักขระระหว่าง ASCII-Code 35และ36ใช้กับองค์ประกอบอาร์เรย์ 4 เท่านั้น

โปรแกรมที่ได้คือ

% echo > delim; find -iname 'program_*.c' | xargs -n1 cat delim

#define S(s)char*q=#s,n[]="####";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$###";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$##";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$##";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="##$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$#$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$$#";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="###$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$##$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$#$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$#$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="##$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$#$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="#$$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="$$$$";i;s
S(main(){while(n[i]==36)n[i++]=35;i==4?q="main(){}":n[i]++;printf("#define S(s)char*q=#s,n[]=\"%s\";i;s\nS(%s)",n,q);})
#define S(s)char*q=#s,n[]="####";i;s
S(main(){})

ผลลัพธ์นี้เป็น2^4 + 1 = 17โปรแกรมที่แตกต่างกัน

ดังนั้นโปรแกรมด้านบนให้ผลลัพธ์((91-35)+1)^101 + 1 = 57^101 + 1 ~= 2.2 * 10^177โปรแกรมที่แตกต่างกัน ฉันไม่แน่ใจอย่างแน่ชัดว่าสิ่งนี้มีค่าหรือไม่หรือการคำนวณของฉันถูกต้อง

— MarcDefiant
แหล่งที่มา
1
คุณช่วยกรุณาระบุว่าเรื่องนี้เกี่ยวกับ 2.2 * 10^177(สำหรับผู้ที่ต้องการเปรียบเทียบ)
— ข้อบกพร่อง
ไม่ทราบวิธีคำนวณอันนี้ แต่ฉันรวมมัน ;-)
— MarcDefiant
— ข้อบกพร่อง
1

Perl, 1 × 10 ^ 163

0มิฉะนั้นนี้เป็นควินสวยขั้นพื้นฐานหดตัวลงไปเป็นตัวอักษรไม่กี่ที่เป็นไปได้ว่ามีเพียงวิ่งในขณะที่นับไม่ได้

use bigint;$i=9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999||die;$_=<<'e';eval
print"use bigint;\$i=$i-1||die;\$_=<<'e';eval
${_}e
"
e
— เฮสติ้งส์ Dom
แหล่งที่มา
1

เสียงกระเพื่อมสามัญ 10 113 -1

(LET ((X
       99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999))
  (WHEN #1=(PLUSP X)
    #2=(SETF *PRINT-CIRCLE* T)
    #3=(PRINT (LIST 'LET `((X ,(1- X))) (LIST 'WHEN '#1# '#2# '#3#)))))
  • มี 113 ไนน์
  • โปรแกรมถัดไปมี 112 เก้าตามด้วย 8
  • โปรแกรมถัดไปมี 112 เก้าตามด้วย 7
  • ...

จำนวนเก้าจะถูก จำกัด ด้วยขนาดสูงสุดของรหัส 256 โดยคำนึงถึงช่องว่างที่เครื่องพิมพ์แนะนำ

— coredump
แหล่งที่มา
1

Perl, 1.4 * 10 ^ 225

use bignum;open$F,__FILE__;$_=<$F>;s/0x\w+/($&-1)->as_hex/e;0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff&&print

วิธีการคล้ายกับงูหลาม ผลลัพธ์เดียวกัน!

— อเล็กซานเด-เบร็ท
แหล่งที่มา
0

> <> โปรแกรม 65534 (?)

ฉันได้เพิ่มเครื่องหมายคำถามถัดจาก 65533 เนื่องจากฉันยังไม่ได้ยืนยันว่าสามารถพิมพ์ 65533 (แม้ว่าฉันมีเหตุผลที่เชื่อว่าควรจะเป็น) เมื่อฉันมีเวลามากขึ้นฉันจะหาวิธีทดสอบ

":?!;1-r00gol?!;a0.�

คุณสามารถลองออนไลน์ได้ที่นี่

ส่วนสำคัญของโปรแกรมนี้คือมันเปลี่ยนเอาท์พุทของตัวละครที่ส่วนท้ายสุดแล้วลดค่าตัวเลขก่อนที่จะพิมพ์ ฉันได้รับโปรแกรม 65534 เพราะค่า ascii ของตัวละครในตอนท้ายของรหัสคือ 65533 ดังนั้นการนับโปรแกรมแรกที่เรามี 65534 (ถ้าคุณนับโปรแกรมเปล่า 65535 ฉันเดา) โปรแกรมสุดท้ายที่ "คืน" คืออะไร มันจะจบลงเมื่อค่าตัวละครเป็น 0

ฉันค่อนข้างแน่ใจว่ามันจะสามารถพิมพ์ตัวอักษรสำหรับการทำซ้ำทั้งหมด: ฉันไม่สามารถหาแหล่งที่ชัดเจนสำหรับจำนวนตัวอักษร> <> สามารถพิมพ์ได้ แต่มีตัวอักษรต่ำกว่า 65533 โดยตรงตัวเลข

แจ้งให้เราทราบหากมีปัญหาใด ๆ กับการใช้งานนี้ ฉันไม่แน่ใจเล็กน้อยเกี่ยวกับความถูกต้องของรายการของฉัน

คำอธิบาย

ฉันขโมยความคิดในการใช้เครื่องหมายอัญประกาศเดี่ยวเพื่อสร้าง pseudo-quine จาก> <> wiki และความคิดเห็นที่ฉันเห็นที่นี่ครั้งเดียว

":?!;1-r00gol?!;a0.�
"                     begins string parsing
 :?!;                 terminates program if final character is 0, numerically
     1-               decrements final character by 1
       r              reverses stack
        00g           grabs quotation mark (fancy way of putting " ")
           ol?!;      prints and terminates if stack is empty
                a0.   jumps back to o to loop

สิ่งที่มันคือการแยกทุกอย่างหลังจากเครื่องหมายคำพูดเป็นตัวอักษรจากนั้นลดลงล่าสุด จากที่นี่เพียงแค่ย้อนกลับสแต็ก (เพื่อที่จะพิมพ์ในลำดับที่ถูกต้อง) ดันเครื่องหมายคำพูดลงบนสแต็กแล้วพิมพ์จนกว่าสแต็กจะว่างเปล่า

— โคล
แหล่งที่มา
0

Python 1 × 10 ^ 194 โปรแกรม

n=99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
if n:print open(__file__).read().replace(str(n),str(n-1))

สิ่งนี้จะต้องเรียกใช้จากไฟล์ไม่ใช่แบบจำลองแบบโต้ตอบ มันไม่ได้เป็นควิน

ขอบคุณ @The Turtle ที่ช่วยฉันประหยัด 3 ไบต์ซึ่งเป็นพื้นที่ที่มากขึ้นสำหรับเก้า!
ขอบคุณ @poke ที่ช่วยฉันประหยัด 2 ไบต์ซึ่งเป็นพื้นที่สำหรับเก้ามากขึ้น!

— คนรักชีส
แหล่งที่มา
@ Cheese Lover The if n!=0ซ้ำซ้อน คุณสามารถเขียนif nได้
— เต่า
คุณสามารถกำจัดช่องว่างสองช่องได้เช่นกัน หลังif n:และระหว่างreplaceอาร์กิวเมนต์
— โผล่
0

Bash, 52 โปรแกรม

ไม่ได้รับการตอบรับอย่างเต็มที่และ (หวังว่า) จะอยู่ในตำแหน่งสุดท้ายอย่างสมบูรณ์

echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo echo
— คริส
แหล่งที่มา
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.