Chaining Programs

Question

Challenge

In this challenge, you will be writing the first program, p₁, of an infinite sequence of programs, in which running p_n outputs/generates program p_n+1. When concatenating the first n >= 2 programs, the sequence should output n.

Example

Let's say the first 4 programs are:

p1 p2 p3 p4

If I were to run p1, it should output:

p2

If I were to run p1p2, it should output:

2

If I were to run p1p2p3p4 it should output:

4

If I were to run p4, it should generate the next program in the sequence:

p5

Scoring

Your score is the byte count of the first 10 programs.

Answer 1

Pyth, 12

p1:

l"1

p2: 1

p3: 1

etc..

p1p2p3:

l"111 

Output: 3

Explanation:

l        length
 "1      string "1"

On first run, this outputs the length of a single character string, 1. This also happens to be a valid Pyth program, outputting 1 again. Therefore, pn+1 is always 1. When the programs are chained, p1 outputs the length of the chained programs, which will be n.

Answer 2

Lua, 950 900 bytes

s=io.open(arg[0]):read()if#s<95 then print(s)do return end end print(#s/90) do return end;

Ungolfed:

s=io.open(arg[0]):read'*a'
if #s < 96 then 
    print(s)
    do return end 
end 
print(#s/90) 
do return end;

Explanation:

The first line grabs the entire source of the program. Then we compare the length of the entire program to 1 + the length of one single program. If the size of the current program is smaller than this value, than the source is printed, which is the next program, p2, and we exit. Each iteration is just a quine. When several of these are put together, the the conditional fails, and we print the length of the concatenated program divided by the length of one program, which is the number of concatenated programs, n.

Answer 3

Vitsy, 14 bytes

Similar to the Pyth and Jolf answers, I'm mapping strings. The only difference is that I use the line wrapping features to make sure I always get the right length.

p1

'l3-N

p2

1

Replace 1 with any single number.

p3 and so on match this pattern, and you can do this until Integer.MAX_VALUE, the integer restriction of the language.

Explanation:

'l3-N
'     Wrap around the line until finding another '. Since no ' is found before the
      End of the line, it wraps around.
 l    Get the length of the stack.
  3-  Subtract three.
    N Output as number.

Try it online!

Answer 4

Vitsy, 19 bytes

Not dealing with strings here, but using method tricks.

p1

1ml1-\+N
1

p2

1

p3

1

So on, so forth.

Explanation below:

1ml1-\+N
1m       Execute the first index of lines (the bit with the ones)
  l1-    Get the length minus 1.
     \+  Add them all up.
       N Output as number.

1        Push one to the stack.

Try it online!

Answer 5

Seriously, 15 bytes

First program, 6 bytes (contains an unprintable):

5Ql-.

Hex Dump:

35516c2d2e7f

This program prints 1: Try it online

The rest of the programs are all 1, a valid program that prints itself just like the Pyth answer. The original program prints the length of its source code minus 5 and terminates immediately. 1s appended to the end increase the length of the source code by 1 byte each time, but never get executed.

Answer 6

Jolf, 14 bytes

Try it here!

a-lq4
a      print
  lq   the length of the source code
 -  4  minus 4

When executed, this prints 1. Thus, p2 = 1. Executing p2 yields 1. So, for all N > 1, pN = 1.

Observe p1p2: a-1q41. This transpiles to:

alert(sub(length("a-lq41"),4));
1;

Since implicit printing is disabled after the first print, this prints 2, as the length of the source code minus 4 is 2. And on and on and on.

Answer 7

Ruby, 318 bytes

p₁:

x=DATA.readlines.size
_="_=%p;puts _%%_"
puts x>0?x+1:_%_
__END__

Each separate program p_i outputs this one-line quine: _="_=%p;puts _%%_";puts _%_.

When you add these quines to the end of p₁, they end up as lines in the DATA object because they are below the magic __END__.

Here's a test:

$ ruby chain.rb                                    # running p1
_="_=%p;puts _%%_";puts _%_

$ ruby -e '_="_=%p;puts _%%_";puts _%_'            # running p2
_="_=%p;puts _%%_";puts _%_

$ ruby -e '_="_=%p;puts _%%_";puts _%_'            # running p3
_="_=%p;puts _%%_";puts _%_

$ # Concatenating p2 and p3 to p1:
$ ruby -e '_="_=%p;puts _%%_";puts _%_' >> chain.rb
$ ruby -e '_="_=%p;puts _%%_";puts _%_' >> chain.rb

$ ruby chain.rb                                    # running p1p2p3
3

The ten first programs concatenated looks like this (318 bytes):

x=DATA.readlines.size
_="_=%p;puts _%%_"
puts x>0?x+1:_%_
__END__
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_

Answer 8

C#, 2099 + 7 = 2106 bytes

First program (uses compiler flag /main:A):

class A{static void Main(){int a=System.Reflection.Assembly.GetEntryAssembly().GetTypes().Length;var b=@"class A{0}{{static void Main(){{var a=@""{1}"";System.Console.Write(a,{0}+1,a.Replace(""\"""",""\""\""""));}}}}";System.Console.Write(a>1?"{2}":b,0,b.Replace("\"","\"\""),a);}}

Second program:

class A0{static void Main(){var a=@"class A{0}{{static void Main(){{var a=@""{1}"";System.Console.Write(a,{0}+1,a.Replace(""\"""",""\""\""""));}}}}";System.Console.Write(a,0+1,a.Replace("\"","\"\""));}}

Third program:

class A1{static void Main(){var a=@"class A{0}{{static void Main(){{var a=@""{1}"";System.Console.Write(a,{0}+1,a.Replace(""\"""",""\""\""""));}}}}";System.Console.Write(a,1+1,a.Replace("\"","\"\""));}}

You get the idea.

Answer 9

Javascript ES6, score 483 455

Program 1, 77 bytes:

v=1;setTimeout(_=>alert(v>1?v:'a=_=>this.v?v++:alert("a="+a+";a();");a();'));

Program 2 and beyond, 42 bytes each:

a=_=>this.v?v++:alert("a="+a+";a();");a();

Answer 10

PHP, 1470 bytes

Program 1: 219 bytes:

class O{public$n=1;function __destruct(){echo($n=$this->n)>1?$n:'if(!$o->n++)echo str_replace(chr(9),$a=aWYoISRvLT5uKyspZWNobyBzdHJfcmVwbGFjZShjaHIoOSksJGE9CSxiYXNlNjRfZGVjb2RlKCRhKSk7,base64_decode($a));';}}$o=new O();

progam 2 and beyond 139 bytes:

if(!$o->n++)echo str_replace(chr(9),$a=aWYoISRvLT5uKyspZWNobyBzdHJfcmVwbGFjZShjaHIoOSksJGE9CSxiYXNlNjRfZGVjb2RlKCRhKSk7,base64_decode($a));

use like:

php -r "class O{public$n=1;function __destruct(){echo($n=$this->n)>1?$n:'if(!$o->n++)echo str_replace(chr(9),$a=aWYoISRvLT5uKyspZWNobyBzdHJfcmVwbGFjZShjaHIoOSksJGE9CSxiYXNlNjRfZGVjb2RlKCRhKSk7,base64_decode($a));';}}$o=new O();"

Uses a slightly golfed version the php quine technique detailed here: http://10types.co.uk/the-lab/a-minimal-php-quine/