text:
codegolf.com: Saving Time
From codegolf.com (not loading as of Sept 15, 2011) was one that was driving me crazy. Print to STDOUT a clock of an exacting form, reading time from STDIN and marking an h at the hour and m at minute (rounded down to a multiple of 5) and an x if they overlap, unused ticks are marked with an o, so that
echo "23:13" | perl script.pl

yields
        o
    h       o

 o             m

o               o

 o             o

    o       o
        o

Mine is:
$/=':';($h,$m)=<>;printf'%9s
%5s%8s

%2s%14s

%s%16s

%2s%14s

%5s%8s
%9s',map{qw'o h m x'[2*($_==int$m/5)^$_==$h%12]}map{$_,11-$_}0..5

for 136 characters, using Perl. I wish I could get on the site, but I seem to recall that the leaders were under 100, also using Perl. Can someone else beat it?

http://www.perlmonks.org/?node_id=811919

A fascinating read :)

@Peter, its the goldmine! Thanks for finding that, I wonder if mine can adapt their techniques?

What do you mean, "adapt"? Same golf, same solutions, no?

@J B, I was mostly proud of the way that I selected the marker, so I had been hoping to mesh their formatter with it. The reason I haven't posted it is that it is still many chars longer than those mad geniuses from the article.

Is there a serious reason why to use something in such lemon shape, instead of a circle?

@userunknown: The original task was probably designed using a wider font.

Golfscript, 75 bytes
Inspired by the article linked in the comments.
':'/{~}/5/:m;12%:h;"XXXXXXXXXXXX"{..318\%9/' '*@12%.h=2*\m=+'omhx'=@85/n*}%

The XXXXXXXXXXXX part represents 12 bytes of data, some of them unprintable, and should be replaced with the byte sequence 120 47 253 22 194 9 183 44 196 55 125 246.
For convenience, here is a base64 encoded version:
JzonL3t+fS81LzptOzEyJTpoOyJ4L/0Wwgm3LMQ3ffYiey4uMzE4XCU5LycgJypAMTIlLmg9Mipc
bT0rJ29taHgnPUA4NS9uKn0l

Example run:
$ echo -n "JzonL3t+fS81LzptOzEyJTpoOyJ4L/0Wwgm3LMQ3ffYiey4uMzE4XCU5LycgJypAMTIlLmg9MipcbT0rJ29taHgnPUA4NS9uKn0l" | base64 -d > saving-time.gs
$ ls -l saving-time.gs
-rw-r--r-- 1 ahammar ahammar 75 2012-01-29 17:31 saving-time.gs
$ ruby golfscript.rb saving-time.gs <<< "15:37"
        o
    o       o

 o             o

o               h

 o             o

    m       o
        o

C, 259 244 163 chars
Replaced command line argument with stdin (as required, also ends up shorter).
Removed support for minutes above 59 - a waste of 3 characters.
The code is shown with line breaks and indentation, but characters were counted without them.
main(i,h,m,x){
    scanf("%d:%d",&h,&m);
    for(i=0;i<12;
        printf("%*c","IEHBNAPBNEHI"[i++]-64,"ohmx"[(x==h%12)+2*(x==m/5)]))
        x=i%2?puts("\n"+(i%10==1)),11-i/2:i/2;
    puts("");
}

Older attempt (using ANSI escape codes), 244 chars:
f(x,y)char*y;{printf("\033[%d%c",x>0?x:-x,y[x<0]);}
main(i,h,m,x){
    char*v="HIJJJJIGFFFFPKJHFDCCDFHJ";
    f(i=f(scanf("%d:%d",&h,&m),"J")*0,v);
    for(;i<12;i++)
        (x=v[i+12]-72)&&f(x,"CD"),
        f(v[i]-72,"BA"),
        putchar("omhx"[2*(i==h%12)+(i==m%60/5)]);
    f(i,"B");
}

Python, 175 chars
h,m=map(int,raw_input().split(':'))
S=([' ']*17+['\n'])*11
for i in range(12):p=1j**(i/3.);S[98+int(8.5*p.imag)-18*int(5*p.real)]='ohmx'[2*(i==m/5)+(i==h%12)]
print''.join(S),

Doesn't beat your Perl code, but maybe a more concise language with built in complex numbers (or trig functions) could use this idea to do better.

Python, 226 chars
h,p,s=raw_input().split(':'),['o']*12,[0,11,1,10,2,9,3,8,4,7,5,6]
a,b=int(h[0])%12,int(h[1])/5
p[a],p[b]='h','m' if a!=b else 'x'
print '%9s\n%5s%8s\n\n %s%14s\n\n%s%16s\n\n %s%14s\n\n%5s%8s\n%9s'%tuple([p[i] for i in s])

Usage: run 'python script.py' then type the required time. (Ex: 09:45)
Output:
        o
    o       o

 o             o

x               o

 o             o

    o       o
        o

My perl solution:
use POSIX;$/=':';@ss=(8,4,1,0,1,4,8);@sn=(0,7,13,15,13,7,0);$h=<stdin>;
$m=<stdin>;if($h>12){$h=$h-12;}$m=floor($m/5);
for($c=0;$c<7;$c++){for($s=0;$s<$ss[$c];$s++){printf(" ");}
$ac='o';if($h>5&&$h-6==6-$c){$ac='h';}if((($m>5)&&$m-6==6-$c)||($m==$c)&&($c==0)){
if($h>5&&$h-6==6-$c){$ac='x';}else{$ac='m';}}
print($ac);for($s=0;$s<$sn[$c];$s++){printf(" ");}$bc='o';if($h<6&&$h==$c){$bc='h';}
if($m<6&&$m==$c){if($h<6&&$h==$c){$bc='x';}else{$bc='m';}}
if($sn[$c]){print($bc);}printf("\n");if($c&&($c!=5)){printf("\n");}}

527 bytes
My C solution:
main(){int x[]={8,4,1,0,1,4,8},y[]={0,7,13,15,13,7,0}
,h,m,z,c,s;scanf("%d:%d",&h,&m);h>12?h-=12:h;m/=5;
for(c=0;c<7;c++){for(s=0;s<x[c];s++){printf(" ");}z='o';
if(h>5&h-6==6-c){z='h';}if((m>5&m-6==6-c)|(m==c)&!c){
z='m';if(h>5&h-6==6-c){z='x';}}printf("%c",z);
for(s=0;s<y[c];s++){printf(" ");}z='o';if(h<6&h==c){
z='h';}if(m<6&m==c){z='m';if(h<6&h==c){z='x';}}
if(y[c]){printf("%c",z);}printf("\n");if(c&&(c!=5)){printf("\n");}}}

440 bytes

a quick suggestion on the Perl: you don't need posix, you can read from stdin with simply <> and I don't think you need to printf the way you are using it, print will work :)

Scala 327 chars
object C extends App{
val R=List(2,4,6,8,10)
val r=1::R:::11::R.reverse
val C=List(3,6,12,18,21)
val c=1::C:::21::C.reverse
def p(n:Int,i:Char){
val z=r(n)
val s=c((n+3)%12)
printf("[%d;%dH"+i,z,s)}
val t=readLine.split(":")
val h=t(0).toInt%12
val m=t(1).toInt/5
(0 to 11).map(x=>p(x,'o'))
p(h,'h')
p(m,'m')
if(h==m)p(h,'x')}

in use with a proper circle shape, not your lemon-XXXX:
clear  && echo 5:43 | scala C
           o
     o           o

  o                 o

o                    o

  m                 o

     o           h
           o

ungolfed:
object Clock {
 val R = List (2,4,6,8,10)
 val r = 1 :: R ::: 11 :: R.reverse
 val C = List (3,6,12,18,21)
 val c = 1 :: C ::: 22 :: C.reverse

 def pos (n: Int, i: Char)={
   val z = r (n)
   val s = c ((n+3) % 12)
   printf ("[%d;%dH" + i, z, s)
 }

 def main (args: Array [String]) {
   val t = args (0).split (":")
   val h = t (0).toInt % 12
   val m = t (1).toInt /  5
   (0 to 11).map (x=> pos (x, 'o'))
   pos (h, 'h')
   pos (m, 'm')
   if (h == m) pos (h, 'x')
  }
}

Uses Ansi-Code for output at pos(y,x). Since we only need 5 Minutes accuracy, precalculated values for x and y seem to be shorter than handling sin and cos functions with their import.

Python, 176 characters
o=map(ord,' .@Set~lWC2&!/0ABTUfgu')
h,m=map(int,raw_input().split(':'))
print''.join([' ',['\n','ohmx'[2*(i==o[m/5])+(i==o[h%12])]][i in o[:12]]][i in o]for i in range(24,127))

Perl 131 characters
<>=~/:/;$h=$`%12;$m=$'/5;printf'%9s
%12$5s%8s

%11$2s%14s

%10$s%16s

%9$2s%14s

%8$5s%8s
%9s',map$_^$h?$_^$m?o:'m':$h^$m?h:x,0..11


text:
Optimize matrix chain multiplication
This challenge is to compute the most efficient multiplication order for a product of several matrices.
The size of the matrices is specified on a single line of standard input.  You should print to standard output a list of integers indicating the order in which to do the multiplications to minimize the total multiplication cost.
example 1
input
5x6 6x12 12x100 100x7

output
3 2 1

The input line will be a space-separated list of matrix sizes, each of which is the number of rows, followed by an x, followed by the number of columns.  For the example, there are 4 matrices to multiply together (so 3 total multiplications), and since matrix multiplication is associative they can be done in any order.
The output should be the order in which to perform the multiplications to minimize total cost.  This should be a space-separated list of integers representing the index of the multiplication to perform next.  For N matrices, this list should contain the numbers 1 through N-1, inclusive.  For example 1, the output 3 2 1 means you should do the 12x100 * 100x7 multiplication first, then the 6x12 * 12x7 multiplication (the second matrix times the result of the previous step), then finally the resulting 5x6 * 6x7 multiplication.
The matrix multiplications will always be compatible, i.e. the number of columns of a matrix will match the number of rows of the subsequent matrix.  Assume the cost of multiplying two matrices AxB * BxC is A*B*C.
Your code must handle lists of up to 100 matrices, each of dimension up to 999, and do so in a reasonable time.
example 2
input
5x10 10x5 5x15 15x5

output
1 3 2

or
3 1 2

example 3
input
22x11 11x78 78x123 123x666 666x35 35x97 97x111 111x20 20x50

output
2 3 4 5 6 7 8 1

Note: for verification, the best total cost for the three examples is 9114, 750, and 1466344.
Shortest code wins!

Are you sure about the last example? The total cost given by my code is 1466344.

@Howard: Yep, you're right, a bug in my code.  Fixed.

Ruby, 176 172 205 characters
Here is another version (several chars longer) which will also run for large input in reasonable time.
q=(gets.split<<$_[/\d+$/]).map &:to_i
r=Hash.new{|h,i|h[i]=Hash.new{|h,j|h[j]=1e12;h[j]=i==j ?[0,[]]:(i...j).map{|k|a,c=r[i][k];b,d=r[k+1][j];[a+b+q[i-1]*q[k]*q[j],c+d+[k]]}.min}}
$><<r[1][q.size-1][1]*' '

First version: straight recursive implementation in Ruby. It does a complete search and thus might be slow on large inputs.
k=->m{m[2]?(1..m.size-2).map{|l|s=k[m[0,l]+m[l+1..-1]];[m[l-1]*m[l]*m[l+1]+s[0],[l]+s[1].map{|u|u<l ?u:u+1}]}.min: [0,[]]}
$><<k[(gets.split<<$_[/\d+$/]).map &:to_i][1]*' '

Part of the challenge is to handle 100 matrices in a reasonable time, which this code doesn't.

@KeithRandall Ah, I didn't read that sentence (and I don't like it - it is a very strong restraint). I will try to build a solution which can handle this case also.

source: Stack Exchange

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

sort: votes


text:
Shana tova umetuka! (Happy Jewish New Year!)
Write the shortest program, in the language of your choice, that takes as input a year on the Hebrew calendar, and outputs the corresponding Gregorian date for Rosh Hashana, in YYYY-MM-DD format.
~$ rh 5771
2010-09-09
~$ rh 5772
2011-09-29
~$ rh 5773
2012-09-17

The input may come from either the command line or from stdin, whichever is more convenient.
You may assume that the year will be between 5600 (1839) and 6000 (2239), inclusive.

@trinithis i beg your pardon, dude. the Hebrew calendar was inherited from the Babylonian system of computing ephemerides. this guy figured that out: http://en.wikipedia.org/wiki/Otto_Neugebauer it is a very cool piece of precognate almagestian mathematics worthy of study by any geek worth his unix pipe

CPAN 5.10, 109
This is even cheaper than the C# solution, for reasons enumerated below.  Code first: (character count as a difference to perl -E'' as usual)
$ perl -E'$_="DateTime::Calendar::Hebrew";/:/;eval"require $_";say$`->from_object(object,$_->new(year,<>,month,7))->ymd'

steals Peter Olson's idea of just outsourcing it to the library
CPAN's current release of DateTime::Calendar::Hebrew doesn't install out of the box, you need to patch it.
needs Perl 5.10.  No earlier, no later.

At least it's short.

Ruby, 192 181 165 characters
require'date'
s=(-6+235*n=gets.to_i)/19*765433+73848;e=s/u=25920
$><<Date.jd(347641+e+([h=s%u/19440,84>>e%7+h&1,v=e%7*(374454>>n%19&1-h&s%u/9923),v,n-5765].count 1))

Input is given as a single number on STDIN.
Edit 1: Several arithmetic transformations saved quite a few characters.
Edit 2: There was some room for improvement.

C#, 212
This might seem cheap, but here I go:
using System;using System.Globalization;class P{static void Main(){int y=int.Parse(Console.ReadLine())-5771;var a=new HebrewCalendar().AddYears(new DateTime(2010,9,9),y);Console.Write(a.ToString("yyyy-MM-dd"));}}

with spacing
using System;
using System.Globalization;
class P
{
    static void Main()
    {
        int y = int.Parse(Console.ReadLine()) - 5771;
        var a = new HebrewCalendar().AddYears(new DateTime(2010, 9, 9), y);
        Console.Write(a.ToString("yyyy-MM-dd"));
    }
}

You could save one character by using 5771 as your reference year instead of 5772.

@dan04 Done....

You shouldn't count Console.Read(); as a part of the program, it's not really needed.

@PeterOlson Here's a version at only 190 bytes: using System;class P{static void Main(){Console.Write(new System.Globalization.HebrewCalendar().AddYears(new DateTime(2010,9,9),int.Parse(Console.ReadLine())-5771).ToString("yyyy-MM-dd"));}}.

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


text:
There Was an Old Lady
Your goal is to write a program that prints the following poem exactly as it appears here:
There was an old lady who swallowed a fly.
I don't know why she swallowed that fly,
Perhaps she'll die.

