Bidirectional Quine Chain

Question

PPCG hasn't had enough of quines already...

Challenge:

Your task is to create a program "A0". When this program is run with no input, it outputs nothing. When this program is run with input, it outputs "A1". When "A1" is run with no input, it outputs "A0". When "A1" is run with input, it outputs "A2". Pretty much, "A(k)" will output "A(k-1)" when run with no input, and will output "A(k+1)" when run with input.

Details

I believe this challenge is simple enough; there are no other rules really. Every program must contain at least 1 byte, by the way. You may assume that the input will consist of only ASCII characters, and you may ignore whitespace if you want, but you may not specify a specific input. Output may be to either STDOUT or STDERR, but all of your programs must output to the same one. The other one may also contain text (so you may output to STDOUT and then exit with an error). Thanks to @Dennis for pointing that out.

All programs must be in the same language, and each program must be unique from the rest of them.

The score is equal to the length of program "A0". As this is a code-golf challenge, the lowest score wins!

Answer 1

Pip, 28 bytes

V Y"I#qSti0+i?`V Y`.RPyRtiu"

Try it online!

Explanation

This is a modified version of the shortest known Pip quine V Y"`V Y`.RPy". That quine works by defining a string, yanking it into the y variable, and then evaluating it. When evaluated, the string takes the repr of y (thus wrapping the value of y in double quotes) and concatenates the pattern literal `V Y` to the front of it.

Our strategy is to put a 0 in the program, then replace 0 with 10 if there was input, or replace 10 with 0 if there was no input. (Thus, A(k) will contain a number consisting of k 1's followed by a 0.) 0 and 10 are convenient because there are built-in variables (i and t, respectively) with those values, so we can refer to them without using actual digits.

So instead of RPy, we want RP yRit if there was input and RP yRti if not. We can combine the two cases by swapping the values of t and i if there is input (I#q Sti), then doing RP yRti. (We have to test #q, the length of the input, because inputs like 0 are falsey.)

Now we just have to get a literal 0 in the code and handle the special case of A0 producing no output. Both can be solved by testing 0+i and returning u if it is falsey:

• For any k > 0, the number in A(k) will be nonzero and therefore truthy (e.g. 110+i).
• For k = 0, the number in A(k) will be zero:
  • If there is input, i and t are swapped and i is 10. 0+i is still truthy.
  • If there is no input, i is still 0 and 0+i is falsey. Instead of the quine core, we output u, which is a built-in variable for nil. Printing nil produces no output.

Answer 2

Python 2, 93 bytes

There is a trailing linefeed.

p=1+2*bool(input())-1;s='print"p=%r+2*bool(input())-1;s=%r*(p>0);exec s"%(p,s)'*(p>0);exec s

Try it with input | Try it without input

This is modified from my answer on a similar question.

If there is input, then it will increment p. So the resulting program will be p=2+..., p=3+..., etc.

Answer 3

Vyxal, 21 bytes

1`I$u?[N]+p`I$u?[N]+p

Try it Online!

The number on front is k.

1                     # Push 1 (or k)
 `I$u?[N]+p`          # Push a string containing part of the program code
            I         # Quinify, unevaling and appending
             $        # Swap with k
              u?[N]   # Push 1 if input, else -1
                   +  # Add
                    p # Prepend to the string

Answer 4

PARI/GP, 67 bytes

(f=(a)->(a+=(-1)^!readstr("/dev/stdin"))&&print("(f="f")("a")"))(1)

Attempt This Online!

PARI/GP doesn't have a built-in to read a string from stdin. The shortest workaround I can find is readstr("/dev/stdin"), which only works on unix-like systems.