[Question]
  [
*Disclaimer: This is heavily inspired by ["Polyglot the OEIS!"](https://codegolf.stackexchange.com/questions/137846/polyglot-the-oeis) but fixes the problem that lead to closure (see the output section) and was re-posted as to not invalidate answers.*
## Introduction
We all know and love the *on-line encyclopedia of integer sequences* ([OEIS](https://oeis.org/)). So what if we made an *off-line* version of the interesting sequences? Well, that would be kinda too easy, wouldn't it and how would you select a sequence with our standard interface!? No. We need an easier solution to this. A polyglot!
## Input
Your input will be a non-negative integer `n`.
## Output
Your output will either be
* The `n`-th entry of an OEIS sequence OR
* The first `n` entries of an OEIS sequence.
You may take the index to be 1-based or 0-based as you prefer.
To not make this question a duplicate of *[The versatile integer printer](https://codegolf.stackexchange.com/q/65641/55329)* **constant sequences are banned.** This should also increase the difficulty level of submissions and avoid "boring" solutions ;)
A sequence is non-constant if there exist two sequence members that are unequal.
## Uhm, so where is the Challenge?
You have to polyglot the above functionality. That is if you support languages A, B and C all must implement different OEIS sequences. The choice of sequence is not limited except that you need different ones for all languages.
That is, if you run the provided program in language A, then sequence X shall be generated, if you run the provided program in language B, then sequence Y shall be generated (with X!=Y) and if you run the provided program in language C, then sequence Z shall be generated (with X!=Z && Y!=Z).
## Who wins?
The answer with the most sequence/language pairs wins. First tie-breaker is code-size (in bytes) with lower being better. Second tie-breaker is submission time with earlier being better.
## Any final Words / Rules?
* You must declare which language will generate which sequence.
* [Standard I/O rules apply.](https://codegolf.meta.stackexchange.com/q/2447/55329)
* If different encodings are used between languages, both programs must use the same byte-sequence.
* Language (Python 2/3) revisions *do* count as different languages. Different implementations of a language (such as Browser JS vs Node.js) also count as different languages.
* [Standard loopholes apply.](https://codegolf.meta.stackexchange.com/q/1061/55329)
  
[Answer]
# 3 languages (1 byte) - [Pyth](https://pyth.readthedocs.io) ([A001477](https://oeis.org/A001477)), [MATL](https://github.com/lmendo/MATL) ([A000027](https://oeis.org/A000027)), [Braingolf](https://github.com/gunnerwolf/braingolf) ([A000217](https://oeis.org/A000217))
```
Q
```
* **[Try Pyth online!](https://tio.run/##K6gsyfj/P/D/fxMA)**, 0-indexed (non-negative integers)
* **[Try MATL online!](https://tio.run/##y00syfn/P/D/fxMA)**, 0-indexes (positive integers)
* **[Try Braingolf online!](https://tio.run/##SypKzMxLz89J@/8/8P///yYA)**, 1-indexed (triangular numbers)
---
# How?
`Q` does the following:
* In MATL, it means `+ 1`, so it basically evaluates to `input + 1`.
* In Pyth, it means input, so it just outputs the input.
* In Braingolf, it is the built-in for triangular numbers.
## Mini-polyglot
**[Pyth](https://tio.run/##K6gsyfj/P/D/fxMA)** can be replaced by any of the following languages: **[GolfScript](https://tio.run/##S8/PSStOLsosKPn/P/D/f0MA)**, **[Pyke](https://tio.run/##K6jMTv3/P/D/fxMA)**, **[Brachylog](https://tio.run/##SypKTM6ozMlPN/r/P/D/f@P//gA)** or **[Brain-Flak](https://tio.run/##SypKzMzTTctJzP7/P/D/f0MA)**.
[Answer]
# 10 languages, 122 bytes
```
#|A=1:0;~@}{\,[.,];oi
#coding:utf-8
print (0 and gets.to_i-1 or int(input())**(2+(1/2>0)));quit()#⎚Ｉ±Ｎ»
# x
#x%:+.
```
I definitely can add a bunch more. 1-indexed unless otherwise specified.
Note that I may not be up-to-date on TIO links when I'm sure newer changes didn't affect older programs - you can test them if you want to, but copying 10+ new TIO links every time I make a change gets tiring after a bit. I'll copy new ones every 5 updates or so.
# cQuents v0, [A000007](https://oeis.org/A000007)
Relevant code: `#|A=1:0;`
`#|A` catches the input and is there for Python comments. `=1` means the first item is `1`, `:0` mean the rest are `0`, outputs the `n`th term given input `n`. cQuents v0 has a weird bug/feature that when an unexpected but valid token, such as `;`, is read, it causes parsing to end.
[Try it online!](https://tio.run/##Sy4sTc0rKf7/X7nG0dbQysC6zqG2OkYnWk8n1jo/k0s5OT8lMy/dqrQkTdeCq6AoM69EA4ILSks0NDW1tDSMtDUM9Y3sDDQ1Na0LSzOBosqP@ma937Py0Mb3e9Yd2v3/v6EBAA "cQuents – Try It Online")
# PingPong, [A001478](http://oeis.org/A001478)
Relevant code: `#|A=1:0;~@`
***Outputs via exit code.*** 0-indexed.
`#` skips the next char. `=` does nothing here. `1` pushes `1`, and `:` prints `1` to STDOUT. `0` pushes `0`. `)` does nothing. `;` pushes input, `~` pops and pushes `-n-1`. `@` terminates. The exit code is the top of the stack.
[Try it online!](https://tio.run/##K8jMSy/Iz0v//1@5xtHW0MrAus6htjpGJ1pPJ9Y6P5NLOTk/BajEqrQkTdeCq6AoM69EA4ILSks0NDW1tDSMtDUM9Y3sDDQ1Na0LSzOBosqP@ma937Py0Mb3e9Yd2v3/v6EBAA "PingPong – Try It Online")
# axo, [A001477](http://oeis.org/A001477)
Relevant code: `}{\`
0-indexed. `}` reads and pushes an integer from STDIN (requires trailing newline for some reason), `{` prints an the top of stack, and `\` ends the program. I'm not sure what the preceding characters do, but nothing that matters in this case.
[Try it online!](https://tio.run/##S6zI//9fucbR1tDKwLrOobY6RidaTyfWOj@TSzk5PyUzL92qtCRN14KroCgzr0QDggtKSzQ0NbW0NIy0NQz1jewMNDU1rQtLM4Giyo/6Zr3fs/LQxvd71h3a/f@/oQEXAA "axo – Try It Online")
# brainfuck, [A000027](https://oeis.org/A000027)
Relevant code: `,[.,]`
Simple cat program from esolangs.org. Outputs the input.
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fucbR1tDKwLrOobY6RidaTyfWOj@TSzk5PyUzL92qtCRN14KroCgzr0QDggtKSzQ0NbW0NIy0NQz1jewMNDU1rQtLM4Giyo/6Zr3fs/LQxvd71h3a/f@/oQEA "brainfuck – Try It Online")
# ><>, [A000030](https://oeis.org/A000030)
Relevant code: `#` ... `;oi`
`#` mirrors and wraps to the right, which direct it to read `io;`, which outputs the first character of the input. 0-indexed.
[Try it online!](https://tio.run/##S8sszvj/X7nG0dbQysC6zqG2OkYnWk8n1jo/k0s5OT8lMy/dqrQkTdeCq6AoM69EA4ILSks0NDW1tDSMtDUM9Y3sDDQ1Na0LSzOBosqP@ma937Py0Mb3e9Yd2v3/v6EBAA "><> – Try It Online")
# Ruby, [A023443](https://oeis.org/A023443)
Relevant code: `print (0 and gets.to_i-1` ... `)`
0-indexed. Prints the input minus 1. `0` is truthy in Ruby, but falsey in Python.
[Try it online!](https://tio.run/##KypNqvz/X7nG0dbQysC6zqG2OkYnWk8n1jo/k0s5OT8lMy/dqrQkTdeCq6AoM69EQcNAITEvRSE9taRYryQ/PlPXUCG/SAEoo5GZV1BaoqGpqaWlYaStYahvZGegqalpXViaCRRVftQ36/2elYc2vt@z7tDu//@NDAA "Ruby – Try It Online")
# Python 3, [A000578](http://oeis.org/A000578)
Relevant code: `print (0 and gets.to_i-1 or int(input())**(2+(1/2>0)));quit()`
Ripped off of HyperNeutrino's original post, but it's a pretty well-known polyglot. `quit()` ends the program.
[Try it online!](https://tio.run/##K6gsycjPM/7/X7nG0dbQysC6zqG2OkYnWk8n1jo/k0s5OT8lMy/dqrQkTdeCq6AoM69EQcNAITEvRSE9taRYryQ/PlPXUCG/SAEoo5GZV1BaoqGpqaWlYaStYahvZGegqalpXViaCRRVftQ36/2elYc2vt@z7tDu//@NDAA "Python 3 – Try It Online")
# Python 2, [A000290](https://oeis.org/A000290)
Relevant code:
```
#coding:utf-8
print (0 and gets.to_i-1 or int(input())**(2+(1/2>0)));quit()
```
`#coding:utf-8` is required for the Charcoal stuff to work. Also ripped off of HyperNeutrino's original post. `quit()` ends the program.
[Try it online!](https://tio.run/##K6gsycjPM/r/X7nG0dbQysC6zqG2OkYnWk8n1jo/k0s5OT8lMy/dqrQkTdeCq6AoM69EQcNAITEvRSE9taRYryQ/PlPXUCG/SAEoo5GZV1BaoqGpqaWlYaStYahvZGegqalpXViaCRRVftQ36/2elYc2vt@z7tDu//@NDAA "Python 2 – Try It Online")
# Charcoal, [A001489](https://oeis.org/A001489)
Relevant code: `⎚Ｉ±Ｎ»`
0-indexed. `⎚` clears the console (Charcoal prints ASCII as-is) and `Ｉ±Ｎ` prints the negative of the input. `»` is a parse error and terminates the program.
Thanks to ASCII-only for help in chat.
[Try it online!](https://tio.run/##S85ILErOT8z5/1@5xtHW0MrAus6htjpGJ1pPJ9Y6P5NLOTk/JTMv3aq0JE3XgqugKDOvREHDQCExL0UhPbWkWK8kPz5T11Ahv0gBKKORmVdQWqKhqamlpWGkrWGob2RnoKmpaV1YmgkUVX7UN@v9npWHNr7fs@7Qbi5lhQou5QpVK229//8NAQ "Charcoal – Try It Online")
# Cardinal, [A020725](https://oeis.org/A020725)
Relevant code:
```
 x
x%:+.
```
Adds 1 to the input, and squashes all other pointers.
[Try it online!](https://tio.run/##S04sSsnMS8z5/1@5xtHW0MrAus6htjpGJ1pPJ9Y6P5NLOTkfKJ9uVVqSpmvBVVCUmVeioGGgkJiXopCeWlKsV5Ifn6lrqJBfpACU0cjMKygt0dDU1NLSMNLWMNQ3sjPQ1NS0LizNBIoqP@qb9X7PykMb3@9Zd2g3l7JCBZdyhaqVtt7//4YA "Cardinal – Try It Online")
[Answer]
# 5 languages ([05AB1E](https://github.com/Adriandmen/05AB1E), [Actually](https://github.com/Mego/Seriously), [CJam](https://sourceforge.net/p/cjam), [Jelly](https://github.com/DennisMitchell/jelly), [MATL](https://github.com/lmendo/MATL)), 7 bytes
```
UD>li)+
```
Try it online!:
* [**05AB1E**](https://tio.run/##MzBNTDJM/f8/1MUuJ1NT@/9/QwsA): sequence [A000027](https://oeis.org/A000027) (positive integers: *a*(*n*) = *n*; 1-based)
* [**Actually**](https://tio.run/##S0wuKU3Myan8/z/UxS4nU1P7/39TEwA): sequence [A023443](https://oeis.org/A023443) (non-negative integers including 1: *a*(*n*) = *n*−1; 0-based)
* [**Cjam**](https://tio.run/##S85KzP3/P9TFLidTU/v/f1MA): sequence [A020725](https://oeis.org/A020725) (positive integers excluding 1: *a*(*n*) = *n*+1; 1-based)
* [**Jelly**](https://tio.run/##y0rNyan8/z/UxS4nU1P7////pgA): sequence [A005843](https://oeis.org/A005843) (non-negative even numbers: *a*(*n*) = 2\**n*; 0-based)
* [**MATL**](https://tio.run/##y00syfn/P9TFLidTU/v/fxMA): sequence [A000290](https://oeis.org/A000290) (squares: *a*(*n*) = *n*2; 1-based). Exits with an error after producing the output.
[Answer]
# 3 languages: Proton, [A000583](http://oeis.org/A000583); Python 3, [A000578](http://oeis.org/A000578); Python 2, [A000290](https://oeis.org/A000290)
## [Proton](https://github.com/alexander-liao/proton), 49 bytes
```
print(int(input())**(2+(1/2>0)+((''',''')!=',')))
```
[Try it online!](https://tio.run/##KyjKL8nP@/@/oCgzr0QDggtKSzQ0NbW0NIy0NQz1jewMNLU1NNTV1XWAWFPRFkhramr@/28KAA "Proton – Try It Online")
## [Python 3](https://docs.python.org/3/), 49 bytes
```
print(int(input())**(2+(1/2>0)+((''',''')!=',')))
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EA4ILSks0NDW1tDSMtDUM9Y3sDDS1NTTU1dV1gFhT0RZIa2pq/v9vCgA "Python 3 – Try It Online")
## [Python 2](https://docs.python.org/2/), 49 bytes
```
print(int(input())**(2+(1/2>0)+((''',''')!=',')))
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69EA4ILSks0NDW1tDSMtDUM9Y3sDDS1NTTU1dV1gFhT0RZIa2pq/v9vCgA "Python 2 – Try It Online")
# Explanation
Proton doesn't have `'''...'''` strings, so `(''',''')` becomes `('' ',' '')`, which somehow doesn't cause issues. It evaluates to `''`, making `(''',''')!=','` evaluate to `True`.
Python does have these strings, so `(''',''')` is just `','` so `(''',''')!=','` evaluates to `False`.
Python 2 uses floor division for integers, so `1/2>0` is false in Python 2 and true in Python 3.
[Answer]
## 5 Languages, 107 bytes
```
s=1/2;1//2;q=int(input())*([2,3][s>0]);"""/.__id__;'
alert(+prompt()+1);`"""#=;#';q=gets
print(q)#)|<>%2)#`
```
### Perl: [A000035](http://oeis.org/A000035)
Using `=` as a delimiter for `s///` means we can easily exclude code we don't want, and using `)` as the delimiter for `q{}` means after `print`ing `q` in all other languages, we can just work on `<>` directly, without worrying.
```
s/1...q/i...#/;
print(<>%2)
```
[Try it online!](https://tio.run/##FcxBDoMgEEDRvceAGJlqpNC4GvEixmCTkobE2hHorndH3PzVyycXtiHnaJTUqGTJYfyehN/plwTATcy6eyxznO4LIGNM9tb6l7XYVM/NhSRaCt8PFdsqwLUIbpA3ZfN2KVYUrtsBHP7jVGvga87DCQ "Perl 5 – Try It Online")
### Ruby: [A001477](http://oeis.org/A001477)
In Ruby, `//` is actually `/` (divide by) `/.../` (regex match), so as long as the regex is terminated, and converted to a number, we can divide by it safely. `__id__` is shorter than `.to_s.ord`, then we just contain the rest of the code we don't want in `'`s, set `q` to `gets` and `print` it with all the others.
```
s=1/2;1//2..."/.__id__;'...';q=gets
print(q)
```
[Try it online!](https://tio.run/##KypNqvz/v9jWUN/I2lAfSBTaZuaVaGTmFZSWaGhqamlEG@kYx0YX2xnEalorKSnp68XHZ6bEx1urcyXmpBaVaGgXFOXnFgDVahtqWicAVSjbWiurA41JTy0p5iooAplWqKmsWWNjp2qkqZzw/78pAA "Ruby – Try It Online")
### Python 2: [A005843](http://oeis.org/A005843)
Using the standard trick to differentiate 2 from 3 and enclosing stuff we don't want in `"""` and comments.
```
s=1/2;1//2;q=int(input())*([2,3][s>0]);"""/...`"""
print(q)
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v9jWUN/I2lAfSBTaZuaVaGTmFZSWaGhqamlEG@kYx0YX2xnEalorKSnp68XHZ6bEx1urcyXmpBaVaGgXFOXnFgDVahtqWicAVSjbWiurA41JTy0p5iooAplWqKmsWWNjp2qkqZzw/78pAA "Python 2 – Try It Online")
### Python 3: [A008585](http://oeis.org/A008585)
[Try it online!](https://tio.run/##K6gsycjPM/7/v9jWUN/I2lAfSBTaZuaVaGTmFZSWaGhqamlEG@kYx0YX2xnEalorKSnp68XHZ6bEx1urcyXmpBaVaGgXFOXnFgDVahtqWicAVSjbWiurA41JTy0p5iooAplWqKmsWWNjp2qkqZzw/78pAA "Python 3 – Try It Online")
### JavaScript (ES6 browser): [A000027](http://oeis.org/A000027)
Pretty straightforward for JS, it ended up being easier not to re-use the existing `print` and go for SpiderMonkey, but that might also be possible too.
```
s=1/2;1//2;q=int(input())*([2,3][s>0]);"""/.__id__;'
alert(+prompt()+1);`"""#=;#';q=gets
print(q)#)|<>%2)#`
```
[Answer]
# 6 languages: Cubically 5/6/7/8/9/10, ~~44~~ ~~40~~ 32 bytes
[Crossed out 44 is still regular 44 ;(](https://codegolf.stackexchange.com/a/153011/61563)
```
DDR'DDR$:_0?{R'DDRDDB'%0}!{+00%}
```
This prints:
* [A010710](http://oeis.org/A010710) in Cubically 5x5x5
* [A010711](http://oeis.org/A010711) in Cubically 6x6x6
* [A010712](http://oeis.org/A010712) in Cubically 7x7x7
* [A010713](http://oeis.org/A010713) in Cubically 8x8x8
* [A010714](http://oeis.org/A010714) in Cubically 9x9x9
* [A010715](http://oeis.org/A010715) in Cubically 10x10x10
Explanation:
```
DDR'DDR$:_0?{R'DDRDDB'%0}!{+00%}
DDR'DDR                            get top face sum to 2 (all versions)
       $:                          read input and set notepad to it
         _0                        set notepad to input modulo 2
           ?{...........}          if truthy
             R'DDRDD                reset cube
                    B'              set top face to Cubically version number
                      %0            print top face
                         !{....}   if falsy
                           +00      add 2 to notepad twice
                              %     print
```
[Try it online!](https://tio.run/##Sy5NykxOzMmp/P8/SN0lyEUdRKpYmccb2JtVA9nqQS5g0kld1aBW0azaykDbQNWs9v9/s/9mAA) (Cubically 6x6x6)
]