text:
Display OEIS sequences
The 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)
prime numbers (A000040)
Fibonacci numbers (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 (about 3 megs) or sequence values (about 9 megs). Note that this download is covered by the OEIS End-User License Agreement.

Can we write it so that it takes the leading 0's?

WHOO! A challenge on OEIS!

@TrojanByAccident if your idea is to connect to OEIS, that's not allowed on PPCG

@NathanMerrill I wasn't sure if that counted in this instance

Are functions allowed?

@xnor that's ok

http://codegolf.stackexchange.com/a/105891/59376 is this allowed lol?

@carusocomputing Given that the language in question doesn't exist, no.

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
Good rational approximations of pi

Many thanks to 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.

Might it be useful that the n'th non-square is given by n + round(sqrt(n))?

@xnor, nice one. I tried to find a nice formula with sqrt(n) but it didn't occur to me to round to nearest rather than down. That gives an immediate three byte saving, which isn't quite enough to add a fallback but keeps the hope alive.

Python 2, 875 sequences
print', '.join('%020d'%(10**20/(input()-21004)))

Works for 875 of the sequences 21016 (decimal digits of 1/12) through 21999 (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 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.
I counted the ones that match using a downloaded copy of the sequence names.
A different block gives 848 sequences from 16742 to 17664.
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 through 42397, numerators and denominators of continued fraction convergents.
~3300 matching sequences: 147999 to 151254: 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 (multiples of 3) through 8607 (multiples of 25), and 1018 (powers of 8) through 1029 (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.

haha, nice one!

also, shorter: lambda n:range(0,(n-8582)*20,n-8582)

@Maltysen Spec said program, so I went with that. I'll ask.

Oh wow, never would have though of that one. Nice.

Good idea, but I don't think the range 21016-21999 consists entirely of reciprocals. For example, A21021 is 1, 33, 727, 13365, 221431, 3428733, ..., not the decimal digits of 1/17. I haven't checked to see which sequences are reciprocals and which ones aren't.

@MitchellSpector That's too bad. I'll see if I can scrape the sequences and see how many match.

@xnor However many matches you get, you can combine it with my answer to add another 252 to the count: if the input is not in the range 21016-21999, output 20 0's.  (None of my 252 sequences lie in that range.)

@MitchellSpector Thanks for the suggestion, but I'll first try to find a bigger chunk.

https://oeis.org/wiki/Reciprocal gives a partial list. There's no need to scrape sequences: it's far easier to download the whole database. The URL's out there somewhere.

I make it 875, not 877: list at http://pastebin.com/raw/FqwkKcFu

@PeterTaylor I'll believe your count. I only checked that the name had the right keywords, which could have matched similarly-formatted exceptional cases.

The last continued fraction convergent sequence is 42937, not 42397. I only caught that because I once implemented A042545. :P

Bash + coreutils, 252 sequences
yes 0|head -20

Try it online!
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

Heh, cute idea!

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 through A016723 inclusive.
All of these are output by the test harness at repl.it.
The 49 sequences A016578 through A016626 inclusive are the decimal expansions of log(3/2), log(5/2), log(7/2), ..., log(99/2).
The 97 sequences A016627 through 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).

Jelly, 1127 1975 sequences
-- this currently combines the findings of xnor and Mitchell Spector, 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!
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 to 17664 that match the (a*n+b)**c formula (the behaviour for input in [16000,17999]); and
the 875 sequences lying in the range 21016 to 21999 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

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.
Works for:

1477, 2837, 4830, and 8554 (the first 20 terms of these are
{0, 1, 2, ... , 19})
16578 to 16626 (decimal expansion of log(3/2), decimal expansion of log(5/2), ... decimal expansion of log(99/2))
16627 to 16723 (decimal expansion of log(4), decimal expansion of log(5), ... decimal expansion of log(100))
22958 to 22996 (2-n, 3-n, ... 40-n)

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\$.

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.

PHP, 28 bytes, 33 Sequences I assume
for(;;)print_r(range(0,32));

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


text:
Hello World! generator
Often I need a simple Hello World! program to show some basic concepts of a programming language on my travels. As I usually travel only with light luggage I can't to carry a Hello World! program for each language. So a program that generates Hello World! programs in as many languages as possible would be a great help.
Task
Write a program or function that accepts a language as an input and outputs or returns the source code for program or function that accepts no input and outputs (not returns) Hello World!.
Input
The input defines in which language the Hello World! program should be generated. The input can be a number, a string, or whatever is the easiest for you. The input must only be used to select the language. You are not allowed to use the input as part of the output.
Please specify the valid inputs in your answer.
Output
The output can the return value, or be written to a file or STDOUT (or equivalent). It must full program of function in the language defined by the input. The resulting program/function must write Hello World! to STDOUT (or equivalent for the language). The output doesn't need to be exactly "Hello World!". Everything reasonably recognizable as Hello World! is acceptable. Eg. "HeLLo w0rlD1" would be an acceptable output. Also the resulting Hello World! string can be different for different languages. See bonus points section for more details.
Scoring
The program should work for as many languages as possible, and be as short as possible. Therefore the score is calculated by number of bytes / (number of supported languages - 1). Eg. an answer with 15 bytes and 3 supported languages would have a score of 7.5.
As usual with code-golf challenges lower scores are better.
Bonus points

You can subtract 10 percent from your score if the resulting Hello World! output for all supported languages is the same.
You can subtract and additional 10 percent from your score if the output for all supported languages is exactly Hello World!

@Rod: I don't think it is a duplicate. The other question asks for polyglot, while my question asks for program, that output an other program.

why a bonus for polyglots?

This challenge should be [tag:code-challenge], not [tag:code-golf], since the scoring is custom. Bonuses are generally discouraged. Also, the criteria of "Everything reasonably recognizable as Hello World!" is quite vague; challenges should have definitive criteria for valid submissions.

Duplicate asks for a polyglot, your questions asks for a program that outputs that polyglot. I don't think putting a println("..") infront of any of the answers of the other post is any interesting (though, a valid solution). @raznagul

PHP, 13 bytes, 9 languages, Score: 1.625*0.9^2 = 1.31625
Hello, World!

Explanation:
Hello, World! outputs Hello, World!. This can be used as input, and produce the same output in at least 9 languages.
Here's a list of languages this works for:

Chaîne
///
Lines
if(j)invert()if(l)change()if(q)input()if(t)output(x);
Carrot
MicroSoft Windows HTA
PHP
pl
Dogless
Swap

This would give a fairly low score too, in Octave:
disp('print("Hello, World!")')

It prints print("Hello, World!") and should work in Perl,  R, Ruby, Julia, Python 2, Python 3, Qbasic, Zsh/ksh, Cheddar among others.
Thanks to Dada for noticing I had capital instead of lower case P.

I think you can use the 0-byte program in Stuck to generate the program Hello, World! for all 10 languages ;-)

Haha :) Can't get a much lower score than that :)

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Write an Incident tokeniser
Background
Incident is a fairly unusual programming language, in that its list of tokens is not predetermined, but rather inferred from the input. As such, tokenising an Incident program can be fairly difficult, especially if you want to do so efficiently. This task is about doing that yourself.
The task
Your program will be given a string as input. Here's the algorithm that Incident uses to tokenise it:

Identify all strings that occur as a substring of the input in exactly three ways (i.e. there are exactly three occurrences of that string within the input).
Discard any of these strings that are a substring of another such string (e.g. for input ababab, the only remaining string would be ab, not a or b, because a and b are both substrings of ab).
Discard any strings that overlap within the input. (For example, aaaa contains exactly three copies of aa, but these copies overlap at the second and third characters, so would be discarded. Likewise, in abababa, there are three copies of ab and three copies of ba, but the second to sixth characters are each at the overlap of an ab and a ba, so both ab and ba would be discarded).
Any strings that remain at this point are the tokens used by the program. Tokenise the original input into a sequence of these tokens (due to the discarding in the previous step, there will only be one way to do it). Any characters in the input that aren't part of any token are treated as comments and discarded.

