You are to write a sequence of 10 programs p1 p2 ... p10 that satisfy the following properties:

  • pK prints pK+1 for K from 1 to 9
  • p10 prints p10
  • When the first K programs are concatenated, the resulting program p1...pK prints p1...pK.
  • Each program pK must be larger in byte size than the previous program pK-1.
  • All programs must be in the same language.
  • Built-in quining functions (e.g. Q in many languages) are allowed.

Your score is the sum of the byte counts of the 10 programs. Since there are only ten programs, you must make your codes as short as possible. Good luck.

  • \$\begingroup\$ "Each program pK must be larger in byte size than the previous program pK-1" - huh, why this strange requirement? \$\endgroup\$
    – nicael
    Jan 3, 2016 at 21:30
  • 6
    \$\begingroup\$ @nicael Because it's a growing quine sequence. \$\endgroup\$ Jan 3, 2016 at 21:31
  • \$\begingroup\$ Why does p10 print itself and not p11? That makes the problem a bit harder. \$\endgroup\$ Jan 4, 2016 at 0:28
  • \$\begingroup\$ @SuperJedi224 Because simply there is no p11. \$\endgroup\$ Jan 4, 2016 at 0:31
  • \$\begingroup\$ This challenge would have been a lot more interesting if built-in quining functions had been forbidden. \$\endgroup\$
    – Dennis
    Jan 4, 2016 at 17:42

4 Answers 4


Seriously, 245 bytes:

All ten programs concatenated:









There are invisible characters that become visible when executed, a strange property of byte 7F. The trailing newlines on each program are significant. In fact, Seriously automatically appends newlines to its output whether you want it to or not. This just counts the number of newlines in the output, and as soon as that number exceeds 8, it deletes the last character of output. As such, p1..pK will print p1..pK for all K>4.

Q                                  Push source code.
 9uc                               Push \n
    Qc                             Push the number of times it appears in source code.
      8<                           Check if it appears more than 8 times.
        WX     0WX                 If so, run the included code.
          #dX                      Convert string to list, dequeue and discard a newline.
             εj                    Join list back into string.
                  .                Print and halt. (Invisible byte here.)
  • 1
    \$\begingroup\$ Interesting! It is indeed possible. \$\endgroup\$ Jan 3, 2016 at 21:32
  • 7
    \$\begingroup\$ can i haz explanation leik wat each char duz \$\endgroup\$
    – Seadrus
    Jan 3, 2016 at 21:40
  • 3
    \$\begingroup\$ It should be noted that this uses the quining built-in Q which pushes the source code of the program. \$\endgroup\$ Jan 3, 2016 at 22:59
  • \$\begingroup\$ (And further noted that the total length would be somewhere in the vicinity of 150 bytes longer without said built-in.) \$\endgroup\$
    – quintopia
    Jan 3, 2016 at 23:01
  • \$\begingroup\$ Built-in quining functions are allowed for this challenge. \$\endgroup\$ Jan 3, 2016 at 23:41

JavaScript (ES6), 985

function f(x){x<0||x>8||f.a||x++;alert(f.a=' '.repeat(x)+`${f}f(${x});`.replace(/\d/,x))}f(0);
 function f(x){x<1||x>8||f.a||x++;alert(f.a=' '.repeat(x)+`${f}f(${x});`.replace(/\d/,x))}f(1);
  function f(x){x<2||x>8||f.a||x++;alert(f.a=' '.repeat(x)+`${f}f(${x});`.replace(/\d/,x))}f(2);
   function f(x){x<3||x>8||f.a||x++;alert(f.a=' '.repeat(x)+`${f}f(${x});`.replace(/\d/,x))}f(3);
    function f(x){x<4||x>8||f.a||x++;alert(f.a=' '.repeat(x)+`${f}f(${x});`.replace(/\d/,x))}f(4);
     function f(x){x<5||x>8||f.a||x++;alert(f.a=' '.repeat(x)+`${f}f(${x});`.replace(/\d/,x))}f(5);
      function f(x){x<6||x>8||f.a||x++;alert(f.a=' '.repeat(x)+`${f}f(${x});`.replace(/\d/,x))}f(6);
       function f(x){x<7||x>8||f.a||x++;alert(f.a=' '.repeat(x)+`${f}f(${x});`.replace(/\d/,x))}f(7);
        function f(x){x<8||x>8||f.a||x++;alert(f.a=' '.repeat(x)+`${f}f(${x});`.replace(/\d/,x))}f(8);
         function f(x){x<9||x>8||f.a||x++;alert(f.a=' '.repeat(x)+`${f}f(${x});`.replace(/\d/,x))}f(9);

I misunderstood the rules earlier, so my previous answer was incorrect.

This one uses function hoisting instead of variable hoisting, so it doesn't depend on program 10. In fact, I think it's a quine for any combination of two or more concatenated programs.

