Multiplying Quines

Question

The program should start out with 2 separate files, here named "a" and "b". "a" and "b" should be what I am calling inverse quines: "a", when run, should output "b"'s source code, and "b", when run, should output "a"'s source code, for example:

./a
#source code of b, optionally followed by newlines
./b
#source code of a, optionally followed by newlines

If the outputs of "a" and "b" are then appended to the same file, here called "c", such as this:

touch c
./a >> c
./b >> c

The resulting file, "c", when run, should output the code of "a", followed by a newline, followed by the source code of "b" and a newline. The full running of these files should go as follows:

touch c
./a >> c
./b >> c
./c
#source code of a \n
#source code of b \n

Any coding languages can be used, and as this is code golf, the source code should be as small as possible.

There are no limits on what the source code of "a" and "b" can be, and newlines can be placed freely at the end of code outputs, such that the output ends in a single or a string of newlines.

Answer 1

Bash, ⁶³ 37 bytes

a

t=;x(){ cat $2 $1;};x b \

b

${t-cat} a

^{-26 bytes thanks to Nahuel Fouilleul}

Try it online!

quick explanation

There are two key tricks:

• We define our own version of cat called x which swaps its arguments, when there are 2 arguments given. It will have only 1 argument when a is run, but 2 arguments when c is run.
• b uses bash default arguments to accomplish what it needs. When t is undefined, as it will be when b is run alone, it becomes cat a. When t is defined, it just returns a, becoming the second argument to a command x b a.

Answer 2

05AB1E, 39 (20+19) bytes

Program a:

"34çìD«r»¨"34çìD«r»¨

Try it online.

Program b:

"34çìD«r»¨"34çìD«r»

Try it online.

Program c (concatenation of a+b):

"34çìD«r»¨"34çìD«r»¨"34çìD«r»¨"34çìD«r»

Try it online or try it online as pure quine.

Explanation:

Program a:

"34çìD«r»¨"           # Push string '34çìD«r»¨'
           34         # Push 34
             ç        # Convert it to a character: '"'
              ì       # Prepend it in front of the string: '"34çìD«r»¨'
               D      # Duplicate it
                «     # Merge the copy to itself: '"34çìD«r»¨"34çìD«r»¨'
                 r    # Reverse the items on the stack
                      # (no-op, since there is just a single item)
                  »   # Join all items on the stack by newlines
                      # (no-op, since there is just a single item)
                   ¨  # Remove the last character: '"34çìD«r»¨"34çìD«r»'
                      # (after which the result is output implicitly)

Program b:

The same as program a, but without the trailing ¨, so it'll output "34çìD«r»¨"34çìD«r»¨ (being program a) instead.

Program c:

"34çìD«r»¨"34çìD«r»¨  # It starts the same as program a
"34çìD«r»¨"           # Push string '34çìD«r»¨'
                      #  STACK: ['"34çìD«r»¨"34çìD«r»', '34çìD«r»¨']
           34çìD«     # Do the same as above
                      #  STACK: ['"34çìD«r»¨"34çìD«r»', '"34çìD«r»¨"34çìD«r»¨']
                 r    # Reverse the items on the stack
                      #  STACK: ['"34çìD«r»¨"34çìD«r»¨', '"34çìD«r»¨"34çìD«r»']
                  »   # Join all items on the stack by newlines
                      #  STACK: ['"34çìD«r»¨"34çìD«r»¨\n"34çìD«r»¨"34çìD«r»']
                      # (after which the result is output implicitly)

Answer 3

Ruby, 60 * 2 bytes

This is essentially a quine relay but within one language. Here is a.rb:

eval s=%q[1;puts "eval s=%q[#{s[0][?1]&&?2||?1}#{s[1..]}]"]

The b.rb is only different in one symbol:

eval s=%q[2;puts "eval s=%q[#{s[0][?1]&&?2||?1}#{s[1..]}]"]

Testing:

$ ruby b.rb > c.rb
$ diff c.rb a.rb
$ ruby a.rb > c.rb
$ diff c.rb b.rb
$ ruby b.rb >> c.rb
$ ruby c.rb
eval s=%q[1;puts "eval s=%q[#{s[0][?1]&&?2||?1}#{s[1..]}]"]
eval s=%q[2;puts "eval s=%q[#{s[0][?1]&&?2||?1}#{s[1..]}]"]