Your program has to take a string as input, and return the corresponding tokenisation of the string (a list of tokens, each of which are expressed as strings) as output. Additionally, this has to be done at least moderately efficiently; specifically, the program has to run in quadratic time ("O(n²)") or better. (Incidentally, it's almost certainly possible to go faster than quadratic, but this is not fastest-algorithm, so feel free to use the tersest algorithm you can find that fits within the complexity bounds.)
Clarifications

Although Incident programs can in theory contain any of the 256 octets, it's acceptable for the purpose of this challenge for your program to handle only inputs formed out of printable ASCII (including space), plus newline and tab. (All known Incident programs restrict themselves to this subset). Note that space/newline/tab aren't special and can appear in the middle of tokens; Incident treats all 256 octets as opaque.
The definition of "quadratic time" is "if the size of the input is doubled, the program will run slower by no more than a constant plus a factor of 4", i.e. if t(x) is the maximum time your program takes to process an input of size x, then there must be some constant k such that t(2 x) < 4 t(x) + k for all x. Bear in mind that comparing strings takes time proportional to the length of the strings.
Your program should theoretically be able to handle input programs of any length if run in a (possibly hypothetical) variant of your language that has unlimited memory and uses unbounded integers (it's OK if the program fails to achieve this goal when run in practice due to the language's integers or memory actually being finitely large). You may assume (for the purpose of calculating the complexity) that integers that are no greater than the length of the input can be compared in constant time (although bear in mind that if you use larger values, e.g. due to converting the input into a single integer, they will take a length of time to compare proportional to the number of digits they have).
You can use any algorithm that fits within the complexity bounds, even if it doesn't follow the same steps as the algorithm posted above, so long as it produces the same results.
This puzzle is about tokenising the input, not really about formatting the output. If the most natural way to output a list in your language involves an ambiguous format (e.g. newline-separated when the strings contain literal newlines, or without delimiters between the strings), don't worry about the fact that the output ends up ambiguous (so long as the list is actually constructed). You may want to make a second version of your submission that produces unambiguous output, to aid in testing, but the original version is the version that counts for the scoring.

Test case
For the following input string:
aaabcbcbcdefdfefedghijghighjkllkklmmmmonono-nonppqpq-pqprsrsrstststuvuvu

your program should produce the following output list:
a a a bc bc bc d e f d f e f e d gh gh gh k l l k k l pq pq pq u u u

Victory condition
This is code-golf, so the shortest valid (i.e. correct input/output behaviour and sufficiently fast to execute) program, measured in bytes, wins.

For people who can see deleted posts: the Sandbox post was here.

Howe many languages have you created? ... Wait, 35?!

C (gcc), 324 bytes
The function f takes a null-terminated string and prints the tokens to stdout. All newlines can be removed from the code below.
f(char*s){
int n=strlen(s),b=0,z[n-~n],F[n+1],u,a,x=0,l,m,*t=z+n;
int K(i){~m&&s[i]^s[a+m]?m=t[m],K(i):++m;}
for(;b<2*n;){
for(a=b++%n,m=l=-1;a+l<n;K(a+l))t[++l]=m;
for(l=0;l<n;++F[m])K(l++),F[l]=z[a]*=b>n?m^z[a]||~(m=t[z[l-m]]):0;
for(printf("%.*s",z[a],s+a);n/b*l&&a+l>x;l--)F[l]^3?F[t[l]]+=F[l]:(a<x?z[u]=0:(z[u=a]=l),x=a+l);
}
}

This older 376-byte version is a little easier to read; the explanation below applies to it.
*t,m;
char*p;
K(c){for(;~m&&c^p[m];)m=t[m];++m;}
k(i){for(*t=m=-1;p[i];t[++i]=m)K(p[i]);m=0;}
f(char*s){
int n=strlen(s),z[n-~n],F[n+1],u,*Z=z,a=0,x=0,l;
for(t=z+n;a<n;a++){
p=s+a;
for(k(l=z[a]=0);l<n;++F[m])K(s[l++]),F[l]=0;
for(;l&&a+l>x;l--)F[l]^3?F[t[l]]+=F[l]:(a<x?z[u]=0:(z[u=a]=l),x=a+l);
}
for(p=s;*p;printf("%.*s",*Z++,p++))
for(k(x=0);x<n;m==*Z?*Z*=!!z[x-m],m=t[m]:0)
K(s[x++]);
}

k(0) generates the table t for pattern p for the Knuth–Morris–Pratt algorithm.
K(c) process the next character c of the search string and updates m, the length of the largest prefix of p which can be found ending at the most recently processed character.
In the first for loop, for each index a in the string, we count the number of times each possible value of m occurs when searching in the entire string for the substring beginning at a. Then we look for the largest l such that the length-l substring starting at a occurred exactly 3 times. If it's short enough to be entirely contained by a string found for a previous a, we ignore it. If it overlaps, we delete the previous string from z, the array recording which tokens will be kept. Otherwise, its length is stored in z.
Then, we use KMP again to search the string for the tokens recorded in z. If one of them is found at a location with a 0 entry in z, we know that this token was deleted due to overlap. If the token was not deleted, it is printed.

What is the time complexity of this? Has to be O(n^2) or faster. And why is there !! at !!z[x-m]?

@TuukkaX It's exactly O(n^2). *Z is the length of the next token which needs to become 0 if any of the other occurrences of the token have the value 0 at their index in the array, or keep the same value otherwise (in that case !!z[x-m] should be 1.

Alright. But I still don't understand why the !! is there. !!x should still be x, or does it invoke a trick I don't know of?

@TuukkaX Well, !!x makes x a boolean representing its "truthiness". So, !!1 == true and !!0 == false. I don't know C specifically, but that's how it usually goes

JavaScript, 878 867 842 825 775 752 717 712 704 673 664 650 641 bytes
Thanks to @Kritixi Lithos for helping golf the code
Thanks to @User2428118 for golfing off 14 bytes
(Will not work in IE7)
(Newlines should be entered as "\n" and tab as "\t" in the input string, any unicode characters should be entered as \u####)
w=>{for(a=[],b=[],c=[],d=[],f=[],e=[],k=0;k<(g=w.length);a[k++]=h)for(b[R='push']([]),h=[d[k]=f[k]=j=i=0];i++<g-k;){while(j&&w[k+i]!=w[k+j])j=h[j-1];w[k+i]==w[k+j]&&j++,h[R](j)}for(k=0;k<g;k++)for(j=i=0;i<g;i++)if(w[i]!=w[k+j]){while(j&&w[i]!=w[k+j])j=a[k][j-1];w[i]==w[k+j]?i--:b[k][R](j)}else b[k][R](++j);for(k=0;k<g;c[k++]=l){for(h=f.map(Q=>i=l=0);i<g;)h[b[k][i++]]++;for(;i;)h[i]==3?(l=i,i=0):a[k][--i]?h[a[k][i]]+=h[i+1]:0}for(k=0;g>k++;)for(i=0;(S=c[k])&&i<g;)b[k][i++]==S?d[i-S]=S:0;for(k=0;k<g;k++)for(e[R](w.slice(k,(S=d[k])+k)),i=1;i<S;)f[k+i]=1,f[k]|=S<d[k+i]+i++;f.map((X,i)=>(P=e[i],X?e=e.map(Y=>P==Y?"":Y):0));return e.join``}

Try it Online
Explanation of how it works and ungolfed code
First, the program generates Knuth Morris Pratt arrays for every possible substring;
for(index=0;index<word.length;index++){
  kmpArray=[0];
  j=0;
  for(i=1;i<word.length-index;i++){
    while(j&&word.charAt(index+i)!=word.charAt(index+j)){
      j=kmpArray[j-1];
    }
    if(word.charAt(index+i)==word.charAt(index+j)){
      j++;
    }
    kmpArray.push(j);
  }
  kmpArrays.push(kmpArray);
}

Next, the program finds the maximum matching lengths at every single index in the word with each substring. (this is O(n^2) time)
for(index=0;index<word.length;index++){
  j=0;
  matchLength=[];
  for(i=0;i<word.length;i++){
    if(word.charAt(i)!=word.charAt(index+j)){
      while(j&&word.charAt(i)!=word.charAt(index+j)){
        j=kmpArrays[index][j-1];
      }
      if(word.charAt(i)==word.charAt(index+j)){
        i--;
      }else{
        matchLength.push(j);
      }
    }else{
      j++;
      matchLength.push(j);
      if(j==kmpArrays[index].length){
        j=kmpArrays[index][j-1];
      }
    }
  }
  matchLengths.push(matchLength);
}

The program uses this data to find the longest substrings that appear three times for each starting character in the string.
for(index=0;index<word.length;index++){
  counts=[]
  max=0;
  for(i=0;i<=word.length;i++){
    counts.push(0);
  }
  for(i=0;i<word.length;i++){
    counts[matchLengths[index][i]]++;
  }
  for(i=word.length-1;i>0;i--){
    if(counts[i]==3){
      max=i;
      break;
    }
    if(kmpArrays[index][i-1]){ //if this value has a smaller value it could be as well
      counts[kmpArrays[index][i]]+=counts[i-1];
    }
  }
  maxLengths.push(max);
}

The program uses this data to eliminate all substrings that do not appear exactly three times and all substrings of the longest valid substrings.
for(index=0;index<word.length;index++){
  if(!maxLengths[index])
    continue;
  for(i=0;i<word.length;i++){
    if(matchLengths[index][i]==maxLengths[index]){
      tokens[i-maxLengths[index]+1]=maxLengths[index];
    }
  }
}

Next, the program sets all overlapping or partial substrings as to be removed.
for(index=0;index<word.length;index++){
  sStrs.push(word.substring(index,tokens[index]+index));
  for(i=1;i<tokens[index];i++){
    toRemove[index+i]=1;
    if(tokens[index]<tokens[index+i]+i){
      toRemove[index]=1;
    }
  }
}

For each of the to be removed values, all equivalent substrings are removed as well.
for(index=0;index<word.length;index++){
  if(toRemove[index]){
    removal=sStrs[index];
    for(i=0;i<3;i++){
      indxOf=sStrs.indexOf(removal);
      sStrs[indxOf]="";
      toRemove[indxOf]=0;
    }
  }
}

Finally, the program joins the array of substrings together and outputs it.

You have some while and if blocks that have only 1 statement inside of them. You can remove the braces {} around those statement. For example, if(word.charAt(index+i)==word.charAt(index+j)){j++;} can become if(word.charAt(index+i)==word.charAt(index+j))j++;

I used &&s to replace if statements, I moved statements around in loops so that they would end up with one statement under them so that I could remove braces. I used ternaries to replace some if-statements. I moved stuff around and ended up at 946 bytes. If you don't understand something I did, feel free to ask me :)

At this point my main problem with golfing it is trying to understand what I wrote there. I also don't know what optimisations I can do for golfing in javascript.

Do you want to discuss this in a separate chatroom?

Saved 14 bytes.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
It's raining in my terminal!
Challenge Description
You have to show a simulation of rain in terminal.
In the example given below its adding 100 raindrops at random (use the default random function which your language offers) coordinates, waiting for 0.2 seconds and then redrawing again until the given time expires. Any character can be used for representing the raindrop.
Parameters

Wait time between redrawing in seconds.
Time for which the rain will be visible. This is just an integer representing the number of iterations. [So, the net time for which the rain will be visible is this integer multiplied by the wait time]
Message to be displayed when the rain ends. (This has to be centered)
Number of raindrops to be displayed on the screen.

Rules

A single byte should be used for representing a rain drop, and it can be anything, even cats and dogs.
It doesn't have to be responsive to terminal size which means you don't have to handle the bug for varied terminal sizes. You can specify the terminal width and height on your own.
Standard rules of golfing apply.

Code Sample and Output
This is an ungolfed version written in python 2.7 using ncurses.
import curses
import random
import time

myscreen = curses.initscr()
curses.curs_set(0) # no cursor please
HEIGHT, WIDTH = myscreen.getmaxyx()
RAIN = '/' # this is what my rain drop looks like
TIME = 10

def make_it_rain(window, tot_time, msg, wait_time, num_drops):
    """
    window    :: curses window
    time      :: Total time for which it rains
    msg       :: Message displayed when it stops raining
    wait_time :: Time between redrawing scene
    num_drops :: Number of rain drops in the scene
    """
    for _ in range(tot_time):
        for i in range(num_drops):
            x,y=random.randint(1, HEIGHT-2),random.randint(1,WIDTH-2)
            window.addstr(x,y,RAIN)
        window.refresh()
        time.sleep(wait_time)
        window.erase()

    window.refresh()
    window.addstr(HEIGHT/2, int(WIDTH/2.7), msg)

if __name__ == '__main__':
    make_it_rain(myscreen, TIME, 'IT HAS STOPPED RAINING!', 0.2, 100)
    myscreen.getch()
    curses.endwin()

Output -

In the future instead of posting again please edit the original.  If people think the specs are clear they will nominate it for reopening.

Does the text have to be centered? Is it randomly raining, does initial position of droplets matter? How are you measuring time? In milliseconds, seconds, minutes? What is "Extra Points"?

If you, A. Specify units. B. Specify terminal size or take it as input. and C. Remove the part about extra points; this challenge would be better defined.

When you say "random", can we assume that means "uniformly random"?

1 day in the sandbox is often not enough.  Remember that people are here recreationally and from diverse timezones - immediate feedback should not be expected.

@carusocomputing I have added the information.

@DigitalTrauma Can be sampled from any distribution.

Note that a constant pattern would qualify as any distribution You probably want the drop positions to be independently chosen in each frame. Also, you mention values like 200 ms but then say it's an input parameter. So is it fixed or is it an input? Same for the other parameters. Also, the concept of terminal may be ill-defined in certain languages. Can we assume say an MxN character rectangle?

@LuisMendo Yes they are inputs and I just called my own function to show it in the example code. You just have to write the function. And there are no constraints related to terminal so yes you can assume it.

@LuisMendo What I actually meant was you can use the default random function which your language offers. I'll edit it.

"Any character can be used for representing the raindrop." this is a bit broad. Like, one could use space and claim it's random.

MATL, 52 bytes
xxx:"1GY.Xx2e3Z@25eHG>~47*cD]Xx12:~c!3G80yn-H/kZ"why

Inputs are, in this order: pause between updates, number of drops, message, number of repetitions. The monitor has size 80×25 characters (hard-coded).
GIF or it didn't happen! (Example with inputs 0.2, 100, 'THE END', 30)

Or try it at MATL Online.
Explanation
xxx      % Take first three inputs implicitly and delete them (but they get
         % copied into clipboard G)
:"       % Take fourth input implicitly. Repeat that many times
  1G     %   Push first input (pause time)
  Y.     %   Pause that many seconds
  Xx     %   Clear screen
  2e3    %   Push 2000 (number of chars in the monitor, 80*25)
  Z@     %   Push random permutation of the integers from 1 to 2000
  25e    %   Reshape as a 25×80 matrix, which contains the numbers from 1 to 2000
         %   in random positions
  HG     %   Push second input (number of drops)
  >~     %   Set numbers that are <= second input to 1, and the rest to 0
  47*c   %   Multiply by 47 (ASCII for '/') and convert to char. Char 0 will
         %   be displayed as a space
  D      %   Display
]        % End
Xx       % Clear screen
12:~     % Push row vector of twelve zeros
c!       % Convert to char and transpose. This will produce 12 lines containing
         % a space, to vertically center the message in the 25-row monitor
3G       % Push third input (message string)
80       % Push 80
yn       % Duplicate message string and push its length
-        % Subtract
H/k      % Divide by 2 and round down
Z"       % Push string of that many spaces, to horizontally center the message
         % in the 80-column monitor
w        % Swap
h        % Concatenate horizontally
y        % Duplicate the column vector of 12 spaces to fill the monitor
         % Implicitly display

I like how it ends in why :)

