[Question]
  [
The [On-Line Encyclopedia of Integer Sequences](https://en.wikipedia.org/wiki/On-Line_Encyclopedia_of_Integer_Sequences) (OEIS) is an online database of integer sequences. It contains nearly 280000 sequences of mathematical interest. 
Examples of sequences: 
* positive integers ([A000027](https://oeis.org/A000027))
* prime numbers ([A000040](http://oeis.org/A000040))
* Fibonacci numbers ([A000045](https://oeis.org/A000045))
Your task is to write a program or function that displays as many OEIS sequences as you can, with a source code of **100 bytes** maximum. Your program should accept as input the sequence id (without the prepending `A` and the zeroes), and output the 20 first numbers in that sequence.
You are not allowed to fetch the data directly from the OEIS website; all sequences must be computed by your code.
**Scoring**
Score is the number of OEIS sequences the program can display.
Answers will have to list the IDs of the sequences recognised by their program.
**Example**
Here's a valid answer in Java 8:
```
(int a) -> {
    for (int i = 0; i < 20; i++) {
        System.out.println(a==27?i+1:i*i); 
    }
};
```
This program can display the positive integers (A000027 - input 27) and the squares (A000290 - input 290), thus its score is 2.
**Note**
Please avoid scraping the whole OEIS website :-) you can download the [sequence names](https://oeis.org/names.gz) (about 3 megs) or [sequence values](http://oeis.org/stripped.gz) (about 9 megs). Note that this download is covered by the [OEIS End-User License Agreement](http://oeis.org/wiki/The_OEIS_End-User_License_Agreement).
  
[Answer]
## Python 2, 875 sequences
```
print', '.join('%020d'%(10**20/(input()-21004)))
```
Works for 875 of the sequences [21016](https://oeis.org/A021016) (decimal digits of 1/12) through [21999](https://oeis.org/A021999) (decimal digits of 1/995). 
I found this chunk with the sophisticated search algorithm of haphazardly typing in sequence id's by hand. Some of the sequences in the range are not of this format and appear elsewhere (thanks to Mitchell Spector for pointing this out). For example, [21021](https://oeis.org/A021021) is not the expansion of 1/17. 
Even with the interruptions, the sequences for 1/n appear as id `n+21004`. The remainder is not shifted, but the missing sequences appear elsewhere. For example, 1/17 appears as [7450](https://oeis.org/A007450). 
I counted the ones that match using [a downloaded copy](https://oeis.org/names.gz) of the sequence names.
A different block gives **848 sequences** from [16742](https://oeis.org/A016742) to [17664](https://oeis.org/A017664).
```
n=input()-16729
for i in range(20):k=n/12;a=int((8*k+1)**.5/2+.5);print(a*i+k-a*(a-1)/2)**(n%12+1)
```
These all have form `n -> (a*n+b)^c`, where `2≤a≤12, 0≤b<a, 1≤c≤12`. The code extracts the coefficients via inverting triangular numbers and moduli. As before, not all sequences in the range match. If these two expressions could fit in 100 bytes, it would give 1723 sequences.
Promising chunks:
* 1929 matching sequences: [41006](https://oeis.org/A041006) through [42397](https://oeis.org/A042937), numerators and denominators of continued fraction convergents.
* ~3300 matching sequences: [147999](https://oeis.org/A147999) to [151254](https://oeis.org/A151254): counts of walks on Z^3, if you can find how the vector lists are ordered.
Here are categories for other potential chunks, via grouping the OEIS sequence names by removing all numbers (digits, minus sign, decimal point). They are sorted by number of appearances.
```
3010    Number of walks within N^ (the first octant of Z^) starting at (,,) and consisting of n steps taken from {(, , ), (, , ), (, , ), (, , ), (, , )}
2302    Number of reduced words of length n in Coxeter group on  generators S_i with relations (S_i)^ = (S_i S_j)^ = I
979     Primes congruent to  mod 
969     Numerators of continued fraction convergents to sqrt()
967     Denominators of continued fraction convergents to sqrt()
966     Continued fraction for sqrt()
932     Decimal expansion of /
894     Duplicate of A
659     Partial sums of A
577     Divisors of 
517     Inverse of th cyclotomic polynomial
488     Expansion of /((x)(x)(x)(x))
480     Decimal expansion of th root of 
471     Number of nX  arrays with each element x equal to the number its horizontal and vertical neighbors equal to ,,,, for x=,,,,
455     First differences of A
448     Decimal expansion of log_ ()
380     Numbers n such that string , occurs in the base  representation of n but not of n+
378     Erroneous version of A
375     Numbers n such that string , occurs in the base  representation of n but not of n
340     Numbers n with property that in base  representation the numbers of 's and 's are  and , respectively
```
---
**35 sequences:**
```
c=input()
for n in range(20):print[(c-1010)**n,(c-8582)*n][c>2e3]
```
Works from [8585](https://oeis.org/A008585) (multiples of 3) through [8607](https://oeis.org/A008607) (multiples of 25), and [1018](https://oeis.org/A001018) (powers of 8) through [1029](https://oeis.org/A001029) (powers of 19). Conveniently, these are all in one chunk ordered by id. 
This uses only 65 of the 100 allowed bytes and isn't fully golfed yet, so I'll look for another nice chunk.
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + coreutils, 252 sequences
```
yes 0|head -20
```
[Try it online!](https://tio.run/nexus/bash#@1@ZWqxgUJORmpiioGtk8P8/AA "Bash – TIO Nexus")
Works on 252 OEIS sequences:
A000004, A006983, A011734, A011735, A011736, A011737, A011738, A011739, A011740, A011741, A011742, A011743, A011744, A011745, A023975, A023976, A025438, A025439, A025443, A025444, A025466, A025469, A034422, A034423, A034427, A034429, A034432, A034435, A034437, A034438, A034439, A034441, A034443, A034445, A034447, A034449, A034450, A034451, A034452, A034453, A034454, A034455, A034456, A034457, A034458, A034459, A034461, A034462, A034464, A034465, A034466, A034467, A034468, A034469, A034471, A034473, A034475, A034476, A034477, A034479, A034480, A034481, A034482, A034483, A034484, A034485, A034486, A034487, A034489, A034490, A034492, A034493, A034495, A034497, A034498, A034499, A034500, A034501, A034502, A034503, A034504, A034505, A034506, A034507, A034508, A034509, A034510, A034511, A034512, A034514, A034515, A034516, A034518, A034519, A034520, A034521, A034522, A034523, A034525, A034526, A034527, A034528, A034529, A034530, A034531, A034532, A034533, A034534, A034535, A034536, A034537, A034538, A034539, A034540, A034541, A034542, A034543, A034544, A034545, A034546, A034547, A034548, A034549, A034550, A034551, A034552, A034553, A034554, A034555, A034556, A034557, A034558, A034559, A034560, A034561, A034562, A034563, A034564, A034565, A034566, A034567, A034568, A034569, A034570, A034571, A034572, A034573, A034574, A034575, A034576, A034577, A034578, A034579, A034580, A034581, A034582, A036861, A047752, A052375, A055967, A061858, A065687, A066035, A067159, A067168, A070097, A070202, A070204, A070205, A070206, A072325, A072769, A076142, A082998, A083344, A085974, A085982, A086007, A086015, A089458, A093392, A094382, A105517, A108322, A111855, A111859, A111898, A111899, A112802, A122180, A129947, A137579, A159708, A161277, A161278, A161279, A161280, A165766, A167263, A178780, A178798, A180472, A180601, A181340, A181735, A184946, A185037, A185203, A185237, A185238, A185245, A185246, A185255, A185264, A185284, A191928, A192541, A197629, A198255, A200214, A206499, A210632, A212619, A217148, A217149, A217151, A217155, A217156, A228953, A230533, A230686, A235044, A235358, A236265, A236417, A236460, A238403, A243831, A243832, A243833, A243834, A243835, A243836, A248805, A250002, A256974, A260502, A264668, A276183, A277165, A280492, A280815
[Answer]
## CJam (2182 2780 3034 sequences)
```
{:ZA3#:Cb(40-z_!!:B-\+CbB)/)_mqmo:M+:NK{)[N0{N1$_*-@/M@+1$md@M@-}K*]<W%B{X0@{2$*+\}%}*ZB&=}%\C)<f*}
```
This gives correct answers for the inclusive ranges
* `[A040000, A040003]`, `[A040005, A040008]`, `[A040011, A040013]`, `A040015`, `[A040019, A040022]`, `A040024`, `[A040029, A040033]`, `A040035`, `A040037`, `[A040041, A040043]`, `A040048`, `A040052`, `[A040055, A040057]`, `A040059`, `A040063`, `[A040071, A040074]`, `A040077`, `A040080`, `[A040090, A040091]`, `[A040093, A040094]`, `A040097`, `A040099`, `[A040109, A040111]`, `A040118`, `A040120`, `[A040131, A040135]`, `A040137`, `A040139`, `[A040142, A040143]`, `A040151`, `[A040155, A040157]`, `A040166`, `A040168`, `[A040181, A040183]`, `[A040185, A040968]`
* `[A041006, A041011]`, `[A041014, A042937]`
* `A006983`, `[A011734, A011745]`, `[A023975, A023976]`, `[A025438, A025439]`, `[A025443, A025444]`, `A025466`, `A025469`, `[A034422, A034423]`, `A034427`, `A034429`, `A034432`, `A034435`, `[A034437, A034439]`, `A034441`, `A034443`, `A034445`, `A034447`, `[A034449, A034459]`, `[A034461, A034462]`, `[A034464, A034469]`, `A034471`, `A034473`, `[A034475, A034477]`, `[A034479, A034487]`, `[A034489, A034490]`, `[A034492, A034493]`, `A034495`, `[A034497, A034512]`, `[A034514, A034516]`, `[A034518, A034523]`, `[A034525, A034582]`, `A036861`, `A047752`, `A052375`, `A055967`, `A061858`, `A065687`, `A066035`, `A067159`, `A067168`, `A070097`, `A070202`, `A070204`, `[A070205, A070206]`, `A072325`, `A072769`, `A076142`, `A082998`, `A083344`, `A085974`, `A085982`, `A086007`, `A086015`, `A089458`, `A093392`, `A094382`, `A105517`, `A108322`, `A111855`, `A111859`, `[A111898, A111899]`, `A112802`, `A122180`, `A129947`, `A137579`, `A159708`, `[A161277, A161280]`, `A165766`, `A167263`, `A178780`, `A178798`, `A180472`, `A180601`, `A181340`, `A181735`, `A184946`, `A185037`, `A185203`, `[A185237, A185238]`, `[A185245, A185246]`, `A185255`, `A185264`, `A185284`, `A191928`, `A192541`, `A197629`, `A198255`, `A200214`, `A206499`, `A210632`, `A212619`, `[A217148, A217149]`, `A217151`, `[A217155, A217156]`, `A228953`, `A230533`, `A230686`, `A235044`, `A235358`, `A236265`, `A236417`, `A236460`, `A238403`, `[A243831, A243836]`, `A248805`, `A250002`, `A256974`, `A260502`, `A264668`, `A276183`, `A277165`, `A280492`, `A280815`
The `A040???` sequences correspond to the continued fractions of non-rational square roots from `sqrt(2)` to `sqrt(1000)` (with the gaps corresponding to ones which appear earlier in OEIS, but conveniently filled with random sequences). The `A041???` sequences correspond to the numerators and denominators of the continued fraction *convergents* for non-rational square roots from `sqrt(6)` to `sqrt(1000)` (with the gap corresponding to `sqrt(10)`, at `A005667 and A005668`). The other assorted sequences have zeroes for their first twenty values.
The answer ports elements of two earlier answers of mine in GolfScript:
* [Determining the continued fractions of square roots](https://codegolf.stackexchange.com/a/6416/194)
* [Good rational approximations of pi](https://codegolf.stackexchange.com/a/4236/194)
Many thanks to [xnor](https://codegolf.stackexchange.com/users/20260/xnor) for the short closed form `x -> x + round(sqrt(x))` mapping sequence offsets to the value to sqrt. The savings over my previous calculation (generating the list of non-squares and selecting by index) provided enough to have an all-zero fallback for most out-of-range indices.
[Answer]
# Python (with sympy), ~~144~~  146 sequences
```
import sympy
f=lambda a,M=16627:[int(c)for c in str(sympy.log((a<M)*46.5+4+a-M).n(20))if'.'<c][-20:]
```
The function `f` works for the **146** sequences **[A016578](https://oeis.org/A016578)** through **[A016723](https://oeis.org/A016723)** inclusive.
All of these are output by the test harness at **[repl.it](https://repl.it/FMWx/3)**.
The **49** sequences **[A016578](https://oeis.org/A016578)** through **[A016626](https://oeis.org/A016626)** inclusive are the decimal expansions of log(3/2), log(5/2), log(7/2), ..., log(99/2).
The **97** sequences **[A016627](https://oeis.org/A016627)** through **[A016723](https://oeis.org/A016723)** inclusive are the decimal expansions of log(4), log(5), log(6), ..., log(100).
The first **two** of the **49** start at the first decimal place since the log values for them are less than **1**, so the `[-20:]` takes the trailing 20 decimal places of the result of the call to `...n(20)` which gets 20 significant figures. The `if'.'<c` filters out the decimal place character, and the `int(c)` casts each remaining digit character to an integer (although maybe not necessary).
[Answer]
# Jelly, ~~1127~~ 1975 sequences
-- this currently combines the findings of [xnor](https://codegolf.stackexchange.com/a/107210/53748) and [Mitchell Spector](https://codegolf.stackexchange.com/a/107220/53748), but still has some room for growth at 78 bytes. Go give them some credit!
```
0x20
_21004µȷ20:DU¢oU
20Ḷ×⁸+µ*þ12
11R‘µẋ`€F$ç"Ḷ€F$;/
_108ị¢
“æÑØ‘×ȷ3¤>J×$S‘µĿ
```
**[TryItOnline!](https://tio.run/nexus/jelly#@29QYWTAFW9kaGBgcmjrie1GBlYuoYcW5YdyGRk83LHt8PRHjTu0D23VOrzP0IjL0DDoUcOMQ1sf7upOeNS0xk3l8HIloCIw01qfK97QwOLh7u5Di7i4HjXMObzs8MTDM4DqD08/sd340BI7r8PTVYLB@o/s////v6GZubkFAA)**
The 1975 sequences are:
* the 252 that start with twenty zeros (the behaviour for input outside of `[16000,21999]`);
* the 848 sequences lying in the range [16742](https://oeis.org/A016742) to [17664](https://oeis.org/A017664) that match the `(a*n+b)**c` formula (the behaviour for input in `[16000,17999]`); and
* the 875 sequences lying in the range [21016](https://oeis.org/A021016) to [21999](https://oeis.org/A021999) that match the decimal expansion of `1/n` (the behaviour for input in `[18000,21999]`).
### How?
```
0x20 - Link 1, TwentyZeros: no arguments
0    - zero
  20 - twenty
 x   - repeat
_21004µȷ20:DU¢oU - Link 2, DecimalExpansionOfReciprocal: oeisIndexNumber
      µ          - monadic chain separation
       ȷ20       - 1e20
_21004           - subtract 21004 from oeisNumber to get the n value
          :      - integer division, i.e. 1e20 // n
           D     - decimal list
            U    - reverse
             ¢   - call last link (1) as a nilad, i.e. get twenty zeros
              o  - logical or, i.e. pad the right of the reversed list to twenty with zeros
               U - reverse again
20Ḷ×⁸+µ*þ12 - Link 3, BlockOf12abcFormulaResults: a, b
20Ḷ         - lowered range of 20 [0,1,...,19] i.e. the values of n in (a*n+b)**c
    ⁸       - left argument, a
   ×        - multiply
     +      - add b
      µ     - monadic chain separation
        þ12 - outer product with [1,2,...,12] of... i.e. the values of c in (a*n+b)**c
       *    -     exponentiation
11R‘µẋ`€F$ç"Ḷ€F$;/ - link 4, AllabcFormulaResults: no aguments
11R                - range of 11 [1,2,...,11]
   ‘               - increment   [2,3,...12] i.e. the values of a in (a*n+b)**c
    µ              - monadic chain separation
         $         - last two links as a monad
     ẋ`€           - repeat list with repeated arguments for €ach [[2,2],[3,3,3],...,[12,12,12,12,12,12,12,12,12,12,12,12]]
        F          - flatten into one list
               $   - last two links as a monad
            Ḷ€     - lowered range of €ach [[0,1],[0,1,2],...,[0,1,2,3,4,5,6,7,8,9,10,11]]
              F    - flatten into one list
          ç"       - zip with (") last link (3) as a dydad (ç) i.e. get all the results
                 / - reduce with
                ;  - concatenation i.e. make the list of lists of lists one list of lists.
_108ị¢ - Link 5, abcFormulaResult: oeisIndexNumber
_108   - subtract 108 from the oeisNumber (indexes in Jelly are modular and there are 924 entries, this is shorter than _16740)
     ¢ - call last link (4) as a nilad
    ị  - index into i.e. get the one relevant result of 20 terms
 - Link 6, an empty link (cheaper in bytes than the %6 alternative in the main link)
“æÑØ‘×ȷ3¤>J×$S‘µĿ - Main link: oeisIndexNumber           e.g. 1-15999; 16000-17999; 18000-21999; 22000+
        ¤         - nilad followed by link(s) as a nilad
“æÑØ‘             - codePage indexes [22,16,18]
      ȷ3          - 1e3
     ×            - multiply [22000,16000,18000]
         >        - greater than (vectorises)            e.g. [1,1,1]; [1,0,1];     [1,0,0];     [0,0,0]
            $     - last two links as a monad
          J       - range(length) [1,2,3]
           ×      - multiply                             e.g. [1,2,3]; [1,0,3];     [1,0,0];     [0,0,0]
             S    - sum                                  e.g. 6;       4;           1;           0
              ‘   - increment                            e.g. 7;       5;           2;           1
               µ  - monadic chain separation
                Ŀ - call link(index) as a monad with the oeisIndexNumber
                        link indexing is 1-based and modular so 7 calls link 1
              ><        hence the empty link 6 replacing a %6 here
```
[Answer]
# Mathematica, ~~39~~ ~~173~~ 189 sequences
```
If[l=0~Range~19;#<4^7,l,If[#<3^9,#&@@RealDigits[Log[j=16627;#-j+If[#<j,49.5,4]],10,20],#-22956-l]]&
```
Inspired by [Jonathan Allan's answer](https://codegolf.stackexchange.com/a/107218/60043).
Works for:
* [1477](https://oeis.org/A001477), [2837](https://oeis.org/A002837), [4830](https://oeis.org/A004830), and [8554](https://oeis.org/A008554) (the first 20 terms of these are
`{0, 1, 2, ... , 19}`)
* [16578](https://oeis.org/A016578) to [16626](https://oeis.org/A016626) (decimal expansion of log(3/2), decimal expansion of log(5/2), ... decimal expansion of log(99/2))
* [16627](https://oeis.org/A016627) to [16723](https://oeis.org/A016723) (decimal expansion of log(4), decimal expansion of log(5), ... decimal expansion of log(100))
* [22958](https://oeis.org/A022958) to [22996](https://oeis.org/A022996) (2-n, 3-n, ... 40-n)
[Answer]
## CJam, 1831 sequences
```
{168680-:Zz1320b900b48md:R;H+:QB+2*,:!1_tQWtQ)WtK{[WQW*_(]+1$f=[1R2+R~R4+*2/WR-X$-].*1b+}/J~>ZW>f*}
```
This gives correct output for 199 sequences beginning `0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0` and all sequences in the inclusive ranges `[A168680, A169579]` and `[A170000, A170731]`. The bulk of it deals with those two ranges, with a fallback for all-zeroes before the start of the first range.
The two ranges in question have the form
> 
> Number of reduced words of length \$n\$ in Coxeter group on \$P\$ generators \$S\_i\$ with relations \$(S\_i)^2 = (S\_i S\_j)^Q = I\$
> 
> 
> 
for values of \$P\$ ranging from \$3\$ to \$50\$ and values of \$Q\$ ranging from \$17\$ to \$50\$. Their generating functions are given in a thoroughly inefficient manner: I found it useful to multiply numerators and denominators by \$(t - 1)\$ to give g.f. $$\frac{t^{Q+1} + t^Q - t - 1}{\frac12(P-2)(P-1) t^{Q+1} - \frac12(P-2)(P+1) t^Q + (P-1)t - 1}$$ although for golfing purposes I'm actually working with \$R = P + 3\$.
[Answer]
## Batch, 62 sequences
```
@for /l %%i in (1,1,20)do @set/a"n=(n=22956-%1)*(n>>=16)+%%i*(n|%1-8582)"&call echo %%n%%
```
Just implementing one block of sequences was hard, but I managed two in 89 bytes! Explanation: For a parameter `%1` of 8585-8607, `22956-%1>>16` returns zero, causing the `(22956-%1)` expression to be ignored and we end up multiplying the loop variable by 3-25 respectively, while for a parameter of 22958-22996 it returns minus one causing the expression to be negated, while the `n|` causes the multiplication factor to be replaced with minus one effectively subtracting the loop variable.
[Answer]
# [PHP](https://php.net/), 28 bytes, 33 Sequences I assume
```
for(;;)print_r(range(0,32));
```
[Try it online!](https://tio.run/##K8go@G9jXwAk0/KLNKytNQuKMvNK4os0ihLz0lM1DHSMjTQ1rf//BwA "PHP – Try It Online")
<https://oeis.org/A000004> 0
<https://oeis.org/A007395> 2
<https://oeis.org/A010701> 3
<https://oeis.org/A010709> 4
<https://oeis.org/A010716> 5
<https://oeis.org/A010722> 6
<https://oeis.org/A010727> 7
<https://oeis.org/A010731> 8
<https://oeis.org/A010734> 9
<https://oeis.org/A010692> 10
<https://oeis.org/A010850> 11
<https://oeis.org/A010851> 12
<https://oeis.org/A010852> 13
<https://oeis.org/A010854> 15
<https://oeis.org/A010855> 16
<https://oeis.org/A010857> 18
<https://oeis.org/A010859> 20
<https://oeis.org/A010861> 22
<https://oeis.org/A010863> 24
<https://oeis.org/A010871> 32
]