Disclaimer: it's really late right now, so everything above could be completely wrong.

  • \$\begingroup\$ I don't think you need alert because of function output. \$\endgroup\$ Jan 4, 2016 at 4:07
  • \$\begingroup\$ Oh I see, nevermind. \$\endgroup\$ Jan 4, 2016 at 4:11
  • \$\begingroup\$ You can take out trailing semicolons, saving you 20 bytes. (Make sure to update the template string inside, too.) \$\endgroup\$ Jan 4, 2016 at 4:32
  • 1
    \$\begingroup\$ @ՊՓԼՃՐՊՃՈԲՍԼ I think the semicolons are needed for concatenation, since I'm not actually including the newlines. \$\endgroup\$
    – grc
    Jan 4, 2016 at 5:05
  • \$\begingroup\$ Nevermind again, then. \$\endgroup\$ Jan 4, 2016 at 5:06

Javascript ES6, 1935 bytes

Ten programs:

a=_=>{t=`a=${a};a()`;setTimeout(_=>alert(t.length>200?t:";".repeat(82)+'a=_=>{/*  */u=";".repeat(82)+"a="+a+";a();";this.t?t+=u:alert(u.length<198?u.replace((\\s)+g,"$0$1"):u)};a();'))};a()
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;a=_=>{/*  */u=";".repeat(82)+"a="+a+";a();";this.t?t+=u:alert(u.length<198?u.replace((\s)+g,"$0$1"):u)};a();
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;a=_=>{/*   */u=";".repeat(82)+"a="+a+";a();";this.t?t+=u:alert(u.length<198?u.replace((\s)+g,"$0$1"):u)};a();
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;a=_=>{/*    */u=";".repeat(82)+"a="+a+";a();";this.t?t+=u:alert(u.length<198?u.replace((\s)+g,"$0$1"):u)};a();
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;a=_=>{/*     */u=";".repeat(82)+"a="+a+";a();";this.t?t+=u:alert(u.length<198?u.replace((\s)+g,"$0$1"):u)};a();
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;a=_=>{/*      */u=";".repeat(82)+"a="+a+";a();";this.t?t+=u:alert(u.length<198?u.replace((\s)+g,"$0$1"):u)};a();
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;a=_=>{/*       */u=";".repeat(82)+"a="+a+";a();";this.t?t+=u:alert(u.length<198?u.replace((\s)+g,"$0$1"):u)};a();
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;a=_=>{/*        */u=";".repeat(82)+"a="+a+";a();";this.t?t+=u:alert(u.length<198?u.replace((\s)+g,"$0$1"):u)};a();
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;a=_=>{/*         */u=";".repeat(82)+"a="+a+";a();";this.t?t+=u:alert(u.length<198?u.replace((\s)+g,"$0$1"):u)};a();
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;a=_=>{/*          */u=";".repeat(82)+"a="+a+";a();";this.t?t+=u:alert(u.length<198?u.replace((\s)+g,"$0$1"):u)};a();
  • 4
    \$\begingroup\$ This is beautiful to look at. \$\endgroup\$ Jan 4, 2016 at 1:27
  • 4
    \$\begingroup\$ All those extra semicolons just to ensure that program 2 is longer than program 1... \$\endgroup\$ Jan 4, 2016 at 1:27
  • \$\begingroup\$ Could you maybe use the regex (\S)+ and the substitution $0$1 to save some bytes? \$\endgroup\$ Jan 4, 2016 at 15:25
  • \$\begingroup\$ @MartinBüttner Probably, I'll try this afternoon \$\endgroup\$ Jan 4, 2016 at 15:44

𝔼𝕊𝕄𝕚𝕟 2, 214 chars / 334 bytes

ℹ)đ ⬭ď9)?ℹ):⬭+ℹ)
 ℹ)đ ⬭ď9)?ℹ):⬭+ℹ)
  ℹ)đ ⬭ď9)?ℹ):⬭+ℹ)
   ℹ)đ ⬭ď9)?ℹ):⬭+ℹ)
    ℹ)đ ⬭ď9)?ℹ):⬭+ℹ)
     ℹ)đ ⬭ď9)?ℹ):⬭+ℹ)
      ℹ)đ ⬭ď9)?ℹ):⬭+ℹ)
       ℹ)đ ⬭ď9)?ℹ):⬭+ℹ)
        ℹ)đ ⬭ď9)?ℹ):⬭+ℹ)
         ℹ)đ ⬭ď9)?ℹ):⬭+ℹ)

Try it here (Firefox only).


ℹ)                // quine function: get source code
  đ ⬭ď9)          // are there 9 spaces in a row anywhere in the source?
        ?ℹ):      // if so, pass the source itself to implicit output
            ⬭+ℹ) // otherwise, add a leading space to the source and pass to implicit output

The program counts the searches for 9 spaces in a row, which is the amount of leading spaces in the 10th program. If it finds a match, then the source code is outputted; otherwise, the source code, lead by a space, is outputted.

  • \$\begingroup\$ Which encoding are you using? Seems to be 284 bytes on the ISO 8859-1 encoding. Tested here \$\endgroup\$
    – Downgoat
    Jan 4, 2016 at 6:34
  • \$\begingroup\$ I'm using UTF-8. \$\endgroup\$ Jan 4, 2016 at 8:03
  • \$\begingroup\$ I forgot that it's ESmin 2, so I read the char count as "2,214 chars" :P \$\endgroup\$ Jan 4, 2016 at 12:02

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.