There was an old lady who swallowed a spider,
That wriggled and iggled and jiggled inside her.
She swallowed the spider to catch the fly,
I don't know why she swallowed that fly,
Perhaps she'll die.

There was an old lady who swallowed a bird,
How absurd to swallow a bird.
She swallowed the bird to catch the spider,
She swallowed the spider to catch the fly,
I don't know why she swallowed that fly,
Perhaps she'll die.

There was an old lady who swallowed a cat,
Imagine that to swallow a cat.
She swallowed the cat to catch the bird,
She swallowed the bird to catch the spider,
She swallowed the spider to catch the fly,
I don't know why she swallowed that fly,
Perhaps she'll die.

There was an old lady who swallowed a dog,
What a hog to swallow a dog.
She swallowed the dog to catch the cat,
She swallowed the cat to catch the bird,
She swallowed the bird to catch the spider,
She swallowed the spider to catch the fly,
I don't know why she swallowed that fly,
Perhaps she'll die.

There was an old lady who swallowed a horse,
She died of course.

The text must appear exactly as it does here, and fewest characters wins.
Edit: Your program may not access the internet.

Counted in UTF-8 encoded bytes?

The golf clearly says "fewest characters", not bytes. Encode it how you want as long as it is still a valid program.

For reference, the poem is 1208 characters long.

Perl 5.10, 392 384 372 235 369 (ASCII) / 234 (Unicode)
The shortest ASCII version of this is 369 characters long:
@_=(fly,spider,bird,cat,dog);$_="There was an old lady who!ed a";for$P("",",
That wrJand Jand jJinside her",",
How absurd&",",
Imagine that&",",
What a hog&"){$p=$c;$c=$".shift@_;$t=$p?"She!ed the$c to catch the$p,
$t":"I don't know why she!ed that$c,
Perhaps she'll die.

$_";$_.="$c$P.
$t";s/&/ to! a$c/}s/!/ swallow/g;s/J/iggled /g;say"$_ horse,
She died of course."

It started from this base program:
my @animals = qw(fly spider bird cat dog);
my $buf = "There was an old lady who swallowed a ";
for my $phrase ( "",
                 ",\nThat wriggled and iggled and jiggled inside her",
                 ",\nHow absurd&",
                 ",\nImagine that&",
                 ",\nWhat a hog&" ) {
  $previous = $current;
  $current = shift @animals;
  $trail = $previous ? "She swallowed the $current to catch the $previous,\n$trail"
                     : "I don't know why she swallowed that $current,\n"
                       . "Perhaps she'll die.\n\n$buf";
  $buf .= "$current$phrase.\n$trail";
  $buf =~ s/&/ to swallow a $current/;
}
say "$buf horse,\nShe died of course.";

The core idea is to keep the end of the rhyme and the beginning of the next one in $trail, augmenting it as we go along.  It's made non-trivial by the need of a special case for the first use, and the attempt to re-use the animal name variable even in the animal-specific phrase.  Further optimizations include:

one-character identifiers for everything
using barewords instead of quoted strings for the animal list
use of the accumulator $_ for $buf to shorten most substitution operations even more (use of @_ is by force of habit and doesn't win anything more than any other character)
including the preceding space directly inside the animal name variable (the space character taken from the $" variable)
regexp substitution to shorten the most common phrases: ' swallow' and 'iggled '
no code spacing whatsoever and all \n in string literals replaced with actual newlines

All but the last optimization yield this:
@_ = (fly, spider, bird, cat, dog);
$_ = "There was an old lady who!ed a";
for $P ( "",
         ",\nThat wrJand Jand jJinside her",
         ",\nHow absurd&",
         ",\nImagine that&",
         ",\nWhat a hog&" ) {
  $p = $c;
  $c = $" . shift @_;
  $t = $p ? "She!ed the$c to catch the$p,\n$t"
          : "I don't know why she!ed that$c,\nPerhaps she'll die.\n\n$_";
  $_ .= "$c$P.\n$t";
  s/&/ to! a$c/;
}
s/!/ swallow/g;
s/J/iggled /g;
say "$_ horse,\nShe died of course.";

Additionally, this golf is a victim of the underspecified encoding problem.  As it—as of now—counts individual characters instead of bytes in a specified encoding, there's a big gain to be achieved by decoding the program source from UCS2 before starting.  The final result isn't very readable anymore, but it's short all right. (234 characters, counted as a difference from perl -E'' as usual) (I had to include the trailing newline back to make it valid UCS2)
$ perl -MEncode=from_to -e'$_="䁟㴨晬礬獰楤敲Ɫ楲搬捡琬摯朩㬤弽≔桥牥⁷慳渠潬搠污摹⁷桯Ⅵ搠愢㭦潲⑐⠢∬∬੔桡琠睲䩡湤⁊慮搠橊楮獩摥敲∬∬ੈ潷扳畲搦∬∬੉浡杩湥⁴桡琦∬∬੗桡琠愠桯朦∩笤瀽④㬤挽␢⹳桩晴䁟㬤琽⑰㼢卨攡敤⁴桥④⁴漠捡瑣栠瑨攤瀬ਤ琢㨢䤠摯渧琠歮潷⁷桹⁳桥Ⅵ搠瑨慴④Ⰺ健牨慰猠獨攧汬楥⸊ਤ弢㬤弮㴢④⑐⸊⑴∻猯☯⁴漡④⽽猯ℯ⁳睡汬潷⽧㭳⽊⽩杧汥搠⽧㭳慹∤张桯牳攬੓桥楥搠潦潵牳攮∊";from_to($_,utf8,ucs2);eval'

A good thing there was a lot to golf from before resorting to Unicode, or it wouldn't be much fun.
Edit: can't find a way to copy/paste the 234-character version to this browser, so I'm leaving the 235-character one.  Will fix this evening, when I get my hands on a real UTF8-aware clipboard. found a way.  Quasi-proof on ideone.

I revoked my upvote.  The unicode packing trick is getting old.

The non-packed version is still in, you know ;p

@JoeyAdams really? I didn't even notice the packed version until I read your comment

Perl, 120 94 chars
Count includes call to the interpreter.
You did say to reproduce it exactly as it does here ;)
perl -MLWP::Simple -E'($p=get("http://goo.gl/kg17j"))=~s#^.+?pr.*?de>|</co.*?re>.+$##sg;say$p'

N.B.
This solution is what prompted the 'no-Internet' restriction. Let it be a lesson for future code-golf question specifications :)

This entry turned into a quine the moment I posted it! A little regex manipulation restored service back to normal...

Clever, but a little too easy... :P I should have clarified on my rules.

Quotation marks around address should be double. Very good way to solve it :-)

Rotten way to solve it, because it relies on the existence of an outside resource. I'd count the length of the question against it same as I would a program that read the poem from a file.

Outside resources are not problem, since it is quite questionable what is resource and what is environment at all. I like exploit of gap in not strictly defined initial question. This is not a solution, but good example to take a care asking questions :-)

It may be a rotten way to solve it, but it relies on an outside resource that's exactly as liable to exist as the question it answers.  Which makes it perfectly acceptable as an answer to said question, IMO.

@trinithis : The 'no-Internet' restriction was imposed after my post. Admittedly, this is not a serious attempt at coding a solution, but it met the specifications at the time of posting it. Oh, and LWP::Simple is part of the Perl core, at least on v5.12.3.

I didnt intend to imply it wasn't. I was just continuing my rant about crap like it in code golf in general.

I'd need to amend my comment to say that the answer only stays valid as long as it remains on the first page of answers.  It's still the case for the time being, but who knows...

Use a URL Shortener.

@st0le : Implemented your good suggestion.

The hilarious thing about this post is that it reads the required output text from this page.  I changed my downvote to an upvote.

Vim, 373 keystrokes
iThere was an old lady who swallowed a fly.
I don't know why she s<C-n> that f<C-n>,
Perhaps she'll die.

T<C-x><C-l><Left><C-w>spider<Esc>oThat wriggled <Esc>6hiand <Esc>3hy$u$ppbij<End>inside her.
She s<C-n> the sp<C-n> to catch the f<C-n>,
I<C-x><C-l><C-x><C-l><Esc>qqyapGp3jYPkk$Bqcwbird<Esc>+CHow absurd to sw<C-n><Backspace><Backspace> a b<C-n>.<Esc>qwyb5wvep$Bvepq@qcwcat<Esc>+CImagine that to sw<C-p> a cat.<Esc>@w@qcwdog<Esc>+CWhat a hog to sw<C-p> a dog.<Esc>@w@qcwhorse<Esc>+cGShe d<C-p>d of course.

Funny how exponential that scrambling is.

Python 3.x: 407 chars
import base64,zlib;print(zlib.decompress(base64.b64decode(b'eNrlkLFOxDAQRPt8xXTXoHwHdEhEot7L+myD8Z7snKz8Pd6LT7mgFFQIRGftPs/OzOBMMiiUQRESGIF4RnGCXCgEKYZBOIW5B7onsMTDhPcopTIzsjN33ORoUvShos8mOTpnJQ4hgL3pu2741rF89mySigwqWJK3NugmMu6eb+3tY648qrRafPniyDQ5TIKRptFdZ83kz+Q5+sQq8ViP0DFfEquZRrT9vnXdbI2v3fzCoPXs9dgHWR/NorpJWoH9oONCrr5vnf35TlisKryqGsGJ3TZS1/uN8EKurlu5/6k7Jymbm7f6kSEnjHKp0/4TSSOZgA==')).decode('utf8'))

You can get it down to 391 chars by doing something like:
import zlib;print zlib.decompress("""eJzlkLFOxDAQRPt8xXTXoHwHdEhEot7L+myD8Z7snKz8Pd6LT7mgFFQIRGftPs/OzOBMMiiUQRES
GIF4RnGCXCgEKYZBOIW5B7onsMTDhPcopTIzsjN33ORoUvShos8mOTpnJQ4hgL3pu2741rF89myS
igwqWJK3NugmMu6eb+3tY648qrRafPniyDQ5TIKRptFdZ83kz+Q5+sQq8ViP0DFfEquZRrT9vnXd
bI2v3fzCoPXs9dgHWR/NorpJWoH9oONCrr5vnf35TlisKryqGsGJ3TZS1/uN8EKurlu5/6k7Jymb
m7f6kSEnjHKp0/4TSSOZgA==""".decode('base64'))

Creative way to compress this.

JavaScript (422)
Works in the SpiderMonkey interpreter versions used by both anarchy golf and ideone.
for(a="fly0spider0bird0cat0dog0horse0How absurd0Imagine that0What a hog".split(i=0);p=print;p("I don't know why she swallowed that fly,\nPerhaps she'll die.\n")){p("There was an old lady who swallowed a",a[i]+(i?",":"."));i>4&&quit(p("She died of course."));i&&p(i>1?a[4+i]+" to swallow a "+a[i]+".":"That wriggled and iggled and jiggled inside her.");for(j=i++;j;)p("She swallowed the "+a[j]+" to catch the "+a[--j]+",")}

A bit more nicely formatted:
for (a = "fly0spider0bird0cat0dog0horse0How absurd0Imagine that0What a hog".split(i = 0);
p = print; p("I don't know why she swallowed that fly,\nPerhaps she'll die.\n")) {
    p("There was an old lady who swallowed a", a[i] + (i ? "," : "."));
    i > 4 && quit(p("She died of course."));
    i && p(i > 1
        ? a[4 + i] + " to swallow a " + a[i] + "."
        : "That wriggled and iggled and jiggled inside her."
    );
    for (j = i++; j;) p("She swallowed the " + a[j] + " to catch the " + a[--j] + ",");
}

Clever use of the splitting by 0 trick to initialize i to 0 in only 2 bytes. Have a +1

C (gcc), 429 424 423 bytes
-5 bytes thanks to ceilingcat
c,*w[]={"384fly<1","I don't know why she5ed that fly<Perhaps she'll die.772","There was an old lady who5ed a ","She5ed the "," to catch the "," swallow"," to5 a ","\n","spider","bird","cat","iggled ",",7","3948<0"};U(char*s){for(;c=*s++;)c>47&c<65?U(w[c-48]):putchar(c);}f(){U("2fly.718<That wr;and ;and j;inside her.709<How absurd69.7=:<Imagine that6:.73:49<=dog<What a hog6dog.73dog4:<3:49<=horse<She died of course.7");}

Try it online!

ink, 370 369 354 bytes
LIST B=fly,spider,bird,cat,dog,horse
VAR s=" swallow"
-(i)~B=B(i)
There was an old lady who{s}ed a {B}{.|,}
{|That wriggled and iggled and jiggled inside her|How absurd|Imagine that|What a hog|She died of course.->END}{|.| to{s} a {B}.}
-(k)~B--
{B:
She{s}ed the {B+1} to catch the {B},
->k
}I don't know why she{s}ed that fly,
Perhaps she'll die.
\
->i

Try it online!
Explanation
LIST B=fly,spider,bird,cat,dog,horse           // Ink's "LIST"s aren't much like lists - they're more like enums. Here we create a list type stating what animals exist, and make a set containing none of them.
VAR s=" swallow "                              // Pretty self-explanatory
-(i)~B=B(i)                                    // The i label keeps track of how many times we've visited it. We set B (the set) to be equal to the i-th item in B (the list type).
There was an old lady who{s}ed a {B}{.|,}      // Print the first line. {.|,} is a sequence - it's a period the first time it's encountered, and a comma every subsequent time.
                                               // Sequences can have more than one item in them, which is how we print the second line. When we get to the horse one, we terminate the program right away.
{|That wriggled and iggled and jiggled inside her|How absurd|Imagine that|What a hog|She died of course.->END}{|.|to{s} a {B}}.}
-(k)~B--                                       // Step back through the list type.
{B:                                            // A conditional - we execure the next two lines if B is non-empty.
She{s}ed the {B+1} to catch the {B},           // Print the "she swallowed the..." line
->k                                            // And repeat
}I don't know why she{s}ed that fly,           // Only reached when the conditional fails.
Perhaps she'll die.
\                                              // A backslash and a space to force an empty line.
->i                                            // Back to the top

Ruby, 436 characters
w=" swallowed "
f="There was an old lady who#{w}a "
c=" to swallow a %s"
b="dog","cat","bird","spider","fly"
s=nil,"That wriggled and iggled and jiggled inside her","How absurd"+c,"Imagine that"+c,"What a hog"+c
a=[]
5.times{k=g=b.pop;t,*s=s
puts f+k+(t ??,:?.),t&&[t%k+?.,a.map{|x|y,k=k,x;"She#{w}the #{y} to catch the #{k},"}],"I don't know why she#{w}that fly,","Perhaps she'll die.",""
a=[g]+a}
puts f+"horse,","She died of course."