@tkellehe I like the description on your profile :-)

thank you. Your language is so much fun to read. (Yes, I have been stalking your MATL answers lol)

JavaScript (ES6), 268 261 bytes

t=
(o,f,d,r,m,g=(r,_,x=Math.random()*78|0,y=Math.random()*9|0)=>r?g(r-(d[y][x]<`/`),d[y][x]=`/`):d.map(a=>a.join``).join`
`)=>i=setInterval(_=>o.data=f--?g(r,d=[...Array(9)].map(_=>[...` `.repeat(78)])):`

`+` `.repeat(40-m.length/2,clearInterval(i))+m,d*1e3)
<input id=f size=10 placeholder="# of frames"><input id=d placeholder="Interval between frames"><input id=r size=10 placeholder="# of raindrops"><input id=m placeholder="End message"><input type=button value=Go onclick=t(o.firstChild,+f.value,+d.value,+r.value,m.value)>

At least on my browser, the output is designed to fit into the Stack Snippet area without having to go "Full page", so if you ask for more than 702 raindrops it will crash.
Edit: Saved 7 bytes by using a text node as my output area.

You can save a few bytes by passing the function as a string to setInterval. Also, why do you use textContent instead of innerHTML?

@L.Serné Using an inner function allows me to refer to the variables in the outer function.

Oops, my bad, didn't notice that.

R, 196 192 185 bytes
Just a mock version I wrote based on the description. Hopefully it's somewhat what OP was looking for.
Saved some bytes thanks to @plannapus.
f=function(w,t,m,n){for(i in 1:t){x=matrix(" ",100,23);x[sample(2300,n)]="/";cat("\f",rbind(x,"\n"),sep="");Sys.sleep(w)};cat("\f",g<-rep("\n",11),rep(" ",(100-nchar(m))/2),m,g,sep="")}

The arguments:

w: Wait time between frames
t: Total number of frames
m: Custom message
n: Number of rain drops

Example
Why does it look like it's raining upwards?
Edit: I should mention that this is my customized 23x100 character R-studio console. The dimensions are hardcoded into the function but one could in principle use getOption("width") to make it flexible to console size.

Ungolfed and explained
f=function(w,t,m,n){
    for(i in 1:t){
        x=matrix(" ",100,23);             # Initialize matrix of console size
        x[sample(2300,n)]="/";            # Insert t randomly sampled "/"
        cat("\f",rbind(x,"\n"),sep="");   # Add newlines and print one frame
        Sys.sleep(w)                      # Sleep
    };
    cat("\f",g<-rep("\n",11),rep(" ",(100-nchar(m))/2),m,g,sep="")  # Print centered msg
}

This looks perfectly fine! +1 and I don't think its going upwards it just your perception lol

@plannapus. Realized rep() automatically floors the times argument so no need for that either. Saved another 7 bytes!

Very nice solution. You can save one byte by pushing the console size to function arguments (if that's allowed); you can save another byte by using runif rather than sample to randomly populate the matrix. Like so: f=function(w,t,m,n,x,y){for(i in 1:t){r=matrix(" ",x,y);r[runif(n)*x*y]="/";cat("\f",rbind(r,"\n"),sep="");Sys.sleep(w)};cat("\f",g<-rep("\n",y/2),rep(" ",(x-nchar(m))/2),m,g,sep="")}

C 160 bytes
f(v,d,w,char *s){i,j;char c='/';for(i=0;i<v;i++){for(j=0;j<d;j++)printf("%*c",(rand()%100),c);fflush(stdout);sleep(w);}system("clear");printf("%*s\n",1000,s);}

v-Time the raindrops are visible in seconds.
d-Number of drops per iteration
w-Wait time in seconds, before the next iteration
s-String to be passed on once its done

Ungolfed version:
void f(int v, int d, int w,char *s)
{

   char c='/';
   for(int i=0;i<v;i++)
   {
      for(int j=0;j<d;j++)
         printf("%*c",(rand()%100),c);

      fflush(stdout);
      sleep(w);
   }
   system("clear");
   printf("%*s\n", 1000,s);
}

v - 5 seconds
d - 100 drops
w - 1 second wait time
s - "Raining Blood" :)

R, 163 chars
f=function(w,t,n,m){for(i in 1:t){cat("\f",sample(rep(c("/"," "),c(n,1920-n))),sep="");Sys.sleep(w)};cat("\f",g<-rep("\n",12),rep(" ",(80-nchar(m))/2),m,g,sep="")}

With indents and newlines:
f=function(w,t,n,m){
    for(i in 1:t){
        cat("\f",sample(rep(c("/"," "),c(n,1920-n))),sep="")
        Sys.sleep(w)
    }
    cat("\f",g<-rep("\n",12),rep(" ",(80-nchar(m))/2),m,g,sep="")
}

