An OEIS polyglot

Question

This is an answer-chaining challenge relating to the OEIS.

Oh, the justification for this is because a company needs one program to print out their OEIS sequences real bad and they have every language.

The answer-chaining format works in the following way:

Someone posts the first answer, from which all further solutions stem. This answer is a program that, given a number N, inputs the Nth number in OEIS sequence of whatever index they choose (we'll call it sequence 1), in whatever language they choose (language 1)

Someone else comes along and chooses their own sequence (that has to be different from the previous, and from all previous sequences). They make a program, in another language (which has to be different from all previous languages), that given a number N in the language 1 outputs the Nth number of sequence 1 and, given a number in language 2 outputs the Nth number of sequence 2.

This process continues ad infinitum.

The nth term of a sequence is the term that comes n times after the first, working from the first item. Here we use 0 and 1-indexing, to be easy on the coders!

No language or sequence reusing.

Input must be an integer or a string representation of an integer and output must be the correct value of the sequence. Error handling (non-int input) is not needed.

You must not post twice in a row.

You must wait an hour or more before posting again.

Whoever is the SECOND-to-last to post after a week of no answers (the person who didn't break the chain) wins, though the contest can continue indefinitely. If you're last and can show that you can add one more language to it, you continue the challenge until the next winner.

You can assume that the input or the output won't be outside the numerical range of your language (for example, assuming that IEEE's limit won't be surpassed by any sequence) but don't be a trickster and abuse this by using a language that only has 1.

Any sequence can be chosen, as long as it hasn't been used before.

The input cannot be out-of-bounds for the sequence you are using.

Two different language versions are different languages (Python 2 and Python 3 are considered different langs of their own). This isn't rigid, but as a rule of thumb, if it's separated from another version of the same language on TIO, it's different.

This isn't banned, but try once not to use the formula the OEIS gives.

If your resulting code is over 65536 characters long, provide a link to access it (e. g. Pastebin).

That's it and that's all. Ready? Set? FUN!

Yes, this IS "One OEIS after another" but put on multiplayer. I thought it'd be cool.

Answer 1

15. Commentator, A020739

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC//*/0#
/*	
박망희		   		0#
;*/	
 	

n=>5/2>2?1:40-n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Try it online!

C#
Brainfuck
Runic Enchantments
Jelly
Gol><>
Javascript (Node.js) (All 1s)
Parenthetic
Whitespace (All 3s)
05AB12 (All 0s)
Unreadable
Grass
Width
AlphaBeta
Aheui (All 2s)

I had a few plans with Commentator, but only one survived contact with all the other languages. One caused errors in the Jelly (iirc) and I wasn't able to resolve it because I don't know why Jelly interpreted the bytes the way it did.

Answer 2

4. Jelly, A000312

n=>40-n//
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
       //ip@
       //
;/**/

C# (Visual C# Interactive Compiler)
brainfuck
Runic Enchantments
Jelly

Explanation:

We only account for the last line, all of the other lines are ignored.

;/**/ Argument: z
;/    Reduce z by ; (concatenation) [1]
      z is an integer, so this just returns z itself.
   */ Reduce z by * (exponentiation) [2]
      Again, this returns z itself.
  *   Exponentiation: return [1] ** [2]
      This resolves to (z ** z).

To make C# ignore the code, we're trying to put it in a comment. However, a line starting with / isn't valid in Jelly, because / needs an operand. The operand we're using here is ;, since that also fits perfectly as a semicolon in C#. In fact, the semicolon and empty multi-line comment together make a link that calculates \$^2z=z^z\$. Note that the function submission in C# is still valid, as there's no general consensus disallowing multiple statements in an anonymous function submission (e.g. imports).

Answer 3

16. Java 8, A000290

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC//*/0e#'
/*  
박망희             0#
;*/ 
    //\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip@
                          //
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Never thought I'd see the day where I would be able to add a Java answer as 16th answer in a polyglot-chain! :D

1. Try it in C#: \$a(n)=40-n\$
2. Try it in brainfuck: \$a(n)=1+n\text{ mod }2\$
3. Try it in Runic Enchantments: \$a(n)=4^n\$
4. Try it in Jelly: \$a(n)=n^n\$
5. Try it in Gol><>: \$a(n)=-n\$
6. Try it in JavaScript: \$a(n)=1\$
7. Try it in Parenthetic: \$a(n)=1\text{ if }x^n+y^n=z^n\text{ has a nontrivial solution in integers, otherwise }a(n)=0\$
8. Try it in Whitespace: \$a(n)=3\$
9. Try it in 05AB1E: \$a(n)=0\$
10. Try it in Unreadable: \$a(n)=n\$
11. Try it in Grass: \$a(n) = \lfloor n/10^\left(\lfloor log_{10}(n)\rfloor\right)\rfloor\$
12. Try it in Width: \$a(n)=n+1\text{ with }n\geq2\$
13. Try it in AlphaBeta: \$a(n)=1\Vert n\$
14. Try it in Aheui: \$a(n)=2\$
15. Try it in Commentator. \$a(n)=2n+6\$
16. Try it in Java 8: \$a(n)=n^2\$

Explanation:

Let me start by saying that although I've heard from each of these languages before here on CGCC, I'm only skilled with Java, C#, 05AB1E, and Whitespace, and apart from that can read the JavaScript part of the code. The other languages are mostly unfamiliar for me, so I hoped after the changes I had in mind to make the Java interact with C#/JavaScript, most other languages would still work.

The first main thing to tackle was Java's n-> vs C#/JavaScript's n=>. Java support unicode values as part of the code, so using the following:

//\u000A\u002F\u002A
n=>//\u002A\u002Fn->

Will be interpret as this in C#/JavaScript:

//\u000A\u002F\u002A
n=>//\u002A\u002Fn->

But as this in Java:

//
/*
n=>//*/n->

This is because \u000A is a line-break, \u002F is / and \u002A is * in Java.

Then to differentiate the sequence between Java vs C#/JavaScript I added the following:

""+n==""+n?...:n*n

where ... is the existing 5/2>2?1:40-n, and n*n is the Java part of the code for oeis sequence A000290 (squares a.k.a. \$a(n)=n^2\$).

Why does this work? In Java Strings are Objects, where == is used to check if references of objects are pointing to the same place (or to check if primitives are equal), and the actual Object.equals(Object) has to be used to check if the values of these Objects are the same. So ""+n==""+n will be falsey in Java, but truthy in C#/JavaScript.

---

After that was tackled (by re-using the existing newlines to not break the Whitespace program), some things had to be fixed. Four of the existing programs were failing now: Runic Enchantments, Jelly, Unreadable, and Commentator.

The fix for Unreadable was easy. We added four """" before the first ', so we simply put the ' somewhere earlier (I placed it at the end of the first line), and remove the leading '"""" from the Unreadable part of the code at the bottom.

After that came Jelly, which was giving an IndexError: pop from empty list. I'm not too skilled in Jelly, so I don't exactly know why it gave this error. If I remember correctly the last line will be the main-link of a Jelly program, and because the code in that last line doesn't use any of the other links, everything else should be ignored. But somehow the part ""+n==""+n still gave some issues. I was able to fix this by adding /**/ in front of that line.

As for Runic Enchantments, it didn't output anything anymore. @Draco18s pointed out to me that Runic Enchantments starts at all > simultaneously, but only the >2?1:40-n/ and /ip@ were relevant. This was a huge help to understand the flow of the Runic Enchantments program, and I was able to fix the path by adding a /**/ at >2?1:40-/**/n:n*n, and changing the positions of the //ip@, //, and space on the last line.

All that's left was Commentator. At that point I realized that my previous fixes of adding /**/ weren't such a good idea after all, since it would output a bunch of additional rubbish due to the builtins /* (convert active to unicode character and output) and */ (output active as number).. >.> After a bit of fiddling around and trying some things, the fix turned out to be very easy: I've added an e before the # on the first line. e# is the builtin to negate an active, fixing the issues caused by the code I added (apparently).

Answer 4

6. JavaScript (Node.js), A000012

//
n=>5/2>2?1:40-n//
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
               //ip@
               //
;/**/
//I01-* h
//
 ;/**/

C# (A022996): Since 5/2==2 the function returns 40-n (Line 2)

BF (A000034): The added part only pushes the whole tape one cell to the right, others unchanged (Line 2-3)

Runic (A000302): The ? after 2 skips the 1:, and other operations follows from 4 (Line 2)

Jelly (A000312): Unchanged last line

Gol><> (A001489): Unchanged first column

JS(ES6) (A000012): Since 5/2>2 the function returns 1 (Line 2)

Sneaked the ternary 5/2>2?1:40-n into the C# part. In C# since 5/2==2 the function returns 40-n, while in JS 5/2>2 the functions returns 1. The C-style comments made it nearly impossible to add more practical languages (specifically C and Python). More spaces are added on lines 4-5 to ensure that the Runic part works.

Answer 5

8. Whitespace, A010701

//   
	
		   		
	
 	

n=>5/2>2?1:40-n//(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
               //ip@
               //
;/**/
//I01-* h
//
 ;/**/

Try it online!

C#
Brainfuck
Runic
Jelly
Gol><>
Javascript
Paranthetic

I have no idea how Whitespace works. I tried super hard to multiply the input with another value, but it kept complaining about infix arithmetic, so as I had input working, output working, and push-value-to-stack working, so I just went with that.

The input value appears to get lost when pushing 3 to the stack, but oh well. Enjoy a sequence of 3s. The program does technically take input it just ends up discarding it.

_{I also don't know how Paranthetic works, so I can't actually verify that submission as valid, but as far as I can tell the Whitespace code doesn't interfere.}

_{Future answers: be aware that tabs in Runic are a single instruction wide and play havoc with code layout.}

Answer 6

11. Grass, A000030

//0q   
	
		   		
	
 	

n=>5/2>2?1:40-n//(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Try it online!

Grass ignores all characters except w, v and W; conveniently, these three characters are ignored by several of the previously used languages. Luckily, sequence A000030 (return the initial digit in base 10) was still available, as coding even slightly complicated functions in Grass is beyond my ability.

C#
brainfuck
Runic
Jelly
Gol><>
JavaScript
Parenthetic
Whitespace
05AB1E
Unreadable

The relevant part for Grass is wvWwwWWwwwwwwWwWWWw. Here is my (probably flawed) understanding of how it works: the stack is initialized as OUT::SUCC::w::IN::ε (that w is just the character w). Each instruction adds an element to the stack (they are never popped); the number of ws or Ws indicates how deep to go in the stack; v separates instructions.

wv        # identity
Www       # identity OUT
WWwwwwww  # identity IN (read in 1 character)
Ww        # apply the function identity IN
WWWw      # apply the function identity OUT to the value at the top of the stack

If the input is 1234, at the end, the stack probably looks like this: 1::1::id IN::id OUT::id::OUT::SUCC::w::IN::ε.

It could be made shorter (don't need to define id OUT for example), but I stopped as soon as I found a version which worked.

If someone who knows Grass wants to correct/improve the explanation, please edit my answer!

Answer 7

17. Pepe, A000578

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC//*/0e#'
/*	
박망희		   		0#
;*/	
 	//\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip@
                          //rEeE rEeeEe reEE
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Online Interpreter

C#
Brainfuck
Runic Enchantments
Jelly
Gol><>
Javascript (Node.js) (All 1s)
Parenthetic
Whitespace (All 3s)
05AB12 (All 0s)
Unreadable
Grass
Width
AlphaBeta
Aheui (All 2s)
Commentator
Java

You'll have to excuse the Pepe link for not containing the full source: The interpreter disregards any code that is not Pepe (lit. any character not in the set RE re) and so its short link doesn't bother encoding it. Ditto input values.

Computes \$a(n) = n^3\$

The AlphaBeta has started throwing errors after writing output, but as a prior answer injected that issue I left it alone. I had planned on fixing it for this answer, but I need to spend some time digging into the jump offsets to resolve the issue. The error with inputs >0 are easy to fix, but giving it 0 will produce the same error and it will take time to relearn the code in order to fix the offset for it. I wish I could use W instead of UUUUUUUUUU, but it plays havoc with the Grass code.

Answer 8

1. C# (Visual C# Interactive Compiler) A022996

n=>40-n

Also works in C# (.NET Core), C# (Mono C# compiler), C# (Mono C# Shell), and C# (Visual C# Compiler)

Try it online!

Answer 9

7. Parenthetic, A019590

//
n=>5/2>2?1:40-n//(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
               //ip@
               //
;/**/
//I01-* h
//
 ;/**/

C# (A022996)

BF (A000034)

Runic (A000302)

Jelly (A000312)

Gol><> (A001489)

JS(ES6) (A000012)

Parenthetic (A019590)

Parenthetic ignores everything but the ( and ) characters. I've had to insert 1s before every closing parenthesis to stop Jelly from freaking out though (EDIT: I left one ) unpreceded by a 1, so apparently not all of them need one, but it's too late to golf it down now). The actual code defines a lambda called ((())), that can be called on a number to yield the result (1-indexed).

Answer 10

9. 05AB1E, A000004

//0q   
	
		   		
	
 	

n=>5/2>2?1:40-n//(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
               //ip@
               //
;/**/
//I01-* h
//
 ;/**/

C# (Visual C# Interactive Compiler)
brainfuck
Runic Enchantments
Jelly
Gol><>
JavaScript (Node.js)
Parenthetic
Whitespace
05AB1E

Answer 11

10. Unreadable, A001477

//0q   
	
		   		
	
 	

n=>5/2>2?1:40-n//(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Try it online!

C#
Brainfuck
Runic
Jelly
Gol><>
Javascript
Paranthetic
Whitespace
05AB1E

Unreadable, as its name suggests, is unreadable. In order to program it I had to use a template and then convert from readable text to Unreadable code.

[A=READ()];DO{(A+1)?:BOTH(PRINT(A),[A=READ()])}
[A=READ()]: '""""""'"""'""""""""""
PRINT(A): '"'"""""""'"""
A?: '""'"""
Functioning:
['""""""'"""'""""""""""];'"""""{('""'"""""""'""")?:'""""('"('"""""""'"""),['""""""'"""'""""""""""])}

All it does is read each character in the input and output it. One of the more boring sequences, but good for a language that's difficult to work with. I also toyed with using the sequence A000030 before getting the loop to work.

_{Working via remote desktop is a pain, you think things work, do all the links, then realize that one of them broke and didn't notice.}

Answer 12

14. Aheui, A007395

Slightly changed to make AlphaBeta works.

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC
/*  
박망희*/               



n=>5/2>2?1:40-n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Try it online!

Aheui dismiss any non-Korean character, so 박망희 excuted, which prints 2 and terminates.

C#
Brainfuck
Runic Enchantments
Jelly
Gol><>
Javascript (Node.js)
Parenthetic
Whitespace
05AB12
Unreadable
Grass
Width
AlphaBeta
Aheui

Answer 13

2. brainfuck, A000034

n=>40-n
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.

Try it online!

C#

Answer 14

3. Runic Enchantments, A000302

n=>40-n//
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
       //ip@
       //

Try it online!

C#

BF

If you need help keeping the Runic functional, there is the Esoteric IDE as well as my own IDE (built in Unity3D) in the master branch of Runic's git repo. Esoteric IDE doesn't handle displaying the IP directionality very well (primarily my own inability to add such to the existing framework).

All the BF creates a bunch of IPs that self terminate due to performing invalid actions (mainly due to stack underflow) while the > in the C# populates the stack with a 4, bounces of the comment makers (mirrors in Runic), reaching ip@ to execute x^4 on an input x and print the result.

Answer 15

5. Gol><>, A001489

//
n=>40-n//
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
       //ip@
       //
;/**/
//I01-* h
//
 ;/**/

Try it online!

C#
Brainfuck
Runic
Jelly

Use single-line comment markers in C# to redirect the Fish IP to the operative code, I01-*h, reading input, multiplying by -1, and outputting the result. Gol><> made reading input and dumping the stack as a number easy compared to raw ><>.

Spaces inserted to insure the proper flow of the Fish and Runic IPs, where both C# and Jelly ignore the leading whitespace on the last line (and is a NOP cell in both fungoids).

Answer 16

12. Width, A020725

//0q   
	
		   		
	
 	

n=>5/2>2?1:40-n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

1-indexed. Outputs by exit code.

Try it online!

The only relevant characters to Width are a-zA-Z. The code Width runs is the following:

qnnAcaAcAAI

The first three characters, qnn, are no-ops. Ac reads an integer from input, a is a no-op, and then AcAA increments the integer by one. I ends the program, and the top of the stack is becomes the exit code. All other letters in the program are ignored since the program terminated.

C#
brainfuck
Runic Enchantments
Jelly
Gol><>
JavaScript
Parenthetic
Whitespace
05AB1E
Unreadable
Grass

Answer 17

13. AlphaBeta, A162672

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC
	
		   		
	
 	

n=>5/2>2?1:40-n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Try it online!

I had originally planned to use sequence A000030 and the code JCL, but that got yoinked (I don't blame them, its a good sequence for languages that take input as single bytes). The original code for this entry after having to pick a new sequence was:

JiiiiihhZUUUUUNYAxcccccbCLDLxyzUUUUTTxxyzJCLOzWRxyxyzcccccbbCL
^                                                                 Read input (single byte)
                 ^          ^^^      ^^^^    ^  ^^^^^             Clear regisers
        ^                                            ^^^^^^^^^    Input = 0: print 0
 ^^^^^^^ ^^^^^                 ^^^^^^         ^                   Set jump locations
                  ^^^^^^^^                                        Print `1`
                          ^^                                      Print initial byte
                                         ^^^                      Read and print input
                                            ^                     (and loop)

Sequences of xxx or xyzxyz are useful spacers to make the jump-to targets easy values (46 is easier as "5*10-4"--9 instructions--than "4*10+6--ten instructions--but 50 is even simpler: only five). You'll see a fair few of those.

But as there are other bytes on the first line, the jump-to codels needed some new values and that turned into:

//0q   xxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzWRxyxyzcccccbbCL

Avoiding executing this code as Width code just involved wrapping it in G to make it a string literal (which does nothing important in AlphaBeta), a command to pop the top of the stack, and then some extra W to make alpha beta not crash when exiting:

//0q   GxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzWWWWWWRxyxyzcccccbbCLGw

To avoid conflicts with Grass, though, instead of popping the command with w C is used instead. Then the "exit program" jump is replaced with UUUUUU instead of WWWWWW This does leave the IP somewhere in the middle of the rest of the junk code, but far enough out that it doesn't print any errors. Any number of additional Us can be added in pairs if this becomes a problem.

//0q   GxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzUUUUUURxyxyzcccccbbCLGC

The additional i that Runic ends up executing is a NOP on valid inputs as no-input-left-to-read pushes nothing to the stack ("reading all input" is a pain in Runic).

C#
brainfuck
Runic Enchantments
Jelly
Gol><>
JavaScript
Parenthetic
Whitespace
05AB1E
Unreadable
Grass
Width

Answer 18

18. ]=[, A010716, the all 5's sequence

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC//*/0e#'[=====[===]]=[[==========]]=[
/*] 
박망희             0#
;*/ 
    //\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip@
                          //rEeE rEeeEe reEE
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

This language isn't on TIO and its only interpreter is written itself in another interpreted language, which is also not on TIO. And the one that didn't play nice with Brainfuck last week at the last minute, but I figured out what was wrong a few hours after posting the Pepe answer, so I saved it for this week. Being a language not on TIO I was considering this one an ace-in-the-hole that could easily be tacked onto just about ANY entry and continue the chain.

• Interpreter code: https://pastebin.com/raw/yqtpynnh
• Interpreter interpreter: https://12me21.github.io/12-basic/

Put the interpretter code into the "code" box at the top, code from the answer in the input, and click run and get an output (plus some extra junk that is always printed).

The operational portion of the ]=[ is this at the end of the first line:

[=====[===]]=[[==========]]=[

Its that trailing [ that played havoc with the Brainfuck (the rest being ignored, due to how [ and ] are handled by Brainfuck) and once I looked at the Brainfuck spec again I realized the problem and that all I had to do was insert a ] somewhere after the first line (as the ]=[ interpreter does not read newlines) and before the Brainfuck. I chose the 2nd line.

C#
Brainfuck
Runic
Jelly
Gol><>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
Unreadable
Grass
Width
AlphaBeta
Aheui (esotope)
Commentator
Java (OpenJDK 8)
Pepe

Answer 19

19. Actually, A005843 (2*n)

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC//*/0e#,2*1z⌂'[=====[===]]=[[==========]]=[
/*]	
박망희		   		0#
;*/	
 	//\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip@
                          //rEeE rEeeEe reEE
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Try it online!

Operational part: ,2*1z⌂ (first line)

As ⌂ terminates the program, none of the code after it has any effect, and none of the symbols before it result in any output or pollute operational memory adversely. Section exists within a comment (C#, JS, Java), only contains ignored characters (Commentator, ]=[, Pepe, Aheui...), is not on the last line (Jelly), or otherwise in un-executed parts of the code (Gol><>, Runic, AlphaBeta).

C#
Brainfuck
Runic
Jelly
Gol><>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
Unreadable
Grass
Width
AlphaBeta
Aheui (esotope)
Commentator
Java (OpenJDK 8)
Pepe
]=[ (link not possible, see #18 for instructions)

Answer 20

20. Neim, A008592 (10*n)

//0q   ÷GxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLxGC//*/0e#§≈2*1z⌂'>[=====[===]]=[[==========]]=[
/*]	
박망희		   		0#
;*/	
 	//\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip@
                          //rEeE rEeeEe reEE
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Try it online!

I have no idea how the heck Neim works. I know what the code here ends up doing, but I have no idea how the language itself works.

Also turns out I messed up the Brainfuck with #19. Due to command conflicts between multiple languages, changing Actually's input to § and then coercing it to an int with ≈ was the optimal solution.

C#
Brainfuck
Runic
Jelly
Gol><>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
Unreadable
Grass
Width
AlphaBeta
Aheui (esotope)
Commentator
Java (OpenJDK 8)
Pepe
]=[ (link not possible, see #18)
Actually

Answer 21

21. Flobnar, A010709 (All 4s)

//0q   ÷GxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLxGC//*/0e#§≈2*1z⌂'>[=====[===]]=[[==========]]=[
/*]	
박망희		   		0#
;*/	
 	//\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip!4@
                          //rEeE rEeeEe reEE
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Try it online!

Flobnar starts at @ and expands outwards evaluating items as the rules dictate (@ evaluates to whatever's on its left, 4 evaluates to 4, + evaluates to whatever's on the left summed with whatever's on the right, etc). As the placement of the @ only comes into contact with Runic, a simple ! prevents alteration of Runic's stack.

Given that Flobnar's input metric is "one byte" and goes into an infinite loop if there are no bytes to read, I decided not to bother with anything more complex.

Previous languages

C#
Brainfuck
Runic
Jelly
Gol><>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
Unreadable
Grass
Width
AlphaBeta
Aheui (esotope)
Commentator
Java (OpenJDK 8)
Pepe ]=[ (link not possible, see #18)
Actually
Neim