Scala (706 619 599 550 chars)
val L=Seq("fly","spider","bird","cat","dog")
val M="\nThere was an old lady who %sed a %s,"
type S=String
def s(l:S,a:S="",b:S="")=l.format("swallow",a,b)
def p(l:S,a:S=""){println(s(l,a))}
var i=0
var r=List[S]()
L.map{a=>{p(M,a)
if(i>0){p(Seq("","That wriggled and iggled and jiggled inside her.","How absurd","Imagine that","What a hog")(i)+(if(i>1)" to %s a %s."else""),a)
r::=s("She %sed the %s to catch the %s,",L(i),L(i-1))
r.map(p(_))}
p("I don't know why she %sed that fly,\nPerhaps she'll die.")
i+=1}}
p(M,"horse")
p("She died of course.")

Using map instead of foreach allows to squeeze more chars... In codegolf, we don't care about performance, elegance (non-mutability) or logic...

Stax, 195 bytes
ó┤♣≤jß¡εD<Çjò≡²£c¼ìv┴Åô║,·~┼¢╝EΦ5xZ&√σ"ømÿ≡ZπvÅ╦♣1♦>▄\¬◘¡jS¢í╞╟╚);4j↕i¢s♦éÇöy‼ac┴àÇ╩»-ó»ónú¢│g5εÿ╔µ┬bîæ¢k‼f╓fJ○▐═╜<^Γ▀o▀Δnq░╩αÄ&│♣ⁿâmû╣Ç≡*@☺pG_ⁿö┤mσ/V\└?iq┌îB½Ä¿L╙N┐£Ç≥δ2 0δrµLä⌡(⌡▀╬àΦ⌠tƒìg" ⌠ZHó

Run and debug it
Unpacked, ungolfed, and commented, it looks like this.
`]q~*}8x9uA3_P0O`jX         push ["fly", "spider", "bird", "cat", "dog"] and store in X register
{                           start iteration over animal list
  `p{+P91{m@Lwe\Jk?!#8`Yp   Store "There was an old lady who swallowed a " in Y register and print it
  .,.i!@+                   Concatenate "." on the first iteration and "," thereafter to the animal
  P                         Print
  i{                        On all iterations after the first, execute this block
    `r4uB2O'O(4XghNqE PhaMg^-riMgR{N>A8LfCNqh@Rn$=aHX|93@_5d?d7qp2-`
                        Push "That wriggled and iggled and jiggled inside her. How absurd, bird. Imagine that, cat. What a hog, dog. She died of course"
    ',`?~nA${F"`R       Replace "," with " to swallow a"
    .. /                Split on string ". "
    iv@                 Get the (i-1)th element where i is the iteration index
    '.+P                Concatenate "." and print
  }M                    End of conditional block
  x2B                   Get adjacent pairs from x (list of animals)
  i(                    Keep first i pairs where i is the iteration index
  r{                    Iterate over reversed list of pairs
    `_,m+"S3&#`p        Print "She swallowed the "
    Ep                  Print the second animal from the pair
    `p<qr?t`p           Print " to catch the "
    ',+P                Concatenate "," to the first animal from the pair and print
  F                     End iterating block
  `;p(9Cv,77BzpP'kB|"`P Print "I don't know why she swallowed that fly,"
  `%?/3.=iHiS6y!`P      Print "Perhaps she'll die."
  zP                    Print a newline
F                       End outer animal iteration.
yp                      Print y register. ("There was an old lady who swallowed a ")
`zvVH`P                 Print "horse,"
                        Print "She died of course." with an unterminated literal
`AJt6Q.3+$!

Run this one

Zsh + coreutils, 406 375 bytes
g()ls -t<>"She$d the $1 to catch the $2,"
set bird spider \ swallow iggled\
<<Z
${b=There was an old lady who${d=$3ed} a }fly.${5=
I don't know why she$d that fly,
Perhaps she'll die.

$b}$2,
That wr$4and $4and j$4inside her.
`g $2 fly`$5$1,
How absurd${6= to$3 a }$1.
`g $@`$5cat,
Imagine that$6cat.
`g cat $1`$5dog,
What a hog$6dog.
`g dog cat`$5horse,
She died of course.

Try it online!
Tricks:

the g function creates the line as a file and then ls lists the files in the current directory in order of creation (-t), to avoid having to repeat the previous lines every time.

I used <> (which creates the file before the command is executed) instead of >...; because using multiple commands in a function  requires {} around them

set bird ... assigns the words to $1, $2, etc.
\ swallow includes a space at the start of without needing to use quotes
<<Z starts a heredoc which is effectively a long interpolated string
${b=There...} is a shorthand form setting b to that string and substituting its value in
Indexed variables like $1, $2, etc. can be substituted without a space afterwards (rather than being interpreted as a variable called 5dog, for example), so we prefer them as it allows us to include the space inside the assignment to avoid repeating it
g $@: since we set $1 and $2 to bird and spider respectively, we can pass all the numbered variables to g in one go with $@ instead of g $1 $2 (it ignores the extra ones, $3 etc.)

PowerShell Core, 503 484 bytes
$i=" bird"
$k=" swallowed"
$g="She$k the"
$h=" to catch the"
$c="There was an old lady who$k a"
$e=" to swallow a"
$s=" spider"
"$c fly."
$c="`n$c"
($a="I don't know why she$k that fly,`nPerhaps she'll die.")
"$c$s,`nThat wriggled and iggled and jiggled inside her."
($d="$g$s$h fly,")
$a
"$c$i,`nHow absurd$e$i."
($j="$g$i$h$s,")
$d
$a
"$c cat,`nImagine that$e cat."
($b="$g cat$h$i,")
$j
$d
$a
"$c dog,`nWhat a hog$e dog.`n$g dog$h cat,"
$b
$j
$d
$a
"$c horse,`nShe died of course."

Try it online!
It was a fun one! :)

05AB1E, 237 222 218 224 bytes
+6 bytes to fix a bug (In most verses the first line ends in a ,)
“¤†É¾£‡—Ä‹·î€“#©€“€Ç€¥€¤„Ï£î€Ð 1ed€… ÿ,“®¦¦¨.•Ω\3¯ÓõÔ)V₄H`«Å₆éÅΘΓåò•ć¡δ"ÿ to 1 a ÿ."Å\“€Š wr0€ƒ 0€ƒ j0‹â‚®.“š“‚Îœ·€‚…£.“ª0šø0δK®ü“‚Î 1ed€€ ÿ€„¬ª€€ ÿ,“¨ηíõšε“i¥Ú'tƒ€„Ý‚Î 1ed€Š¤†,“ª“™¡‚Î'll—Ç.
“ª}õª.ι˜.ª»T.•4Ƶ›₅8zεÚS•#‡¨','..;

Try it online!
Commented:
“¤†É¾£‡—Ä‹·î€“              # push dictionary compressed string "fly spider bird cat dog horse"
#                           # split on spaces
©                           # store the list of animals in the register
€“€Ç€¥€¤„Ï£î€Ð 1ed€… ÿ,“    # for each animal, push the string "there was an old lady who 1ed a ÿ,"
                            #   where ÿ s replaced by the animal
®                           # push the list of animals again
¦¦¨                         # remove the fly, the spider and the horse: ["bird", "cat", "dog"]
.•Ω\3¯ÓõÔ)V₄H`«Å₆éÅΘΓåò•    # push alphabet compressed string "xhow absurdximagine thatxwhat a hog"
ć                           # extract the first character "x"
¡                           # split the remaining string on "x": ["how absurd", "imagine that", "what a hog"]
δ"ÿ to 1 a ÿ."Å\            # format the string "ÿ to 1 a ÿ." with a value from this list and one from the short animal list
                            #  => ["how absurd to 1 a bird.", "imagine that to 1 a cat.", "what a hog to 1 a dog."]
“€Š wr0€ƒ 0€ƒ j0‹â‚®.“      # push compressed dictionary string "that wr0 and 0 and j0 inside her."
š                           # prepend this to the list
“‚Îœ·€‚…£.“                 # push compressed dictionary string "she died of course."
ª                           # append this to the list
0š                          # prepeand a 0
ø                           # zip both lists together
0δK                         # remove 0's in sublists
                            #  => [["there was an old lady who 1ed a fly,"],
                            #      ["there was an old lady who 1ed a spider,", "that wr0 and 0 and j0 inside her."],
                            #      ["there was an old lady who 1ed a bird,", "how absurd to 1 a bird."],
                            #      ["there was an old lady who 1ed a cat,", "imagine that to 1 a cat."],
                            #      ["there was an old lady who 1ed a dog,", "what a hog to 1 a dog."],
                            #      ["there was an old lady who 1ed a horse,", "she died of course."]]
®                           # push the list of animals again
ü“‚Î 1ed€€ ÿ€„¬ª€€ ÿ,“      # format the string "she 1ed the ÿ to catch the ÿ," with adjacent pairs of animals
¨                           # remove the last string
                            #  => ["she 1ed the spider to catch the fly,", "she 1ed the bird to catch the spider,", "she 1ed the cat to catch the bird,", "she 1ed the dog to catch the cat,"]
η                           # take the prefixes of this list
í                           # reverse each prefix
õš                          # prepend the empty string
ε                           # map over the prefixes:
  “i¥Ú'tƒ€„Ý‚Î 1ed€Š¤†,“    #   push compressed string "i don't know why she 1ed that fly,"
  ª                         #   append to the prefix
  “™¡‚Î'll—Ç.\n“            #   push compressed string "perhaps she'll die.\n"
  ª                         #   append to the prefix
}                           # end of map
õª                          # append an empty string to the list of prefixes
.ι                          # interleave the list of prefixes with the earlier list
˜                           # flatten everything into a list of lines
.ª                          # sentence-case each line
»                           # join by newlines
T                           # push 10
.•4Ƶ›₅8zεÚS•                # push compressed string "swallow iggled"
#                           # split on the space
‡                           # in the poem replace every digit of 10 with the corresponding word in this list
                            #   1 -> swallow, 0 -> iggled
¨                           # remove a trailing newline
','..;                      # replace the first "," with a "."

Haskell, 515 498
Score does not count newlines and spaces added for presentation.
b c a="There was an old lady who swallowed a "++a++c++".\n"
t r a=b(",\n"++r++" to swallow a "++a)a
s(a,b)="She swallowed the "++a++" to catch the "++b++",\n"
z=["fly","spider","bird","cat","dog"]
h=[b"",b",\nThat wriggled and iggled and jiggled inside her",t"How absurd",
 t"Imagine that",t"What a hog"]
v(g,p)=g++(=<<)s(zip p$tail p)++
 "I don't know why she swallowed that fly,\nPerhaps she'll die.\n\n"
main=putStr$(=<<)v(zip(zipWith($)h z)(tail$scanl(flip(:))[]z))++b
 ",\nShe died of course""horse"

Ungolfed:
type Animal = String
type Comment = String

beginning :: Animal -> Comment -> String
beginning animal comment = "There was an old lady who swallowed a " ++ animal ++ comment ++ ".\n"

ending :: String
ending = "I don't know why she swallowed that fly,\nPerhaps she'll die.\n\n"

to_swallow :: String -> Animal -> Comment
to_swallow start animal = ",\n" ++ start ++ " to swallow a " ++ animal

swallowed_to_catch :: (Animal, Animal) -> String
swallowed_to_catch (a, b) = "She swallowed the " ++ a ++ " to catch the " ++ b ++ ",\n"

animals :: [(Animal, Animal -> Comment)]
animals = [("fly",    const "")
          ,("spider", const ",\nThat wriggled and iggled and jiggled inside her")
          ,("bird",   to_swallow "How absurd")
          ,("cat",    to_swallow "Imagine that")
          ,("dog",    to_swallow "What a hog")
          ]

-- Turn [1,2,3,4,5] into [[1], [2,1], [3,2,1], [4,3,2,1], [5,4,3,2,1]]
trail :: [a] -> [[a]]
trail = tail . scanl (flip (:)) []

verses :: [String]
verses = zipWith verse animals (trail $ map fst animals)

verse :: (Animal, Animal -> Comment) -> [Animal] -> String
verse (animal, comment) swallow_chain =
    beginning animal (comment animal) ++
    concatMap swallowed_to_catch (zip swallow_chain (tail swallow_chain)) ++
    ending

poem :: String
poem = concat verses ++ beginning "horse" ",\nShe died of course"

main :: IO ()
main = putStr poem

Aliasing (++) with a shorter identifier might be a good idea.

@ThomasEding or aliasing it to the # operator or something similar

C, for fun (561 chars)

Score does not count newlines and spaces added for presentation.
Thanks to J B for his improvements!
#include <stdio.h>

void main() {
    char *e = "\nShe swallowed the cat to catch the bird,\nShe swallowed the bird to catch the spider,\nShe swallowed the spider to catch the fly,\nI don't know why she swallowed that fly,\nPerhaps she'll die.\n\nThere was an old lady who swallowed a ";
    printf("%sfly.%sspider,\nThat wriggled and iggled and jiggled inside her.%sbird,\nHow absurd to swallow a bird.%scat,\nImagine that to swallow a cat.%sdog,\nWhat a hog to swallow a dog.\nShe swallowed the dog to catch the cat,%shorse,\nShe died of course.", e+191, e+128, e+85, e+41, e, e);
}

Are you sure you need all those & and []?

@J B is right, you can replace a[] with *a and just remove the &. You should gain 25 chars.

There's probably something cool to be done in C, with pointers to the middle of a common shared string.

@PhiLho Thanks, yesterday my brain was a bit fried and I forgot to remove the &s when using pointers and it didn't work :P.  JB, I don't know of a method that wouldn't require indexing (and use even more chars).

It's not indexing, it's pointer arithmetic.  ",*z=" vs +nn

Indexing is pointer arithmetic depending on how you look at it. But either way it eliminates 24 chars only to add 52 more.

Something like this.  Your version, reordered, 627 chars http://pastebin.com/MQ4LJue7 ; my version, 561 chars http://pastebin.com/7eMAWmAi

Ah, I see now with reordering the string.  Very clever.  I won't steal that but I'll keep it in mind for the future.

Steal away! It's really something that's best done in C, it would be a shame not to have it shown off in the page's only C answer.

Technically new lines and spaces should be removed from answers, if the score does not count them. https://codegolf.meta.stackexchange.com/questions/6886/how-are-line-breaks-and-formatting-counted-for-code-golf-challenges/6893#6893
(I was informed of this myself recently).
But you can post the ungolfed version below it.

@LyndonWhite You'll note that this answer predates that one by 4 years.

@MatthewRead so it does.

@MatthewRead I see no reason why that rule should not be applied to answers that predate it.

@pppery If you want to edit every post on the site from prior to 2015, go for it.

Use int main() instead of void main(). You would save 1 byte and would also be using standard C https://www.stroustrup.com/bs_faq2.html#void-main

C#, 556 chars
class P{static void Main(){string a="There was an old lady who swallowed a ",b="I don't know why she swallowed that ",c="She swallowed the ",d=" to catch the ",e="Perhaps she'll die.\n\n",f="fly",g="spider",h="bird",i="cat",j="dog",k=",\n",l=".\n",m="to swallow a ",n=c+g+d+f+k,o=c+h+d+g+k,p=b+f+k,q=c+i+d+h+k,r=n+p,s=o+r,t=q+s,u=e+a;System.Console.Write(a+f+l+p+u+g+k+"That wriggled and iggled and jiggled inside her"+l+r+u+h+k+"How absurd "+m+h+l+s+u+i+k+"Imagine that "+m+i+l+t+u+j+k+"What a hog "+m+j+l+c+j+d+i+k+t+u+"horse"+k+"She died of course.");}}

Perl, 489 chars
sub Y{$t=pop;my$s;while($b=pop){$s.="She ${W}ed the $t to catch the $b,\n";$t=$b;}$s.=$l{fly}.$/;}$W='swallow';$w='iggled';$q=" to $W a";$o="There was an old lady who ${W}ed a";$h='hat';@f=qw/fly spider bird cat dog/;@l{@f}=("I don't know why she ${W}ed t$h fly,
Perhaps she'll die.$/","T$h wr$w and $w and j$w inside her.","How absurd$q bird.","Imagine t$h$q cat.","W$h a hog$q dog.");map{$m=$f[$_];print"$o $m,
$l{$m}
",$_?Y@f[0..$_]:'';}0..$#f;print"$o horse,
She died of course.$/"

Python, 484
Ok, I did it but was pretty boring...
The last sentence is always with "fly" so some chars were removed...
f,s,b,c,d=o='fly spider bird cat dog'.split()
x='There was an old lady who swallowed a %s.\n'
t=' to swallow a %s.\n'
r=['That wriggled and iggled and jiggled inside her.\n','How absurd'+t%b,'Imagine that'+t%c,'What a hog'+t%d]
t=("She swallowed the %s to catch the %s,\n"*4%(d,c,c,b,b,s,s,f)).split('\n')
print("I don't know why she swallowed that fly,\nPerhaps she'll die.\n\n".join([x%f]+[x%o[i]+r[i-1]+'\n'.join(t[-i-1:])for i in range(1,5)]+[''])+x%'horse'+'She died of course.')

Less golfed version:
f,s,b,c,d = all = 'fly spider bird cat dog'.split()

what = 'There was an old lady who swallowed a %s.\n'

t = ' to swallow a %s.\n'
comments = ['That wriggled and iggled and jiggled inside her.\n',
            'How absurd' + t%b,
            'Imagine that' + t%c,
            'What a hog' + t%d]

swallowed = "She swallowed the %s to catch the %s,\n"
lines = (swallowed*4%(d,c,c,b,b,s,s,f)).split('\n')

end = '''I don't know why she swallowed that fly,
Perhaps she'll die.\n\n'''

def who_catch_who(i):
    return '\n'.join(lines[-i-1:])

p = end.join([what % f] +
             [what % all[i] +
              comments[i-1] +
              who_catch_who(i) for i in range(1,5)] +
             [''])

print(p + what % 'horse' + 'She died of course.')

tcl, 451 bytes
lassign {\ swallowed fly, spider " to catch the " bird cat iggled " to swallow a"} W f s c b a i w
puts "[set t "There was an old lady who$W a "]fly.
[set I "I don't know why she$W that $f
Perhaps she'll die.

"]$t$s,
That wr$i and $i and j$i inside her.
[set S "She$W the "]$s$c$f
$I$t$b,
How absurd$w $b.[set v \n$S$b$c$s,\n$S$s$c$f\n$I]$t$a,
Imagine that$w $a.
[set X $S$a$c$b,$v$t]dog,
What a hog$w dog.
${S}dog$c$a,
$X\horse,
She died of course."

Available to run on: http://rextester.com/live/GXF89639 (10th attempt)

PHP, 344 bytes
<?=gzinflate(base64_decode("5VAxTsQwEOz9iu2uifIO6JA4iXovu2cbjPdk+2Tl96zjoLugFFQIRGfNjGdn5ug4MVTMgBEkEASkGaoTyBVDkMoECOcwj+YRSOKhwFuUqooZsuM7VXFYmnAwT5wcXnLjDyEAeR6NOX7rUL544jSoWs1q8taGhkeCu+fr+vYxqxrUeDTPX7LwagVFYMIyuQVb4v1Ej5NPNJgHPYCnfE3UYqz8yu5Fbvg28Ocev6yentRD72h95O646af0Xr2p6255+0p/eAcSO5iX5oTgxG5XUHJvBeq6W9plzP+wlpOUuafSbwRyhkmuio0f"));

Try it online!
PHP, 405 bytes
<?=strtr("0fly.
106That wr8and 8and j8inside her.
23107,
How absurd57.
274623109,
Imagine that59.
2947,
27462310dog,
What a hog5dog.
2dog49,
2947,
27462310horse,
She died of course.",["There was an old lady who swallowed a ","I don't know why she swallowed that fly,
Perhaps she'll die.

","She swallowed the ","spider to catch the fly,
"," to catch the "," to swallow a ","spider,
",bird,"iggled ",cat]);

Try it online!

Python 2, 453 442 427 387 bytes

@nore saved 11 bytes:  Thanks a ton!!: pointed £ used before was a double byte char!!
saved 15 bytes: swallow shorthand
@nore saved 40 bytes!!!!! THANKS A LOT!!!
@Zachary T saved 1 byte: space between in and "..." removed
Thanks to notepad++'s find and replace tool. ;)

r="%2(:0)That wr66j5 inside her(_1)How absurd+1({3)Imagine that+3(}4)What a hog+4(~4*3)}horse)She died of course."
for i in"}~3*1){!{~1*0)_!_~0*2):!:^2)$%!~She7ed the !%There was an old lady who7ed a !$Perhaps she'll die(\n!* to 3ch the !^I don't know why she7ed that !+ to7 a !(.\n!),\n!0spider!1bird!2fly!3cat!4dog!65 and !5iggled!7 swallow".split("!"):r=r.replace(i[0],i[1:])
print r

Try it online!

You can save a lot of bytes by using ~ instead of £ (which is two bytes long as it is not ASCII).

Woah, Thanks man! Never knew that was an extended chararcter!!

This can still be pretty heavily golfed (a few chars with the symbols at the beginning, 1 by using Python2, and more optimizing replacements)

You don't need a space between in and a string literal.

Groovy, 475 bytes
b="swallowed"
a="There was an old lady who $b a"
c="I don't know why she $b that fly,\nperhaps she'll die."
d="She $b the"
e=" to catch the"
f=" to swallow a"
g="iggled"
h=" spider"
i=" fly"
j=" dog"
k=" cat"
l=" bird"
m="$d$h$e$i,"
n="$d$l$e$h,"
o="$d$k$e$l,"
print"""
$a$i.
$c

$a$h,
That wr$g and $g and j$g inside her.
$m
$c

$a$l,
How absurd$f$l.
$n
$m
$c

$a$k,
Imagine that$f$k.
$o
$n
$m
$c

$a$j,
What a hog$f$j
$d$j$e$k,
$o
$n
$m
$c

$a horse,
She died of course."""

Nothing too interesting, just a lot of string interpolation. Golfing tips on this one are welcome!

did you mean to write swallowed, not shallowed?

@Destructible Lemon it is fixed now :P

Bubblegum, 255 bytes
0000000: e0 04 85 00   f7 5d 00 2a   1a 08 a7 55   8e 22 31 d2 │ à...÷].*..§U."1Ò
0000010: cb f7 30 fa   52 4d 88 81   61 e4 be 9d   c2 f0 0e f8 │ Ë÷0úRM..aä¾.Âð.ø
0000020: dc c9 de 24   63 c9 1f c7   f7 71 e4 ed   40 68 0e d2 │ ÜÉÞ$cÉ.Ç÷qäí@h.Ò
0000030: cd 76 d8 d9   0d 61 78 f7   40 cf 23 95   48 e9 be 27 │ ÍvØÙ.ax÷@Ï#.Hé¾'
0000040: aa 75 57 ff   51 9e 1f 1f   25 d8 93 4d   18 69 c9 01 │ ªuWÿQ...%Ø.M.iÉ.
0000050: 12 16 ec c1   ff e0 01 7e   fa ea 1e cc   84 d7 58 b8 │ ..ìÁÿà.~úê.Ì.×X¸
0000060: 47 d4 40 b4   ff c7 64 a9   2f 07 bf 7b   f4 25 74 94 │ GÔ@´ÿÇd©/.¿{ô%t.
0000070: af da 8a fc   0c 18 81 58   b8 3c 2e 97   c0 9d e8 27 │ ¯Ú.ü...X¸<..À.è'
0000080: 3e 02 8a d2   1b 7c 94 cc   cb f4 05 7c   c7 77 f3 75 │ >..Ò.|.ÌËô.|Çwóu
0000090: ea 7e 02 d6   3a 84 5c 4e   1f 88 e7 03   9a 1d 3f 13 │ ê~.Ö:.\N..ç...?.
00000a0: a6 9f 2e cf   be 77 16 be   f1 5f 01 52   cf 13 89 b3 │ ¦..Ï¾w.¾ñ_.RÏ..³
00000b0: f3 8a f7 90   18 08 50 99   27 f7 83 d2   a4 32 08 76 │ ó.÷...P.'÷.Ò¤2.v
00000c0: ef b4 99 6c   80 dd 1a 47   04 26 fe b1   02 b3 d4 e7 │ ï´.l.Ý.G.&þ±.³Ôç
00000d0: 3d 44 3a 64   64 46 39 77   35 61 6b 6c   7b 68 34 db │ =D:ddF9w5akl{h4Û
00000e0: 51 75 39 2e   bc 46 8e 96   d1 8a 4c 79   f4 7a 7b e0 │ Qu9.¼F..Ñ.Lyôz{à
00000f0: f5 44 85 eb   ef 68 d5 22   26 4a 2a ef   fc 60 00    │ õD.ëïhÕ"&J*ïü`.

