text:
Write lines in detention
Introduction
Bad news guys - you got detention. Your English teacher doesn't understand this site and wants you to "stop doing math on your digital dohickeys, this is English class!"
She sentenced you to write her favorite saying on the blackboard 25 times, which will give a total of 100 lines on the blackboard.
The eighteen-hundreds were a time for rum.
The nineteen-hundreds were a time for fun.
The two-thousands are a time to run
a civilized classroom.

Lucky for you, you are an avid reader (not to mention an expert code-golfer)! You have a read about a trick that might possibly get you off easy.

(Foxtrot by Bill Amend)
Unfortunately for Jason, it didn't work out. But you have a better idea! Since your English teacher thinks you're doing math, if you leave all the numbers out of your program it just might work! You also want to keep your program as short as possible because you are a lazy student and don't want to write a lot on the board.
Write a program that complies with the following rules:

Your program must print the 4 above lines 25 times. The lines must be outputted in that order, repeating. Total exactly 100 lines of output (a trailing newline at the very end or a leading newline at the very beginning is okay).
You cannot use the characters 0123456789. Your teacher gets confused by math and will call you out!
You can use any imports and external libraries without counting the imports. Your English teacher doesn't know about programming. Jason could have saved a lot of work by not writing #include <stdio.h> and you don't want to make his same mistakes!
Score your program by byte count. Lowest score wins!

If the text would've read "1900s", writing the output would've been slightly more tricky.

to the comix: he's not printing \n's, and the loop from 1 is pretty awkward (like against C nature)...

@V-X Bill Amend is a long-time Pascal die-hard, and whenever he writes C that becomes pretty apparent.

Can we see some Brainfuck code here? :)

@cybermonkey It's here http://codegolf.stackexchange.com/a/40256/148

The issue with allowing free imports is Python: from random import random as r - it can combine imports and aliases into one statement. Probably not too useful for a simple challenge like this though

Would you allow a leading newline?

This sounds very much like one of my old English teachers.

Banning + would have made sense here, but maybe that would have been too difficult.

CJam, 109 107 106 104 103 bytes
0000000: 22 0c 20 4f 18 41 e4 d8 a5 f3 95 cf 5e 2b cb 1c  ". O.A......^+..
0000010: 44 64 2f bf 28 23 e2 47 4e 4e 77 73 fc 43 09 a2  Dd/.(#.GNNws.C..
0000020: 09 0b fb 18 29 e8 e8 49 5d fc 00 da b8 70 b6 3e  ....)..I]....p.>
0000030: 0c 24 d7 5a 5b 28 1c 45 2e 90 63 86 04 5c 3e 95  .$.Z[(.E..c..\>.
0000040: 4b ae 66 22 48 48 2a 62 46 47 2b 62 22 54 0a 20  K.f"HH*bFG+b"T.
0000050: 2d 2e 22 27 7b 2c 57 25 7c 66 3d 7b 28 2f 29 2a  -."'{,W%|f={(/)*
0000060: 7d 5a 2a 43 44 2b 2a                             }Z*CD+*

The above is a reversible xxd dump.
Testing
You can generate and execute the above code by running this in the online interpreter:
"bxyyeighxrum.yninexfun.ytwo-thousands abto run
a civilized classroom.y
The xteen-hundreds webfor bre a time ""T
 -."'{,W%|f#31bHH*b:c`'\2*/'\*"HH*bFG+b""T
 -."`"'{,W%|f={(/)*}Z*CD+*"]:+~

To see the generated code (without executing it), remove the final ~.
To count the number of bytes (one character is one byte in ISO-8859-1), replace the final ~ with a ,.
Printable version (122 bytes)
"bxyyeighxrum.yninexfun.ytwo-thousands abto run
a civilized classroom.y
The xteen-hundreds webfor bre a time "{(/)*}Z*CD+*

After pushing the string (S), the following gets executed:
{    }Z*        " Repeat 3 times:     ";
 (              "     Q := S.shift()  ";
  /             "     T := S.split(Q) ";
   )            "     R := T.pop()    ";
    *           "     S := T.join(R)  ";
        CD+*    " S *= 12 + 13        ";

Moar golfing
After pushing the unprintable string (U), the following gets executed:
HH*b                        " U := U.base(17 * 17) ";
    FG+b                    " U := U.base(15 + 16) ";
        "T\n -."            " P := 'T\n -.'        ";
                '{,W%|      " P |= 'zyx...\0'      ";
                      f=    " U[i] -> P[U[i]]      ";

This pushes the string of the printable version. The rest of the code works as before.

Using the code, I get this generated code which is 144 bytes. Am I doing something wrong ?

UTF-8 encoding would result in a higher byte count, yes. With ISO-8859-1, the byte count is 109. You can replace ~ with , to verify.

Not sure about ISO-8859-1 , but simply replace ~ with , just gives character count, no ?

Correct, but all character codes are less than 256, so one character is one ISO-8859-1 byte.

I dunno about this. I see a ½ in there... ;)

I got the exact result Optimizer did, but adding the ]:+~ made it work. Why don't you just add that to your code?

Does CJam support ISO-8859-1?

@user23013: The Java interpreter respects $LANG for I/O. Internally, CJam just has 16-bit chars.

@Dennis That's great. I have an unfinished CJam program to generate ASCII-only bmp files, which is meaningless now.

You actually do not have to unicode-ize your solution as without compression itself it is only 124 bytes, beating all others.

JavaScript (ES6) 164
B='teen-hundreds were a time',alert(B.replace(/./g,
"The eigh"+B+" for rum.\nThe nine"+B+" for fun.\nThe two-thousands are a time to run\na civilized classroom.\n"))

Test In FireFox/FireBug console.

This is genius!

@Optimizer I don't know JavaScript well, but is this taking the string B and replacing its entirety with the larger string a number of times equal to B's length?

Yup, replacing each character by the larger string. Making 25 copies of the larger string.

@Optimizer That is genius :)

I can't help thinking the OP was expecting it.  The oddly phrased repeated section just happened to be 25 characters long.

@Malvolio In fact the repeated section is 30 characters. And I could show a huge sequence of attempts, adding and cutting words and replacing replaces before finding this simple solution.

Why specifically are we using alert? Is there some rule that the JS console output is undesirable?

@ShadowCat7 implicit console output is cheating in my opinion. console.log is longer.

Such cleverness in a simple challenge like this. PPCG never stops amazing me.

Brilliant. Great work!

http://pastebin.com/YMSYGYzu < 151 bytes. Try here: http://www.es6fiddle.net/if2va393/

Oops, left a few bytes behind: http://pastebin.com/djn6Yhy6 < 146 bytes (tweetable). Try on: http://www.es6fiddle.net/if2vm7qm/ (for any ES5 browser).

@IsmaelMiguel I think you mean any ES6 browser. Problem: at time this challenge was posted, template strings were not implemented in any browser: Firefox was the first - rel 34, dec first 2014 - then Chrome, march 2015. But even without template strings your scoure would be 153, better than mine. You should post it as an answer.

@IsmaelMiguel if you decide to post it, you have my vote (I always vote answer better than mine)

@edc65 No no, that link works in any browser. I tested it on IE11. It's an online transplier.

@IsmaelMiguel uh, ok, nice. Something to remember, thank you

@edc65 Nice work, I hadn't considered using str1.replace(/./g, str2) as a loop... I'll have to consider this for future golfs...

Python : 188 173 160 153
a="teen-hundreds were a time"
print"The eigh%s for rum.\nThe nine%s for fun.\nThe two-thousands are a time to run\na civilized classroom.\n"%(a,a)*len(a)

I don't python much, but this seems pretty short to me.
Edit: So I was wrong, it wasn't short at all! Thanks for the assistance in comments :D

You could lose the newline and indent on the for loop to save a couple of bytes.

@Trengot Thanks, I forgot about that for some reason :)

I'm fairly sure you could save a fair few in the string as well. Give me a moment.

@Trengot I tried it as a single line and got a runtime error ('a' not defined). For an extra byte I can split it in two lines, though. Thanks!

If you move the last five characters out of a, it will be 25 characters long. Then your for loop can be for i in a:

@RobWatts He could also do for i in a[3:].

@FryAmTheEggman 3 is not allowed

@RobWatts Ach, you're right :). I think this is better: len(b[ord('x'):]).

@FryAmTheEggman, still too long. Stop a after time, then for i in a:print b

@Geobits, I make that 157

@Trengot What's 157? The code I have posted is 160. I've counted it several times now... Is what you're counting different somehow?

@Geobits are you running on a windows machine? The line encodings in windows are frequently \r\n instead of just \n. That might be why it's showing 157 bytes for us, but 160 for you.

This is 160 only. You are probably skipping the three \ in \n due to escaping ...