It's adapted to a terminal size of 24 lines by 80 columns. w is the waiting time, t the number of frames, n the number of raindrops and m the final message.
It differs from @billywob's answer in the different use of sample: if the output size is omitted, sample gives a permutation of the input vector (here a vector containing the needed number of raindrops and the corresponding number of spaces, thanks to the fact that argument times of function rep is vectorized). As the size of the vector corresponds exactly to the size of the screen, there is no need to add newlines, or to force-shape it into a matrix.

NodeJS: 691 158 148 Bytes
Edit
As requested, additional features removed and golf'd.
s=[];setInterval(()=>{s=s.slice(L='',9);for(;!L[30];)L+=' |'[Math.random()*10&1];s.unshift(L);console.log("\u001b[2J\u001b[0;0H"+s.join('\n'))},99)

The rules specify disregard for size, but this version includes a glitch for the first few frames. It is 129 bytes.
s='';setInterval(()=>{for(s='\n'+s.slice(0,290);!s[300];)s=' |'[Math.random()*10&1]+s;console.log("\u001b[2J\u001b[0;0H"+s)},99)

Previous answer
Perhaps not the best golfing, but I got a bit carried away. It has optional wind direction and rain factor.
node rain.js 0 0.3
var H=process.stdout.rows-2, W=process.stdout.columns,wnd=(arg=process.argv)[2]||0, rf=arg[3]||0.3, s=[];
let clr=()=>{ console.log("\u001b[2J\u001b[0;0H") }
let nc=()=>{ return ~~(Math.random()*1+rf) }
let nl=()=>{ L=[];for(i=0;i<W;i++)L.push(nc()); return L}
let itrl=(l)=>{ for(w=0;w<wnd;w++){l.pop();l.unshift(nc())}for(w=0;w>wnd;w--){l.shift();l.push(nc())};return l }
let itrs=()=>{ if(s.length>H)s.pop();s.unshift(nl());s.map(v=>itrl(v)) }
let d=(c,i)=>{if(!c)return ' ';if(i==H)return '*';if(wnd<0)return '/';if(wnd>0)return '\\';return '|'}
let drw=(s)=>{ console.log(s.map((v,i)=>{ return v.map(  c=>d(c,i)  ).join('') }).join('\r\n')) }
setInterval(()=>{itrs();clr();drw(s)},100)

See webm of it working here

Noodel, noncompeting 44 bytes
I had centering text on my list of things to do since I made the language... But, I was lazy and did not add until after this challenge. So, here I am not competing, but had fun with the challenge:)
ØGQÆ×Øæ3/×Æ3I_ȥ⁻¤×⁺Æ1Ḷḋŀ÷25¶İÇæḍ€Æ1uụC¶×12⁺ß

The console is size is hard coded to 25x50 which does not look good in the online editor, but does for the snippet.
Try it:)

How It Works
Ø                                            # Pushes all of the inputs from the stack directly back into the stdin since it is the first token.

 GQÆ×Ø                                       # Turns the seconds into milliseconds since can only delay by milliseconds.
 GQ                                          # Pushes on the string "GQ" onto the top of the stack.
   Æ                                         # Consumes from stdin the value in the front and pushes it onto the stack which is the number of seconds to delay.
    ×                                        # Multiplies the two items on top of the stack.
                                             # Since the top of the stack is a number, the second parameter will be converted into a number. But, this will fail for the string "GQ" therein treated as a base 98 number producing 1000.
     Ø                                       # Pops off the new value, and pushes it into the front of stdin.

      æ3/×Æ3I_ȥ⁻¤×⁺                          # Creates the correct amount of rain drops and spaces to be displayed in a 50x25 console.
      æ3                                     # Copies the forth parameter (the number of rain drops).
        /                                    # Pushes the character "/" as the rain drop character.
         ×                                   # Repeats the rain drop character the specified number of times provided.
          Æ3                                 # Consumes the number of rain drops from stdin.
            I_                               # Pushes the string "I_" onto the stack.
              ȥ                              # Converts the string into a number as if it were a base 98 number producing 25 * 50 = 1250.
               ⁻                             # Subtract 1250 - [number rain drops] to get the number of spaces.
                ¤                            # Pushes on the string "¤" which for Noodel is a space.
                 ×                           # Replicate the "¤" that number of times.
                  ⁺                          # Concatenate the spaces with the rain drops.

                   Æ1Ḷḋŀ÷25¬İÇæḍ€            # Handles the animation of the rain drops.
                   Æ1                        # Consumes and pushes on the number of times to loop the animation.
                     Ḷ                       # Pops off the number of times to loop and loops the following code that many times.
                      ḋ                      # Duplicate the string with the rain drops and spaces.
                       ŀ                     # Shuffle the string using Fisher-Yates algorithm.
                        ÷25                  # Divide it into 25 equal parts and push on an array containing those parts.
                           ¶                 # Pushes on the string "¶" which is a new line.
                            İ                # Join the array by the given character.
                             Ç               # Clear the screen and display the rain.
                              æ              # Copy what is on the front of stdin onto the stack which is the number of milliseconds to delay.
                               ḍ             # Delay for the specified number of milliseconds.
                                €            # End of the loop.

                                 Æ1uụC¶×12⁺ß # Creates the centered text that is displayed at the end.
                                 Æ1          # Pushes on the final output string.
                                   u         # Pushes on the string "u" onto the top.
                                    ụC       # Convert the string on the top of the stack to an integer (which will fail and default to base 98 which is 50) then center the input string based off of that width.
                                      ¶      # Push on a the string "¶" which is a new line.
                                       ×12   # Repeat it 12 times.
                                          ⁺  # Append the input string that has been centered to the new lines.
                                           ß # Clear the screen.
                                             # Implicitly push on what is on the top of the stack which is the final output.

Ah thats a cool language to have in my toolbox haha! Anyways, glad you liked the challenge :) +1