PowerShell, 349 bytes = Script:9 + Archive:340
tar xOf t

Try it online!
The Powershell script to create the archive t (see TIO):
(
@'
There was an old lady who swallowed a fly.
I don't know why she swallowed that fly,
Perhaps she'll die.
......
There was an old lady who swallowed a horse,
She died of course.
'@
) | Set-Content f -Force
tar zcfo t f
Get-ChildItem f,t # output info about archive size

Wolfram Language (Mathematica), 295 bytes
BinaryDeserialize@ByteArray@ToCharacterCode@"8C:xœåPANÃ0<ãWì—(ï€R‘8o³[ÛÅx+;••ðnÖqª6(NÄÍšÏÎÌþãáÅqb(˜#H H'† …	ŽaêÍÄÝoQŠ*&ÈŽïT£Ã±
;óÌÉá9W~çÞ˜ïÊgOœ:U«YIÞÚPñHp÷<-o³ªA{³ÿ’…+7cs¼Ÿèqð‰:ó¨ð/‰jŒ…_ØÈ_¾îñËêéI=ôŽÖGnŽ«~JoÕšî–·ô‡w ±yNNìz%·V ¦»¥Çük9I™[*ýF Gä¢Xÿ	Tÿ”\""

Try it online!
This solution is a 46-byte decompressor BinaryDeserialize@ByteArray@ToCharacterCode@"..." acting on a 248-byte array masquerading as an ASCII string. Transferring this string between different programs is a bit tricky. TIO, for instance, blows this solution up into 416 bytes using UTF-8 encoding instead of keeping the ASCII string. To get the minimal 295-byte solution, save the text in a variable text and run
BinaryWrite["ThereWasAnOldLady.wl", Join[
  ToCharacterCode["BinaryDeserialize@ByteArray@ToCharacterCode@\""],
  Normal[BinarySerialize[text, PerformanceGoal -> "Size"]] /. {34 -> Sequence[92, 34]},
  ToCharacterCode["\""]]]

then execute the generated file on the command-line with
wolframscript -print -f ThereWasAnOldLady.wl

05AB1E, 516 408 chars
-108 chars by not restricting the allowed characters to CJK Unified Ideographs Extension B
""ÇŽáá-•Gαm•β₆BŽm&",.'
"‡""ÇŽáá-•Gαm•βbT„Aa‡.Ï

Try it online!
This exploits the fact that this is an old question that counts in chars.
Version without using UTF-16 strings, 925 bytes
•*™w8?áZм<r¼Ë}ÈdEÄŸ€Kβ;’Ì÷`₆NËr;OÙнΛ¤øoE~ÝùÇ?}6Å±T÷Eā2²ïápK|¯Ð†˜CYîâÀJ¯Ð₅“λ˜'=\₃0ˆN‹BM©мe½Ì½ÜÙÈ?QXt”
v´qØú!þ3$òšpô/—èi_ð@tγµðB}¯S₄6´>ÝN¯ζlçæ‡¼¶§āj]\0þGwN₁<âX1oƵ[Òg³KÓ‹ì‚üÿ₃1E®Ìηʒ(ΔÃλËXŒlµV#₃ Î¤Ý´ö÷ε_%C+zÝ-C-†¬‘mö¹z∍³ǝq†€Tʒ„2žUÞ>Ï©ι‹ó≠ÿöì₆н—₃\мā9þ6jΩÛγ„€LÙÐ¾Ym9îîaü±µŒžÖ»Ÿæ×çîóú®ùŽÊ>Ô₄G÷5Λ‚sÙ₆=øHlãsPÏØ\¬»E†¯ÄÇŠP@¡ŠÁ*Ñ₁oƵ°eø¾Ù₂Îæ₂.Â(₅”uCDr‡₃OþR₃Æ-&ÑâÀ₄˜g¾þ;q‡8}5,z—H÷‹}Þjô&„HKFÈ≠ΘúĆ0¸aJ+bàGÈzÞÉY4w-/Ê‡α_Ù$!i±—þq9ǝ*SнǝθeBQÑK+}‰Ý‰—‡Ω¶Σx¢32DÓ†vª‰Í%иt5ž*|Îæ)³₄¡NýXн¦®ÇÃþ¸.¸ò8r¢›§e›Ì"P₆ƵāÑÖºjΣ~ï`
∞åŒwïìsÐº∊ā‰Š®#¸вP=jû∊ÕÇëäûм—sJTǝ—ƒв¼êι‘Ù†¨ΓõćIÎåš¢4û6é›a™ÌV½ƶ≠ÃÑlëðβ‰«˜p:™°½“°2ï$£äζgŸ
¯ΛÿĆ„…û≠Q³¹îèïuøÉ₁¦ÁÝl^¨{Ê}мÁñ₄<нΘï÷@ãr1ôÑÌнÕ´…+ÕûÒO}öNηÆßã‘ó÷ß0xå1_|£ÒζÜqzÚ¼W^ÕæÓt\[šIvε©lø‚Õ∊H∞OŒƵŒ›ö;»E¾ƶćĀ#8lràQ˜aç½>¬λÓ™¾²ópöη¼Ā-æĆ„Wp6m”^tøgOõΛ¦≠ÅúÑDβ=ʒRJζã₂4N,]ÄKåí•₆BŽm&",.'
"‡•vŽ²~³ÖĀw`]¬ê₂R∞v³ÿkØæ!Xh¤li£4ĆdCµ Aëp
UÎ‘±6ʒιéµÞ3Y>Ý{#r9›½, å<š*å$”Wµ->Mé₅åˆíÏV"£³§`%kIŽ²,‡èα²‚… ÙP§¢∞>r”∍(+Ā~∊³β¨ÔX3ÃðØ³ž˜ûтÇiúÉ,9ΩÍÌJöεš¢≠«¼“UPºi]¤z¥•bT„Aa‡.Ï

Try it online!

I believe most Chinese people may know 0 of these Han characters on average. @_@

Is there reason you choose such a "low" base for your first anwer? Unicode character codes go up to 1114112.

@ovs 42719 is the number of defined characters in the largest Unicode block (CJK Unified Ideographs Extension B). For some reason, I did not want to use undefined characters.

C (gcc), 512 493 bytes
-19 bytes thanks to ceilingcat
*s[]={"That wriggled and iggled and jiggled inside her.","How absurd to swallow a bird.","Imagine that to swallow a cat.","What a hog to swallow a dog.","fly","spider","bird","cat","dog","horse"};r(i,x){return i&&r(i-1,!printf("She swallowed the %s to catch the %s,\n",s[i+4],s[i+3],x&&puts(s[i-1])));}f(i){for(i=0;printf("There was an old lady who swallowed a %s.\n",s[i+4]),i<5&&puts("I don't know why she swallowed that fly,\nPerhaps she'll die.\n",r(i++,1)););puts("She died of course.");}

Try it online!

Since the program is kolmogorov complexity, that implies no input, so input is not allowed in your answer to the question.

Oh all right, thank you for letting me know. I am going to delete the answer

@GioD I made a new program :D

You've forgotten the horse.

I added the horse!

@ceilingcat thank you very much!

Java 758 chars
Here is my Java effort ( 758 chars )
public class Poem{public static void main(String[] args){String s1="swallowed",st="There was an old lady who "+s1+" a |.",d1="Perhaps she'll die.",d2="She died ofcourse.",e="I don't know why she " + s1 + " that fly,\n";String[] a={ "fly","spider","bird","cat","dog","horse"};String[] q={ "","That wriggled and iggled and jiggled inside her.","How absurd |","Imagine that |","What a hog |",null};for(int i=0;i < a.length;i++){print(st.replace("|",a[i]));if(q[i]==null){print(d2);break;}if(!q[i].isEmpty()){               print((q[i].replace("|","to swallow a " + a[i])).trim());for(int j=i;j > 0;j--){print("She swallowed the " + a[j] + " to catch the " + a[j - 1] + ",");}}print(e + d1 + "\n");}}
static void print(String value){System.out.println(value);}}

You can gain some chars... Poem => P, args => x, print => p, value => v, two letters vars => one letter vars, removing more spaces.

Charcoal, 369 366 bytes
Ａ”↓0*)Ｂ⎚D³9;7Ｑ7∨-f¶_²χ⁶；↧l⁺I´”¦αＡ“V×q▶²▷O≕⦃0j↖▷(τ⎇⦄4ω\`j0Ｔ⁹ψＩ2b1züρÀ↑‹⁻ê£ＡＺ‹？ＤOR§1φ”¦βＡ⟦spider¦bird¦cat¦dog⟧¦λＡ,¶¦νＡ⟦”↶7⎇ＩＰＶpθθ⪪➙Ｓ²p⸿H⁸✂ν‖2↖²φ↘nτME⦄Ｂ↓ξlＦ⁵y”¦”↶7Nl@;⪫λ38Ｎ∕´≕⁺)³ nÀ‴⦃”¦”↶7←´<7ＹKＢYχnＺ-↖Ｕ⎇ι\HUθ%；⟧”¦”↶7∧§‴⟧O×φ¢\`*NQ¶G⁺$π‽ξat”⟧μＡ”↓/!Ｚm⪫⟧αÀ⁻Ｖε>⟲”¦σＡ”｜‽aＣ-⁴t;Z⌕”¦τＡ“Y∨↷ur1ＢＯ#ÿk»⁻υv‽⌊←zω↘^”¦η⁺αβＦ⁴«⁺⁺⁺α§λιν§μιＦ⮌…⁰ι«⁺⁺⁺⁺σ§λ⁺κ¹τ§λκν»⁺⁺⁺σ§λ⁰τβ»⁺αη

Try it online!
Link to the verbose version of the code.

Java, 655 bytes
public class M{public static void main(String[]P){String S="swallowed",T="There was an old lady who "+S+" a |.",e="I don't know why she "+S+" that fly,\n";String[]a={"fly","spider","bird","cat","dog","horse"};String[]q={"","That wriggled and iggled and jiggled inside her.","How absurd |","Imagine that |","What a hog |",null};for(int i=0;i<a.length;i++){p(T.replace("|",a[i]));if(q[i]==null){p("She died of course.");break;}if(!q[i].isEmpty()){p((q[i].replace("|","to swallow a "+a[i])).trim());for(int j=i;j>0;j--){p("She swallowed the "+a[j]+" to catch the "+a[j-1]+",");}}p(e+"Perhaps she'll die.\n");}}static void p(String v){System.out.println(v);}}

This is a golfed version of this answer. There's over 100 bytes saved on minor things.

Some more things to golf: public  can be removed; class M{public static void main can be interface M{static void main; String S=...,T=...,e=...;String[]a=...;String[]q=...; can be String S=...,T=...,e=...,a[]=...,q[]=...;; for(int i=0;...)...for(int j=i can be for(int i=0,j;...)...for(j=i; for(j=i;j>0;j--)...a[j]...a[j-1] can be for(j=i;j>0;)...a[j]...[a--j]; static void p(String v){...} can be static<T>void p(T v){...} (623 bytes) Try it online.

611 bytes building on @KevinCruijssen

PowerShell, 512 bytes
[IO.StreamReader]::new(([IO.Compression.GZipStream]::new([IO.MemoryStream]::new(([Convert]::FromBase64String('H4sIAAAAAAAEAOVQQWoDMQy8L+wfdMsl5B3tLdBAz8pKsd26VrAdzP4+cm2SbNlDT6WlN6EZzYzmYDkyFEyAAcQTeKQZihVIBb2XwgQIJz/vxuEZSMImw3uQopQZkuUHWraYK3M7DnuOFs+pEjbeAznW83E4fMssnR1x3Fa6CpbojPEVCAQP41ufXUhKB1VWi5cvgbiLQRaYME/2c9cy/tA3RxdJNZ7UBI/pEqlm6YQOrwavwDL2rZdf+KXaVrMPNC5wU128qfjql1Mj3lP3uv56HyRGJV6rGoIVs2xD0dU2qBHvmVut/6c2KzFxj6aXBHKCSS663F0B')),0,249),[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()

Try it online!
Credit to @Chirishman for their post.

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


text:
Blockbox that Hex?
Write a program or a function in any programming language that takes a 6 digit hexadecimal input/argument. The input/argument can be 6 values or a 6 character string.
Your program should output an exactly 8 character wide rectangular block of characters containing only the hexadecimals supplied combined with spaces (+Linefeed). The rectangular block is a combination of smaller block shapes, one for each of the 6 supplied values.
Here follows 2 demostrative sample inputs and sample valid outputs:
Sample input:
"464fa6" or [4, 6, 4, 15, 10, 6]

One valid solution output:
44 66 ff
44 66 ff
   66 ff
aa     f
aaa ffff
aa  ffff
aaa
    6 44
66666 44

Sample input:
"35bf12"

One valid solution output:
55555 22

bbbbbbbb
b b b
      33
fffff  3
ff  ff
ffffff 1

Rules:

The output must be a rectangular shape
The output can be of any vertical height, but must be exactly 8 characters wide
The "inner blocks", refered to as the "block shape"s, cannot connect to any other block shape, the block shapes must be separated by a wall of blankspaces exactly 1 character wide horizontally, vertically and diagonally.
The wall of blankspaces cannot run parallell to the outer edges, only 1 character wide wall-edges can exist at the output edges. There should not exist any linked spaces anywhere on the outmost rectangle edge on the output.
The width of the wall of blankspaces should Not at any point exceed 1 character.
The inner block shapes should be uniform with the area of x characters, where x is the hexadecimal value supplied and the shape should consist of the charater x where x is the hexadecimal character representative.
The inner block shapes can be of any form as long as all of the shape characters connects vertically or horizontally, and does not valiating the rules for the wall of blankspaces.
The 6 block shapes can be placed in any internal "order" inside the outputted rectangle.
Valid input range: 1 ... 15 ("1" ... "f") for each shape. The input to your program should not contain any other information than the 6 hexadecimal numbers, and the input should not be sorted in any other way than in the samples before it is supplied to your program/function. Tell us what input format your solution uses (the input can not contain any other information than the hexadecimal values).
A inner block shape can be hollow. The hole should be of blankspace characters which counts as wall of blankspaces, meaning the hole in a hollow inner block shape cannot be more than 1 characters wide.

Three examples of valid hollow shapes:
aaa
a aaa
aaa

999
9 9
999
9

ffffff
f   ff
ffffff

One example of an invalid hollow shape:
ffffff
f   f
f   f
fffff

I assume that all input combinations is not possible to "solve" according to the rules above, therefor I list
10 sample inputs that your program should be able to "solve" (all is verified solveable):
 1. 464fa6 (same as the first sample)
 2. 35bf12 (second example input seen above)
 3. 111126
 4. ff7fff
 5. 565656
 6. abcdef
 7. 1357bd
 8. 8c6a42
 9. ab7845
10. 349a67

Your program should be able to solve any of the 10 sample inputs in resonable time.
translate resonable time to within 1 hour on a standard desktop computer.
Say like: 3 Ghz Dual core, 4GB memory for a reference.
This is code golf, the shortest solution wins. The solution can be a fully working program or a function

What does rule 7 mean about "connecting"? Is this just a restatement of the rule 5 constraint that (my phrasing) prohibits the existence of a 2x2 blank square?

I am sorry about some restatements, but rule 7 is more of an restatement of rule 6 where it is stated that the shapes should be uniform. In other words rule 7 says that a single shape cannot be divided into 2 separate smaller shapes.

I've no intention of being mean, but this problem is by no way intriguing, interesting or showing any esthetically pleasing characteristic. it's just an abstract challenge and I don't see why anyone would have the necessary patience to even read all the rules, needless to say anything about solving it. good luck with your next one though!

Clarification: the whitespace can form any shape as long as it separates the blocks and it contains no 2x2 block and no two consecutive whitespace blocks on the outer edge?

@Jan Dvorak : You are correct, that is exactly what I meant

I have now activated a bounty and hope for an answer

This question is really tricky (or maybe I'm a poor problem solver)... do you have a solution yourself, Plarsen? Anyway, I think it would've been more interesting to drop the whitespace requirements and make it a code-challenge where the score depends on both the character count and the height of the block (thus making it beneficial to pack it a lot without making it a hard requirement).

I have no solution ready. You might be right about I set the requirements to tricky but I won't change it. I have two algorithms in mind that perhaps can be used to solve it, I will try it out and aim to have one answer ready when the bounty time is up.

@wastl Output rectangle must be 8 characters wide and input must be 6 characters.

Haskell, 156
Well, this one stretches the rules a bit.  I don't have any blankspace walls except for the linebreaks, therefore all my walls have a length of 1.
import Data.List
r=replicate
main=getLine>>=putStrLn.concatMap(\b->unlines$s(head$elemIndices b"0123456789abcdef")b)
s n c|n<9=[r n c,""]|True=r 8 c:s(n-8)c

output for 464fa6:
4444

666666

4444

ffffffff
fffffff

aaaaaaaa
aa

666666

Very, very close :) but rule 4 is not met, creating an imaginary rectangle of your output, you have more than 1 aligning whitespace in a row on the rightmost edge.

BrainF*ck - 134 (newline intr
>>+[++++++++++>,----------]>++++++[<+++++>-]<++[<]<++++++[>+++++<-]>++>-
>..<<.>>>..<<<.>>>>..<<<.<........>.>>>>..>>>.<<..>>.<..[<]>>.

I think that this is the simplist answer
Input taken via 6 hexadecimal characters to stdin, followed by a newline to submit.
EDIT: This fails due to rule 6, that I didn't fully realize until now :/


text:
Plant a tree and watch it grow
The trees we are growing have some rules that define how they grow:
Growth Rules:

Trees consist only of branches.
Branches are made up of a combination of the following symbols:  _, \, |, /, & _
A tree starts as a single vertical branch/trunk (|) on the ground (_):
__________________|___________________
The food for branch growth comes from light.

Light starts at an intensity of 2 at each point in the sky and travels straight down.
Each branch is able to eat half the light available to it and the rest passes through to lower branches.
Thus, a branch with no other branches above it will get 1 unit of light-food each season, a branch with 1 branch above it will get .5 units of food each season, and in general a branch with n branches over it will get 1/(2^n) units of food each season.

At the end of each season, the food is totaled starting with the trunk and moving up and converted into new branches and fruit (apply the following rules until the branch turns into fruit or has less than 1 unit of food remaining):

If a branch has less than 1 unit of food at the end of a season, all the food for that branch is stored in that branch until the next season.
If a branch has greater than or equal to 1 unit of food and has room to grow, it randomly grows a new branch using the available growth patterns (see below) and stores the remaining food for the next season.
If a branch has >= 1 unit of food, nowhere to grow, and has offshoot branches, it evenly distributes the food to its offshoot branches
If a branch has >= 1 unit of food, nowhere to grow, and no offshoot branches, it becomes fruit (represented by O)

Here are the possible growth configurations

Growth Configurations:
_    \     |     /   _      _   \   |    /   \    |   /   _
 |    |    |    |   |        \   \   \   \   /   /   /   /     __   \_   |_   _|  _/  __
--- Vertical Branches ---      --- Diagonal Branches ---      --- Horizontal Branches ---

Example potential tree:
                \
                /   /
              \/O  |___//
            \_/  \//O\_/
              \__/|\|_/
                 \|/
__________________|__________________

Input:
Your program should be able to take as input a list of which snapshots of the tree you would like to see.  For example [10,20,50] would mean you'd like to see the tree after 10 seasons, 20 seasons, and 50 seasons.
Output:
For each input season, your program should output the season and then a picture of the tree in that season.  If it helps, you can define a maximum age for the tree, such as 60, so that the maximum height for a tree would be 61, and the maximum width would be 121, and then always show the tree on that scale.  Otherwise, feel free to scale your image to any sized tree.  For example, if the input was [0,1,2,3], your output might be:
Season 0:
_|_

Season 1:
 \
__|__

Season 2:
 _
  \|
___|___

Season 3:

 |_/ _
   \|
____|___

Winner
Each solution must post the output of the coder's favorite run of their program with input of [10,40], along with their source code.  Also, ALL the above criteria must be met in order to qualify.
The winner will be the qualifier with the highest number of votes.
Good luck and merry planting!!!

"Room to grow" doesn't seem to be defined.

I think the tags "code-challenge" and "code-golf" do not fit together ("objective criterion other than code size" vs. "fewest bytes of source code").

@Peter Taylor:  To see if there is room to grow, you must first check the growth configurations for that branch type (e.g. vertical branches can go up-left, up, and up-right), and then see if any of those spaces are empty.  If so, there is room for growth.

@Howard: Yeah, I was thinking the same thing, but wasn't sure.  I think this is definitely more challenging than most problems I've seen on here, so I definitely wanted "code-challenge".  However, if there are multiple solutions, I wanted a way to determine a clear winner.  The scoring calculation above favors voting over atomic-code-golf scoring, so the atomic-code-golf score is really mainly a tie-breaker.  I'll leave it up to the people:  The golf requirements will be waved if Howard's comment gets more up-votes than this one.

With the present scoring mechanism, it isn't a [tag:code-golf]. It's not really a [tag:atomic-code-golf] either.

@Peter Taylor:  You and Howard are right.  I've simplified the winning criteria to pure votes and removed those tags so that people can be as creative as they want without worrying about golfing it.

@boothby: Yes, thanks for pointing that out.  Question updated.

Pure votes isn't really an objective criterion, though.

@Peter Taylor:  Currently, the objective criterion is "did you meet all the qualifications" and the tie-breaker is # of votes.  If you can think of a better way to judge the winner of this competition, I am definitely open to suggestions.

Some different ideas for this competition.  Develop your own growth algorithm (not random).  Grow a tree that maximizes total fruit production over a 50 year period.  Or grow the largest possible tree (defined by total characters) within a certain number of generations (fruit would thus be a liability because it impacts future growth).

@Steven Rumbalski:  Thanks for the suggestions, I especially like the fruit production over 50 year period one.  However, since there is already an answer, I don't think I should change the requirements to force that.  That said, people may feel free to take liberty with this as long as the above rules are met.  For example, maybe the starting intensity of light is n and the absorbtion rate is 1/n for each branch.  Maybe instead of growing a new branch in a random direction you can have it be deterministic.  Maybe a branch consumes a minimum amount of food for survival each season.  etc.

@Briguy37, if branches consumed a minimum amount of food each season, the trunk would break very quickly.

@boothby: True.  For that case we'd probably have to have a "Survival Mode" where lower branches can suck the nutrients they need from the upper branches.  This would be interesting with variable light intensities to represent the different seasons of the year, i.e. during "summer" where there is a lot of light the tree would outgrow what it could support during the "winter", and thus during the "winter" quite a few branches would die off.

Beautiful question!

Python
I took a little liberty with this:

I allow multiple trees
Fruit is preceded by flower -- once a flower has 1 food, it turns into a fruit.
Fruit turns ripe when it has 3 food.  It then falls off of the tree, and turns back into a flower.
If fruit falls at least 4 places from any given trunk, it buds into a new tree.  Since it doesn't get much light, I seed it with as much food as was in the fruit.

Sample Output, 2 trees
                            /
     \/\_ |  /             |
 _  _/\|\|_\/             /|/
  |/ \/|/|O/              \|/
   \_/O|@|/               /|_
     \_|_|                \|
_______|___________________|__

                       _      \
                _/ _ \/\___/\|/                  \
             /|\|\O@|/\/|__\/ \__/_\|/\\|  _ |/| _||/\\ /
             \|_|@|\|@/O|@@/O_/@O|@/ \//\   \|\||@||@///
           \_ \_|\|/@\\O|@||/OO//O\\O/ \@|@\||/@|\/\/|/   | / _
        ___/    |/|/O//O|O||\\/|/O// \_O\|__| \O|/\/O|   _/\\|
         / \_O@@_\/\O\\@|/O|/O\@\O\\@/OO/|O_@O/O|\/\/     \//|/__
     _|/|_|  \\|O\\/O/O||_@|\O|\/O//|O|@\|/O_O\@|/O/\_@O__//_||
    | \\|____// |O|\O\O|/\@|/ |/O/ \|O|OO|\/@_/O|_O\/O//O_//O/
    |_O\\@O\/\\OO\|/|/\O\O\|__@\|O@/|/O|O|/\OO\/|_O/  \\|OO\/
   /  \\||_|\|||_O|\|@/OO\//OOO/|/@\|OO|\|\@|O \|\|O@O//  \/\
 _/\_/@\|\@|/  \_||/ \\@|/\\\||/ \//O|O|/|/@|\@/|/O/OO\\__/  \||/
  \||/  |_|O\__@ |O\O/O||\///@|O_//|/OO|@|OO|/O\|O/OO|// /|\|/\|
   ||___O@|_/  |__\/||_||/|\\/OO/|@|O|/ \|_O||_/O/O/O|/_|\/\|_/
    \_OO\\_O\@_|/|_\|_O|/\|//\/|/@|O\|@_O|O_O\/||\/O/|/_|/|O|
      \_|\@\@|_|\|OO|O|/\//O\/\O\@|_/|_@\|/\O/\||/\|/|@@|@|/
       /|//|\|O|_|O\O\O\/|O\/|@|/_|\OO@\/ \/|O/_|O//@|@/\_|
       \O\\|/|_OO|OO\O|/\|@@\|O|/ @//|_@\_/\|//O_/|O/  \/
        \O\|O_/|/ \|O|O\/|/OO|O|O_/ \|    \/|/|/@ |/\__/
         |O|_O\|\O/|_|O/\|\//|/   \_/     /\@\| \_/\/
          \OO\O|/ \ _|@\/O||@|\___/       \/|/    \/
           |__|O\__|OO\/\@||/\/            \|O____/
              |____|/@/\|\|O\/            _/|/O
                   |/ \/|/|@/              \|/
                    \_/O|@|/              |/|__
            \|/       \_|_|  \|_      \|/  \|    \|/  _|_
_____________|__________|_____|________|____|_____|____|__________

Source
from random import choice, shuffle
format = '_\|/_@O'
directions = [(-1,0),(-1,1),(0,1),(1,1),(1,0)]
placement = [[[],[0,1,2],[]],[[],[0,1,2],[3]],[[0,1],[2],[3,4]],[[1],[2,3,4],[]],[[],[2,3,4],[]]]

def shine():
    for x in ymax:
        light = 2.
        for y in range(ymax[x],-1,-1):
            if (x,y) in tree:
                tree[x,y][1] += light/2
                light        /= 2

def grow((x,y)=(0,0),flow=0):
    type,store,children = tree[x,y]
    food = store + flow
    if type == 5:
        if food > 1:
           tree[x,y][0] = 6
           tree[x,y][1] = food-1
        return
    elif type == 6:
        if food > 3:
            tree[x,y]=[5,0,[]]
            if min(abs(x-xi) for xi in roots) > 4:
                tree[x,0] = [2,food,[]]
                roots.append(x)
        else:
            tree[x,y][1]=food
        return

    if food < 1:
        shuffle(children)
        for c in children:
            grow(c)
        return

    sites = []
    x0 = x+directions[type][0]-1
    y0 = y+directions[type][1]
    for i,t in enumerate(placement[type]):
        if t and (x0+i,y0) not in tree:
            sites.append((t,x0+i,y0))

    if sites:
        t,x1,y1 = choice(sites)
        t1 = choice(t)
        children.append((x1,y1))
        tree[x,y][1]=food-1
        tree[x1,y1]= [t1,0,[]]
        ymax[x1] = max(ymax.get(x1,0),y1)
    elif children:
        shuffle(children)
        for c in children:
            grow(c,food/len(children))
        tree[x,y][1]=0
    else:
        tree[x,y][0]=5

def output():
    X = range(min(ymax.keys())-1,max(ymax.keys())+2)
    for y in range(max(ymax.values()),-1,-1):
        s = ''
        for x in X:
            s += format[tree[x,y][0]] if (x,y) in tree else '_ '[y>0]
        print s

roots = [0,20]
seasons = [10,40]
tree = {}
ymax = {}
for r in roots:
    tree[r,0] = [2,0,[]]
    ymax[r]=0

for season in range(max(seasons)):
    shine()
    shuffle(roots)
    for r in roots:
        grow((r,0))
    if season+1 in seasons:
        output()
        print

I'm curious to see a golfed solution.

I like the flowers turning into fruits and seeds idea!  One suggestion:  add a space rule to keep trees separate.  For example, maybe branches cannot sprout on any space adjacent to a branch from another tree.

Python, 673 chars
Here's a golfed version:
import random
Z='|_\/O'
T={60:0}
F={60:0}
C={60:[]}
B=[((1j-1,1),(1j-1,2),(1j,0),(1j+1,3),(1j+1,1)),((-1,1),(-1,2),(-1,0),(1,0),(1,3),(1,1)),((1j-1,1),(1j-1,2),(1\
j-1,0),(1j,3)),((1j,2),(1j+1,0),(1j+1,3),(1j+1,1)),()]
S=input()
for s in range(61):
 if s in S:
  for y in range(60,0,-1):print''.join(Z[T[x+y*1j]]if x+y*1j in T else' 'for x in range(121))
  print'_'*60+'|'+'_'*60
 for p in T:F[p]+=.5**sum(q.real==p.real and q.imag>p.imag and T[q]<4for q in T)
 for p in[q for q in T if F[q]>=1]:
  D=[p+d,c for d,c in B[T[p]]if p+d not in T]
  if D:q,c=random.choice(D);F[p]-=1;T[q]=c;F[q]=0;C[q]=[];C[p]+=[q]
  elif C[p]:
   for q in C[p]:F[q]+=F[p]/len(C[p])
  else:T[p]=4

sample @10 (truncated to the interesting part):
           |  |_
       |_|/\_\ \|
 |   \\/\|\/__|/
 |/   \\O|O\__|
  \___/O|/\/
      \/O\/
       \|/
________|__________

sample @40:
             _  _        \_ _ / _|
        // _|/\|_\||_\___/ \_|_|/|/|_ |  _    //
/     _|\\|_/\/|\/_/\/O|O\OO\|\|OO\|  \\/  |/|/|_/|
\/\|OOO|//OO\O\|//OO/O_|O||\O|/|/|/OOO/ \OOO\/\| \||_|  |
 \_|/|_O\\|\O\/|/O/O\_O|/  \\|O|O|/OO\\_/\O\|\/OO/\|O_|\|
   |_|OO/O|/O/\|\/\O|O||_OOO|\\|/ \/O_|O\/OO|/O_|\/|OO|/
     |/|\O|\|\/OO\O\|_|OO\|||// \OO\_O|O/  |||/_O/O|__|
      \|O\O\|/\O\/\O|O|O\/O||/O_/|OO/\| \OO/\|/  \_|
       |_/ O|\/O/\/\O\|\|\O|/\/OO|/ \/OO/\O\O\\__/
         \_/O/\||/\O|\|O|O\\\/O_| \O/|/ \/O/_//
           \O\/  \O\|_|O/\// \/OOOO|\|OO/|/|_|
            |/\OO/O/  |O\/|\O/\O\|\O\|_|\|_|
             \/OO\_\O__\|\|O|\/OO|/OO|___|
              \|OOO\|O \\\|O|/|OO|OO\|
               |/ \O|\_O\\|O|\|OO|O|/
                \_/O|/O_//|O|/OO\|\|
                  \_|OO \\O\|\/O_|/
                    |/   \\O|O\__|
                     \___/O|/\/
                         \/O\/
                          \|/
___________________________|______________________________

Interesting... your tree looks very flat on top, whereas mine look rounded.   I wonder if one of us has a bug, or it's that I shuffle children to randomize what order they spawn grandchildren in.  Also, I notice that your fruit doesn't capture light... I wasn't sure if I should do that or not.

Javascript
UPD: Added some new rules:

if branch can grow it become leaf at first, when leaf have >= 1 food it became a branch with food = leaf food
if branch have nowhere to grow and have food >= 1 food its turn into flower
if flower have more than 1.5 food it become a froot with flower food / 2
if froot have more than 1 food it drops on the ground and grows into new tree
each season have 10% chance to have rain which gives additional food to the branches on the ground which distributing food to the others.

Here is not the most beautiful code on javascript. May be later would be some improvements.
Code on JSFiddle
var leaf = function(food, branchDirection){
    this.food = food || 0;
    this.branchDirection = branchDirection;
    this.char = 'o';

    this.getHtml = function(){
        var color = "#00FF00";
        var bgColor = "#00BBEE";

        return "" + this.char + "";
    };
};

var branch = function(food, direction){
    var directionChars = ["_", "\\", "|", "/"];

    this.food = food || 0;
    this.char = directionChars[direction];
    this.direction = direction;
    this.child_branches = [];

    this.getPossibleDirections = function(){
        if(this.direction === 0)
        {
            return [
                    [-1, 0, [0,1,2]],
                    [+1, 0, [2,3,0]]
                ];
        }
        if(this.direction == 1)
        {
            return [
                    [-1, +1, [0,1,2]],
                    [0, +1, [3]]
                ];
        }
        if(this.direction == 2){
            return [
                    [-1, +1, [0,1]],
                    [0, +1, [2]],
                    [+1, +1, [3,0]]
                ];
        }
        if(this.direction == 3){
            return [
                    [+1 ,+1 , [0,2,3]],
                    [0 ,+1 , [1]]
                ];
        }
    };

    this.getHtml = function(){
        var color = "brown";
        var bgColor = "#00BBEE";

        return "" + this.char + "";
    };
};

var froot = function(food){
    this.char = "O";
    this.food = food || 0;

    this.getHtml = function(){
        var color = "#FF0000";
        var bgColor = "#00BBEE";

        return "" + this.char + "";
    };
};

var flower = function(food){
    this.char = "@";
    this.food = food || 0;

    this.getHtml = function(){
        var color = "#FFFF00";
        var bgColor = "#00BBEE";

        return "" + this.char + "";
    };
};

var ground = function(){
    this.char = "_";

    this.getHtml = function(){
        var color = "black";
        var bgColor = "#00BBEE";

        return "" + this.char + "";
    };
};

var air = function(){
    this.char = " ";

    this.getHtml = function(){
        var color = "blue";
        var bgColor = "#00BBEE";

        return "" + this.char + "";
    };
};

var tree = function(){
    var me = this;
    var treeSpace = 5;

    this.treeMatrix = [];

    this.calculateFood = function(isRainy){
        //console.log(this.treeMatrix);
        var width = this.treeMatrix[0].length;
        isRainy = isRainy || false;

        for(var i in this.treeMatrix[0]){
            var food = 2;

            for(var j in this.treeMatrix){
                if(this.treeMatrix[this.treeMatrix.length - 1 - j][i] instanceof branch
                  || this.treeMatrix[this.treeMatrix.length - 1 - j][i] instanceof leaf){
                    this.treeMatrix[this.treeMatrix.length -1 - j][i].food += food;
                    food /= 2;
                }
            }

            if(isRainy){
                var rainFood = 5;

                for(var j in this.treeMatrix){
                    if(j == 0 && !(this.treeMatrix[j][i] instanceof branch))
                        continue;

                    if((this.treeMatrix[j][i] instanceof branch
                      || this.treeMatrix[j][i] instanceof leaf)
                      &&
                      (j == 0 || this.treeMatrix[j-1][i] instanceof branch)){
                        this.treeMatrix[j][i].food += food;
                        rainFood /= 2;
                    }

                }
            }
        }
    };

    this.expandMatrix = function(){
        var expandLeft = false;
        var expandRight = false;
        var expandTop = false;

        this.treeMatrix[this.treeMatrix.length - 1].forEach(function(el){
            if(el instanceof branch)
                expandTop = true;
        });

        if(expandTop)
            this.treeMatrix.push(this.treeMatrix[0].map(function(){return new air();}));

        for(var i in this.treeMatrix){
            if(this.treeMatrix[i][0] instanceof branch){
                expandLeft = true;
            }
            if(this.treeMatrix[i][this.treeMatrix.length - 1] instanceof branch){
                expandRight = true;
            }
        }

        this.treeMatrix = this.treeMatrix.map(function(row){
            if(expandLeft)
                row.unshift((row[0] instanceof ground ? new ground() : new air()));
            if(expandRight)
                row.push((row[0] instanceof ground ? new ground() : new air()));

            return row;
        });
    };

    this.calculateNewMatrix = function(){
        if(this.treeMatrix.length === 0){
            this.treeMatrix.push([new ground(), new branch(0,2), new ground()]);
        }

        var rainySeason = Math.random() > 0.9;

        this.expandMatrix();
        this.calculateFood(rainySeason);

        for(var i in this.treeMatrix){
            for(var j in this.treeMatrix[i]){
                var element = this.treeMatrix[i][j];

                // grow a branch/distribute food/set froot or just store food of not(do nothing)
                if(element instanceof branch
                    && element.food >= 1
                ){
                    //console.log("branch coordinates", i, j);
                    var directions = element.getPossibleDirections();
                    var tm = this.treeMatrix;

                    var freeDirections = directions.filter(function(directionArr){
                        if(tm[parseInt(i) + directionArr[1]][parseInt(j) + directionArr[0]] instanceof branch)
                            return false;
                        else
                            return true;
                    });

                    if(freeDirections.length){
                        var newCell = freeDirections.length > 1
                            ? freeDirections[Math.floor(Math.random() * freeDirections.length)]
                            : freeDirections[0];

                        this.treeMatrix[parseInt(i) + newCell[1]][parseInt(j) + newCell[0]] = new leaf(element.food/2, newCell[2][Math.floor(Math.random() * newCell[2].length)]);
                        element.child_branches.push(this.treeMatrix[parseInt(i) + newCell[1]][parseInt(j) + newCell[0]]);
                    }
                    else if(!freeDirections.length && !element.child_branches.length){
                        this.treeMatrix[i][j] = new flower(element.food/2);
                    }
                    else if(!freeDirections.length && element.child_branches.length){
                        element.child_branches.forEach(function(child){
                            child.food += element.food/element.child_branches.length;
                        });

                        element.food = 0;
                    }
                }
                if(element instanceof flower
                    && element.food >= 1.5
                  ){
                    this.treeMatrix[i][j] = new froot(element.food/2);
                }
                if(element instanceof froot
                    && element.food >= 1
                  ){
                    this.plantNewTree(j, element.food);
                    this.treeMatrix[i][j] = new air();
                }
                if(element instanceof leaf
                    && element.food >= 1
                  ){
                   this.treeMatrix[i][j] = new branch(element.food, element.branchDirection);
                }
            }
        }
    };

    this.plantNewTree = function(coord, food){
        var canGrow = true;

        for(var i = 0; i <= treeSpace; i++){
            if(!(this.treeMatrix[0][coord + i] instanceof ground)
               || !(this.treeMatrix[0][coord - i] instanceof ground))
                canGrow = false;
        }

        if(canGrow)
            this.treeMatrix[0][coord] = new branch(food*10, 2);
    };

    this.getTreeString = function(){
        return this.treeMatrix.reduceRight(function(prev, next){
                return (
                typeof prev == "string"
                    ? prev
                    : prev.map(function(el){ return el.char}).join('')
                ) + "\n" + next.map(function(el){ return el.char}).join('');
                 })
    };

    this.getTreeHtml = function(){
        return "
" + this.treeMatrix.reduceRight(function(prev, next){
                return (
                typeof prev == "string"
                    ? prev
                    : prev.map(function(el){ return el.getHtml()}).join('')
                ) + "
" + next.map(function(el){ return el.getHtml()}).join('');
                 }) + "
";
    };
};

var seasonsTotal = 300;
var seasonsCounter = 0;
var showAt = [1,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100,300];
var pageTree = new tree();

var season = function(){
    pageTree.calculateNewMatrix();
    seasonsCounter++;
    if(showAt.indexOf(seasonsCounter) >= 0){console.log(pageTree.getTreeString()); document.body.innerHTML = pageTree.getTreeHtml();}
};

window.onload = function(){
        var intervalId = setInterval(function(){
                season();
                if(seasonsCounter >= seasonsTotal)
                    clearInterval(intervalId);
                }, 100);
};

Some examples(10,40,100):
           \/
        \ |/\_/_
      |  \/\/|/0/_ _
      |/  \/0||/|_//
     / \0_/0/\|0|_|
     \_/00\0\/|_|
       \_|/00\|
         |__|/
    ________|__________

     /
   _ \_
    |/\o_| /
o_/  \/ @|/\|
_@\o__\_/|o/
 \|\|\/ \|/
  |/  \_//
   \__/_|
______|__________

                       \ \/\
                 \    |/\/\_|/ |   |  /
              \ \@\/ \/\/\/ |/  \_/ \||_
          _  _\\/@/\/@\/\/   \_//\__/|/\_
           \ /\|\/|/|_o\/  __/o|\/_|_/\/__|
          |@|\_|/_o\|/\|\__o/\\|/\_|\|//|/\__|
       |_||/|_@|\/|\|_/|/|| \/ |\//\/o\\\\_@\|| |_|
       |/|/\|_||/\o\|/_/\/\_/\o|/ \/|_//// \/ \\|
     __@\|\||/\|@/|/o\/\/\/_@_\|\_/\_/|/ \_/__//
     __\/|/_@\O|o\|@|@\/\/\_|o/|/|\|\/|_//_||_/
  \ \ \|\|_/\|\|//|/\|_\/\//_@\/\|/|/\||//|\|o
 / |/ _|_|@|/|/ \\|__|_o\/o\\|o\||\|\/O|/O|/o_|_|
 \_/\|___|_|  \_/_|\/ \\/@|\\|\/||/|/\_|__|@|\|___/ /
|_||/|_@_\@\o_/o|o|/@_/\\/_//o \|/\|\/@|_o__|_|__/|/
  |@\| /|/\_\|\|/\||_/\_|\@|\\_/|\/@/|/|__/O|_/_/_|/
   \||@\|_@_\|/|\@|//o\||//o\||\|/\/||||o___|/ @|_|  _
    |o\/ \|@@|/ /\O\\/\|o\\|/o|/ \/|/\/\/|\@/\_/|/\_/
     \|\o/ \/ \ \/o_|\/|\//|\/o\_/_|O/\//o_|\/@//\/
      \\|\_@\_/_o\_/|o\|/|_|_\|/O|/|/\|||__|/o \\/
       \|/_|@\\/\\_\|/\|\|@\|\|\_|\|O//O/o_/ \_//
        |_@|_/@\/_/\|@_|//o/_/o//@\|/|\//||____|
 o_______\\/\\|@\/\/__@\\\/|_o/|__|\\|/|/O|
         \|\/ |_o\/\o|_////_/|\|_|@/@|_|\/
          |_\_o\\/\/\o\|/|/ O|/ O|/\/\|\/
            \||/@\/\O\_|\|@_/ \_/|O/@_|/
             |_\|_\O|/o|/ oo\_/@/  \__|
               \|_\|\\_|\_/_|/\|___/
                |/\| \||/ |_|\/|/
                 \ |_/@ \/ o|/\|
                  |_o\\_@\_/|@/
                    \|\|\/ \|/
                     |/  \_//
                      \__/_|
______|__________________|________________________________________

                                                     |
                                                  \  /\_       \/   |      _    \
                                                 |/ |\/_/\  |_\/\|_/\  _\ /  \  |\/\  |
                                              / /_\_|/|__/\/|_|\/_/\/\_|\|\ \ \\|/_/|/\ \    _
                                            _|_//|/ |/__|\/\@\\/|/o/|//\/_/_/@/@|\|\@\/\/_ \/ __
                                   \      \|\|o\\|\o/\/O /\|\/|\O\|_|/_///|@\|\\|/|/@|\/\_|@\|/\\|
                                _ \/\_o_\_/|/ \\\|/|\/ \O\/_@\/\|/|/|_/\\\|_/ \\|\|o_|_\|\|\/|\/\|_|\  /
                              \o_\|\|\_|||\/\_/o\|o|/\_/__\/\/\/\\|o_@\///  \o/o|/|__|\o|/||||/\/|O|/|@\/
                              \|@/|/@\|\/\/o/@\|\|_o\/_/||/\/\o\/O|/|@_\\\__/ \/|\__/|//|\/\|/\/o||@\/\/__|
                               |O\O\|\|/o//o\//|//\|/|o/|O\|\|\|\_|@|/ \\|||\_/\|///O|// @\/O\/|/\\\/\\\/\__|
                                \||/@/|\/\\/|\\o\\ |/|/\|@\|O|/|/ |_|__//_||O\|o|//o_|\\_//\_|\|\/_||//|\/@\|\
                         |   \__@|/\/\|/_/|\|_\|/\\/\/\/| \|_@\/\_|o|/\|_o||o/\\|/@/_o//\@\/\|/|/\o\|\\|/ \/|/
                      o_\|/   \|||\/\||_/\|/|@\|\/\\/\/\|_/|o_|\/o/\o\/|_|/\o\/ \\/|_|/\/_@\/| |__|/|//O\_///\o_
                        \|\|o_/@|\\\||/\|\|o|_@|/o/O\/\_|_/_o_|O\|_/\@\||/  |/\ /|\_/|O/o/|/\|o|/|/\| \|/@/|_/|_|\ _
                  / /\__/|/o__\_|_|\|/\/\/|/|/|_\|\/ \/\|/\@|__o||\|/o_|/\__/\/ \|/@/||o/| \/|_@\|_/___|O|_|@/|_@/|//
                  \/\o_/\| o__|\|@|/\\o\/\|\|_@/\|/_o/o/o\/\\/\\||/|\__|\/|/_/__/ \/\|@\\|\/ @/\/ \|o_/\_|\/o\|  \|/\\
                o_/\/|@\/  _/o|\|\/\/O\/\//\| \\/o\\|\/o_|\/@\o\||\|/O\|\\o\_|@|\_/\_|_/||/@_/_/\_/_/__/@@/|\/\__/|o//
                  \o\|_@\___|/\\|_\/\o|\//\/o_/@\|/@|/  \|/o\|\/\@\|\o\|//@/@|/\/o\/o/OO|/\_/\o\//|o/|/|_/\|/O__o\|/ \__\
             \     |\|__/  \/\/\|_||/\|/|\/   \|/|o_|\__/O\\_|/_/o/|/\/ \\|\\/\/o\/\/\\_|\/ \/_|\\| \|_| \/|//  \/|_o/\__\__
          |   |/ o_o\| o\\_/|@\/ o|/\_|\|@\_o_/|\|/@\/\\_@|\\|/o_/||_/\o//|_|\/__|\/\/ /|/O_/\/\//__/|___/_|@\_o/O|o/@/ \/|_
         \|/o_@\_/|\||_//@_\|_/@__|\/o|/_/\||/| \|_/_\//@\|//o\_o\||/\//\\|_ //_|o/\/\o\|_o\\|\/// @_|\_||@_|/@|\/_/\/\_/_| /
          |\_/|/_|\\|@ \\|o\|o\_o_|@\\|/O_//\\|_o|/\_||_|/| \\/o\/|O\/\\//_/|o\O\/\/|/|/@||//|//@\__/\|__|/\/ \|/|_|/__/||\|
        /_/\|\/\||/ |__@\|/o|_/_|_|\@\|\/  \/ |/_|\/_||o|/|_//\_|\|_|\/O\\/\|o/o/@|\|_|_/o_\\o\\|/_@__|_||\|\_/ \|@|\@|//\\||
        \|\@|/\/\_\_o\|o|\\\|_|o|/\O\_|/\o_/| |_/|/ o\|_|\|o/\/_o/o|\/o_\|\/ |_/\_|/|_||\_O\||/\|\_|@_|__o\|/_@_/__|/\|/\// |//
      o_\|@\|_@\//|\_/_|\\|\|\_@\\/_//\\|\|\|_@_\|\o/o|\|o|/\/O\|/@|O\_/\|/\_@\|/_|\|O||/@_/@/\/o//o__||O\/@\|\/\_||\/o\/ \_|/  _
       _\|_/|\|/\\ \|\O|/o\\|\||/o\/|oo\|/|@|_|_/o/ \\|/|_|\/|/O|\||\@\|/ \/||/|/o\/o_| \o_\|_/O|/@/_@/|_/_|_|/\/o\|/|_/\\/@|\_|
     o__|\o\|_|\@||/|@|/\|/@|/o|\_|\_\|/|/ \@\|/\/\o|\|\|/|/\|\/|_| \\|\\_/\||_|_|/\@\\_//@_\|\||_/|_|O/\|O|\/|/  \|   \_||_|/\
        |/_||o|_||\\|_|\/|\|o\/_/ |/ \|_|__/_//\o\/_|\|/|@ \/_/\||__/ |/_|\/|/\|o|_||//@/\_o\|/@|/@|/@/\/_/_o\|__o/o___/|_|_|o_|
    _ \oo\/\/\|o||\||/|@\|/_/ \o\_@\_/|/|/\|/|\@\|\_|\|/|_o/\_|_|| \__|\||o\|\/_/|_/|/_/_/_@_|@/|\/|_/\//@/o\/ \\/\/ o__|_| @/__o
    /\/@|\\/oo|/@|_|\\|\\|\\\_/\|\|/\\o\\\/o\|/\/|///\|\/\|o/\/  |_@_\\/|O\/|/|///|\|@_|\\@|/\/_|/\|o_//o/\|\\_//\/\_/O|/o__/\_|
    \/\_|/o\/\\\/|O\/||_||//@_\_|/o\/@|/@\\//\\/|o\\\/@_\/_/\|\_/|_|_//\|\/\|\|\\\|/||\_//o|\//|O\/O|\||O\/_//O|o/\/O|_|o_|@\/
     \O_|\_|\/\|\|_o\|_/|@\\|__|\\|/\/_\|/|\\o|\|\/@|\__|\/\/ \|\|o|//\/o \O\\|//_|\||/o_\/|/\\|//\_|_||_/\_|\||O\/\_|@/|_|_/
      |_|/_|@\_|_||_O||\|\\||@||/@|\/_|\|\|_|\|/|o\/|/o/|/|/O/o|/ \||\/\\_/_//|/@|\/O|o__|\o\//| \/|/__|o_/\_//@|/ /@@|\__|
     o  |\_|_|_|O|/o/|o\|/ \\\|\\/|/_/\||o|o\\\\o\/\|_/\O\\\/ o|\_//O/\/|\|@|_o\_|/\_|/\\_/\/\\|_/O||/\_||@/_@\/|o|/\_||\/
      |_@\||o|_/\|\/\|\/ \_||\|\|\\\O\o||/o\/ \|\|\//@_/O_\|\_/|/o|_o\ \|/|_|o//_o\/_@\_|||/O//|/|\||_/ \|// |/O|//|/|/|/
       o\_|/\\@\/| \/|@\__|\o\|_|/ ||/o|o\/\\_o|/\@\\_/\_o\|/ \|/_| \|\//\|/|/o\_|/|@|o|\|o\|/\|/|/o|/\_/|\\_|/O|@\|\/\|
       o|o|o@\|o\|oo\|\/ \\/|_|_|\_@\\/__|\/_|\|_/_/|\_//\\|\_/\\/|_/  \\/|\|/\/o/\|_|o|/|_//\//O|//o\/|/@o|\|_/o \|/ /
 \_____/\|/\|O|/o\\\||/\_o|\|||/|@\|\|\/\_/o\|//@\|\|/\|o/o|/__//\|@o__//o|\|O/\//_|o|_@\|/|_//\_| \\ \||O/|_|  \_/|\/
 o\|\_||_|__|_o\/o\||o\\||O\|/\\|\O|/\/ / \|/ \\_\|O|_/@|\|\\_\/\/_\_o|\\/\/@_\/\\/|o|/// \|@/\/o\| \|/o|_\| @__/@_|/oo
 /||@\\ _|\@|/  \_||_\/|||o/@\/_|/\ \ \|_o/|\o_|\||_|o__| |/@_\\/__||_/\\\|\__|\//\|_|/\\_/@|_/\/||/\||_|_/__/  \__|o/
 \/\\/ |@|_| \ _/@_| \\|/\/\_|\\\\/\_|O|_/\|/_@|/o__|//__/|/|_//|_|_| \o\||/o/|/@\\|/|_///@/|/\/_||_//_||@|_@___/@__|
  \_|\_/\oo|_/_@\_@\_@\|@/ /o\/@\|\_ \\||_/|o|\@\_/|/ \|\_|_@_\\/\|@__/\/_o\|/|O//_|\|@/||/|@\/\/|/\||@/@/|__|_@//|/
    |__\|\|_o\/\/_|\|\O|/\o\_|\|_|_/| \|o|\|o|/\_o\|\__|/o/_|_o\\/_/|\| \ |//o|/ \|\/|//\|@\\|\/_|\/_|/\/\|/o@/|/_|
       \|_||/ \/\_|_|/o|\/|/ \\|o|_||_/o/  |/ \/ |_|//o|\/_@\/\//  \|_|_/o||/\|\_/@_\|\\_|_/_|/|o\//O///\_|/  \|/
        |_\|\_o\/O|o|_\|@\o\_o\|/|_|_@\|\@_/\_/___o|\\_| \/\o\/ \_@_|@|/ \||_/|/@__O\|//O|_||O\|_||\/ \\/o \__/|
          \|/|\|\|/\\\||\/||\|_|\_O|__/|/ |\__\@|\_o\|\\_/_/_/o_/\/\|_@\_@|/\_|__|\|@|/|_|| |_/|_@|/\_//o\_/ O/
           \\|/  |_// |/\\||O|_|o_|\\o\|\o|/__\||o\|\|/o\\||/\_/\/\_|_|\\|||/@|_o/\|/|_||/_o/\_|@\/\/_||\_@\_/
            \|o___o|_o_\//o|_/\\_||\||@|/|\\_@\|/\/@/|\/|||o\/o//\//|o_///O|\/|/o\o|/|_||__|\/|__|\/|/o|/ \/
             |\|@_\O \|\\\/_@\/_\\|_|/\o\|_|\_/@\o\/  \\| \\/\|\\/ \|/\|\\_|/_|_/_||/|O/|/o|/\|_||/\| \/\_/
              \|/  \__|_||\/\/O|\\|_|o/\/|/@\_\|/|/\_o/ |o_|\/|/ \_/o\_|/|\|__|@_/\|/O/_o\/ \o|__|\/  o\/
               |_____o|_|@\\/_o\\|\@\|\/\|\// \|\|\/_|\_/\|\/\ \_/@_|/o|/ \|____/\//\/|o_/   \|/|_/o__//
                 oooo|_/|@|\\||\||/|/|\\//|\\_o|/|/\/\/\|o|/o/o/@_|||o\|\o/ \|O/o/\\|\|_o\___/|O|oo/ \|
               o__|/\|o\|/|_||/\|/\|_@\|\\|/@\\|\|\|\/o/|_|\/\/\|\_|\\\|/ \_/  \|\/O|/|_|/|_//|/_//__/oo
                  |_//  |_|\//@/ \ |__@|O||\//@|_|/|/\/\|o|/\/\_|/||/ \|o_/Oo__/_/\/|\|/|\|/ \|@_|/ooo|
                    |_____|//@|\_/\|O|_/\||/ \/ \\\/\O\/o\/\/\/ |/ o\_/ \||_/ \| \@\|\|\|/|__/___|/|_/
                       ooo|/ \|@\\_|o_@\/_|@_/__/_\\/o/\/o\/\/o  \_//\__/|/\__/__/_o|/|_|_|__|oooo\|
                     o__|/o\__|_//@|/\\o\o\_o\|\\O\|\/|/|_|\/|___/@|\/_|_/\/__|o_@_||\|_|@/ oo\\/\/
                        |_|\\||@|\|@\/|\\|o|\\|o|\_|/_o\|/\|\__@/\\|/\_|\|//O/|__|/_|/|__|oo \/ \/
                          |/ ||_|/|_@\|/\|\|_||/|_@|\/|\|_/|/|| \/o|\//\/o\\\\_o\||o|_|oo_|__@\_/
                           \_o\\|@|_|_|O/  |/|@\|_||/\o\|/_/\/\_/\o|/ \/|_//// \/ O\| oo\/|/@|/oo
                             \_||@|__@| \__@\|\O|/_|@/|/o\/\/\/_@_\|\_/\_/|/o\_/__// oo|/\|\_|@|_oo
                               |/\\_\_|_@_|\/|/_@\\|o\|@|@\/\/\_|o/|/|\|\/|_//_||_/ooo\|\_|/o_/|_|
                                \@|@|\\|\|\|\|_/\|\|//|/\|_\/\//_@\/\|/|/\||//|\|@|_|//|/O|o_/\|
                                 \|\|/ |/|@|_|@|_|/ \\|__|_o\/o\\|o\||\|\/O|/O|/@_|_| \/\/_o_\/
                                  |_|\_/\|O__|_|  \_/_|\/ \\/@|\\|\/||/|/\_|__|@|\|___/\/|\|_/
                                    |_||/|_@_\@\o_/o|o|/@_/\\/_//o \|/\|\/@|_o__|_|__/|/||/|/
                                      |o\| /|/\_\|\|/\||_/\_|\@|\\_/|\/@/|/|__/O|_/_/_|// \|
                                       \||@\|_@_\|/|\@|//o\||//o\||\|/\/||||o___|/o_|@| \_/
                                        |o\/ \|@@|/ /\O\\/\|o\\|/o|/ \/|/\/\/|_o/\_/|/\_/
                                         \|\o/ \/ \ \/o_|\/|\//|\/o\_/_|O/\//o_|\/@//\/
                                          \\|\_@\_/_o\_/|o\|/|_|_\|/O|/|/\|||__|/o \\/
                                           \|/_|@\\/\\_\|/\|\|@\|\|\_|\|O//O/o_/ \_//
                                            |_@|_/@\/_/\|@_|//o/_/o//@\|/|\//||____|
                                    o________\\/\\|@\/\/__@\\\/|_o/|__|\\|/|/O|
                                             \|\/ |_o\/\o|_////_/|\|_|@/@|_|\/
                                              |_\_o\\/\/\o\|/|/ O|/ O|/\/\|\/
                                                \||/@\/\O\_|\|@_/ \_/|O/@_|/
                                                 |_\|_\O|/o|/ oo\_/@/  \__|
                                                   \|_\|\\_|\_/_|/\|___/
                                                    |/\| \||/ |_|\/|/
                                                     \ |_/@ \/ o|/\|
               oooooooo  ooo           oo             |_o\\_@\_/|@/
              oo|_o\|/oo__|_oo        o_\_o_oo          \|\|\/ \|/
               |/\|/|  \/\|/|_o         |\|_/            |/  \_//
                \_|/    \_|_|            \|/              \__/_|
__________________|_______|_______________|__________________|____________________________________________________________________________________________________


text:
Interpreter for a 99 Bottles of Beer program
Write a program (in a first language A) that interprets a "99 Bottles of Beer" program and a FizzBuzz program (both in a second language B) on its standard input. The output should go to standard output; you may implement the interpreter as a function in languages lacking standardized I/O interfaces.
Constraints
The 99-Bottles program must come from either this site's problem or from http://99-bottles-of-beer.net/. Link to (do not copy and paste) the 99-Bottles program in your answer. The specific output is not important; what matters is whether the interpreter produces exactly the same output as a more complete one does.
You may write the FizzBuzz program yourself, or you may obtain it from the Internet or another source. Do not copy and paste the program into your answer in the latter case.
Both languages (and the 99-Bottles program) must have existed prior to September 22, 2011 (when this challenge was first posted). Specifically, you may not invent your own language for the specific purpose.
Any interpreter that hardcodes a non-whitespace character or string to be sent to the output (or that accesses the Internet) is cheating and not permissible. For example, an interpreter that contains "beer", "Buzz", or even "b" as a string or character literal is not acceptable, but looping from 1 to 99 is acceptable if a corresponding print statement is not hardcoded.
Both languages' names must not begin with the same letter and must not have any three character substring in common. For example:

APL and AWK begin with the same letter, and so do C, C++, and C#.
JavaScript and VBScript have SCR in common.

Additionally, the 99-Bottles and FizzBuzz programs must not be valid in language A or any other language that the interpreter depends on – the direct use of eval, exec, or similar language features or methods to compile and execute them is expressly forbidden.
Scoring
The score is the sum of:

Ten times the interpreter's character count
Ten times the FizzBuzz program's character count.
The 99-Bottles program's actual character count (because it should not be a golfed program). This excludes any leading and trailing whitespace but includes whitespace used for indentation. Each newline counts as one character.

For verification, include the code of everything you have written yourself, and link to any published sources you have used.

Excluding 'b' in string literals could be tough on languages that have 'b' keywords (block, begin, double, enable...)

@J B, I 'block' doesn't get sent to output; I think that's ok

I don't get this... PleaseStand, were you drunk when you wrote the question?  Otherwise, why is it named "drunken"?

@boothby: It was named the "drunken" interpreter because it is supposed to interpret a 99 Bottles of Beer program, a program for which I could find published versions for many languages. I don't drink beer or any other alcoholic beverage.

@J B: keywords are no strings or character literals.

@JB Indeed. That requirement could ruin an approach involving scanning only the first character of each token to determine its identity.

JavaScript interpreter for C (3834)
Interpreter (180 * 10 = 1800)
f() is the function to be called.
function prvarf(x){a=arguments;i=0;s+=(t=x.replace(/%./g,function(){return a[++i]}));return t}function f(x){Function(x.replace(/int/g,'var').replace(/#|ma/g,'f//'))(s='');return s}

99-Bottles (1074)
http://99-bottles-of-beer.net/language-c-844.html
FizzBuzz (96 * 10 = 960)
Adapted from one of the programs at http://perl.guru.org/scott/misc/golf.html:
main()
{int b=0;for(;++b<101;)printf(printf("%s%s",b%3?"":"Fizz",b%5?"":"Buzz")?"\n":"%d\n",b);}

Doesn't your C interpreter directly use eval?

A fun one. I don't think it broke any of the rules you laid out, but it might be considered cheating.
VB.NET (2010, needs inline Action(Of t1, t2)), running on Windows, 362:
Imports System.Windows.Forms
Module A
Sub Main()
Dim b As New WebBrowser
IO.File.WriteAllText("C:\t.htm","<body></body><script>"&Console.In.ReadToEnd&"</script>")
b.Navigate("file:///C:/t.htm")
AddHandler b.DocumentCompleted,Sub(sender,e)
Console.Write(b.Document.GetElementsByTagName("body")(0).InnerHtml)
End Sub
Do
Application.DoEvents
Loop
End Sub
End Module

It interprets JavaScript. If you run this, you'll need to go into the Task Manager and stop the process because I just looped infinitely to save characters. You'll also need to make sure there's a reference to System.Windows.Forms in the project.
I haven't tested it yet, but I will as soon as I can.
99 Bottles of Beer, 2134 characters:
http://99-bottles-of-beer.net/language-javascript-1079.html
FizzBuzz, 117 113:
for(b=document.body,i=0;++i<=100;)b.appendChild(document.createTextNode(i%3?i%5?i:'Buzz':i%5?'Fizz':'FizzBuzz'));

For a total score of 3620 + 1130 + 2134 = 6,924 6,884
Oh well...