@RobWatts I thought of that, so counted each line separately (29,111,18), plus a byte for each of 2 newlines makes 160. I really can't see any other way to count it.

You can move the value for b into the print: % has higher precedence than *.

You can lose the space too :) print'' is perfectly valid.

@FryAmTheEggman Cool, I wasn't sure the string/math precedence would work right there.

@Geobits Actually, I think I was mistaken: they have the same precedence, the % just comes first. (So it's still fine)

@Luminous I took those 5 out so that len(a) is 25. If I add them back, it doesn't save because I have to get 25 some other way.

CJam, 151 140 135 132 130 128 bytes (Tweetable)
"TeighYrum.TnineYfun.Ttwo-thousands are a time to run
a civilized classroom.""YT"["teen-hundreds were a time for ""
The "]erAF+*

Try it here
I am able to shorten this down to 110 bytes by converting this to unicode, but since that is not beating the other unicode solution, I would rather not put it :)

Hey, what's that :D emoticon doing there?! Are you texting your friends during detention? Go to the principal's office!

@Doorknob :D
:P

Maybe you could make T alias to .\nThe , then remove the extra line that this produces from the start of the output string (my cjam-fu isn't good enough to figure out whether you can easily do that)

@professorfish that ends up consuming more bytes than it saves. https://mothereff.in/byte-counter#%22TeighYrumTnineYfunTtwo-thousands%20are%20a%20time%20to%20run%0Aa%20civilized%20classroom%22%22YT%22%5B%22teen-hundreds%20were%20a%20time%20for%20%22%22.%0AThe%20%22%5DerAF%2B*%28Y%2F%28%40\

Nitpicking: Using the upper 128 bytes of an ASCII-compatible code page has nothing to do with Unicode.

PHP, 0 bytes

You can use any imports and external libraries without counting the imports.

To run this code, you must import a library called data://text/plain,<?php...classroom.\n"; with this:
<?php require_once 'data://text/plain,<?php
  for($i=ord("z");$i>ord("a");$i--)
    echo "The eighteen-hundreds were a time for rum.
The nineteen-hundreds were a time for fun.
The two-thousands are a time to run
a civilized classroom.
";'; ?>

And you must have allow_url_include enabled in your php.ini.
No more numbers or extensions, thanks to Dennis.

My first instinct was to yell something about loopholes, but since this answer is actually self-contained, I think this is a clever way of using PHP to exploit a loophole that has been created deliberately for Python answers. Since you're already cheating, you could just use require_once "data://text/plain,The eighteen-hundreds...";, which doesn't require sh, doesn't use numbers and is still 0 bytes.

I'll upvote this for creativity but I won't accept this one.

Ruby, 185 180 176 bytes
EDIT: String interpolation, thanks @britishtea
It's my first golf ever, and I'm not much of a Rubist (but I certainly love Ruby). Anyway, this is it (shortened, Doorknob's suggestion).
t=' were a time for '
s="The eighteen-hundreds#{t}rum.
The nineteen-hundreds#{t}fun.
The two-thousands are a time to run
a civilized classroom."
s.split.size.next.times{puts s}

You can golf this down further by replacing some of the repeating words / word-groups with String interpolation.

+1 for noticing there are (almost) 25 words in the string

s.split.size.next saves 5 characters (you don't need to specify the space to split on).

I don't know Ruby, but wouldn't (s.split.size+1).times be 1 byte shorter?

@Sieg not allowed to use numbers!

@rjdown Somehow I forgot.

Java 249 231 230 222
My first answer! Why not start off using the language I know so well.
class c{public static void main(String[]g){for(int a='!';a++<':';out.println("The eighxrum.\nThe ninexfun.\nThe two-thousands are a time to run\na civilized classroom.".replaceAll("x","teen-hundreds were a time for ")));}}

Ungolfed
import static java.lang.System.*;
class c
{
    public static void main(String[]g)
    {
        for(int a='!';a++<':';out.println("The eighxrum.\nThe ninexfun.\nThe two-thousands are a time to run\na civilized classroom.".replaceAll("x","teen-hundreds were a time for ")));
    }
}

Welcome! You can get rid of the public for your class and shorten args to a single character. You could also do a++<':' instead of incrementing it separately. Since the OP isn't counting imports, you can save a bit more with import static java.lang.System.*;, then you don't need to write System. later (where it counts). Doing that I got it down to around 230. You might want to take a look at the Java tips page if you haven't already.

@Optimizer Thanks! I just didn't see the strikeout above.

@Luminous NP :)

@Geobits Thank you! Apparently, you can also stick code right into the loop itself. Didn't add or remove anything, but I think it looks more golfed that way.

Loop abuse is pretty common. If you had multiple statements in the body, you could put one on the outside and the rest inside to save a single character (since you need a semicolon outside anyway). A lot of golfs end up being one big loop that way. Also, "looks more golfed" is a totally valid reason to do anything even if it doesn't save :P

@Geobits Interesting. I'll remember that. Also between you, me, and anyone reading these comments, I wonder where the C# answer got his inspiration from?

Not really. There's usually only a few short ways to do it, so there's bound to be overlap. Compare yours to the older C version, for example.

C 171
a='a';b="teen-hundreds were a time for ";main(){for(;a++<'z';)printf("The eigh%srum.\nThe nine%sfun.\nThe two-thousands are a time to run\na civilized classroom.\n",b,b);}

At first, I tried the simplistic version (189 bytes), which was better than the other C solution...
main(a){for(a='a';a<'z';++a)printf("The eighteen-hundreds were a time for rum.\nThe nineteen-hundreds were a time for fun.\nThe two-thousands are a time to run\na civilized classroom.\n");}

which I later optimized a bit...

Huh, that's nifty.  I didn't realise static variables with string literals assigned to them implicitly have type char *.

@FireFly GCC compiles fine on the a presumably because it defaults to int, which can accept a char value. It doesn't like b unless I call it a char[] though. V-X, what compiler are you using?

b is int too but it holds the pointer to the string literal. It's completely ok in GCC (I have on my machine 4.8.2).

for(a='a';++a<'z';)

JavaScript, ES6, 174 172 154 bytes
Using @edc65's replace trick. Thanks!

alert((d="teen-hundreds were a time").replace(/./g,`The eigh${d} for rum.
The nine${d} for fun.
two-thousands are a time to run
a civilized classroom.
`))

Works only in latest Firefox (34 and above) due to use of template strings.

@Nijikokun You know that will cause 30 repetitions instead of 25, right ?

I am guessing that ff 34 is beta or something since I am on latest (just checked) and it is 33 and it does not work on there

BrainFuck (1,597 characters)
+++++++++++++++++++++++++[>->-[--->+<]>-.[---->+++++<]>-.---.--[--->+<]>-.+[->+++<]>++.++++.--.+.++++++++++++.+++[->+++<]>..+++++++++.[----->++<]>+.[->++++++++<]>.[--->+<]>---.-------.----------.++++++++++++++.-------------.-.--[--->+<]>---.+[---->+<]>+++.--[->++++<]>-.[->+++<]>.+++++++++++++.-------------.--[--->+<]>-.[->+++<]>+.-[->+++<]>.---[->++++<]>.-----------.++++.--------.--[--->+<]>-.++[->+++<]>.+++++++++.+++.[-->+++++<]>+++.---[----->++<]>.+++.--------.+[----->++<]>++.>++++++++++.>-[--->+<]>-.[---->+++++<]>-.---.--[--->+<]>-.+[----->+<]>+.-----.+++++.---------.[--->+<]>---.+++[->+++<]>..+++++++++.[----->++<]>+.[->++++++++<]>.[--->+<]>---.-------.----------.++++++++++++++.-------------.-.--[--->+<]>---.+[---->+<]>+++.--[->++++<]>-.[->+++<]>.+++++++++++++.-------------.--[--->+<]>-.[->+++<]>+.-[->+++<]>.---[->++++<]>.-----------.++++.--------.--[--->+<]>-.++[->+++<]>.+++++++++.+++.[-->+++++<]>+++.++[->+++<]>.-[--->+<]>--.-------.[----->++<]>++.>++++++++++.>-[--->+<]>-.[---->+++++<]>-.---.--[--->+<]>-.---[->++++<]>.+++.--------.[->+++++<]>++.+[--->++<]>.------------.+++++++.++++++.--.++[->+++<]>++.+++++++++++++.----------.--[--->+<]>---.+[---->+<]>+++.[->+++<]>+.--[--->+<]>---.-------------.--[--->+<]>-.[->+++<]>+.-[->+++<]>.---[->++++<]>.-----------.++++.--------.--[--->+<]>-.---[->++++<]>.-----.[--->+<]>-----.---[----->++<]>.+++.-------.>++++++++++.--[--->++++<]>+.-[->+++<]>.+[->+++<]>.++++++.[->++++++<]>.[------>+<]>.+++.---.-[--->+<]>++.---[->+++<]>.-.-[--->+<]>-.+[->+++<]>.+++++++++.-----------.--[--->+<]>--..-.---..--.+[----->++<]>++.>++++++++++.[[-]<+]<-]

This can still be golfed further, if anyone is interested.
You can test this out and confirm that it gives the correct output while meeting all of the rules.

What's this? I told you to write sentences, not random squiggles! There aren't even any words in here!

Ummm.. I think the goal is to use the fewest characters. You sure won the "anti-goal" :-)

Since she hates math so much, why not Mathematica (177)
   a = "teen-hundreds were a time for "; Do["The eigh" <> a <> "rum.
   The nine" <> a <> "fun.
   The two-thousands are a time to run a civilized classroom." // Print, {StringLength@a}]

Perl - 145
I'm happy to see so many answers! Here's a Perl solution.
$s="teen-hundreds were a time for";print"The eigh$s rum.
The nine$s fun.
The two-thousands are a time to run
a civilized classroom.
"for b..z

Javascript ES6, 198 193 bytes
m=Math;alert("The eighteen-hundreds were a time for rum.\nThe nineteen-hundreds were a time for fun.\nThe two-thousands are a time to run\na civilized classroom.\n".repeat(~~(m.exp(m.PI)+m.E)))

Your teacher doesn't want any numbers, but since they are an english teacher, they've got no clue what Math.floor(Math.exp(Math.PI)+Math.E) means.
More readably:
alert("The eighteen-hundreds were a time for rum.\n\
 The nineteen-hundreds were a time for fun.\n\
 The two-thousands are a time to run\na civilized\n classroom.".repeat(Math.floor(Math.exp(Math.PI)+Math.E)))

Must be run in the latest firefox

Missing a newline at end, so the first and last rows are appended giving 75 rows

I'll award +1 for bending the rules with XKCD's reference of e^pi, but with +e as opposed to -pi... Bravo!

-4 bytes: with(Math)alert("long string here".repeat(exp(PI)+E|[]))

Oh well, forget about Math: (q='aaaaa'.length)*q

Forget about @edc65 comment too! Use this:"\x18".charCodeAt()! (hardcode the arrow up and you will save a ton!)

Javascript - 178 Bytes 176 Bytes
My first golf, thought I'd give it a shot with bit twiddling operators, didn't turn out quite as well as hoped, but oh well!
c="teen-hundreds were a time for "
b=!!c
alert(Array((b+b+b<<b+b)+b<<b).join("The eigh"+c+"rum.\nThe nine"+c+"fun.\nThe two-thousands are a time to run\na civilized classroom.\n"))

Since I'm already in detention, and obviously have troubles behaving myself...
Javascript - 71 Bytes
This one will probably get me in deeper trouble, but, if I already landed myself in detention, AND I'm planning on cheating my detention, apparently I lack good judgement on how I should behave myself in class. Maybe if I can pull one over my on teacher, I can pull one over on all the other golfers out there.
b=+true;alert( Array((b+b+b<<b+b)+b<<b).join($('code')[+!b].innerHTML))

Quick! Chrome/IE 11/Firebug users, open your consoles RIGHT NOW and try it.
(Please don't hurt me too much, I thought it was funny)

The 72 is fun. The 176 is many times wrong: Array(25).join() gives 24 repetitions, and a newline at end sentence is missing. All in all 24*3=72 rows instead of 100 (lazy boy!)

AUGH, ok fixed. Now 178 and 71.

You can save 2 bytes adding the t and a trailing space in "een-hundreds...for".

What is the second code doing?

+1 for abusing the OP's use of "code" in the second submission ;)

@justhalf, It takes use of JQuery, a common JavaScript library that apparently the SO network utilizes. The $ is actually a function that, among many many other things, takes a lot of the work out of DOM element selection. By using $(''), which is in this case all elements with the 'code' tag, I get an object containing all elements. By using [+!b] I get the integer value of false, which is zero, so I select the 0th index, which happens to be the OP's first code block, which is in fact the teachers favorite saying.

That "taking it from the question or another answer" thing is not funny anymore. It's been done plenty of times.

C# - 229 216 Bytes
Free using FTW!
using c=System.Console;
class S{static void Main(){var a="teen-hundreds were a time";for(int b=a.Length,i=b-b;i++<b;)c.Write("The eigh"+a+" for rum.\nThe nine"+a+" for fun.\nThe two-thousands are a time to run\na civilized classroom.\n");}}

Alternative, same byte count (more usingabuse, though)
using i=System.Int32;
using c=System.Console;
class S{static void Main(){var a="teen-hundreds were a time";for(int b=new i();b++<a.Length;)c.Write("The eigh"+a+" for rum.\nThe nine"+a+" for fun.\nThe two-thousands are a time to run\na civilized classroom.\n");}}

~~ (╯°□°）╯︵ ┻━┻

You can add " for " to a

@FryAmTheEggman the string is 25 characters long, he is using it to obtain the number 25 discretely. However, he can swap this method out for simply subtracting chars from each other (':'-'!' == 25), which is shorter than a.Length, and will allow for to be included as you suggest. (Alternativly, do as other answers seem to, and just loop between ! and :, funny how we all chose the same chars)

@VisualMelon Whoops, you're totally right.

Int32... that sounds like math to me! So your second code is not allowed...

I thought I could since usings are not even being counted, has OP clarified this?

I guess you can say the second solution is abUsing...

Using the overload for Console.Write(format, args) instead of declaring a saves you even more "+a+" x2 (10b) >>> {0} x2 & , (7b), var a= & ; (7b) removed completely. Combined with suggestion from @VisualMelon should allow you to break 200.

{0} contains a number

Aye, makes sense that I never post here. :)

Befunge-93, 268 260 256 (grid size: 72x6=432)
#v"K">:!#@_v>$"enin">,,,,::-" rof emit a erew sderdnuh neet">:#,_$::!!-#
, ,,,"The "<|\!\%-"\^"::%-" #":-!!:
   -"#-"-::$_ "hgie"^v1"two-thousands are a time to run"
$_$  "nuf"v"rum"
v1-"##",,,<      >:#,_"moorssalc dezilivic a"1
_# < ^,,\-"AK."$_,#!:

This is my first time golfing, so I figured I'd try a language that hadn't already been done for this problem, since I wouldn't be adding anything otherwise.
Since it's Befunge-93 compatible (fits inside an 80x25 grid and uses only Befunge-93 instructions), it should work in Befunge-98 too. Just in case, I also avoided having the pointer pass over any non-instruction characters other than space. I couldn't remember whether the specification actually defined those characters as no-ops, and I'll be having no nasal demons in MY code.
You can't really ungolf Befunge code. The key thing to note here is that Befunge pushes characters to the stack as their ASCII values, making it relatively simple to refer to numbers without literally referring to them. The "K" in the top left is 75, referring to the number of repetitions times the number of "the" clauses per repetition; I use modulus and some other craftiness on (copies of) this number to determine which path to take through the printing on each go-around. ::- is a nice idiom for zero, useful for zero-terminating strings; I use it twice here.
On occasion the pointer needs to pass through a place where I'm defining a string, hence the specific choices of characters used to get certain numbers at some points.
The nice thing about a lot of Befunge interpreters is that you can watch the pointer dart around the grid, as well as see what values are in the stack. That way you can step through and see how the program works yourself, more or less! I'd recommend using http://befungius.aurlien.net/ if you don't have your own preferred Befunge interpreter.
This can probably be pared down a bit (or a lot) more. Please give me feedback! If I need to provide a better explanation, someone let me know; I'm new to this.
Edit - shaved off a few bytes by getting rid of the unnecessary redirect to the last row when the program terminates (just putting the @ where the ^ used to be).
Another edit - shaved off some more bytes in various places, mostly with trickery. (Also added the grid size, as seems to be the trend with Befunge answers.)

Hey Kasran welcome to the codegolf stack exchange! This answers look great. Your explanation is good and you linked to a Befunge interpreter which is really helpful for weird languages not everyone has a compiler for (people commonly do things like "run this here").

Befunge is a really hard language, and you have to keep the size of the code itself in your mind when writting. Your code looks great and works. But would it reduce the size if you save re a time  somewhere?

I'm not using any Funge-98-specific instructions or behaviors that I know of, but since I wrote this answer I did learn that certain behaviors of the Befungius interpreter aren't standard - namely using # at one end of a line to skip the character at the other end (in CCBI, for instance, the # just skips the infinite space in between it and the character at the other end), which breaks this program. I haven't bothered to come back and fix this submission with this in mind.

There's a few 1 digits in there, which are not allowed

Pyth 135 136 140
*ltG%"The eigh%srum%snine%sfun%stwo-thousands are a time to run\na civilized classroom.\n"*hhZ("teen-hundreds were a time for "".\nThe

Note the trailing space.
Uses pretty much the same trick as @Geobits and his commenter friends in the Python answer to construct the string. Now also uses some of this answer.
This uses the built-in variable G, which contains abcdefghijklmnopqrstuvwxyz and gets one less than its length to produce the 25 outputs.

This seems to be 136 bytes rather than 135

@Optimizer Sorry, I should read my own notes: I forgot the trailing space when I pasted it there myself :S

Ruby - 152 141
puts"The eight#{e="een-hundreds were a time for "}rum.
The ninet#{e}fun.
The two-thousands are a time to run
a civilized classroom.
"*(?X-??)

http://repl.it/2Om/6

Clever use of 1.8's character literals! You might be able to use String#* to repeat the lines 25 times instead of Integer#times.

@britishtea - worked a treat :)

You could shave off a few more bytes by not assigning the lines first. The space between puts and a string literal is optional (puts"hi" is legal).

Assigning e inside the interpolation is a nice touch.

LiveScript - 181
p=(a,b)->"The #{a}teen-hundreds were a time for #b.\n"
each console.log,map (->(p \eigh \rum)+(p \nine \fun)+'The two-thousands are a time to run\na civilized classroom.'),[\A to\Y]

Required imports:
{each, map} = require 'prelude-ls'

If you want to run it under Node.js, install the LiveScript (not livescript) and prelude-ls packages from npm, replace alert with console.log and run lsc prog.ls, where prog.ls contains the program.

See rules: "You cannot use the characters 0123456789"

Nice catch, fixed.

PHP (175 157 156 bytes; 152 with unix EOF):
Not the most golfed solution, but surely does the job and is smaller than some attempts.
Here is the code:
$a=a;$f='re a time';$r="teen-hundreds we$f for";while($a++<z)echo"The eigh$r rum.
The nine$r fun.
The two-thousands a$f to run
a civilized classroom.
";

Old version:
$a=a;while($a++!=z)echo"The eighteen-hundreds were a time for rum.
The nineteen-hundreds were a time for fun.
The two-thousands are a time to run
a civilized classroom.
";

This works because php cycles the chars, and we just check if it isn't z and stop.
(One curiosity is that when php reaches z, it then goes to aa.)

The general convention here is to count newlines as only one byte, unless perhaps your language is so stubborn it only accepts CRLF, which is not the case for PHP.

Python 2 - 155
Note: since control characters don't show on SE, I've replaced it with \x19.
a,b='\nThe ','teen-hundreds were a time for '
print(a+'eigh'+b+'rum.'+a+'nine'+b+'fun.'+a+'two-thousands are a time to run\na civilized classroom.')*ord('\x19')

Base 64 version:
YSxiPScKVGhlICcsJ3RlZW4taHVuZHJlZHMgd2VyZSBhIHRpbWUgZm9yICcKcHJpbnQoYSsnZWln
aCcrYisncnVtLicrYSsnbmluZScrYisnZnVuLicrYSsndHdvLXRob3VzYW5kcyBhcmUgYSB0aW1l
IHRvIHJ1bgphIGNpdmlsaXplZCBjbGFzc3Jvb20uJykqb3JkKCcZJyk=

Regarding the import, I think you could save a bit with from string import * or however it's called in Python

You can move "teen" into b.

You can remove the [] brackets in the first line, which implicitly creates a tuple and then unpacks it.

You can also move the ord('d')//len('aaaa') to before the string so you don't have to bracket it.

Your output is missing the dots. I'm not sure if the leading newline is allowed.

@Dennis The OP's latest edit allows leading newlines.

Python, 165 bytes
h="hundreds were a time for "
t="The "
for i in h:print t+"eighteen-"+h+"rum.\n"+t+"nineteen-"+h+"fun.\n"+t+"two-thousands are a time to run\na civilized classroom."

It worked out really nicely that the length of h is 25, that was not intentional.  =)

Python 2 - 143
A silly answer:
from this import i
a="teen-hundreds were a time for ",".\nThe "
print"The eigh%srum%snine%sfun%stwo-thousands are a time to run\na civilized classroom.\n"%(a+a)*i

Note that the full count is 162. I left out all of from this import i.
Uses similar replacements to my pyth strategy, but I couldn't resist posting this after discovering the hilariousness of importing from this :)

+1 For use of from this import i! How did you know about that?

@BetaDecay I actually was bored and decided to read the zen of python, so I went to my interpreter and wrote import this. Then I thought: "What else could be in the this module?" So I called dir(this). Lo and behold, along with a dictionary, a garbled up string, and a "!" variable, there was a numeric constant... equal to 25.

05AB1E, 91 bytes
AgG“TheŸ¯een-““«Ã€à€…€º€‡ “©“ê¶m.“««“The¥Šteen-“®„ˆ¦.««“The‚•-““šä€™€…€º€„‡Ð“«“a–Ìized¬¸.“»

Try it online!

83 bytes

TeX - 169
\def\s{teen-hundreds were a time for }\def\p{The eigh\s rum.

nine\s fun.

The two-thousands are a time to run

a civilized classroom.

}\def\m{\p\p\p\p\p}\m\m\m\m\m\bye

Note that the blank lines are intentional and actually required for the output to be properly formatted.

It's fixed now. :)

C, 215 203 199 bytes
main(a){a<<='\xC'+'\xD';while(a>>=!!a)printf("The eighteen-hundreds were a time for rum.\nThe nineteen-hundreds were a time for fun.\nThe two-thousands are a time to run\na civilized classroom.\n");}

Ungolfed
main(a)
{
  a<<='\xC'+'\xD';
  while(a>>=!!a)
    printf("The eighteen-hundreds were a time for rum.\nThe nineteen-hundreds were a time for fun.\nThe two-thousands are a time to run\na civilized classroom.\n");
}

I used bit shifting to iterate without any number.
a<<='\xC'+'\xD' sets a to 0b1[25 zeros]
a>>=!!a shifts right one bit for each time we iterate the loop
Edit : a equals argc, so its value is already 1 when the program is run with no arguments. Changed a>>='\xB'-'\xA' to a>>=!!'\xA' which is 4 bytes shorter. Also the text was displayed only 24 times. Fixed it. Removed extra brackets in the while.
Edit 2: changed !!'\xA' to !!a. Seems to work and saves 4 bytes

You can use puts to save more bytes.

Ruby, 145
?K.upto(?c){puts"The eigh#{x="teen-hundreds we#{t="re a time "}for "}rum.
The nine#{x}fun.
The two-thousands a#{t}to run
a civilized classroom."}

Explanation

Use String#upto to print the lines 25 times. The range "K".."c" is 25 characters.
Use basic String interpolation to shorten the lines.

#{a="The "} is actually costing you more characters! #{a} is the same length as The

T-SQL: 206
Makes use of a cross join on five rows to generate 25 rows selecting the phrase.  The line breaks are important for the output.
with c as(SELECT\ N FROM(VALUES(\),($),($),($),($))A(B))SELECT REPLACE('The eigh$rum.
The nine$fun.
The two-thousands are a time to run
a civilized classroom.','$','teen-hundreds were a time for ')FROM c a,c b

Bash, 151 bytes
Pretty much a straight port of your own answer
t="teen-hundreds were a time for"
for i in {a..y};{
echo "The eigh$t rum.
The nine$t fun.
The two-thousands are a time to run
a civilized classroom."
}

Perl - 152 146 bytes
$_="-hundreds were a time for";say"The eighteen$_ rum.\nThe nineteen$_ fun.\nThe two-thousands are a time to run\na civilized classroom.\n"x y///c

This makes use of perl's string repetition operator and exploits a substring of length 25.
Ungolfed version:
$_ = "-hundreds were a time for";
say "The eighteen$_ rum.\nThe nineteen$_ fun.\nThe two-thousands are a time to run\na civilized classroom.\n"x y///c

Use $_ instead of $h and then you can use length or better yet y///c without the $h argument. You can put a space between the x and length and get rid of the parenthesis. Think perl -E'$_="test";say"t"x y///c'

@chilemagic Thanks, that saved 5 bytes and removing trailing semicolon saved one more.

C, 196 chars
This isn't an easy task for good ol' C.  Factoring out the "The %steen-hundreds ..." pattern saves me a whole two characters.
Whitespace for clarity, include not counted.
#include <stdio.h>
main(){
  for (char*p="The %steen-hundreds were a time for %s.\n",
           *s="The two-thousands are a time to run\na civilized classroom.",
           *q=p;
       *q++ - 'a';
       puts(s))
   printf(p,"eigh","rum"), printf(p,"nine","fun");
}

Golfscript - 139 134
'TeighYrum.TnineYfun.Ttwo-thousands aRto run
a civilized classroom.''#
'{-}**'Y'/'teen-hundreds weRfor '*'T'/'
The '*'R'/'re a time '*

Teacher: Joshy * , are you hashtagging in class again? Two weeks detention! #howdoesthatfeel
* name preserved to protect idensity
EDIT: Found shorter code.

Racket 173
(let([x"teen-hundreds were a time for "])(for([z(+ #xa #xf)])(displayln(~a"The eigh"x"rum.\nThe nine"x"fun.\nThe two-thousands are a time to run\na civilized classroom."))))

Ungolfed:
(let ([x "teen-hundreds were a time for "])
  (for([z(+ #xa #xf)])
    (displayln (~a "The eigh"x"rum.\nThe nine"x"fun.\nThe two-thousands are a
     time to run\na civilized classroom."))))

PHP - 157
$f='re a time';$r="teen-hundreds we$f for";echo str_repeat("The eigh$r rum.\nThe nine$r fun.\nThe two-thousands a$f to run\na civilized classroom.\n",aa^SU);

Use $s instead of $string to save on quite a few bytes.

If you want to use str_repeat, use this: $f='re a time';$r="teen-hundreds we$f for";echo str_repeat("The eigh$r rum.\nThe nine$r fun.\nThe two-thousands a$f to run\na civilized classroom.\n",aa^SU); (hardcode the \n to save bytes.) and you have a 153 byte long answer! (aa^SU is 24, which is the same as (a^S)*10+(a^U) which is (2*10)+4) I based the divisions on my code. Please, present a bytecount next time and try to golf it further.

Please update the byte count when you update the answer. You can use https://mothereff.in/byte-counter, make sure there's no empty line at the end. Also, this can be golfed futher by removing the spaces around the = and the newline after classroom.";.

GML (Game Maker Language), 169
a="teen-hundreds were a time for "b="The eigh"+a+"rum#The nine"+a+'fun#The two-thousands are a time to run#a civilized classroom#"c=b+b+b+b+b;d=c+c+c+c+c;show_message(d)

Common Lisp (165 bytes)
(format t"~v{~{The ~(~A~)~#[~;-thousands are~:;teen-hundreds were~] a time ~A
~}~:*~}"(+ #xA #xF)'((eigh"for rum."nine"for fun."two"to run
a civilized classroom.")))

Explanations

25 equals to 10 + 15, which is equivalent to A + F in base 16. Hence (+ #xA #xF).
25 is passed to the ~v{ ... ~} constructs, which iterates over arguments at most v times, where v is given as an argument of format
~:* rewinds current argument to the previous element in the argument list; inside the ~{...~} constructs, that practically means infinite loop. However, this infinite loop is bounded by ~v, ie. 25.
~#[<zero>~;<one>~;:<else>~] is a switch, based on the value of the remaining number of arguments in the list (due to the # modifier).
~(...~) downcases the contained text

Note: I could have used fewer characters by using ~R on 18, 19 and 2 (and using a litteral 25) but this is forbidden.

Rant, 191 bytes
Not the shortest solution, but still cool. I wrote a subroutine to write the first three lines, and designed it so calling it with an empty argument returned a string 25 characters long. I then pass its length to the repeater.
[pin:][$[_:a]:The [arg:a][sync:;ordered]{thousands a|teen-hundreds we}re a time ][r:[len:[$_:]]]{[step:][$_:eigh]for rum.\N[$_:nine]for fun.\N[step:][$_:two-]to run\Na civilized classroom.\N}

Ungolfed:
[pin:]
[$[_:a]:The [arg:a][sync:;ordered]{thousands a|teen-hundreds we}re a time ]
[r:[len:[$_:]]]
{
    [step:]
    [$_:eigh]for rum.\N
    [$_:nine]for fun.\N
    [step:]
    [$_:two-]to run\N
    a civilized classroom.\N
}

Try it online

LATEX 239 226
The byte count does not include the \documentclass command nor any \usepackage commands. I would argue both count as using external packages, as the former includes definitions in an external .cls file, and usepackage is practically synonymous with an include statement. Output is a pdf file containing the 100 lines with no other text, formatted appropriately. Try it at writelatex.com!
\begin{document}\newcounter=\def\_{re a time }\def\-{een-hundreds we\_}\StrLen\-[\b]\forloop=\parindent{\value=<\b}{The eight\-for rum.\\The ninet\-for fun.\\The two-thousands a\_to run\\a civilized classroom.\\}\end{document}

Ungolfed:
\documentclass{letter}

\usepackage{forloop}
\usepackage{parskip}
\usepackage{xstring}
\usepackage{nopageno}

\begin{document}

\newcounter=

\def\_{re a time }
\def\-{een-hundreds we\_}

\StrLen\-[\b]

\forloop=\parindent{\value=<\b}{

    The eight\-for rum.\\
    The ninet\-for fun.\\
    The two-thousands a\_to run\\
    a civilized classroom.\\

}

\end{document}

Edit: New and improved. Also made link go to read-only version of code. Thank you Dennis!

You should link to the read-only version of your document. I accidentally modified it (but undid all changes). 2. You can save a few bytes by eliminating whitespace and curly brackets : \begin{document}\newcounter=\def\_{re a time }\def\-{een-hundreds we\_}\StrLen\-[\b]\forloop=\parindent{\value=<\b}{The eight\-for rum.\\The ninet\-for fun.\\The two-thousands a\_to run\\a civilized classroom.\\}\end{document}

Suggested changes made, thank you for the tips.

You're over-optimizing it. It would be much shorter if you did it like my plainTeX solution. :P

Interesting, thanks. Rather than modify my answer, I'm going to upvote yours! Cheers!

Looks like mine is currently invalid though, I overlooked the #1s. :/

I had the same problem with my original MATLAB entry, and missed it in yours as well. Typing and seeing numbers while coding is a subtle thing, evidently. Definitely adds to my humility that I am not fully aware of precisely what I am doing at all times!

Perl, 140 139
improving on chilemagic answer. feature say for 3 bytes, text redundancy for 3 bytes.
$r="re a time";$s="teen-hundreds we$r for";say"The eigh$s rum.
The nine$s fun.
The two-thousands a$r to run
a civilized classroom."for b..z

You can move the r into $e as well to save another byte.

@chilemagic duh, thanks! missed that somehow. Under 140 now!

EXCEL, 168 Bytes
Decided to add this for fun. Instead of using the length() I decided to use character codes... If SUBSTITUTE wasn't such a long command, I could have joined in on the string compression too. I am drooling over C# which can use: 'Z'%'A'
Similar to the other Excel, but not using any row / column references.
Decided to add this for fun. Instead of using the length() I decided to use character codes... If SUBSTITUTE wasn't such a long function I could have joined in on the string compression too.
Similar to the other Excel, but not using any row / column references.
=REPT("The eighteen-hundreds were a time for rum.
The nineteen-hundreds were a time for fun.
The two-thousands are a time to
run a civilized classroom. ",ARABIC("XXV"))

excluding new line, I counted it 179. XD. let's wait for the others what should be the correct count byte. Also you can less some bytes if you use subtraction instead of Mod. Also, need to add new line at the end of the sentence

ARABIC("XXV") is even shorter than CODE("Z")-CODE("A").

@remoel - Yes I considered the subtraction, but I liked that there was nothing "Mathy" looking (+ or -) in the formulas. orthoplex - nice, that also meets my other criteria!

Line endings are almost universally counted without carriage return on here. TIO would be correct in that case.

@Origin 1. run is on the wrong line. 2. you no longer use char codes so you need to update the explanation

@orthoplex, never knew that function. lol. Thank you!

Brainfuck, 659 bytes
++++++++++++[->>++>+++++++>++++++++>+++>++++++++>+++++++++>+++++++++>+++++++++>++++>+[<]<]>>+>>+>---->++++>+>>--->-->--[<]>[->.>>>++++.---.<.>.>>>.--.+.<<+++++++.<..>>++.>>-.<.<<+.>.<<-.>---.<+.-.>+.<<.>>++++.<+.>-----.<.<.<.>.>>++.>>+.<-.<<.<.>+.>>++.<--.<<.>>.+++.>--.>>+.>.<<<<<<<<.>>>++.---.<.>>>+.>.<.<<.>-.<..>>.>>-.<-.<<+.>.<<-.>---.<+.-.>+.<<.>>++++.<+.>-----.<.<.<.>.>>++.>>+.<-.<<.<.>+.>>++.<--.<<.>.>+++.>-.>>+.>.<<<<<<<<.>>>++.---.<.>>-.+++.>+.>>-.<<<---.>>-.<.<+.--.<<<.>>>>-.<<-.>.<<.<.>>>-.<+.<.<.>.>>++.>>+.<-.<<.<.>>.>++.<<<.>>--.+++.>-.>>>.<<<<<<<.>.<++.>>>>>.<<+.>>.<--.>.<<++++.<.-.<.<.>>>>.<<---.>-------..-.---..--.>>>+.>.<<<<<+++<<--<<]

Try it online!
I found this using my own mediocre Brainfuck cruncher.

Vyxal, 95 bytes
`λƛ e⋏ṫ⟑⌈-←¾ λ□ a λṙ λ⟑ ≥⁋.
λƛ ∵‹⟑⌈-←¾ λ□ a λṙ λ⟑ ×ė.
λƛ ƛ»-ʁḢ λ½ a λṙ to ÷Ḣ
a ↔Ŀized τ⟇.
`₁½½*

Try it Online!
`...`     # Dictionary compressed string
     ₁½½  # 100 / 2 / 2 = 25
        * # That many times

Ruby, 198 bytes
a='teen-hundreds were a time'
b='The eigh'
c='The nine'
d=' for'
e=' rum'
f=' fun'
a.length.times{puts b+a+d+e+"\n"+c+a+d+f+"\n The two-thousands were a time to run a \n civilized classroom"}

Groovy : 167 chars
Inspired by jmm's answer.
a="teen-hundreds were a time for"
b="two-thousands are a time "
s="The eigh$a rum.\nThe nine$a fun.\nThe ${b}to run\na civilized classroom."
b.size().times{println s}

Scala - 159
val(f,h)=('z'-'a',"teen-hundreds were a time for")
print(s"""The eigh$h rum.
The nine$h fun.
The two-thousands are a time to run
a civilized classroom.
"""*f)

Run with scala golf.scala

C99: 211
Doubt I'll be winning any prizes any time soon:
main(){char*s="The %steen-hundreds were %s for %s.\n",*t="a time",c='A';for(;c<'Z';++c){printf(s,"eigh",t,"rum");printf(s,"nine",t,"fun");printf("The two-thousands are %s to run\na civilized classroom.\n", t);}}

Golf it more by removing #include <stdio.h> and using main(){...} instead of void main(){...}. Also, char *s="..." can be written as char*s="..." to save one byte. Declaring c outside the loop an also save some more bytes:char*s="...",c;

@CoolGuy All done, and I went one better by stripping the first part of the for out and assigning c at the point it is declared. I considered switching the for to a while, but it would be a byte longer. e.g. while(c<'Z'){++c;} (18) vs for(;c<'Z';++c){} (17)

Java 247 229 225
Not counting package and import statements
class A{public static void main(String[] a){String s="teen-hundreds were a time for "; for(int i='a';i++<'z';)out.print("The eigh"+s+"rum.\nThe nine"+s+"fun.\nThe two-thousands are a time to run\na civilized classroom.\n");}}

Ungolfed
    package a;
    import static java.lang.System.*;
    class A{
        public static void main(String[] a){
            String s="teen-hundreds were a time for ";
            for(int i='a';i++<'z';)
            out.print("The eigh"+s+"rum.\nThe nine"+s+"fun.\nThe two-thousands are a time to run\na civilized classroom.\n");
        }
    }

C# (193)(189)
(Executable in LINQPad)
Golfed:
void Main(){for(int i='!';i++<':';)"The eighteen-hundreds were a time for rum.\nThe nineteen-hundreds were a time for fun.\nThe two-thousands are a time to run\na civilized classroom.".Dump();}

Ungolfed:
void Main()
{
    for(int i='!';i++<':';)
        "The eighteen-hundreds were a time for rum.\nThe nineteen-hundreds were a time for fun.\nThe two-thousands are a time to run\na civilized classroom.".Dump();
}

After update:
void Main(){var x="teen-hundreds were a time for ";for(int i='!';i++<':';)"The eigh_rum.\nThe nine_fun.\nThe two-thousands are a time to run\na civilized classroom.".Replace("_",x).Dump();}

Ungolfed:
void Main()
{
    var x="teen-hundreds were a time for ";

    for(int i='!';i++<':';)
        "The eigh_rum.\nThe nine_fun.\nThe two-thousands are a time to run\na civilized classroom.".Replace("_",x).Dump();}

Haskell (210 192 chars)
My code is fairly simple:
import Data.Char
i x y="The "++x++"teen-hundreds were a time for "++y++".\n"
main=putStr.unlines.replicate(ord '\EM')$(i"eigh""rum"++i"nine""fun"++"The two-thousands are a time to run\na civilized classroom.")

Joins a 25x replicated list of the desired string and prints it. (\EM is ASCII 25)
Edit
Updated score to omit import and trailing newline from count.

MATLAB 175 193
R2014a
Fun with fprintf.
I hope I didn't miscount, first timer here.
a = 'a time ';b = 'teen-hundreds were %sfor';for i = length([]):length(b);fprintf(['The eigh',b,' rum.\nThe nine',b,' fun.\nThe two-thousands are %sto run\na civilized classroom.\n'],a,a,a);end

Ungolfed
a = 'a time ';
b = 'teen-hundreds were %sfor';
for i = length([]):length(b);
    fprintf(
        [
            'The eigh',
            b,
            ' rum.\nThe nine',
            b,
            ' fun.\nThe two-thousands are %sto run\na civilized classroom.\n'
        ],
        a,
        a,
        a
    );
end

Note that fprintf prints to MATLAB's console by default, unless a valid file identifier is supplied as the first argument. The character sequence %1$s instructs fprintf to print the first argument after the format string as a string. In this case, the variable b needs to be 25 characters long, so using %s instead of %1$s actually costs a couple more characters overall, once all strings have been manipulated.
Edit: fixed to conform to rules. Lesson learned: don't post early morning.

Fixed to conform to rules. How embarrassing!

Delphi (229 227 224/238)
Not great but still fun.
Repeats for each char in set ['B'..'Z'].
This is a procedure so use clauses aren't included. You will need the unit IdGlobal for this to work. Including the unit it will be 238.
procedure W;var C:Char;begin for C in['B'..'Z']do writeln(StringsReplace('%eigh^+for rum.*%nine^+for fun.*%two-thousands are+to run*a civilized classroom.',['%','^','*','+'],['The ','teen-hundreds were',^J,' a time ']));end;

Ungolfed
procedure W;
var C:Char;
begin
  for C in['B'..'Z']do
    writeln(StringsReplace('%eigh^+for rum.*%nine^+for fun.*%two-thousands are+to run*a civilized classroom.',['%','^','*','+'],['The ','teen-hundreds were',^J,' a time ']));
end;

Replace broken up
StringsReplace(
'%eigh^+for rum.*%nine^+for fun.*%two-thousands are+to run*a civilized classroom.', //source string
['%','^','*','+'], //Patterns to replace
['The ','teen-hundreds were',^J,' a time '])//Replace pattern with.

See rules: "You cannot use the characters 0123456789"

@PaulR Oops, forgot the newline contained numbers -.-; Changed it, saved me 2 characters aswell :P

Better, but I still see 0 and 1 in there...

Oh wow... can't believe I missed that xD

Java: 252 bytes
class M{public static void main(String a[]){String t="teen-hundreds were a";for(int i='!'-'!';i<'z'-'a';i++){System.out.println("The eigh"+t+" time for rum.\nThe nine"+t+" time for fun.\nThe two-thousands are a time to run\na civilized classroom.");}}}

ungolfed:
    class M {
    public static void main(String a[]) {
        String t = "teen-hundreds were a";
        for (int i = '!' - '!'; i < 'z' - 'a'; i++) {
            System.out
                    .println("The eigh"
                            + t
                            + " time for rum.\nThe nine"
                            + t
                            + " time for fun.\nThe two-thousands are a time to run\na civilized classroom.");
        }
    }
}

This doesn't compile (you're missing a } or have an extra {, take your pick). 2) This has been done already in the same language using the same method with 35+ less bytes, so doesn't add anything. 3) It doesn't compile. Note: I didn't downvote this, but I can see why someone would. Also note that voting is intended to be anonymous, and there's no requirement (even morally, IMO) to explain a downvote.

Rebol - 162 160
b: a:"teen-hundreds were a time"forall b[print reword{The eigh$X for rum.
The nine$X for fun.
The two-thousands are a time to run
a civilized classroom.}[X a]]

Shell, 161
sed 's/x/xxxxx/g;s/x/The eigh#rum.\nThe nine#fun.\nThe two-thousands are a time to run\na civilized classroom.\n/g;s/#/teen-hundreds were a time for /g'<<<xxxxx

Haskell - 183
a#b="The "++a++"teen-hundreds were a time for "++b++".";
main=forM_['A'..'Y'](\_->forM["eigh"#"rum","nine"#"fun","The two-thousands are a time to run\na civilized classroom"]putStrLn)

Required imports:
import Control.Monad
import Data.Char
import Data.List

Groovy - 149
Golfed:
x="teen-hundreds were a time";print"""The eigh$x for rum.
The nine$x for fun.
The two-thousands are a time to run
a civilized classroom.
"""*x.size()

Cobra - 194
class P
    def main
        print ('[n="\nThe "]eigh'+(p='teen-hundereds we[m="re a time "]for ')+'rum.[n]nine[p]fun.[n]two-thousands a[m]to run\na civilized classroom.\n').repeat(c'S'to int-c':'to int)

PowerShell
Count = 203 199
$c,$d,$e,$f,$g,$h,$i,$j=("The,eigh, for ,rum.,nine,fun., to run, a time"-split",");$a="teen-hundreds were$j";[char[]]$a|%{"$c $d$a$e$f`n$c $g$a$e$h`n$c two-thousands are$j$i`na civilized classroom."}

Explanation
# Chop up this string of repeated words/phrases
$c,$d,$e,$f,$g,$h,$i,$j=("The,eigh, for ,rum.,nine,fun., to run, a time"-split",");

# Steal everyone else's idea to get 25 chars exactly
$a="teen-hundreds were$j";

# Cast to char array and pipe into foreach
[char[]]$a|%{...}

# Spell everything out
"$c $d$a$e$f`n$c $g$a$e$h`n$c two-thousands are$j$i`na civilized classroom."

181 Bytes

T-SQL - 177
Using the string from the other T-SQL answer here.
PRINT(REPLICATE(REPLACE('The eigh$rum.
The nine$fun.
The two-thousands are a time to run
a civilized classroom.','$','teen-hundreds were a time for '),ASCII('K')/LEN('AAA')))

Okay, this should properly follow the rules this time, silly me. I had almost completely forgotten about the super convenient REPLICATE function. ASCII('K') gives us 75, dividing that by LEN('AAA') which is 3 gives us the 25 we need. I could've used the character with the ASCII value 25, but having a control character seems like a bit of a cop out to me.

Forth (gforth), 174 bytes
: x ." teen-hundreds were a time for ";
: f bl true cell+ do ." The eigh"x .\" rum.\nThe nine"x .\" fun.\nThe two-thousands are a time to run\na civilized classroom.\n"loop ;

Try it online!
Code Explanation
: x                                      \ start a new word definition
  ." teen-hundreds were a time for "     \ outputs "teen-hundreds were a time for "
;                                        \ end word definition

: f                                      \ start a new word definition
  bl                                     \ ascii value of space (32)
  true cell+                             \ true (-1) + size of cell (8 in 64-bit) = 7
  do                                     \ counted loop from 7 to 31 (total of 25)
    ." The eigh"x                        \ output "The eigh" and call x
    .\" rum.\nThe nine"x                 \ output "rum\nThe nine" and call x
    .\" fun.\nThe two-thousands are a time to run\na civilized classroom.\n" \ output the rest
  loop                                   \ end loop
;                                        \ end word definition

Perl 6, 147 bytes
my $t="teen-hundreds were a time for";say "The eigh$t rum.
The nine$t fun.
The two-thousands are a time to run
a civilized classroom." for 'a'..'y'

Try it online!

'a'..'y' -> ^㉕ :P since it looks like unicode numbers are fine

140?

EXCEL , 160 164 bytes
asked Teacher if I could use Excel, Teacher said Yes.
asked Teacher if I could click around, Teacher said Yes.
So click Wrap Text, merge A-TwentyFive to A-OneHundredTwentyFive and Paste this in Cell A-TwentyFive
=REPT("The eighteen-hundreds were a time for rum.
The nineteen-hundreds were a time for fun.
The two-thousands are a time to run
a civilized classroom.
",ROW())

I count this as 164, did I miss something?

I'm using TIO to count the bytes of my code. are you referring to the New Line? maybe its not counting it. will add it. Thank you :)

Zsh, 136 bytes
repeat \##� <<.
The eigh${A=teen-hundreds we${B=re a time} for} rum.
The nine$A fun.
The two-thousands a$B to run
a civilized classroom.

Attempt This Online!
The � represents ASCII 0x19 = 25.

authors: Артём Дадашьянц

authors: Кирилл Колесов

authors: Юрій Писанка

authors: иван семеренько

authors: الاء شكرى حلمى

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


text:
Python: I wish I was PHP
There's an old story about a stonecutter who was never satisfied with what he was. He wished he could become the sun, and so he was. Blocked by the clouds, he wished to be - and became - a cloud. When the wind blew, he wished himself into being the wind. Stopped by the mountain, he wished to be a mountain, and thus became one. Soon, however, he was being hacked at by a stonecutter, and wished to be a stonecutter.
Similarly, your task is to write a program which is never satisfied with the language it is in. Your program must output a set of regex replacements to turn it into a different language. And so on.
Rules

Write a program in a language of your choice.
The program should output a series of at least two segments. A segment is a bunch of text, separated by semicolons. However, if a semicolon is contained within a regex, such that breaking it up there will result in invalid syntax, it does not separate segments. See the example.
The first segment is a regex pattern to find, and the second segment is the replacement pattern. The third is another "find" pattern, and the fourth is a "replace" pattern, and so on.
Apply the regex patterns to the program. Replace the pattern on the first segment with one on the second; replace the third pattern with the one on the fourth, and so on.
The result should be a program in a different language, which, itself, follows rules 2 to 4.
The languages used must form an infinite, repeating cycle.

For example, Python -> PHP -> C++ -> Python -> PHP -> C++ -> Python -> ...

Your score is the period of the cycle. Ties are broken by shortest initial code length.

In the above example, the score is three.

In each iteration of the cycle, no language may be used more than once.
For rules 5 and 7, compatible languages (C and C++) and different versions of the same language (Python 2 and Python 3) are considered the same.
The programs themselves do not need to repeat.

In the above example, the first and fourth programs may be different.

Any version of regex is acceptable, but the same must be used for all the programs.
The total output for each program may not exceed 100 characters.
Each output must contain instructions to actually change the program. That is, no two consecutive programs in the cycle may be the same.

Example
Python -> Ruby -> Python -> ...
print "uts;Z;rint;uts;Z(?=;Z);rint"

Outputs:
uts;Z;rint;uts;Z(?=;Z);rint

The segments are:
FIND     ;    REPLACE
uts      ;    Z
rint     ;    uts
Z(?=;Z   ;    rint   (breaking the first segment in two would result in invalid syntax)

Applying the regex replacements, in order, gives us:
print "Z;Z;rint;Z;Z(?=;Z);rint"      # replace each "uts" with "Z"
puts "Z;Z;uts;Z;Z(?=;Z);uts"         # replace each "rint" with "uts"
puts "rint;Z;uts;rint;Z(?=;Z);uts"   # replace each "Z" followed by ";Z" with "rint"

Running the last line gives us the instructions to turn this back into Python code.

If you're using code size as tie breaker, do we really need the 100 character limit?

@MartinBüttner Yes; why not?

Sure, but it's a character longer than \; ;)

C++ isn't necessarily compatible with C.

I think you probably want to require that all the programs in the cycle be different. If I'm wrong, please state so - and I claim priority on the obvious solution.

@PeterTaylor Indeed (now rule 13).

2 Languages: Python, Ruby; 33 29 bytes
Here is another way to do Python and Ruby, that's a bit shorter than the one in the challenge:
Python:   print'^;puts"^.*?\\42#\\73"#'
prints:   ^;puts"^.*?\42#\73"#

Ruby:     puts"^.*?\42#\73"#print'^;puts"^.*?\\42#\\73"#'
prints:   ^.*?"#;

It shouldn't be too difficult to add PHP into the mix.

2 languages: Python 2 and Befunge-93, 77 bytes
After carefully reading the rules this time, I came up with a real answer. It won't win any prizes, but Befunge is just too fun to program in.
u=u">>>>>:#,_@;Z;print;>>>>>:#,_@;Z(?=;Z);print;<v;Y;u;<v;Y(?=;Y);u"
print u

This Python program outputs:
>>>>>:#,_@;Z;print;>>>>>:#,_@;Z(?=;Z);print;<v;Y;u;<v;Y(?=;Y);u

Which yields these replacements:
FIND         REPLACE
>>>>>:#,_@   Z
print        >>>>>:#,_@
Z(?=;Z)      print
<v           Y
u            <v
Y(?=;Y)      u

Which turns the program into this Befunge program:
<v=<v"print;Z;>>>>>:#,_@;print;Z(?=;Z);>>>>>:#,_@;u;Y;<v;u;Y(?=;Y);<v"
>>>>>:#,_@ <v

Maybe I'll see if I can make it one line. Frankly, I'm a little surprised Befunge works for this sort of problem at all.
(Sorry for deleting and undeleting a bunch; I was panicking for a second because I thought the program might not have worked.)

source: Stack Exchange

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

sort: votes


text:
Book Stack Sort
When stacking books you usually want to put the largest ones at the bottom and the smallest ones at the top. However, my latent OCD makes me feel very uneasy if I've got two books where one is shorter (in height) but wider than the other. No matter which order I place them in, the top book will extend beyond the bottom book on one side.
As an example, say one book has dimensions (10,15) and another has dimensions (11,14). No matter which way around I put them, I get an overhang. But if I have books with dimensions (4,3) and (5,6), I can avoid an overhanging by placing the latter below the former.
For the purposes of this challenge we will consider overhangs only in relation to the book immediately below. E.g. if I have a stack (5,5), (3,3), (4,4) (not that any sane person would do that), the top book counts as an overhang, although it does not extend beyond the bottom book. Similarly, the stack (3,3), (3,3), (4,4) also has only one overhang, despite the top book extending beyond the bottom one.
The Challenge
Given a list of integer pairs for book dimensions, sort those pairs/books such that the number of overhangs is minimal. You must not rotate the books - I want all the spines facing the same direction. If there are multiple solutions with the same number of overhangs, you may choose any such order. Your sorting algorithm does not have to be stable. Your implementation may assume that book dimensions are less than 216 each.
Time complexity: To make this a bit more interesting, the asymptotic worst-case complexity of your algorithm must be polynomial in the size of the stack. So you can't just test every possible permutation. Please include a short proof of your algorithm's optimality and complexity and optionally a plot that shows the scaling for large random inputs. Of course, you can't use the maximum size of the input as argument that your code runs in O(1).
You may write a program or function, take input via STDIN, ARGV or function argument in any convenient (not preprocessed) list format and either print or return the result.
This is code golf, so the shortest answer (in bytes) wins.
I am confident that a polynomial-solution exists, but if you can prove me wrong, you may submit such a proof instead of a golfed submission. In this case, you may assume P ≠ NP. I will accept the first correct such proof and award a bounty to it.
Examples
In:  [[1, 1], [10, 10], [4, 5], [7, 5], [7, 7], [10, 10], [9, 8], [7, 5], [7, 5], [3, 1]]
Out: [[10, 10], [10, 10], [9, 8], [7, 7], [7, 5], [7, 5], [7, 5], [4, 5], [3, 1], [1, 1]]

In:  [[4, 5], [5, 4], [5, 4], [5, 4], [5, 4], [4, 5], [4, 5], [4, 5], [5, 4], [4, 5]]
Out: [[4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [5, 4], [5, 4], [5, 4], [5, 4], [5, 4]]
  or [[5, 4], [5, 4], [5, 4], [5, 4], [5, 4], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5]]

In:  [[2, 3], [1, 1], [5, 5], [7, 1]]
Out: [[5, 5], [2, 3], [7, 1], [1, 1]]
 or  [[5, 5], [2, 3], [1, 1], [7, 1]]
 or  [[7, 1], [5, 5], [2, 3], [1, 1]]
 or  [[7, 1], [1, 1], [5, 5], [2, 3]]

I created these by hand, so let me know if you spot any mistakes.

Are you certain that finding a solution with a minimum number of overhangs can be solved in polynomial time?

@COTO I'm fairly confident, yes.

Hmm. I'd ordinarily tackle it with a greedy algorithm, but I can easily procure inputs leading to suboptimal outputs for any "greed" criterion I can come up with (e.g. area, maximize one dimension, maximize smallest dimension, etc.). The only other approaches I can think of involve partitioning the books into cliques, and all of them have exponential worst-case complexity. I'll be interested to see what answers come up. You might also want to request a brief proof of the optimality of the sort as part of the spec.

@COTO I've added a paragraph about this in case I'm actually wrong, but don't count on it. ;)

Just in case, potential proofs that no polynomial-time algorithm exists should be allowed to assume that P does not equal NP.

Why [tag:code-golf]? Why not [tag:code-challenge] and have a set of test cases and the one with least number of overhangs wins?

@justhalf Optimisation challenges seem to be more suitable for NP-hard problems. With polynomial-time solutions it would be very hard to get test case size and time limit right to prevent optimal solutions. However, this challenge was originally intended to be harder (minimising the overlapping area and potentially allowing books to be rotated) - I have a feeling that this variant might be NP-hard, in which case I might post that as a code challenge some time in the future.

@MartinBüttner: I see. I forgot that some questions did face that issue, having too many submissions of optimal solutions. Sorry if I sounded too harsh, I just personally don't like code-golf :)

I've put out a request for assistance on Math.SE, hence hopefully we can resolve the dilemma. ;)

Pyth, 30
FN_SQFbYIgeeYeb~b]NB)E~Y]]N;sY

This is a direct golf of grc's awesome algorithm. Here is the precise equivalent of the above pyth program, in its compiled python code.
Q = eval(input())
Y = []
for N in sorted(Q)[::-1]:
     for b in Y:
         if Y[-1][-1] >= b[-1]:
             b += [N]
             break
     else:
         Y += [[N]]
print(Psum(Y))

In this context, the Psum(Y) function is equivalent to the python sum(Y,[]).
Actual compiled and run code (from pyth -d):
Y=[]
Q=copy(eval(input()))
for N in neg(Psorted(Q)):
 for b in Y:
  if gte(end(end(Y)),end(b)):
   b+=[N]
   break
 else:
  Y+=[[N]]
Pprint("\n",Psum(Y))

The Python translation needs "Y=[]", remove the eval if you're in Python 2, and the sum needs a second argument sum(Y,[]). This all should work in Pyth, just the translation doesn't automatically include it.

@xnor The last line really reads: Pprint("\n",Psum(Y)). I think he may have simplified it for convenience, along with all of the -1s etc. Psum actually would run more like reduce(lambda x,y:x+y, Y[1:], Y[0]).

Python, 113
P=[]
for n in sorted(input())[::-1]:
 for p in P:
  if p[-1][1]>=n[1]:p+=[n];break
 else:P+=[[n]]
print sum(P,[])

After sorting the list of books in descending order (by width first and then height), this partitions the books into piles without overlaps. To determine where to place each book, its height is compared with the height of the top book in each pile. It is placed on the first pile possible, or else a new pile is created.
I'm not very good with time complexity, but I believe it would have a worst case of O(N2). There are two loops, each with at most N iterations. I also use Python's builtin sort, which is O(n log n).

My first proof that this algorithm produces optimal solutions did turn out to be incorrect. A huge thanks goes to @xnor and @Sp3000 for a great discussion in the chat about proving this (which you can read starting here). After working out a correct proof, @xnor found that part of it had already been done (Dilworth's theorem).
Here's an overview of the proof anyway (credit to @xnor and @Sp3000).
First, we define the notion of an antipile, or antichain, (quoted from @xnor):

An antipile is a sequence of books of decreasing height, but increasing width
  So, each successive book is strictly taller but strictly less wide
  Note that any book in an antipile overhangs over any other book in an antipile
  So, no two books within an antipile can be in the same pile
  As a consequence, if you can find an antipile of x books, then those books must be in different piles
  So, the size of the largest antipile is a lower bound on the number of piles

Then, we sort the books in descending order by their width (first) and their height (second)*.
For each book B, we do as follows:

If B can fit on the first pile, we place it there and move on.
Otherwise, we find the earliest* pile x which B can be placed on top of. This can be a new pile if necessary.
Next, we link B to P, where P is the top book on the previous pile x - 1.
We now know that:

B is strictly* smaller in width than P, since the books are sorted in descending order by width
B is strictly greater in height than P, or we would have placed B on top of P

Now, we have constructed a link from every book (except those in the first pile), to a book in the previous pile that is greater in width and lower in height.
@Sp3000's excellent diagram illustrates this well:

By following any path from the last pile (on the right), to the first pile (on the left), we get an antipile. Importantly, this antipile's length is equal to the number of piles. Hence, the number of piles used is minimal.
Finally, since we have organised the books into the minimum number of piles without overlaps, we can stack them on top of each other to get one pile with the minimum number of overlaps.
* this helpful comment explains a few things

+1 for the expositive proof and link to the discussion. Props to xnor et al.

I should clarify that Dilworth's Theorem doesn't cover the whole proof, just the fact that the smallest number of piles equals the greatest-size antipile.

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