Ruby + GNU Core Utils, 169 bytes
Parameters to the function are wait time, number of iterations, message, and number of raindrops, in that order. Newlines for readability.
Core Utils were needed for tput and clear.
->w,t,m,n{x=`tput cols`.to_i;z=x*h=`tput lines`.to_i
t.times{s=' '*z;[*0...z].sample(n).map{|i|s[i]=?/};puts`clear`+s;sleep w}
puts`clear`+$/*(h/2),' '*(x/2-m.size/2)+m}

SmileBASIC, 114 bytes
INPUT W,T,M$,N
FOR I=1TO T
VSYNC W*60CLS
FOR J=1TO N
LOCATE RND(50),RND(30)?7;
NEXT
NEXT
LOCATE 25-LEN(M$)/2,15?M$

Console size is always 50*30.

Python 2.7, 254 251 bytes
This is my own try without using ncurses.
from time import*;from random import*;u=range;y=randint
def m(t,m,w,n):
    for _ in u(t):
        r=[[' 'for _ in u(40)]for _ in u(40)]
        for i in u(n):r[y(0,39)][y(0,39)]='/'
        print'\n'.join(map(lambda k:' '.join(k),r));sleep(w);print '<esc>[2J'
    print' '*33+m

Thank to @ErikTheOutgolfer for correcting and saving me bytes.

You cannot put a for loop in one line (like you have in 40)];for i in u(). You also need an ESC char in '[2J' I think. Also, there was an extra space in u(n): r[y. I don't know how you counted 249 though. All issues I found were fixed here.

The code I posted is working for me. And yeah I actually counted it wrong, I didn't count the white indented space, I didn't know about it. Thanks for the link! I'll edit it.

@EriktheOutgolfer Oh and yeah regarding that ESC char, no escape sequence is needed. It just prints 'ESC[2J' effectively, which is ansi escape sequence for clearing the screen. It doesn't reset the cursor position though.

You can golf it even more :) But you need to add a note below your code specifying that <esc> denotes a literal 0x1B ESC byte. Byte count is 242, not 246.

@EriktheOutgolfer Oh thanks!

@EriktheOutgolfer Something weird happened, I tried to re run the code after the edits you mentioned and it's throwing error for that for loop thing. No kidding but I checked it like 10 times before posting and after your first comment -_-

Yeah I knew you have to do it like my first link. Basically, put the suggestions of my second link and then separate the statements like the first link.

@EriktheOutgolfer Done. I'm still confused why it happened lol

Let us continue this discussion in chat.

Perl 5, 156 bytes
154 bytes code + 2 for -pl.
$M=$_;$W=<>;$I=<>;$R=<>;$_=$"x8e3;{eval'$-=rand 8e3;s!.{$-}\K !/!;'x$R;print;select$a,$a,$a,$W;y!/! !;--$I&&redo}$-=3920-($l=length$M)/2;s;.{$-}\K.{$l};$M

Uses a fixed size of 160x50.
See it online!

Perl 5, 203 bytes
201 bytes code + 2 for -pl.
$M=$_;$W=<>;$I=<>;$R=<>;$_=$"x($z=($x=`tput cols`)*($y=`tput lines`));{eval'$-=rand$z;s!.{$-}\K !/!;'x$R;print;select$a,$a,$a,$W;y!/! !;--$I&&redo}$-=$x*($y+!($y%2))/2-($l=length$M)/2;s;.{$-}\K.{$l};$M

Uses tput to determine the size of the terminal.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Output the Euler Numbers
Given a non-negative integer \$n ,\$ output the \$n^{\text{th}}\$ Euler number (OEIS A122045).
All odd-indexed Euler numbers are \$0 .\$ The even-indexed Euler numbers can be computed with the following formula (\$i \equiv \sqrt{-1}\$ refers to the imaginary unit):
$$
E_{2n}
= i
\sum_{k=1}^{2n+1}{
  \sum_{j=0}^{k}{
    \left(\begin{array}{c}k \\ j \end{array}\right)
    \frac{{\left(-1\right)}^{j} {\left(k-2j\right)}^{2n+1}}{2^k i^k k}
  }
}
\,.
$$
Rules

\$n\$ will be a non-negative integer such that the \$n^{\text{th}}\$ Euler number is within the representable range of integers for your language.

Test Cases
0 -> 1
1 -> 0
2 -> -1
3 -> 0
6 -> -61
10 -> -50521
20 -> 370371188237525

@donbright You're missing a set of parentheses: https://www.wolframalpha.com/input/?i=j%3D1,k%3D1,n%3D0,(k+choose+j)(((-1)%5Ej)(k-2j)%5E(2n%2B1))%2F((2%5Ek)(i%5Ek)(k)) - with that, the two summands are both -i/2, which yield -i when added. Multiply that by the i outside of the summation, and you get 1.

Mathematica, 6 bytes
EulerE

-cough-

When I saw the title, I immediately thought "Surely Mathematica must have a builtin for this".

That applies to pretty much every title... even detecting goats in images

GoatImageQ is underappreciated

Can you explain this? Edit: this was a joke.

J, 10 bytes
(1%6&o.)t:

Try it online!
Uses the definition for the exponential generating function sech(x).

Does J do symbolic analysis to get the generating function? It doesn't run into floating point errors even for n=30.

@orlp I'm not sure what it does internally, but J knows the Taylor series for a subset of verbs. Any function you can define using a combination of those verbs will be valid for t. or t: where are g.f. and e.g.f. A curious note is that tan(x) is not supported but sin(x)/cos(x) is.

PARI/GP, 9 bytes
eulerfrac
This built-in was added in version 2.13.0, after this challenge was asked.
Attempt This Online!

PARI/GP, 24 bytes
n->2*imag(polylog(-n,I))
Attempt This Online!

PARI/GP, 32 bytes
n->n!*Vec(1/cosh(x+O(x^n++)))[n]
This is the original answer.
Attempt This Online!

The built-in function is eulerfrac.

Maple, 5 bytes
euler

Hurray for builtins?

Love it when mathematica is too verbose for a maths problem...

Maxima, 5 bytes / 42 bytes
Maxima has a built in:
euler

Try it online!
The following solution does not require the built in from above, and uses the formula that originally defined the euler numbers.

We are basically looking for the n-th coefficient of the series expansion of 1/cosh(t) = sech(t) (up to the n!)
f(n):=coeff(taylor(sech(x),x,0,n)*n!,x,n);

Try it online!

Mathematica, without built-in, 18 bytes
Using @rahnema1's formula:
2Im@PolyLog[-#,I]&

21 bytes:
Sech@x~D~{x,#}/.x->0&

JavaScript (Node.js), 70 46 44 bytes
F=(a,b=a)=>a?F(--a,b)*~b+F(a,b-=2)*(a-b):+!b

Try it online!
Surprised to find no JavaScript answer yet, so I'll have a try.
The code consists of only basic mathematics, but the mathematics behind the code requires calculus. The recursion formula is derived from the expansion of the derivatives of \$\mathrm{sech}(x)\$ of different orders.
Explanation
Here I'll use some convenient notation. Let \$T^n:=\mathrm{tanh}^n(t)\$ and \$S^n:=\mathrm{sech}^n(t)\$. Then we have
$$\frac{d^nS}{dt^n}=\sum_{i=0}^nF(n,i)T^{n-i}S^{i+1}$$
Since \$\frac{dT}{dt}=S^2\$ and \$\frac{dS}{dt}=-TS\$, we can deduce that
$$
\begin{equation}
\begin{aligned}
\frac{d}{dt}(T^aS^b)&=aT^{a-1}(S^2)(S^b)+bS^{b-1}(-TS)(T^a) \\
&=aT^{a-1}S^{b+2}-bT^{a+1}S^b
\end{aligned}
\end{equation}
$$
Let \$b=i+1\$ and \$a=n-i\$, we can rewrite the relation above as
$$
\begin{equation}
\begin{aligned}
\frac{d}{dt}(T^{n-i}S^{i+1})&=(n-i)T^{n-i-1}S^{i+3}-(i+1)T^{n-i+1}S^{i+1}\\
&=(n-i)T^{(n+1)-(i+2)}S^{(i+2)+1}-(i+1)T^{(n+1)-i}S^{i+1}
\end{aligned}
\end{equation}
$$
That is, \$F(n,i)\$ contributes to both \$F(n+1,i+2)\$ and \$F(n+1,i)\$. As a result, we can write \$F(n,i)\$ in terms of \$F(n-1,i-2)\$ and \$F(n-1,i)\$:
$$F(n,i)=(n-i+1)F(n-1,i-2)-(i+1)F(n-1,i)$$
with initial condition \$F(0,0)=1\$ and \$F(0,i)=0\$ where \$i\neq 0\$.
The related part of the code a?F(--a,b)*~b+F(a,b-=2)*(a-b):+!b is exactly calculating using the above recurrence formula. Here's the breakdown:
F(--a,b)                 // F(n-1, i)                   [ a = n-1, b = i   ]
*~b                      // *-(i+1)                     [ a = n-1, b = i   ]
+F(a,b-=2)               // +F(n-1, i-2)                [ a = n-1, b = i-2 ]
*(a-b)                   // *((n-1)-(i-2))              [ a = n-1, b = i-2 ]
                         // which is equivalent to *(n-i+1)

Since \$T(0)=0\$ and \$S(0)=1\$, \$E_n\$ equals the coefficient of \$S^{n+1}\$ in the expansion of \$\frac{d^nS}{dt^n}\$, which is \$F(n,n)\$.
For branches that \$F(0,0)\$ can never be reached, the recurrences always end at 0, so \$F(n,i)=0\$ where \$i<0\$ or \$i\$ is odd. The latter one, particularly, implies that \$E_n=0\$ for all odd \$n\$s. For even \$i\$s strictly larger than \$n\$, the recurrence may eventually allow \$0\leq i\leq n\$ to happen at some point, but before that step it must reach a point where \$i=n+1\$, and the recurrence formula shows that the value must be 0 at that point (since the first term is multiplied by \$n-i+1=n-(n+1)+1=0\$, and the second term is farther from the "triangle" of \$0\leq i\leq n\$). As a result, \$F(n,i)=0\$ where \$i > n\$. This completes the proof of the validity of the algorithm.

Extensions
The code can be modified to calculate three more related sequences:
Tangent Numbers (46 bytes)
F=(a,b=a)=>a?F(--a,b)*++b+F(a,b-=3)*(a-b):+!~b

Secant Numbers (45 bytes)
F=(a,b=a)=>a?F(--a,b)*++b+F(a,b-=3)*(a-b):+!b

Euler Zigzag Numbers (48 bytes)
F=(a,b=a)=>a?F(--a,b)*++b+F(a,b-=3)*(a-b):!b+!~b

Python 2.7, 46 bytes
Using scipy.
from scipy.special import*
lambda n:euler(n)[n]

Perl 6, 78 bytes
{(->*@E {1-sum @E».&{$_*2**(@E-1-$++)*[*](@E-$++^..@E)/[*] 1..$++}}...*)[$_]}

Uses the iterative formula from here:
$$E_n = 1 - \sum_{k=0}^{n-1} \left[ E_k \cdot 2^{(n-1-k)} \cdot \binom{n}{k}  \right]$$
How it works
The general structure is a lambda in which an infinite sequence is generated, by an expression that is called repeatedly and gets all previous values of the sequence in the variable @E, and then that sequence is indexed with the lambda argument:
{ ( -> *@E {    } ... * )[$_] }

The expression called for each step of the sequence, is:
1 - sum @E».&{              # 1 - ∑
    $_                      # Eₙ
    * 2**(@E - 1 - $++)     # 2ⁿ⁻ˡ⁻ᵏ
    * [*](@E - $++ ^.. @E)  # (n-k-1)·...·(n-1)·n
    / [*] 1..$++            # 1·2·...·k
}

Maxima, 29 bytes
z(n):=2*imagpart(li[-n](%i));

Try It Online!
Two times imaginary part of polylogarithm function of order -n with argument i [1]

Befunge, 115 bytes
This just supports a hardcoded set of the first 16 Euler numbers (i.e. E0 to E15). Anything beyond that wouldn't fit in a 32-bit Befunge value anyway.
&:2%v
v@.0_2/:
_1.@v:-1
v:-1_1-.@
_5.@v:-1
v:-1_"="-.@
_"}$#"*+.@v:-1
8**-.@v:-1_"'PO"
"0h;"3_"A+y^"9*+**.@.-*8+*:*

Try it online!
I've also done a full implementation of the formula provided in the challenge, but it's nearly twice the size, and it's still limited to the first 16 values on TIO, even though that's a 64-bit interpreter.
<v0p00+1&
v>1:>10p\00:>20p\>010g20g2*-00g1>-:30pv>\:
_$12 0g2%2*-*10g20g110g20g-240pv^1g03:_^*
>-#1:_!>\#<:#*_$40g:1-40p!#v_*\>0\0
@.$_^#`g00:<|!`g01::+1\+*/\<
+4%1-*/+\2+^>$$10g::2>\#<1#*-#2:#\_$*\1

Try it online!
The problem with this algorithm is that the intermediate values in the series overflow much sooner than the total does. On a 32-bit interpreter it can only handle the first 10 values (i.e. E0 to E9). Interpreters that use bignums should do much better though - PyFunge and Befungee could both handle at least up to E30.

Python2, (sympy rational), 153 bytes
from sympy import *
t=n+2
print n,re(Add(*map(lambda (k,j):I**(k-2*j-1)*(k-2*j)**(n+1)*binomial(k,j)/(k*2**k),[(c/t+1,c%t) for c in range(0,t**2-t)])))

This is very suboptimal but it's trying to use basic sympy functions and avoid floating point. Thanks @Mego for setting me straight on the original formula listed above. I tried to use something like @xnor's "combine two loops" from Tips for golfing in Python

You can do import* (remove the space in between) to save a byte. Also, you need to take the number as an input somehow (snippets which assume the input to be in a variable are not allowed).

Axiom, 5 bytes
euler

for OEIS A122045; this is 57 bytes
g(n:NNI):INT==factorial(n)*coefficient(taylor(sech(x)),n)

test code and results
(102) -> [[i,g(i)] for i in [0,1,2,3,6,10,20]]
   (102)
   [[0,1],[1,0],[2,- 1],[3,0],[6,- 61],[10,- 50521],[20,370371188237525]]

(103) -> [[i,euler(i)] for i in [0,1,2,3,6,10,20]]
   (103)
   [[0,1],[1,0],[2,- 1],[3,0],[6,- 61],[10,- 50521],[20,370371188237525]]

CJam (34 bytes)
{1a{_W%_,,.*0+(+W%\_,,:~.*.+}@*W=}

Online demo which prints E(0) to E(19). This is an anonymous block (function).
The implementation borrows Shieru Akasoto's recurrence and rewrites it in a more CJam friendly style, manipulating entire rows at a time.
Dissection
{           e# Define a block
  1a        e#   Start with row 0: [1]
  {         e#   Loop...
    _W%     e#     Take a copy and reverse it
    _,,.*   e#     Multiply each element by its position
    0+(+    e#     Pop the 0 from the start and add two 0s to the end
    W%      e#     Reverse again, giving [0 0 (i-1)a_0 (i-2)a_1 ... a_{i-2}]
    \       e#     Go back to the other copy
    _,,:~.* e#     Multiply each element by -1 ... -i
    .+      e#     Add the two arrays
  }         e#
  @*        e#   Bring the input to the top to control the loop count
  W=        e#   Take the last element
}

APL(NARS), 42 chars, 84 bytes
E←{0≥w←⍵:1⋄1-+/{(⍵!w)×(2*w-1+⍵)×E⍵}¨¯1+⍳⍵}

Follow the formula showed from "smls", test:
  E 0
1
  E 1
0
  E 3
0
  E 6
¯61
  E 10
¯50521

the last case return one big rational as result because i enter 20x (the big rational 20/1)
and not 20 as i think 20.0 float 64 bit...
  E 20x
370371188237525

It would be more fast if one return 0 soon but would be a little more long (50 chars):
  E←{0≥w←⍵:1⋄0≠2∣w:0⋄1-+/{(⍵!w)×(2*w-1+⍵)×E⍵}¨¯1+⍳⍵}
  E 30x
¯441543893249023104553682821

it would be more fast if it is used the definition on question (and would be a little more long 75 chars):
  f←{0≥⍵:1⋄0≠2∣⍵:0⋄0J1×+/{+/⍵{⍺÷⍨(0J2*-⍺)×(⍵!⍺)×(¯1*⍵)×(⍺-2×⍵)*n}¨0..⍵}¨⍳n←1+⍵}
  f 0
1
  f 1
0
  f 3
0
  f 6
¯61J0
  f 10
¯50521J¯8.890242766E¯9
  f 10x
¯50521J0
  f 20x
370371188237525J0
  f 30x
¯441543893249023104553682821J0
  f 40x
14851150718114980017877156781405826684425J0
  f 400x
290652112822334583927483864434329346014178100708615375725038705263971249271772421890927613982905400870578615922728
  107805634246727371465484012302031163270328101126797841939707163099497536820702479746686714267778811263343861
  344990648676537202541289333151841575657340742634189439612727396128265918519683720901279100496205972446809988
  880945212776281115581267184426274778988681851866851641727953206090552901049158520028722201942987653512716826
  524150450130141785716436856286094614730637618087804268356432570627536028770886829651448516666994497921751407
  121752827492669601130599340120509192817404674513170334607613808215971646794552204048850269569900253391449524
  735072587185797183507854751762384660697046224773187826603393443429017928197076520780169871299768968112010396
  81980247383801787585348828625J0

The result above it is one complex number that has only the real part.

Wolfram Language (Mathematica), 47 46 bytes
Without using any special functions:
e@0=1;e@n_:=-n!Sum[e[n-k]/k!/(n-k)!,{k,2,n,2}]

Try it online!

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Draw an ASCIIrisk
There are an abundance of questions involving drawing shapes using asterisks - so I thought, with so many asterisks out there, we should draw one, using the ASCII table.
Challenge
Your task is to write a program or function which takes no input, and outputs this exact text:
          !
         "#
         $%
         &'
         ()
         *+
         ,-
         ./
         01
23456789:;<=>?@ABCDEF
GHIJKLMNOPQRSTUVWXYZ[
        \]^_
       `a  bc
      de    fg
     hi      jk
    lm        no
   pq          rs
  tu            vw
 xy              z{
|}                ~

For reference, this site lists the complete ASCII table.
Rules

The output should be the exact text, as shown above. Leading/trailing whitespace is allowed.
Standard golfing loopholes apply - no reading this ASCIIrisk from the internet, etc.
This is code-golf, so the shortest solution (in bytes) wins.

I want to try this challenge... but it sounds kinda risky.
Please excuse my terrible humor.

Stack Overflow has a NoBadJokes policy so I'm going to have to ignore that comment. Sorry but it policy

Okay. Sorry for violating the policy. Thank you for ignoring my comment by replying to it.

@HyperNeutrino Don't judge a challenge by its cover. Now you've missed a really good challenge just because of your prejudice.

@2x-1 I can't tell if you're being ironic.

Someone has to make a script replacing asterisks with this.

05AB1E, 40 38 37 36 35 bytes
žQ2ô376S3*£`2ôvyN·ð×ýð«}rsJ2äsr)˜.c

Try it online!
Explanation
žQ                                   # push the printable ascii chars
  2ô                                 # split into pairs
    376S                             # split the number 376 into a list of digits
        3*                           # multiply each by 3 to get [9,21,18]
          £                          # divide the pairs of ascii chars into
                                     # pieces of these sizes
           `                         # flatten list to stack
            2ô                       # split the "legs" of the asterisk into pairs of pairs
              v                      # loop over the pairs of pairs
               yN·ð×ý                # join the pairs by index*2 spaces
                     ð«              # append a space
                       }             # end loop
                        rs           # move the middle section to top of stack
                          J2ä        # convert to a string split into 2 pieces
                             sr      # rearrange the stack in the correct order
                               )˜    # wrap in a flattened list
                                 .c  # pad each element with spaces on either side

žQ2ôÐ9£s30£R21£RøsrR18£R2ôvyN·ð×ý})˜.C», I got 39, but I think you can shave some off with ZIP.

@carusocomputing: I don't think zip is very useful here since we want the characters to remain sequential. Splitting everything in pairs at the start was a good idea though. It feels wasteful using so many r and s but I don't see a way around it.

31 bytes: Ć added after žQ so the ð« can be removed; vy to ε; rs to Š; sr removed and À added after the ).

Python 3, 110 bytes
s='%c';print(('\n'.join(['%10c%c']*9+[s*21]*2+[' '*(8-i)+s*2+'  '*i+s*2for i in range(9)]))%(*range(32,128),))

Generates the template
         xx
         xx
         xx
         xx
         xx
         xx
         xx
         xx
         xx
xxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxx
        xxxx
       xx  xx
      xx    xx
     xx      xx
    xx        xx
   xx          xx
  xx            xx
 xx              xx
xx                xx

with %c for x, then uses string interpolation on range(32,128) to insert the ASCII values into the pattern.
Try it online!
Python 2 is one byte longer, with longer tuple unpacking but shorter print.
s='%c';print('\n'.join(['%10c%c']*9+[s*21]*2+[' '*(8-i)+s*2+'  '*i+s*2for i in range(9)]))%tuple(range(32,128))

It deserves a Eiffel Tower similarity award!

V, 54, 50 bytes
¬ ~9ñ9É 11|á
ñ2ñ20lá
ñ$18é 9ñ^y|Ehé
Pf xxywk$hP>ñd

Try it online!
Unlike usual, this program does not contain any unprintable characters.
Explanation:
¬ ~                     " Insert the entire printable ASCII range
   9ñ           ñ       " 9 times:
     9É                 "   Insert 9 spaces at the beginning of this line
        11|             "   Move to the 11'th column on this line
           á<CR>        "   And append a newline after the 11'th column

Now the buffer looks like this:
          !
         "#
         $%
         &'
         ()
         *+
         ,-
         ./
         01
23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Now we build up the middle:
2ñ        ñ             " Two times:
  20l                   "   Move 20 characters to the right (because 'l' == 'right', duh)
     á<CR>              "   Append a newline

Here's where it gets a little weird.
$                       " Move to the end of this line
 18é                    " Insert 18 spaces before the last character
     9ñ                 " Repeat the following 9 times:
       ^                "   Move to the first non-whitespace character
        y|              "   Yank all the whitespace before the current character.
                        "   We'll call this the "Leading whitespace register"
          E             "   Move to the end of the current WORD (up to before a space)
           h            "   Move back one character
            é<CR>       "   And insert a newline before the current character
P                       "   Paste the leading whitespace for indentation
 f                      "   Move forward to a space
   xx                   "   Delete two characters
                        "   (Note how we are inbetween the two bottom branches right now)
     yw                 "   Yank everything upto the next branch (all spaces)
                        "   We'll paste this on the line up so that we can yank it again later
                        "   To keep track of how far apart the branches are
       k$               "   Move up a line and to the end of that line
         hP             "   Move back a character and paste the whitespace we yanked
           >            "   Indent this line by one space
            ñ           "   End the loop

Here's an important note. The > command is actually an operator, which means it doesn't do anything without an argument, the text to operate on. For example,
>_      "Indent the current line
>>      "Indent the current line
>j      "Indent the current and next line
>G      "Indent every line

But since this command is in a loop, we can save a character by not giving an operator. At the end of a loop, if any operator is pending it will fill in _ (the current line) as an argument implicitly.
Now I'll admit this loop is a little weird, and it can be hard to keep track of what all text should look like at any given moment. So you can use this simpler program to see what it will look like after N loops.
If you set it to 9, you can see that we have a little bit of extra text to get rid of. (Just the current line).
So we delete the current line with dd. But wait! You know how I said that operators have to take an argument which is sometime implicitly filled in? Arguments are also implicitly filled at the end of the program. So rather than dd or d_ (which are equivalent), we can simply to d and let V fill in the _ for us.

Nice job abusing the implicit ÿ :)

Poetic, 899 bytes
ill be honest with you
i expect a big solitude
i guess i had a guilt
my own idea being:i was real alone,i was a lonely human
also,i am still
o,i guess i was expecting a shift
i figured,surely i know i am tired of silence
now i dreamed for a shift
a magical desire cant come
i am barely a man,so i guess i see why a woman i see ignores myself
i know i am awful
o,a night of passion and a moment of love
i am truly the foolish person,every time i am saying i may recapture a love
o,i think i can,i think i can
i really do know i am unfit
o,i notice a lot,i think i know i am unfit
o,a novel,or perhaps poetry in code,i do enjoy the writing
and i shudder and i wonder in a moment
i was a weirdo,i was a freak,or like,i am creepy
o,i think i was a misfit
i know i am,really
o,i ought not concern myself
and sure,i am still some joyless man
i focused and i tried
a lasting solace and joy is nearby for me

Try it online!
Poetic is an esolang I made in 2018 for a class project. It's basically brainfuck with word-lengths instead of symbols.
This poem is...depressing.

Python 3 170 165 155 147 bytes
I've golfed this so much, I've forgotten how it works...
i=b=0
for x in range(32,127):a=x%2<1;c=x>90;d=x<50;print(end=[' '*9*d,['\n'+' '*(8-i),'  '*~-i][b]][c]*a+chr(x)+'\n'*(x==70or d*x%2));b^=a;i+=b*c*a

Try it online!

JavaScript (ES6), 156 … 115 114 bytes
Sadly, the infamous String.fromCharCode() costs 19 bytes.

f=(x=y=k=1)=>k<96?String.fromCharCode(x-22?y/2^5&&(y>9?x-y+1>>1&&22-y-x>>1:x/2^5)?32:31+k++:(x=!++y,10))+f(x+1):''

console.log(f())

Formatted and commented
f = (                         // given:
  x =                         //   - x = current column
  y =                         //   - y = current row
  k = 1                       //   - k = current ASCII character code, minus 31
) =>                          //
  k < 96 ?                    // if we havent't reached character #127 (96 + 31):
    String.fromCharCode(      //   let's compute the next character
      x - 22 ?                //   if x is not equal to 22 (end of line):
        y / 2 ^ 5 && (        //     if y doesn't equal 10 or 11 (horizontal bar):
          y > 9 ?             //       and either y is greater than 9:
            x - y + 1 >> 1 && //         and we are not located on one of the
            22 - y - x >> 1   //         bottom diagonals
          :                   //       or y is less or equal to 9:
            x / 2 ^ 5         //         and x doesn't equal 10 or 11 (vertical bar)
        ) ?                   //     then:
          32                  //       append a space
        :                     //     else:
          31 + k++            //       append the next ASCII character
      :                       //   else:
        (x = !++y, 10)        //     increment y, reset x and append a LineFeed
    ) + f(x + 1)              //   do a recursive call with x + 1
  :                           // else:
    ''                        //   stop recursion

I think you can do String.fromCharCode(...[...Array(n)].map(_=>k++)) to save 4 bytes.

@ETHproductions I like the idea of calling String.fromCharCode() on an array, but I went for another approach. Thanks anyway!

QBIC, 153 151 bytes
[32,49,2|?space$(9)+chr$(a)+chr$(a+1)][2|X=Y[a,a+20|X=X+chr$(c)]a=a+21?X][0,8|X=space$(8-d)[0,1|X=X+chr$(a+e)]X=X+space$(d*2)[2,3|X=X+chr$(a+f)]a=a+f?X

It's really just a series of FOR-loops and casting an int to a character (chr$()).
Sample output:
          !
         "#
         $%
         &'
         ()
         *+
         ,-
         ./
         01
23456789:;<=>?@ABCDEF
GHIJKLMNOPQRSTUVWXYZ[
        \]^_
       `a  bc
      de    fg
     hi      jk
    lm        no
   pq          rs
  tu            vw
 xy              z{
|}                ~

Perl, 113 bytes
112 bytes of code + -l flag.
sub g{chr$c+++32}print$"x9,&g,&g for 0..8;print map&g,0..20for 0,1;print$"x-$_,&g,&g,$"x(16+2*$_),&g,&g for-8..0

Try it online!

PHP, 110 105 103 93 91 bytes
for(;$c<95;$y+=!$x%=21)echo"
"[$x],chr(31+($y%11<9&(max($y,10)-abs(9.5-$x++))%11<9?:++$c));

prints a leading newline. Run with -nr or test it online.
The basic principle is adopted from Arnauld, but this iterates.
And it takes good advantage from PHP´s implicit typecasts:
NULL to int for string index, float to int for %, boolean to int for & and for +=.
explanation with pseudo code
If $x is 0, print a newline. ("\n"[$x] is newline for $x=0; empty for every larger $x)
if $y is neither 9 nor 10 (not middle part: $y<9|$y>10 <=> $y%11<9)
AND distance to center == abs(9.5-$x) (in [0.5,1.5,..,10.5]) ->
    lower part:     abs($y-10-distance)>1                   => ($y-distance)%11<9
                (this works because $y is always <20)
    upper part: $x<9|$x>10 <=> distance>1 <=> 10-distance<9 => (10-distance)%11<9
                (this works because % has negative results for negative first operands)
    both parts: $y>9?$y:10 <=> max($y,10)
// $a?:$b evaluates to $a if $a is truthy, to $b else
// and the ternary condition evaluates to 1 if the coords are not in the shape
then print chr(31+1) = space
else print chr(31+incremented $c)

Pyth, 53 bytes
js.e@[+L*9;cb2c2b.e+*-8Ydj*yYdZcL2cb4)kcsrdC127,18 60

A program that prints the result.
Try it online!
How it works
srdC127 creates a list of the printable ASCII characters and concatenates this to a string.
c....,18 60 splits this string at indices 18 and 60, giving a list of three strings corresponding to the different parts of the output: the top, the middle and the bottom.
.e begins an enumerated map over the strings with the strings as b and their indices as k.
[...) creates a list containing the desired action for each part of the diagram. The correct action is chosen by indexing into the list with the current index, using @...k.

Top
cb2 splits the string into pairs of characters, and +L*9; prepends 9 spaces to each pair.
Middle
c2b splits the string into two equal-length strings.
Bottom
cL2cb4 splits the string into groups of four characters, and each group into pairs.
.e begins an enumerated map, with the string pairs as Z and their indices as Y.
j*yYdZ joins the pairs on 2*Y spaces, and +*-8Yd prepends 8-Y spaces.

js merges all the results and joins the resulting list on newlines. This is then implicitly printed.

Haskell, 144 bytes
b!n=[1..n]>>b
('*':r)#(a:s)=a:r#s
(a:r)#s=a:r#s
r#s=r
p="**"
f=unlines([" "!9++p]!9++["*"!21]!2++[" "!(8-n)++p++" "!(2*n)++p|n<-[0..8]])#[' '..]

Try it online!
Explanation:
b!n=[1..n]>>b defines a function ! which repeats a list or string b n-times.
unlines([" "!9++p]!9++["*"!21]!2++[" "!(8-n)++p++" "!(2*n)++p|n<-[0..8]]) uses this function to draw an asterisk of asterisks (Oh, the irony!):
         **
         **
         **
         **
         **
         **
         **
         **
         **
*********************
*********************
        ****
       **  **
      **    **
     **      **
    **        **
   **          **
  **            **
 **              **
**                **

# is defined as a function which consecutively replaces * in a string with chars from a given list. It's called with the above asterisk of asterisks and [' '..] which is an infinite list of all characters starting with the space ' '.

Super late to the party here, but that " "!(2*n) can be "(TWO SPACES)"!n.

Charcoal, 39 bytes (noncompeting)
ＧＨ↑χ→⁴↓χ→¹¹↓⁴←χ↘χ←⁴↖⁹←²↙⁹←⁴↗χ←⁹↑⁴→⁹ ↓¤γ

Try it online! AST provided for explanation, χ being the preinitialized variable for 10.

J, 63
(not competing)
a.{~32>.31+20 21$(* +/\),(9 21&$@{.,1:,1:,}.)(+.1&|."1)|.=|i:10

the expression evaluates right to left thus:

i: 10 counts from -10 to +10
| take abs to get +10 to 0 back to +10
= self classify to get V shape of 1's in a block of 0's
|. reverse row order to get /\ shape
( +. 1&|."1 ) hook expression shifts each row right by one and OR's with original
( 9 21&$@{. , 1: , 1: , }. ) nested forks to put in horizontals and stretch top
, to raze the block into a linear sequence for cumulation
( * +/\ ) cumulate and multiply with self
20 21 $ revert shape to a block 20 rows of 21 elements
31 + add 31 because first 1 should be a space char code 32
32 >. floor at 32
a. {~ pick chars from ascii built-in

Welcome to PPCG! How come you marked this as not competing?

I just thought I'd add my effort even though it's a long time [15mths] after the competition was launched .. are you saying each puzzle stays open? .. also for J expression to print outside the REPL, i.e when executed in a script I'd need to prefix smoutput command or equivalent

Challenges generally stay open indefinitely (even if an answer has already been accepted). There are some special types of challenges that sometimes get closed to new entries (answer-chaining, cops-and-robbers, king-of-the-hill come to mind), but those will usually say so in the challenge description. As for whether this is a valid answer format, you'd have to ask someone with more J experience, but REPL answers are generally fine as long as they're marked as such.

Ruby, 91 bytes
->{(-11..8).map{|i|["%s"*21,"%#{9-i}s%s%#{i*2+1}s%s","%10s%s"][i/2<=>-1]}*$/%[*' '..?~,$/]}

Ungolfed
->{(-11..8).map{|i|            #For each line
  ["%s"*21,                    #If i/2==-1 make a format string of 21 %s
   "%#{9-i}s%s%#{i*2+1}s%s",   #If i/2>-1 make a format string %{9-i}s%s%{i*2+1}s%s
   "%10s%s"][i/2<=>-1]         #If i/2<-1 make a format string %10s%s
  }*$/%                        #Join the format strings with newlines $/ then use sprintf operator %
  [*' '..?~,$/]                #to replace the %s with *' '..'~' and a newline for last corner.
}

Tcl, 209 bytes
proc I {} {incr ::i}
proc A {} {time {append a [$::F %c [I]]} 21;puts $a}
set i 31
time {puts [[set F format] %10c%c [I] [I]]} 9
A
A
time {puts [$F %[expr 32-[I]/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

Try it online!

Tcl, 212 bytes
proc I {} {incr ::i}
proc A {} {time {append a [$::F %c [I]]} 21;puts $a}
set i 31
time {puts [[set F format] %10c%c [I] [I]]} 9
A
A
time {puts [$F %[expr (129-[I])/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

Try it online!

tcl, 213
proc I {} {incr ::i}
set F format
proc A {} {time {append a [$::F %c [I]]} 21;puts $a}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
A
A
time {puts [$F %[expr (129-[I])/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

demo

tcl, 214
proc I {} {incr ::i}
set F format
proc A {} {time {append a [$::F %c [I]]} 21;puts $a}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
A
A
time {I;puts [$F %[expr (129-$i)/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

demo

tcl, 227
proc I {} {incr ::i}
set F format
proc A {} {time {append ::a [$::F %c [I]]} 21}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
A
set a $a\n
A
puts $a
time {I;puts [$F %[expr (129-$i)/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

demo

tcl, 236
proc I {} {incr ::i}
set F format
proc A {} {time {append ::a [$::F %c [I]]} 21}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
set a ""
A
set a $a\n
A
puts $a
time {I;puts [$F %[expr (129-$i)/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

demo

tcl, 237
proc I {} {incr ::i}
set F format
proc A {} {time {set ::a $::a[$::F %c [I]]} 21}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
set a ""
A
set a $a\n
A
puts $a
time {I;puts [$F %[expr (129-$i)/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

demo

Alternative approach with same size:
proc I {} {incr ::i}
set F format
proc A b {time {upvar $b c;set c $c[$::F %c [I]]} 21}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
set a ""
A a
set a $a\n
A a
puts $a
time {I;puts [$F %[expr (129-$i)/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

demo

Tcl, 288
lassign {set while puts format incr expr} S W P F I E
$S i 31
$W \$i<48 {$P [$F %10c%c [$I i] [$I i]]}
$S a ""
$W {[$I i]<71} {$S a $a[$F %c $i]}
$S a $a\n
$W \$i<92 {$S a $a[$F %c $i];$I i}
$P $a
$W \$i<128 {$P [$F %[$E (129-$i)/4]c%c $i [$I i]][$F %[$E $i/2-45]c%c [$I i] [$I i]]; $I i}

demo

tcl, 297 bytes (naïve attempt)
set i 31
while \$i<48 {puts [format %10c%c [incr i] [incr i]]}
set a ""
while {[incr i]<71} {set a $a[format %c $i]}
set a $a\n
while \$i<92 {set a $a[format %c $i];incr i}
puts $a
while \$i<128 {puts [format %[expr (129-$i)/4]c%c $i [incr i]][format %[expr $i/2-45]c%c [incr i] [incr i]]; incr i}

demo

What do you mean by "naïve attempt"? Shouldn't you put the length in the title instead?

I mean there is space for golfing it more, because there is still much repetition. And I will golf it more.

Raw approach has 254 byte extent.

209

@ASCII-only: Thanks. Mine is not exactly equal to your suggestion! ;)

I changed it a bit so the arguments are all [I], but yeah that works too

I missed an answer in C# so...
C# (.NET Core), 175 174 bytes
_=>{var r="";for(int i=0,j,d=32,s=1;i<54;i++)for(j=0;j++<"*#4#4#4#4#4#4#4#4#+K)%1###/#%#-#'#+#)#)#+#'#-#%#/###1#"[i]-33;)r+=(char)(i%2<1?32:d++)+(s++%21<1?"\n":"");return r;}

Try it online!

1 byte saved thanks to Kevin Cruijssen!

You can save a byte by putting the ints inside the for-loop: for(int i=0,j,d=32,s=1;i<54;i++)for(j=0

172 bytes

C (gcc), 119 117 bytes
-2 bytes thanks to ceilingcat
f(c){for(c=0;c<95;c++)printf("%*c%s",c&1?:c<18?10:c<60?:c&2?c/2-30:24-c/4,c+32,c&c<18|c==38|c>58&!(c-63&3)?"\n":"");}

Try it online!

Stax, 33 bytes
¬♣╘╣Ye╗}Ω╩Ñ╬↓ï|§≈b↕£♠╨z▐₧3→ÿ≡Δ:╔♫

Run and debug it
Uses a similar idea to the 05AB1E answer.

Python 2.7, 194 188 bytes
k,l,c,s,r=8,0,chr,' ',range;o=''.join(map(chr,r(32,127)))
for i in r(0,18,2):print s*9+o[i:i+2]
print o[18:39]+'\n'+o[39:60]
for i in r(60,95,4):print s*k+o[i:i+2]+s*l+o[i+2:i+4];k-=1;l+=2

You can drop 2 bytes by changing map(chr to map(c as c has already been defined as chr

Jq 1.5, 180 bytes
foreach((range(9)|[9,2]),(range(2)|[0,21]),(range(9)|[8-.,2,.+.,2]))as$r({s:[range(32;127)]|implode};.r=$r|.p=""|until(.r==[];.p+=" "*.r[0]+.s[:.r[1]]|.s =.s[.r[1]:]|.r=.r[2:]);.p)

Expanded
foreach (                              # instruction sequence: [indent, count]
    (range(9)|[9,2]),                  # 9 rows of 2 characters indented 9 spaces
    (range(2)|[0,21]),                 # 2 rows of 21 characters
    (range(9)|[8-.,2,.+.,2])           # 9 rows of 4 characters with varying indent
) as $r (
    {s:[range(32;127)]|implode}        # state = ascii string
  ; .r = $r                            # current instruction
  | .p = ""                            # print string for this row
  | until(.r==[];                      # until current instruction is exhausted
        .p += " "*.r[0] + .s[:.r[1]]   # add to print string
      | .s = .s[.r[1]:]                # remove from state
      | .r = .r[2:]                    # remove from instruction
    )
  ; .p                                 # emit print string
 )

Try it online!

Slashes (///), 324 bytes
          !
         "#
         $%
         &'
         ()
         *+
         ,-
         .\/
         01
23456789:;<=>?@ABCDEF
GHIJKLMNOPQRSTUVWXYZ[
        \\]^_
       `a  bc
      de    fg
     hi      jk
    lm        no
   pq          rs
  tu            vw
 xy              z{
|}                ~

The first (default) action in Slashes is 'print', so the string is printed. The / and \ must be escaped by proceeding \s.

You should add the byte count and preferably a link to an interpreter. It looks rather ungolfed though (not sure if it's better to do better in ///).

It's somewhat of a joke to show the beauties of ///, and I will add those!

Java 8, 176 173 172 bytes
v->{for(char i=54,j,d=32,s=1;i-->0;)for(j=0;j++<"#1###/#%#-#'#+#)#)#+#'#-#%#/###1%)K+#4#4#4#4#4#4#4#4#*".charAt(i)-33;)System.out.print((i%2<1?d++:32)+(s++%21<1?"\n":""));}

Port of @Charlie's C# .NET answer, so make sure to upvote him.
-4 bytes thanks to @ceilingcat.
Try it online.