text:
The Real Slim Shady
Echo the following in as few bytes as possible:
I'm Slim Shady. Yes, I'm the real Shady.
All you other Slim Shadys are just imitating.
So, won't the real Slim Shady please stand up?
Please stand up. Please stand up.

The following five words must appear EXACTLY ONCE in your code:
I'm
Slim
Shady
real
stand

Now that stupid song is in my head.

Is it ok if the program output more than the full text? Ie. enclosing the lyric in parens.

@Sylwester As long as it follows the rules, you can code it how you want.

do we have to have new lines in the same places you have them in the example output?

@Malachi it must match the output exactly, yes.

Python: 176
print"{0}{1}{2}. Yes, {0}{3}{2}.\nAll you other {1}{2}s are just imitating.\nSo, won't {3}{1}{2} p{4}?\nP{4}. P{4}.".format("I'm ","Slim ","Shady","the real ","lease stand up")

Naturally, the same idea as other compression solutions (though independently obtained).

I mistakenly downvoted this one. Sorry. (If you make any change I think I can remove the downvote)

@edc65: Thanks for the honesty :) I edited the answer.

You can shave off 3 bytes just by reusing the spaces.print"{0}{1}{2}. Yes, {0}{3}{2}.\nAll you other{1}{2}s are just imitating.\nSo, won't{3}{1}{2} p{4}?\nP{4}. P{4}.".format("I'm"," Slim"," Shady"," the real","lease stand up")

Brainfuck 1923 bytes
Enjoy...
-[------->+<]>.+[-->+<]>++.---[->+++<]>+.
[->+++++<]>-.>-[--->+<]>--.--[--->++++<]
>.---.++++.[->+++++<]>-.>-[--->+<]>--.>+
[----->+++<]>+.-------.+++.+[--->+<]>++.
-----[++>---<]>.++[--->++<]>.--[->+++<]>-.
[->++++<]>+.[--->+<]>----.-[++>---<]>+.
------------.++++[->++<]>+.+[-->+<]>++.---
[->+++<]>+.[->+++++<]>-.---[->++++<]
>.------------.---.--[--->+<]>-.---[----->++<]
>.-------------.----.+++++++++++.[++>---<]
>--.>-[--->+<]>--.>+[----->+++<]>+.-------.
+++.+[--->+<]>++.-----[++>---<]>.>
++++++++++.+++[->+++++<]>.[--->+<]>+..
[++>---<]>--.--[->++++<]>+.----------.++++++.-
[---->+<]>+++.+++++[->+++<]
>.+++++.------------.---.+++++++++++++.
[-->+++++<]>+++.>-[--->+<]>--.--
[--->++++<]>.---.++++.[->+++++<]>-.>-
[--->+I'm<]>--.>+[----->+++<]>+.-------.+++.+
[--->+<]>++.------.+[---->+<]>+++.[->+++<]>+.--
[--->+<]>---.-------------.--[--->+<]>-.-
[--->++<]>.+++++++++++.--.+.
[---Slim->+<]>+++.-[--->++<]>-.++++.----.
+++++++++++.+[->+++<]>++.--[--->+<]
>-.-----------.+++++.-------.--[->+++<]>-.
>++++++++++.>-[--->+<]>--.[--->+<]>--.
[->+++++<]>+.------------.--[->++++<]>-.
--------.-.[++>---<]>++.[->+++<]>-.[---->+
<]>+++.---[->++++<]>.------------.---.--[---
>+<]>-.---[----->Shady++<]>.-------------.-
---.+++++++++++.[++>---<]>--.>-[--->+<]
>--.--[--->++++<]>.---.++++.[->+++++<]
>-.>-[--->+<]>--.>+[----->+++<]>+.-------.
+++.+[--->+<]>++.-[---->+<]>++.[-->+++++++<]
>.----.-------.----.--[--->+<]>--.++++[->+++<]
>.--[--->+<]>-.---[->++++<]>-.+.+[->+++<]
>++.+++++++++++++.----------.-[--->+<]
>-.---[->++++<]>+.-----.[--->++++<]>-.>
++++++++++.[->++++++++<]>.+[--->++++<]
>.---real----.----.--[--->+<]>--.++++[->+++<]
>.--[--->+<]>-.---[->++++<]>-.+.+[->+++<]
>++.+++++++++++++.----------.-[--->+<]>-.---
[->++++<]>+.-----.[->+++++<]>--.++[--->++<]
>.[-->stand+++++<]>.+[--->++++<]>
.-------.----.--[--->+<]>--.++++[->+++<]
>.--[--->+<]>-.---[->++++<]>-.+.+[->+++<]
>++.+++++++++++++.----------.-[--->+<]
>-.---[->++++<]>+.-----.[->+++++<]>--.

Standard Loop Holes

Does not include the five words.

Perhaps scroll right, however i'll edit the post so you don't have too...

I did scroll but somehow missed the words, sorry.

how many bytes?

Am I correct in saying 1923 with the new lines removed?

I came up with 1918 characters, I don't know that any of these characters are outside the norm where they would tack on extra bytes. I don't know another way of counting Bytes yet so I would say 1918

Perl, 155
With improvements by Martin Büttner and Thaylon:
$_="01. Yes, 02X.
All you other1s are just imitating.
So, won't21 p3?
P3. P3.";s/\d/("I'm"," SlimX"," the real","lease stand up")[$&]/ge;s/X/ Shady/g;print

@MartinBüttner Excellent suggestions. Thanks :-)

You can omit the last ; too.

Love the "All you other 1s" part

Shifting around the " " for 157: $_="01. Yes, 032.
All you other1s are just imitating.
So, won't31 p4?
P4. P4.";s/0/I'm/g;s/1/ Slim2/g;s/2/ Shady/g;s/3/ the real/g;s/4/lease stand up/g;print

Mines so similar now, and I was later, so Ill just delete it. You can get another 2 Byte with: $_="01. Yes, 02X.
All you other1s are just imitating.
So, won't21 p3?
P3. P3.";s/\d/("I'm"," SlimX"," the real","lease stand up")[$&]/ge;s/X/ Shady/g;print

@Thaylon That's a neat trick with the array replacement. Thanks for all the help!

Ruby, 154 bytes
$><<"012. Yes, 032.
All you other12s are just imitating.
So, won't312 p4?
P4. P4.".gsub(/\d/){%W{I'm \ Slim \ Shady \ the\ real lease\ stand\ up}[$&.hex]}

After helping out a few people with how to split up the filler strings I decided to give their replacement callback idea a go. ;)

You can save some characters: #{h+a} is shorter than "+h+a+", and #{d+h+a} is shorter than "+d+h+a+".

@ProgramFOX o.O ... I'm ashamed to say I only thought of #{h}#{a}.

Can save a few more with h=" Slim"+a=" Shady", and one by replacing puts  with $><<.

154 with .gsub(/\d/){%W{I'm \ Slim \ Shady \ the\ real lease\ stand\ up}[$&.hex]}

@Ventero thanks! :)

JavaScript (E6) 165
Just the same in another language
alert("012. Yes, 05326All you other12s are just imitating6So, won't5312 p4?\nP4. P4."
.replace(/\d/g,x=>"I'm1 Slim1 Shady1real1lease stand up1 the 1.\n".split(1)[x]))

Explanation: replace each single digit in the first string with the corresponding string in the array ["I'm"," Slim"," Shady","real","lease stand up"," the ",".\n"]
Revised with the new rules here at PPCG (output returned from a function, no constraints about features newer than the challenge), this could be 158. See the snippet

F=
_=>`012. Yes, 0532.
All you other12s are just imitating.
So, won't5312 p4?
P4. P4.`.replace(/\d/g,x=>"I'm, Slim, Shady,real,lease stand up, the ".split`,`[x])

console.log(F())

Nice implementation :) You can save a byte by using a template literal in the replace function and replacing \n with an actual newline.

@Shaggy I could do better with template literals, but they where not implemented in any browser at time (Aug 2014)

Ah, I see. Does that invalidate my answer, so, seeing as this question was posted before the spec that defines template literals was standardised?

@Shaggy your answer is not invalid: if there was no acceptable/legal interpreter for the language at the time the question was written, an answer may be submitted as non-competing. (https://codegolf.meta.stackexchange.com/a/7990/21348)

Can someone explain how this works? Looks like magic to me.

@JacobPersi have a look

GolfScript, 162 154 152 144 bytes
"I'm ":i"Slim ":|"Shady":y". Yes, "i"the real ":!y".
All you other "|y"s are just imitating.
So, won't "!|y" p""lease stand up":l"?
P"l". P"l"."

Test online

You can save 8 bytes by replacing \n and n with an actual linefeeds and choosing non-alphanumeric variable names (e.g., &) to eliminate the whitespace around them.

@Dennis Thanks a lot! I edited my answer.

The war has begun.

CJam - 133
"I'm| Slim| Shady| the real|lease stand up|432. Yes, 412.
All you other32s are just imitating.
So, won't132 p0?
P0. P0."'|/~5,{`/\*}/

Try it at http://cjam.aditsu.net/
I think it also works in GolfScript if you replace '| with "|"

All you other thirty-twos are just imitating. So, won't one three two pee ze-ro? Pee ze-ro. Pee ze-ro. That's how it's gonna sound in my head from now on. :P

C, 374
By moving memory
Not the shortest but can it get any faster?
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char *s;
void m (int d, int f, int p)
{
    memmove (s+p+f, s+p, strlen(s)-p+1); // Shift a part of the string to make room for our insertion
    memcpy (s+p, s+d, f); // Copy the desired reference in place
}
int main ()
{
    s = malloc (168);
    strcpy (s,"I'm Slim Shady. Yes, the real.\nAll you others are just imitating.\nSo, won't the please stand up?\nP. ");

    m (0, 4, 21);
    m (8, 6, 33);
    m (3, 11, 54);
    m (28, 5, 100);
    m (3, 11, 105);
    m (118, 14, 135);
    m (134, 16, 151);
    puts (s);
}

It's 374 chars long after minification.
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char*s;void m(int d,int f,int p){memmove(s+p+f,s+p,strlen(s)-p+1);memcpy(s+p,s+d,f);}int main(){s=malloc(168);strcpy(s,"I'm Slim Shady. Yes, the real.\nAll you others are just imitating.\nSo, won't the please stand up?\nP. ");m(0,4,21);m(8,6,33);m(3,11,54);m(28,5,100);m(3,11,105);m(118,14,135);m(134,16,151);puts(s);}

Nice, but you can golf it down to 278 bytes: char s[168]="I'm Slim Shady. Yes, the real.\nAll you others are just imitating.\nSo, won't the please stand up?\nP. ";m(d,f,p){memmove(s+p+f,s+p,strlen(s)-p+1);memcpy(s+p,s+d,f);}main(){m(0,4,21);m(8,6,33);m(3,11,54);m(28,5,100);m(3,11,105);m(118,14,135);m(134,16,151);puts(s);}

Java, 247
My first code golf, while learning Java. Posted it because it beats the other (fully functional) Java entry and the Haskell entry.
class S{public static void main(String[]a){String s="I'm",t=" Slim",u=" Shady",v=" the real",w="lease stand up";System.out.print(s+t+u+". Yes, "+s+v+u+".\nAll you other"+t+u+"s are just imitating.\nSo, won't"+v+t+u+" p"+w+"?\nP"+w+". P"+w+".");}}

VBA 343 bytes
Sub EMINEM()
e = "Slim "
m = "Shady"
i = "I'm "
n = "lease stand up"
em = "real "

MsgBox i & e & m & ". Yes, " & i & "the " & em & m & "." & Chr(10) & "All you other " & e & m & "s are just imitating." & Chr(10) & "So, won't the " & em & e & m & " p" & n & Chr(10) & "P" & n & ". P" & n & "."

End Sub

Very Nice implementation

Thanks Malachi, can't skip this golf as an old fans of Eminem.

I am working on one right now.

I am interested to see another approach!  Maybe ascii?

I could corner the market and port my C# to VB

Looking forward to it!

It's great to see someone golfing in VBA. Can't you print to the immediate window with ? though?

@ckuhn203 "?" changes to 'print' but i'll need debug.print so it screw up everytime i use "?".  Feel free to point out if I can do it here, thanks!

http://codegolf.stackexchange.com/a/35564/20807

C# 209 205 201 197 209 212  217
class P{static void Main(){System.Console.Write("{0}{1}{2}. Yes, {0}{3}{2}.\nAll you other {1}{2}s are just imitating.\nSo, won't {3}{1}{2} p{4}?\nP{4}. P{4}.", "I'm ","Slim ","Shady","the real ","lease stand up");}}

Now with Proper Capitalization and New Lines

You could probably save some more chars by moving spaces from format string to replacements, like WriteLine("{0}{1}","I'm ","Slim ").

The ending newline doesn't seem to be a requirement, so consider using .Write() instead of .WriteLine(). Even if it's required, .Write() with a \n is shorter.

thank you @Bob that saved me another 4 byes! even on my VB answer too!

You don't have capital P's on the Please Stand up twice

@TopinFrassi, I fixed it on this answer and on my VB answer as well.  I was also missing a space.  I am asking about the new lines in the output right now...

VB 253 249 245 241 244 285 259 223
I hate New Line termination
Module M
Sub Main
Console.Write("{0}{1}{2}. Yes, {0}{3}{2}.{5}All you other {1}{2}s are just imitating.{5}So, won't {3}{1}{2} p{4}?{5}P{4}. P{4}.","I'm ","Slim ","Shady","the real ","lease stand up",vbCr)
End Sub
End Module

Now with proper Capitalization And Newlines in the output, and no Tabs *
Thank you VB for vbCrLf
Thank you, @Taylor Scott!

I wonder if this will run without the tabs and new lines?????

it won't let me in Visual Studio 2013

223 Bytes

@TaylorScott, apparently it will allow you to code it without the indentations now. or maybe that is just Mono for you

As far as I am aware, yes, what the compiler can parse is heavily dependent on what version you are on - especially heading back to VB 6.0 and prior

VBA 307 Bytes
And obfuscated with line separators (just for fun). Based on this answer
Function p()
e = "Slim ": m = "Shady": i = "I'm ": n = "lease stand up": s = "real ": a = "."
p = i & e & m & ". Yes, " & i & "the " & s & m & a & Chr(10) & "All you other " & e & m & "s are just imitating." & Chr(10) & "So, won't the " & s & e & m & " p" & n & Chr(10) & "P" & n & ". P" & n & a
End Function

Called from the immediate window with ?p.
The 307 includes the ?p.

Oh, ?P in immediate window I see, +1

you should get rid of a = "." I think you could shave off a few Bytes

Actually, on second thought, I think it's more readable with the line seperators vs new lines...

can't you get rid of the spaces between operators?

@Malachi according to the spec, yes, but actual implementations force the whitespace on you. If I did it in VBScript instead I could probably shorten it up a bit.

Would you save bytes by assigning a variable to Chr(10)?

No @cairdcoinheringaahing. I considered that when I first golfed this, but the variable & line separator would be just as many chars. Maybe one saved?

PHP - 151 bytes
<?="I'm Slim Shady".gzinflate("]Œ1
„0E{Á;üÎFr…ÅÒNHe9à°F&‰d&,Þ~Avmßûï;Ì¬=Æ.ÂVFaø•–ÃµÍ ‚#WäÓx    ñR
*Œª!Ä`d!½Ï¹Ï=>9uöót7Ø…Ij”ÔýÕ6Ó?qx‚/");@realstand;

hexdump:
0000000 3f3c 223d 2749 206d 6c53 6d69 5320 6168
0000010 7964 2e22 7a67 6e69 6c66 7461 2865 5d22
0000020 318c 840a 1030 7b45 3bc1 cefc 7246 c585
0000030 4ed2 6548 e039 46b0 8926 2664 de2c 057e
0000040 7641 df6d effb cc3b 3dac 2ec6 56c2 6146
0000050 f812 9695 b5c3 20cd 2382 e457 14d3 0978
0000060 52f1 2a0a ad8c 21aa 60c4 2164 cfbd cfb9
0000070 3e3d 7539 f3f6 3774 85d8 1949 946a d416
0000080 d5fd d336 713f 8278 222f 3b29 7240 6165
0000090 736c 6174 646e 003b
0000097

Another answer without using gzinflate (228 bytes):
Reads shorts (16 bits), extracts 3 5-bit integers as indices of a lookup table.
<?$a=str_split(" .Yes,AlyouthrajimngSw'pP?
")+[27=>"I'm ",'Slim ',@Shady,'the real ','lease stand up'];$b=unpack(@v26,'o…~:tç       (ƒ-4€t£9ê`0BË-SBT $2U`Y{ÿXg |ác');foreach($b as$c)echo$a[$c>>10],$a[$c>>5&31],$a[$c&31];

hexdump:
0000000 3f3c 6124 733d 7274 735f 6c70 7469 2228
0000010 2e20 6559 2c73 6c41 6f79 7475 7268 6a61
0000020 6d69 676e 7753 7027 3f50 220a 2b29 325b
0000030 3d37 223e 2749 206d 2c22 5327 696c 206d
0000040 2c27 5340 6168 7964 272c 6874 2065 6572
0000050 6c61 2720 272c 656c 7361 2065 7473 6e61
0000060 2064 7075 5d27 243b 3d62 6e75 6170 6b63
0000070 4028 3276 2c36 9d27 026f 8504 7e0c 3a03
0000080 e774 0918 0901 8328 1c2d 8034 a374 ea39
0000090 6001 3011 cb42 532d 5442 a007 3224 6055
00000a0 9d59 ff7b 5802 2067 e17c 2763 3b29 6f66
00000b0 6572 6361 2868 6224 6120 2473 2963 6365
00000c0 6f68 6124 245b 3e63 313e 5d30 242c 5b61
00000d0 6324 3e3e 2635 3133 2c5d 6124 245b 2663
00000e0 3133 3b5d
00000e4

PowerShell 194 189 164
"{0}{1}{2}. Yes, {0}{3}{2}.`nAll you other {1}{2}s are just imitating.`nSo, won't {3}{1}{2} p{4}?`nP{4}. P{4}."-f"I'm ","Slim ","Shady","the real ","lease stand up"

Somehow my answer ened up resembling @nneonneo's a lot, even though it wasn't my original intent...

Changing \n to line breaks save three bytes

Lua 201 193 188 178
h=" Shady"i="I'm"s=" Slim"..h r=" the real"u="lease stand up"io.write(i,s,". Yes, ",i,r,h,".\nAll you other",s,"s are just imitating.\nSo, won't",r,s," p",u,"?\nP",u,". P",u,".")

Ungolfed & expanded some
h=" Shady"
i="I'm"
s=" Slim"..h
r=" the real"
u="lease stand up"
io.write(i,s,". Yes, ",i,r,h,".\nAll you other",s,"s are just imitating.\nSo, won't",r,s," p",u,"?\nP",u,". P",u,".")

PYTHON: 198 193 bytes
i,s,h,r,t="I'm ","Slim ","Shady","real ","lease stand up"
print i+s+h+". Yes, "+i+"the "+r+h+".\nAll you other "+s+h+"s are just imitating.\nSo, won't the "+r+s+h+" p"+t+"?\n"+"P"+t+'. P'+t+'.'

move please into the variable holding stand up and get rid of your g variable, and possibly remove /n you don't need them

If I remove the \n the newlines will be gone, and I presume those are necessary for the output.

PHP - 196 171
<?$S="Shady";$P="lease stand up";$R="the real ";$I="I'm ";$s="Slim ";echo"$I$s$S. Yes, $I$R$S
All you other $s$S"."s are just imitating.
So, won't $R$s$S p$P?
P$P. P$P."

;

Common Lisp, 197
(let((a"I'm ")(b"Slim ")(c"Shady")(d"real ")(e"lease stand up"))(format t"~{~A~}"(list a b c". Yes, "a"the "d c".
All you other "b c"s are just imitating.
So, won't the "d b c" p"e"?
P"e". P"e"")))

Perl, 161 164 bytes
Not quite as short as squeamish ossifrage's answer, but I wanted to share the CamelCaseCompression, which no one else has used and allows the removal of many spaces and quotation marks.
It does need a slightly longer text to become truly beneficial, though.

$_="0 1 2. Yes, 03 2.
AllYouOther 1 2sAreJustImitating.
So, won't3 1 24?
4. 4.";s/\d/qw(I'm Slim Shady TheReal PleaseStandUp)[$&]/ge;s/\B([A-Z])/ \L\2/g;print

Edit: Following Thaylon's suggestion, the s/(\S)([A-Z])/\1 \L\2/g substitution has been shortened by four characters. That doesn't pick up on comma-capital digraphs, though, so an extra space had to be inserted before "won't".

Interesting. A bit shorter with "not a word boundary": s/\B([A-Z])/ \L\1/g;

Thanks @Thaylon. \B is something I'm going to have to read about. It's weird.

Golfscript - 140 (tweetable)
"I'm"" Slim"" Shady"". Yes, "3$" the real"3$".
All you other"6$2$"s are just imitating.
So won't"5$3$3$" p""lease stand up""?
P"1$". P"1$"."

I'm Slim Shady. Yes, 3 the real 3.
All you other 62s are just imitating.
So won't 533 please stand up?
P1. P1.

///, 131 bytes
/0/ Shady//1/lease stand up//2/ the real//3/ Slim0//4/I'm/43. Yes, 420.
All you other3s are just imitating.
So, won't23 p1?
P1. P1.

Try it online!

Rust (full program), 183 180 178 173 172 bytes
178 -> 173 bytes, thanks to Sara J
fn main(){print!("{}{}{}. Yes, {0}{}{2}.
All you other{1}{2}s are just imitating.
So, won't{3}{1}{2} p{}?
P{4}. P{4}.","I'm"," Slim"," Shady"," the real","lease stand up")}

Try it online!

173 bytes

@SaraJ Ofc, obviously! Thanks :)

F#, 250 242
[1..21]|>List.iter((function|1|5->"I'm "|2|9|13->"Slim "|4->". Yes, "|6|12->"the real "|8->".\nAll you other "|11->"s are just imitating.\nSo won't "|15->" p"|16|18|20-> "lease stand up"|17->"?\nP"|19->". P"|21->"."|_->"Shady")>>printf "%s")

More readable version with line breaks:
[1..21]|>List.iter((function
|1|5->"I'm "
|2|9|13->"Slim "
|4->". Yes, "
|6|12->"the real "
|8->".\nAll you other "
|11->"s are just imitating.\nSo won't "
|15->" p"
|16|18|20-> "lease stand up"
|17->"?\nP"
|19->". P"
|21->"."
|_->"Shady")>>printf "%s")

JavaScript 259 240 238 bytes
Not that good but might as well post an answer.
b=String.prototype,b.a=b.replace,alert("123. Yes, 16537All you other 23s are just imitating7So, won't 6523 p4?\nP4. P4.".a(/1/g,"I'm ").a(/2/g,"Slim ").a(/3/g,"Shady").a(/4/g,"lease stand up").a(/5/g,"real ").a(/6/g,"the ").a(/7/g,".\n"))

More readable version :
b=String.prototype
b.a=b.replace
alert("123. Yes, 16537All you other 23s are just imitating7So, won't 6523 p4?\nP4. P4."
    .a(/1/g,"I'm ")
    .a(/2/g,"Slim ")
    .a(/3/g,"Shady")
    .a(/4/g,"lease stand up")
    .a(/5/g,"real ")
    .a(/6/g,"the ")
    .a(/7/g,".\n")
    )

Java, 308 301 298 292 258
Java is a bit verbose, but here is my try:
class P{public static void main(String[]c){String s=" Shady",t=" the real",l="lease stand up",i=" Slim",m="I'm";System.out.format("%s%s%s. Yes, %s%s%s.\nAll you other%s%ss are just imitating.\nSo, won't%s%s%s p%s?\nP%s. P%s.",m,i,s,m,t,s,i,s,t,i,s,l,l,l);}}

You can 1-merge 'real' and 'the', they're always together 2-move some blanks out of the big format string 3-above all: use more single variables, the a array is of no use. All in all you can go to ~270

@edc65 I didn't know that I could declare multiple strings in Java without writing String multiple times. That's why I had the array for all but one variable. Thanks a lot for the hints.

C# 226
class P{static void Main(){System.Console.Write("{0}{1}{2}. Yes, {0} the{3} {2}.All you other{1}{2}s are just imitating.So, won't the{3}{1}{2} please{4}up?Please{4}up. Please{4}up.","I'm"," Slim ","Shady"," real"," stand ");}}

you missed some spots where you can remove a bunch of characters, check mine out.  http://codegolf.stackexchange.com/a/35557/9435

MySQL: 273 267
set @i="I'm", @s="Slim", @h="Shady", @r="real", @t="stand", @p="lease stand up";select concat(@i," ",@s," ",@h,". Yes, ",@i," the ",@r," ",@h,".\r\nAll you other ",@s," ",@h,"s are just imitating.\r\nSo, won't the ",@r," ",@s," ",@h," p",@p,"?\r\nP",@p,". P",@p,".");

Ruby: 211
This one is impressive since simply printing the text is more efficient, but this is way cooler.
puts Zlib.inflate("eJxdjDEKwzAQBHu9Yjs3Rl8ILt0FVKU88GErnCWhO2H8e6sIwUmzxQyz87AjSOyz0XJ6vFhHzB3axqhM8hFuEsGZG3IX9ZYoqDLeTQ1xj0YW0+pdyCOOnAa7/XwTFGFShhqlBa083PMXePyDC15NOP8=".unpack("m0")[0])#I'mSlimShadyrealstand

PHP, 179 Bytes
<?
$i="I'm";
$s=" Slim";
$h=" Shady";
$p="lease stand up";
$r=" the real";
echo"$i$s$h. Yes, $i$r$h.\nAll you other$s$h"."s are just imitating.\nSo, won't$r$s$h p$p?\nP$p. P$p.";

And golfed
<?$i="I'm";$s=" Slim";$h=" Shady";$p="lease stand up";$r=" the real";echo"$i$s$h. Yes, $i$r$h.\nAll you other$s$h"."s are just imitating.\nSo, won't$r$s$h p$p?\nP$p. P$p.";

JavaScript (ES6), 165 163 bytes

f=

_=>`${a="I'm"}${b=` Slim${c=` Shady`}`}. Yes, ${a+(d=" the real")+c}.
All you other${b}s are just imitating.
So, won't${d+b} p${e="lease stand up"}?
P${e}. P${e}.`

console.log(f());

Matlab 206 bytes
i='I''m ';s='Slim ';h='Shady';r=' real ';t=' stand ';p=['Please' t 'up. '];sprintf([i s h '. Yes, ' i 'the' r h '.\nAll you other ' s h 's are just imitating.\nSo, won''t the' r s h ' please' t 'up?.\n' p p])

Found a typo: h ' are should become h 's are. -- You could also save a little by changing up. to up.  so you don't need the ' ' near the end.

F#, 197 bytes
printf"%A"<|System.String.Format("{0}{1}{2}. Yes, {0}{3}{2}.\nAll you other {1}{2}s are just imitating.\nSo, won't {3}{1}{2} p{4}?\nP{4}. P{4}.","I'm ","Slim ","Shady","the real ","lease stand up")

F#, 210 bytes (alternate method)
let a,b,c,d,e="I'm ","Slim ","Shady","the real ","lease stand up"
printf"%s"<|a+b+c+". Yes, "+a+d+c+".\nAll you other "+b+c+"s are just imitating.\nSo, won't "+d+b+c+" p"+e+"?\nP"+e+". P"+e+"."

Java - 204
Ungolfed:
String i = "I'm", s = " Slim", h = " Shady", r = " the real", t = "lease stand up";
System.out.printf(i + s + h + ". Yes, " + i + r + h + ".%n"
        + "All you other " + s + h + "s are just imitating.%n"
        + "So, won't" + r + h + " p" + t + "?%n"
        + "P" + t + ". P" + t + ".");

Golfed:
String i="I'm",s=" Slim",h = " Shady",r =" the real",t="lease stand up";System.out.printf(i+s+h+". Yes, "+i+r+h+".%nAll you other"+s+h+"s are just imitating.%nSo, won't"+r+h+" p"+t+"?%nP"+t+". P"+t+".");

Haskell, 250 221 bytes
Hell it beats the java version, so I'm posting. Is this really as good as it gets, or is there some secret function or monad or something that would make this task easier to complete succinctly?
Edit: I used intercalcate " " instead of unwords...
putStr$let i="I'm";s="Slim";h="Shady";r="the real";p="lease stand up";d=".";n='\n';in unwords[i,s,h++d,"Yes,",i,r,h++d,n:"All you other",s,h++"s","are just imitating"++d,n:"So, won't",r,s,h,'p':p++"?",n:'P':p++d,'P':p++d]

I just posted a Java entry which beats your Haskell entry. Thought you might want to know ;)

Dart - 178 characters

Plain string interpolation and variables.
main({i:"I'm ",r:"the real ",s:"Slim ",z:"Shady",t:"lease stand up"}){print("$i$s$z. Yes, $i$r$z.\nAll you other $s${z}s are just imitating.\nSo, won't $r$s$z p$t?\nP$t. P$t.");}

Fiddling with whitespace can get it down to 176:
main({i:"I'm",r:" the real",s:" Slim",z:" Shady",t:"lease stand up"}){print("$i$s$z. Yes, $i$r$z.\nAll you other$s${z}s are just imitating.\nSo, won't$r$s$z p$t?\nP$t. P$t.");}

Clojure - 255 chars
Simple solution from a Clojure newbie. Golfed:
(defn p[f & x](println(apply format f x)))(let[i "I'm" s "Shady" l "Slim" e "lease stand up" r "the real"](p "%s %s %s. Yes, %s %s %s." i l s i r s)(p "All you other %s %ss are just imitating." l s)(p "So, won't %s %s %s p%s?" r l s e)(p "P%s. P%s." e e))

Ungolfed:
(defn p [f & x] (println (apply format f x)))
(let [i "I'm" s "Shady" l "Slim" e "lease stand up" r "the real"]
    (p "%s %s %s. Yes, %s %s %s." i l s i r s)
    (p "All you other %s %ss are just imitating." l s)
    (p "So, won't %s %s %s p%s?" r l s e)
    (p "P%s. P%s." e e))

Javascript, 191
Pretty basic attempt:
alert((a="I'm")+(b=" Slim")+(c=" Shady")+". Yes, "+a+" the "+(d="real")+c+".\nAll you other"+b+c+"s are just imitating.\nSo, won't the "+d+b+c+" p"+(e="lease stand up")+"?\nP"+e+". P"+e+".");

VBA, 165
Paste directly in the intermediate pane.
i="I'm":s=" Slim Shady":r=" the real":p="lease stand up":?i+s". Yes, "i+r+mid(s,6)".":?"All you other"s"s are just imitating.":?"So, won't"r+s" p"p"?":?"P"p". P"p"."

Major golfing comes from the quirky properties of VBA's intermediate pane's ? command.  You can place a string variable followed immediately by a string literal and they will concatenate with no spaces.

Pure bash, 156 bytes
Nothing especially exciting here:
f()(echo "$1$2$3. Yes, $1$4$3.
All you other $2$3s are just imitating.
So, won't $4$2$3 ${5,}?
$5. $5.")
f "I'm " Slim\  Shady "the real " "Please stand up"

C (gcc), 186 181 bytes
-5 bytes thanks to ceilingcat.
f(){char*a=" Slim Shady",*c="I'm the real";printf("%.3s%s. Yes, %s%s.\nAll you other%ss are just imitating.\nSo, won't%s%s p%s?\nP%8$s. P%8$s.",c,a,c,a+5,a,c+3,a,"lease stand up");}

Try it online!

Python 3.6, 166 bytes
a,b,c,d="I'm","Slim Shady","the real","lease stand up"
print(a,b+". Yes,",a,c,b[5:]+".\nAll you other",b+"s are just imitating.\nSo, won't",c,b,f"p{d}?\nP{d}. P{d}.")

Try it online!

Stax, 116 115 112 97 bytes
═Φ-cgvUV;Mc╔&♠◘Aτö,↔↕■∙o→¬▬⌡♪╓B▒ε,æO5≤,╝2Æ;╗)▀ìc)E]«╬ôÅ∩╖╚d:☻╔╩2Ñs*çφIBë╕gpÜI'mSlimShadyrealstand

Run and debug it
All credit to this answer to Khuldraeseth na'Barya.  I originally had a solution, but it's been completely re-written with none of the original now.
Stax programs have two representations.  Pure ASCII and "packed".  Packed stax uses all 256 byte values, and thus is smaller than ASCII, which uses only 95.  This solution is particularly clever because it's packed code that contains the required words.  When unpacked, the I'mSlimShadyrealstand roughly becomes "j|ksRfwb)ys\\GP*vOyn@[<a\\"d which is a no-op.  The rest of the program is pretty straight-forward compressed string literals.

Compress the whole darn thing and use a comment for 112 bytes.

Wow,  That's so simple.  I love it.

Kinda makes me wonder. The site doesn't allow packing of tabs, but some meddling with TS yields a packing of "\t<c>" that unpacks to "h<c-1>". Might it be possible to pack a tab in such a way that unpacking preserves it and that arbitrary characters can be inserted somewhere in the packed version?

@Khuldraesethna'Barya:  I think you're on to something.  Two ascii programs with the same length that share some suffix will share a prefix in their packed representation.  I don't think tabs are going to be able to help, but I think it might be possible to embed the words in the midst of an ignored string literal when unpacked.
Here is the unpacking code used by the "web app".

Got it! This can likely be shortened by removing the d, but it's an improvement nevertheless.

I'm dumbfounded right now. As far as I can tell, getting that necessary " character (and without something before it that would break execution or output!) was pure luck.

Wow, that was very quick work.

R, 168 160 bytes
-8 bytes thanks to Giuseppe
`[`=gsub;cat(1["I'm",2[" Slim ",3["Shady",4[" the real",5["lease stand up","123. Yes, 14 3.
All you other23s are just imitating.
So, won't423 p5?
P5. P5."]]]]])

Try it online!

Using \[``, we can get to 160

@Giuseppe It must be your life goal to improve on every answer I give... Oh well. I'll update it.

No, I was just not very active on CCGC for a while, so I've been trying to catch up by going through the profiles of the R golfers I know to look for neat tricks, suggest improvements, and help foster community. :-)

Ah, so that's why I was able to actually get some answers posted before the real master showed up.

Zsh, 154 bytes
set "I'm" Slim Shady real stand
<<.
$1${6= $2 $3}. Yes, $1 the $4 $5.
All you other$6s are just imitating.
So, won't the $4$6 p${x=lease $5 up}?
P$x. P$x.

Attempt This Online!

Extended BrainFuck - 195
{S~&I'm&}{I~& Slim&&M}{M~& Shady&}{P~& the real&}{L~&Please&&E~&.&}{E~& stand up&}>&S&I~&. Yes, &&S&P&M~&.
All you other&&I~&s are just imitating.
So, won't&&P&I~& please&&E~&?
&&L~& &&L<[<]>[.>]

Everything pure BF is BF. {name ...} is a macro, &name applies macro and ~"string" stores string in current position." can be any char so I choose & to obfuscate it a little.

What's the point of extending Brainfuck? Doesn't that make it inherently less useful?

@feersum No, It allows for more abstraction. I made it as an exercise in bootstrapping so the compiler is written in itself and it compiles the code to BF. This was just a step towards the ultimate goal to make LISP run on BrainFuck and it only took 3 summers from planning to something working. EBF wasn't designed to be used for golfing but I found out that some of it's features allow for compact code. If I ever make new versions it would be to support a kind of switch-case/if-else and not make it a better golf language.

PHP: 176
Thought I might as well give it a shot, nothing fancy though
$b="I'm ";$c="Slim";$d="Shady";$e="$c $d";$f="the real ";$g="lease stand up";echo"$b$e. Yes, $b$f$d.\nAll you other $e"."s are just imitating.\nSo, won't $f$e p$g?\nP$g. P$g.";

Cobra - 188
class P
    def main
        s,p=" Slim Shady","lease stand up"
        l,p="I'm[s]. Yes, I'm the real[s[5:]].\nAll you other[s]s are just imitating.\nSo, won't the real[s] p[p]?\n","P[p]."
        print l+p,p

Please explain how the code works.

JavaScript - 196 182
s="I'm ",l="Slim Shady",m="the real ",r="lease stand up";alert(s+l+". Yes, "+s+m+l.slice(5)+".\nAll you other "+l+"s are just imitating.\nSo, won't "+m+l+" p"+r+"?\nP"+r+". P"+r+".")

If you want a explanation, just comment.

Groovy - 196 chars
Pretty basic solution:
i="I'm"
s="Shady"
l="Slim"
p="lease stand up"
q="P$p."
r="the real"
f={println it}
f "$i $l $s. Yes, $i $r $s."
f "All you other $l ${s}s are just imitating."
f "So, won't $r $l $s p$p?"
f "$q $q"

Python: 175
Just a small change to the answer by nneonneo, but i can't comment and there don't seem to be private messages on this website so i'll post it this way.
a="Slim Shady"
print"{0}{1}. Yes, {0}{3}{2}.\nAll you other {1}s are just imitating.\nSo, won't {3}{1} p{4}?\nP{4}. P{4}.".format("I'm ",a,a[5:],"the real ","lease stand up")

FASM 212 bytes
z fix equ
A z "I'm "
C z "Shady"
D z "the real "
E z "Slim ",C
F z "Please stand up"
N=$A
L z ". "
display A,E,L,"Yes, ",A,D,C,L,N,"All you other ",E,"s are just imitating.",N,"So, won't ",D,E," ",F,"?",N,F,L,F,L

Wouldn't this capitalise the first Please as well?

Javascript 185
alert((i="I'm")+(s=" Slim"+(h=" Shady"))+". Yes, "+i+(r=" the real")+h+".\n"+"All you other "+s+"s are just imitating.\n"+"So, won't"+r+s+" p"+(p="lease stand up")+"?\n"+"P"+p+". P"+p+".")

///, 131 132 135 bytes
/!/lease stand up//#/ Shady//@/ Slim#//$/ real//%/I'm/%@. Yes, % the$#.
All you other@s are just imitating.
So, won't the$@ p!?
P!. P!.

Try it online!

c, 214 byte
main(){char*k[]={"I'm ","Slim ","Shady","the real ","lease stand up"},*w="012. Yes, 032.\nAll you other 12s are just imitating.\nSo, won't 312 p4?\nP4. P4.",c;for(;*w;)c=*w++,c>47&&c<58?printf(k[c-48]):putchar(c);}

Try it online

198 bytes

C, 220 bytes
char*s="I'm",*h="Slim",*a="Shady",*d="real",*y="lease stand up";f(){printf("%s %s %s. Yes, %s the %s %s.\nAll you other %s %ss are just imitating.\nSo, won't the %s %s %s p%s?\nP%s. P%s.",s,h,a,s,d,a,h,a,d,d,h,a,y,y,y);}

Detailed Live
#include <stdio.h>

char  *  s  =  "I'm"             ;
char  *  h  =  "Slim"            ;
char  *  a  =  "Shady"           ;
char  *  d  =  "real"            ;
char  *  y  =  "lease stand up"  ;

f(){printf("%s %s %s. Yes, %s the %s %s.\n\\
All you other %s %ss are just imitating.\n\\
So, won't the %s %s %s p%s?\nP%s. P%s.",

    s,
        h,
            a,
    s,
                d,
            a,
        h,
            a,
                d,
                d,
        h,
            a,
                    y,
                    y,
                    y

);}int main(){f();return 0;}

VBA, 164 Bytes
Anonymous VBE immediate window function that take no input and outputs to the VBE immediate window.
l=" Slim Shady":i="I'm":r=" the real":t="lease stand up":?i;s". Yes, "i;r;Mid(s,6)".":?"All you other"s" are just imitating.":?"So, won't"r;s" p"t"?":?"P"t". P"t".

PHP, 166 bytes:
<?=($i="I'm"),($l=" Slim".$s=" Shady"),". Yes, $i",($r="  the real"),"$s.
All you other${l}s are just imitating.
So, won't$r$l p",($p="lease stand up"),"?
P$p. P$p.";

J, 152 151 bytes
echo(0 :0)rplc'12345';"0'\'cut' Slim\ Shady\lease stand up\ the real\I''m'
512. Yes, 542.
All you other12s are just imitating.
So, won't412 p3?
P3. P3.

Try it online!

Java 8, 181 bytes (function)
v->"".format("%s%s%s. Yes, %1$s%s%3$s.%nAll you other %2$s%3$ss are just imitating.%nSo, won't %4$s%2$s%3$s p%s?%nP%5$s. P%5$s.","I'm ","Slim ","Shady","the real ","lease stand up")

Try it online.
Java 8, 229 bytes (full program)
interface M{static void main(String[]a){System.out.printf("%s%s%s. Yes, %1$s%s%3$s.%nAll you other %2$s%3$ss are just imitating.%nSo, won't %4$s%2$s%3$s p%s?%nP%5$s. P%5$s.","I'm ","Slim ","Shady","the real ","lease stand up");}}

Try it online.

ink, 177 bytes
VAR i="I'm"
~temp s=" Slim"+w
VAR w=" Shady"
VAR r=" the real"
VAR l="lease stand up"
{i+s}. Yes, {i+r+w}.
All you other{s}s are just imitating.
So, won't{r+s} p{l}?
P{l}. P{l}.

Try it online!

C# .NET 211 + class stuff etc = 255 bytes
public class p{public static void Main(){System.Console.WriteLine(@"{0}{1}{2}. Yes, {0}the {3}{2}.
All you other {1}{2}s  are just imitating.
So, won't the {3}{1}{2} please {4}up?
Please {4}up. Please {4}up.","I'm ","Slim ","Shady","real ","stand ");}}

This is probably as {1} as it gets ;)
I just the @ string tag instead of \r\n because thats 1 byte instead of 12 (3 * \r\n)EDIT: Didn't know you needed the full class so here

You can get 229 bytes by moving some more words into the variables and shuffling the spaces around a bit.

181 bytes by changing to using the Visual Interactive Compiler. By the way, class stuff and the main method are usually not counted toward the bytes anyway.

05AB1E, 124 122 bytes
"real"“‚µ stand€¾“"Shady""Slim"…I'm)•AΘ¥в‚Y•Sè`“ÿ ÿ ÿ.…Ü, ÿ€€ ÿ ÿ.
All€î€¶ ÿ ÿs€™‚‰ imitating.
So,¢²'t€€ ÿ ÿ ÿ ÿ?
ÿ. ÿ.“.ª

Try it online or verify that it's correct.
Explanation:
"real"              # Push string "real"
“‚µ stand€¾“        # Push dictionary string "please stand up"
"Shady"             # Push string "Shady"
"Slim"              # Push string "Slim"
…I'm               '# Push string "I'm"
)                   # Wrap all strings on the stack into a list:
                    #  ["real","please stand up","Shady","Slim","I'm"]
 •AΘ¥в‚Y•           # Push compressed integer 11123023204234
         S          # Converted to a list of digits: [1,1,1,2,3,0,2,3,2,0,4,2,3,4]
          è         # Index each into the string-list:
                    #  ["please stand up","please stand up","please stand up","Shady","Slim",
                    #   "real","Shady","Slim","Shady","real","I'm","Shady","Slim","I'm"]
           `        # Pop and push these strings separated to the stack
“ÿ ÿ ÿ.…Ü, ÿ€€ ÿ ÿ. # Push dictionary string "ÿ ÿ ÿ. yes, ÿ the ÿ ÿ.\n
All€î€¶ ÿ ÿs€™‚‰ imitating.
                    #                         All you other ÿ ÿs are just imitating.\n
So,¢²'t€€ ÿ ÿ ÿ ÿ? '#                         So, won't the ÿ ÿ ÿ ÿ?\n
ÿ. ÿ.“              #                         ÿ. ÿ."
                    # where the `ÿ` are automatically filled with the strings of the stack
      .ª            # And sentence capitalize every sentence
                    # (without disturbing existing uppercase letters)
                    # (after which the result is output implicitly)

See this 05AB1E tip of mine (sections How to use the dictionary? and How to compress large integers?) to understand why “‚µ stand€¾“ is "please stand up"; •AΘ¥в‚Y• is 11123023204234; and “ÿ ÿ ÿ.…Ü, ÿ€€ ÿ ÿ.\nAll€î€¶ ÿ ÿs€™‚‰ imitating.\nSo,¢²'t€€ ÿ ÿ ÿ ÿ?\nÿ. ÿ.“ is "ÿ ÿ ÿ. yes, ÿ the ÿ ÿ.\nAll you other ÿ ÿs are just imitating.\nSo, won't the ÿ ÿ ÿ ÿ?\nÿ. ÿ.".

authors: p̻̻̥r̥̻̥o̻j̤͛ec͔t̞dp

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


text:
Rank a list of scores with "skips"

Given a list of scores (non-negative integers) pre-sorted from greatest to least:
[ 10, 10, 6,  6,  4,  0]

Assign each score an integer rank, beginning with 1 and ascending, such that equal scores have the same rank (i.e. they are tied):
[ 1, 1, 3, 3, 5, 6 ]

In the case of ties, ranks are "skipped," e.g. since the first and second-greatest scores (10 and 10) are tied, they both have rank 1, and rank 2 is "skipped," so the third-greatest score (6) has rank 3.
Output a list of non-descending ranks corresponding to the input scores.
Examples
In:  10 10  6  6  4  0
Out:  1  1  3  3  5  6

In:  10  9  8
Out:  1  2  3

In:   0  0  0
Out:  1  1  1

In:  16 15 15 12 11 11 10  9  9  9  8  2  2  2  0
Out:  1  2  2  4  5  5  7  8  8  8 11 12 12 12 15

Input
Assume all scores will be between 0 and 1,000 inclusive, and the input will have no more than 500 scores. Input can be in whatever format is convenient for your language of choice (including but not limited to STDIN, arguments to a function, an array already stored in a variable, etc.).
Output
Return or store in a variable the resulting ordered list of ranks, or write it to STDOUT in a human-readable way (e.g. 1 2 3, [1,2,3], 1\n2\n3\n, and { 1, 2, 3 } are all fine; 123 is not, for want of a delimiter). The input scores may be stored/printed along with their corresponding output ranks, but that's not required.
Restrictions
You may use any standard library your language offers. Standard loopholes apply.
Winning conditions
This is code-golf, so the smallest program (in bytes) wins. In case of a tie, the answer with the most votes wins.
Notes
This is based on a Ruby question on SO that generated some interesting answers, including one very short one. I encourage you to come up with your own solutions before looking there.

I think this would be better, and illicit better answers, if it was not presorted, and the ranks needed to retain their original order. That is [10, 4, 6, 0, 6, 10] would be [1, 5, 3, 6, 3, 1]

That's a good point, @Cruncher; feel free to start a new thread.

J (7 6)
EDIT: Oh, wait! It doesn't need to be a function!
>:i.~y

Thank god for i.~...
>:@:i.~

Or as a named function (3 chars more, but not functionally different):
f=:>:@:i.~

Run tests:
   f=:>:@:i.~
   f 10 10  6  6  4  0
1 1 3 3 5 6
   f 10  9  8
1 2 3
   f 0  0  0
1 1 1
   f 16 15 15 12 11 11 10  9  9  9  8  2  2  2  0
1 2 2 4 5 5 7 8 8 8 11 12 12 12 15

Care to comment what this does?

1+i.~ is the kind of train that can be both assigned and used inline, so can be used as a function without its usual train parens. That's 5 chars. And for the record, @ does the same job as @: in this case, so you could've saved an easy character there.

T-SQL (40)
SELECT RANK()OVER(ORDER BY B DESC)
FROM @

Assume @ is a table containing the scores as rows.

Python (33 characters)
lambda x:[1+x.index(i)for i in x]

Functionally the same as my J answer.

Because input can be in the format of your choice, you can declare the array to be stored in x to begin with, and "output" it by storing the result in a variable.

Pyth, 6
m'XYdY

List is stored in Y to begin with. This is functionally the same as the 22 character ruby solution: map over d in Y to index of d in Y plus 1, then print.
Example:
$ echo "=Y[16 15 15 12 11 11 10 9 9 9 8 2 2 2 0)m'XYdY" | python3 pyth.py

[1, 2, 2, 4, 5, 5, 7, 8, 8, 8, 11, 12, 12, 12, 15]

APL, 2 bytes
⍳⍨

In ⎕IO←1. Dyadic iota searches its right argument into its left argument. The operator ⍨ copies the right argument to the left argument if the operand is used monadically. Hence the solution simply searches the position of each one of the elements of the vector given in itself.
Samples:
    ⍳⍨10 10 6  6  4  0
1 1 3 3 5 6
    ⍳⍨0  0  0
1 1 1
    ⍳⍨16 15 15 12 11 11 10  9  9  9  8  2  2  2  0
1 2 2 4 5 5 7 8 8 8 11 12 12 12 15

STATA (16)
egen b=rank(c),f

Result is in b.
Assumes c is a variable in the dataset containing the input.

Stata in code golf? This one really opens a can of worms.

Haskell (31)
f x=succ.(`elemIndexJust`x)<$>x -- Requires the Safe module

Usage:
f [10,10,6,6,4,0] --evaluates to [1,1,3,3,5,6]

my solution was r l=concat$tail$scanl(\s->map$const$length s+s!!0)[0]$group l with 61 characters

also, your first solution doesn't work because of monomorphism restriction

That darn momoprophism restriction... I got it to work in GHCI, but since it won't compile I guess I should remove it...

You could remake it so it would work

So as to establish a baseline:
Ruby (38)
Assuming a is an array:
r,i=1,0;a.map{|x|i+=1;x==a[i-2]?r:r=i}

(This is based on falsetru's answer on the original SO thread and isn't my original work. I know there's a Ruby solution that's 22 characters, but I'd like to see someone come up with one shorter than that in Ruby.)

JavaScript (E6) 41
A function with an array argument, returning an array
F=s=>s.map((n,i)=>p-n?(p=n,r=i+1):r,p=-1)

Test In Firefox console
F([10,10,6,6,4,0])

Output: [1, 1, 3, 3, 5, 6]
F([16, 15, 15, 12, 11, 11, 10, 9, 9, 9, 8, 2, 2, 2, 0])

Output: [1, 2, 2, 4, 5, 5, 7, 8, 8, 8, 11, 12, 12, 12, 15]

You can drop the F= for -2 bytes. Also save another 2 with s=>s.map((n,i)=>p-(p=n)?r=i+1:r,p=-1)

R, 15
with input stored as vector x,
rank(-x,T,"mi")

Powershell (70)
$n=1;$c=0;$l=$a[0];$a|%{if($l-eq$_){$n}else{$n=$c+1;$n}$l=$a[$c];$c++}

It's only 51 characters if you take out the variable assignments at the beginning, which makes me feel slightly less inadequate.
Assumes $a is assigned and sorted as specified by the problem. $n tracks rank, $c is just a counter which works with $l, the last element checked in the array.
If there's anything I can do to improve this, I'd love to know.

Java (57)
Using the same 'rules' as Allbeert:
Constant i is defined as int[] array and contains the input, z contains the size of the input. Others, l,c,x and n, are defined as int.
The left over snippet of code is:
l=0;c=1;for(x=0;x<z;x++){n=i[x];i[x]=n==l?c:(c=x+1);l=n;}

The result is in the input array.

Ruby, 22
I haven't looked at the SO thread but I imagine this is what they came up with.
a.map{|i|a.index(i)+1}

Edit: Yep, it is. I doubt it's possible to get smaller in Ruby, unless you assume you're defining it as an Array method, then you can do it in 18 characters with
map{|i|index(i)+1)

But of course the full program around that snippet looks like
class Array
  def ranks
    map{|i|index(i)+1)
  end
end

p [1, 2, 2, 4, 5, 5, 7, 8, 8, 8, 11, 12, 12, 12, 15].ranks

><> (47)
Not particularly optimized, just testing the water with my first golf.
r:1:nr2&>ao$:@=?vr~&:|
&1+&l3)?^;      >r:nr

Assumes that the input is prepopulated in the stack, such that the first element of the input is the first to be popped off.
Testing:
fish.py ranks.fish -v 1 2 3 4 5 6 7 8 9 9 10 10

outputs
1
1
3
3
5
6
7
8
9
10
11
12

"testing the water" in a fish submission made me smile

Clojure, 35
With some Java interop mixed in:
(fn[l](map #(+ 1(.indexOf l %)) l))

REPL session:
golf> ((fn[l](map #(+ 1(.indexOf l %)) l)) [10 10  6  6  4  0])
(1 1 3 3 5 6)
golf> ((fn[l](map #(+ 1(.indexOf l %)) l)) [16 15 15 12 11 11 10  9  9  9  8  2  2  2  0])
(1 2 2 4 5 5 7 8 8 8 11 12 12 12 15)

C - 62
As a code snippet, since there was no requirement for function or full program.
Assumes a, n, j, and k are already defined as int*, int, int, and int respectively, where a is an array containing the input, and n contains the length of the input.
This fails for input of length 0, in which case 3 more characters are needed.
printf("1");for(k=j=1;++j<=n;)printf(" %d",*a-*(a+++1)?k=j:k);

source: Stack Exchange

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

sort: votes


text:
Collatz Graph Plotting
Write a program that outputs a graph of the collatz sequence any way you want (ASCII Image Video etc). You have to implement it that way that you can adjust the size of the graph by either the maximum number of nodes or highest number in graph. A boring example here.
Try to present the graph in a creative / insightful way, this is a popularity contest!
Please comment your code / algorithm and post at least one example output in your answer.
Background: Collatz sequence
The Collatz sequence is defined for any natural number n > 0 by the recursion:

The Collatz conjecture states that the sequence ends in the cycle 1,4,2

Good luck with telling people when to vote. ;)

@MartinBüttner: I've got it now. I'm cleaning up comments now.

See also: http://martin-thoma.com/the-collatz-sequence/

Ruby (via ChunkyPNG)
I don't know if this is quite what you had in mind, but I had the idea to try this a while ago and hadn't gotten around to it. We create a row of random colors, then iteratively replace each color n with the color at collatz(n), or an empty pixel if greater than the max, until every sequence either escapes or converges. The result is that each pixel gradually propagates to the positions connected to it in the graph.
gem 'chunky_png'
require 'chunky_png'

def random_color
  ChunkyPNG::Color.rgba(*(1..3).map{rand(1..255)},255)
end

def collatz(n)
  n.even? ? n/2 : 3*n + 1
end

def collatz_grid(max)
  grid = []
  colors = (1..max).map { |i|  random_color  }
  collatz_steps = (1..max).map { |n| collatz(n) }
  overflow = ChunkyPNG::Color::TRANSPARENT
  while colors.uniq.count > 4
    grid << colors
    colors = collatz_steps.map { |i| colors[i-1] || overflow }
  end

  img = ChunkyPNG::Image.new(max, grid.size, ChunkyPNG::Color::TRANSPARENT)
  max.times do |x|
    grid.size.times do |y|
      img[x,y] = grid[y][x]
    end
  end
  img.save("collatz#{max}.png")
end

Images below, suggest opening them in a new window and zooming in.
collatz_grid(100):

collatz_grid(10000):

Python+Graphviz
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import networkx as nx
import os

"""Tool to generate collatz sequence graphs."""

def collatz_one(x):
    """Make a single step in the collatz sequence."""
    if x % 2 == 0:
        x = x/2
    else:
        x = 3*x + 1
    return x

def main(max_collatz=20):
    """Create the collatz graph. """
    G = nx.DiGraph()
    seen = [1]
    G.add_node("1")
    edges = []

    for i in range(1, max_collatz):
        while i != 1:
            if i not in seen:
                seen.append(i)
                G.add_node(str(i))
                j = collatz_one(i)
                edges.append((str(i), str(j)))
                i = j
            else:
                i = 1

    for i, j in edges:
        G.add_edge(i, j)
    nx.write_dot(G, 'test.dot')
    os.system("dot -Tpng test.dot -o test.png")

if __name__ == '__main__':
    from argparse import ArgumentParser
    parser = ArgumentParser(description=__doc__)
    parser.add_argument("-m", dest="m",
                        help=("The first 1..m elements are guaranteed "
                              "to be included"),
                        default=20,
                        type=int)

    args = parser.parse_args()
    main(args.m)

Image
Created with dot and m=20:

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


text:
Program your favorite phrase
Pick a quote or phrase that is exactly 5 words long, such as Programming puzzles and code golf!.
Write a program that, when appended to itself n times, outputs the first n + 1 words of your phrase in order.
For example, if your program code was MYPROG and your phrase was Programming puzzles and code golf!, running...

MYPROG should output Programming
MYPROGMYPROG should output Programming puzzles
MYPROGMYPROGMYPROG should output Programming puzzles and
MYPROGMYPROGMYPROGMYPROG should output Programming puzzles and code
MYPROGMYPROGMYPROGMYPROGMYPROG should output Programming puzzles and code golf!

Appending more than 4 times is undefined, your program may do anything.
Rules

Your phrase must be grammatical meaningful English. Ideally it should be properly capitalized and punctuated.
Your phrase may be any length but its entropy, as calculated by http://www.shannonentropy.netmark.pl/, may not be less than 3.5.
(Paste in your phrase, hit Calculate and look for the last H(X).)
Your phrase can only contain printable ASCII characters (hex 20 to 7E). Your code can only contain printable ASCII and tabs and newlines.
Your phrase must contain exactly 5 unique words and 4 spaces. All non-spaces count as parts of words. Spaces are the word boundaries. They may not be leading or trailing; there should be one after all but the last word.
The output should contain one space between words as well. The output at each appending step may contain trailing spaces but not leading spaces.
Output to stdout. There is no input.

Scoring
Your score is the length in bytes of your initial un-appended program. (e.g. MYPROG scores 6)
As this is code-golf, the lowest score wins.

aww, the entropy and uniqueness requirements kill my idea of "buffalo " as an entry.

I was going to have so much fun in Piet until "Your code can only contain printable ASCII and tabs and newlines." :(

@Sp3000 You're welcome to put in an honorary answer. I'd love to see a Piet solution :)

grammatical meaningful English Too unclear what is "grammatical meaningful English" due to different interpretations of grammatical and meaningful.

CJam - 24
"TheguywasnotI"Lm3<]S*:L

Try it at http://cjam.aditsu.net/
Explanation:
Lm removes the letters contained in L (initially "") from "TheguywasnotI"
3< takes the first 3 letters
] collects the contents of the stack in an array
S* joins the array using space as a separator
:L assigns the resulting string to L (also leaving it on the stack)
Old version (28 bytes):
"He is but a dog."S/W):W=]S*

Explanation:
S/ splits by space
W):W increments W (initially W = -1)
= gets the W'th word
] collects the contents of the stack in an array
S* joins the array using space as a separator

This language is really interesting. Like they say, "You learn about a new language every day"...or something like that. Good work!

Accepting this instead of Dennis' equally short answer as this was posted first.

Piet (honorary answer)

Snakes its way downwards, running out the right through blue and re-entering through green. Prints out "Fruit flies like a banana."
I used PietCreator to make this, but you can try it out here. Remaking Piet programs is a pain, so I started out at 35x35 and continued that way, meaning that I used a lot more codels than I needed.
Actual size versions

Python 66
i='i'in dir()and i+1;print("Tfpcfhaialetgny"[i::5],end=" ."[i>3]);

Entropy: 3.61635
Ouput:
The fat pig can fly.

Thanks @JasonS and @grc for the tips on shortening the variable detection part.
Update: Do see JasonS' answer for a wicked wraparound trick which pushed this down to 55 bytes.  :)

i=locals().get('i',-1)+1; is -5 bytes

Beat me to it! I was going to use i='i'in dir()and i+1. Edit: rules changed.

Well, that is another -4

60 bytes with Python 2: i='i'in dir()and i+1;print"Tfpcfhaialetgny"[i::5]+" ."[i>3],

><> (42)
Fish are truly the greatest pet. Some people keep bugs as pets due to an incomprehensible lack of logic. This program does its best to reason with such people.
!v'?od gub yna nac tahW;'00p!
<<|ov!
voo <

Note there this is no trailing newline in the program. The full output is reversed in the first line; the complete phrase is "What can any bug do?" (entropy 3.58418).
Full explanation:
This is one of the more fun ><> programs I've written, since this is the first that uses reflection. The first line is where the meat of the program is.
!v is a no-op, as ! causes the next instruction to be skipped.
'?od gub yna nac tahW;' stores the full phrase on the stack (it's backwards because each letter is pushed onto the stack in the order written, so it must be reversed to be popped off nicely).
00p is where the real magic starts happening. Note that it didn't just store the phrase, it also stored a ;. 00p inserts the top character onto the stack into the program at position (0, 0), so now the first character of the program is a ;.
The ending ! skips that semicolon, and moves the cursor onto v, which directs the program flow downwards.
From here on out, it's all just printing routines. Since there's no trailing newline, successive appendings of the program simply add the last two lines, in effect, since the first line will be to the right of voo <, and thus will never be executed.
At the end, the cursor is directed out the bottom left of the program, and wraps back around to the top left, where the ; was inserted earlier, ending the program.

A minute ago this was technically invalid but I've just change the spec so that newlines (and tabs) are allowed in the code (which is what I wanted originally).

Oh, my bad, totally missed that that applied to the source, not just the phrase. I'm glad that was the intent, ><> programs rely on newlines fairly heavily.

If you want to golf this down a bit, you could use a  phrase with 11 letters and no repeated characters, such as "It is by a rope." Your phrase repeats characters, so it has lower entropy than it could.

Problem is that each output basically has to be the same length to print nicely, since ><> can't detect spaces easily. I haven't been able to find a shorter one.

@isaacg Personally I prefer Mike's phrase ;)

Python 3, 55 (bonus 67)
# 55 bytes, H(X)=3.72, Based on bitpwner's 66. "Mix dog and cat fur."
i=0;print("Mdacfionauxgdtr"[i::5],end=" ."[i>3]);i+=1;i

# 67 bytes, H(X)=4.28. "Thanks for supporting Python development."
q=b"qx!%%0077C";a,b,*q=q;print((str(credits)*2)[49:][a:b],end='');q

# 60 bytes, H(X) = 3.51. "Fix the bed old pal"
s="Fixthebedoldpal";a,b,c,*s=s;print(a+b+c,end='. '[s>[]]);s

You mean it wraps around?
OK, some explanation on #2 (spoilers)

credits is a python builtin that contains text I'd like to use. It's of a special type with a formatted repr so that you can just type it in the interactive interpreter and see nice output, so I have to str() it. I spent quite a bit of time looking at builtins for this, and "Thanks for supporting Python development" as a phrase was too good to pass up.
Since there's a lot of text and I only want my 5 words, I want to store the start and end positions of each substring. That's in the bytes at the beginning. bytes objects in python3 act like arrays of integers when you use sequence operations on them.
But the code can contain only printable characters, so I had to find an offset (49) that would make all my position values printable as characters.
"Thanks" is near the beginning of the string while the other words are nearer the end, which means my position values were too far apart to all be in the printable range. Mulitplying the string by 2 makes another copy of "Thanks" that is nearer to the other words.
Taking the [49:] slice of the string is one fewer source byte than adding 49 to both a and b.
The construct used in all three answers is x=<value>;dostuff and increment;x. The trailing x doesn't do anything at all, but when combined with the next copy of the code it turns into xx=<value> which prevents the x counter from being overwritten.
a,b,*q=q is perfectly normal Python 3 sequence unpacking.

+1. Wicked trick. :) Can I update it to my answer?

Well, I used your middle

I am currently marveling at your 2nd answer. So many tricks packed into it.

Can you please tell me, how the second answer work?

Python 2 (37)
After Sarah became president of her local Mensa chapter, she became a focus of romantic attention from men looking for an intelligent partner. On every date, Sarah would try to make a personal connection, but the men would just probe her on abstruse philosophical questions. Frustrated that nobody cared about her emotional side, she exclaimed ...
i=4;print"mniIMeosQy!t"[i::5],;i-=1;i

Output:
My
My IQ
My IQ is
My IQ is not
My IQ is not me!

The entropy is H(x)=3.5 exactly.
Credit to Jason S., whose answer I basically used wholesale. The ii wraparound trick is wonderful.

Nice! Props for finding a shorter phrase with the right entropy. I gave up. Also forgot that py2 print prepends spaces rather than appending them

This is amazingly short for a Python answer! Well done.

You can remove the comma that you have in the middle of your program to drop down to 36 chars.

C - 65
Comment abuse :)
char*z="Ah, \0the \0good \0ol' \0times!";
for(printf(z);*z++;);//

Because of this, the new lines are important and the code should be appended as follows:
char *z="Ah, \0the \0good \0ol' \0times!";
for(printf(z);*z++;);//char *z="Ah, \0the \0good \0ol' \0times!";
for(printf(z);*z++;);//...

This is a nice solution!

BBC Basic, 40
Includes one newline. Would be 30 if the keywords could be considered as tokenised instead of ASCII.
I caught my girlfriend sleeping with the milkman, so I dumped her and I am sleeping with her sister out of revenge. As my ex do I! (five two-letter "words" with unique characters) wasn't enough entropy, so I added the tongue-out smiley at the end to make the entropy exactly 3.5. After all, in reality I have a fairly normal life, not some weird soap opera plot.
  READa$:PRINTa$;" ";
  DATAAs,my,ex,do,I:-P

Repeating the program 5 times we get
  READa$:PRINTa$;" ";
  DATAAs,my,ex,do,I:-P
  READa$:PRINTa$;" ";
  DATAAs,my,ex,do,I:-P
  READa$:PRINTa$;" ";
  DATAAs,my,ex,do,I:-P
  READa$:PRINTa$;" ";
  DATAAs,my,ex,do,I:-P
  READa$:PRINTa$;" ";
  DATAAs,my,ex,do,I:-P

Only the 5 READ statements are executed, and the first 5 items of data are read from the first DATA statement. the rest of the data is redundant. Output:
  (once)
  As
  (5 times)
  As my ex do I:-P

J - 42 char
I could go for a shorter phrase, but why? It wouldn't be my favourite.
(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '

This works because of J's monad/dyad duality: every verb can be invoked as a monad—with one argument to its right—or as a dyad—with an argument on the left and another on the right.
Consider the following session with the J REPL:
   'You multiplied 6 by 9. '
You multiplied 6 by 9.
   'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. '
You multiplied 6 by 9. You multiplied 6 by 9.
   ;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. '   NB. break into words
+---+----------+-+--+--+---+----------+-+--+--+
|You|multiplied|6|by|9.|You|multiplied|6|by|9.|
+---+----------+-+--+--+---+----------+-+--+--+
   (#\) ;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. '             NB. count off
1 2 3 4 5 6 7 8 9 10
   (6 | #\) ;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. '         NB. mod 6
1 2 3 4 5 0 1 2 3 4
   (1 = 6 | #\) ;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. '
1 0 0 0 0 0 1 0 0 0
   (#~ 1 = 6 | #\) ;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. '  NB. select
+---+----------+
|You|multiplied|
+---+----------+
   (#~ 1 = 6 | #\)&.;: 'You multiplied 6 by 9. ' , 'You multiplied 6 by 9. ' NB. undo ;:
You multiplied

There, , is treated as a dyad, because it is between two arguments, and (#~1=6|#\)&.;: is a monad because it has no left argument. So if we had a verb that could act like , when dyadic and (#~1=6|#\)&.;: when monadic, we'd be set.
As you may have already guessed, such a conjunction exists and it looks like :. Monadic f :g is equivalent to f, and it is equivalent to g when dyadic. This solves the problem.
Examples, which you can try for yourself at tryj.tk:
   (#~1=6|#\)&.;: :,'You multiplied 6 by 9. '
You
   (#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '
You multiplied
   (#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '
You multiplied 6
   (#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '
You multiplied 6 by
   (#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '(#~1=6|#\)&.;: :,'You multiplied 6 by 9. '
You multiplied 6 by 9.

And yes, the nature of the inverse of ;: makes it so that there are no trailing spaces.
Using It is by a rope. as the phrase gives 35 char: (#~1=6|#\)&.;: :,'It is by a rope.'. We don't need the trailing space like we do for my sentence, for arcane, ;:-based reasons.

CJam, 24 bytes
"LwOtmiaKoezs"W):W>5%]S*

If run five times, it prints Liz was OK to me. Punctuation not included, sorry.
How it works
"LwOtmiaKoezs"  " Push that string. ";
W):W            " Push W (initially -1), increment and save the result in W. ";
>               " Shift that many characters from the string. ";
5%              " Select every fifth character, starting with the first. ";
]S*             " Wrap the stack in an array and join its strings using spaces. ";

Cool idea, although the phrase is kinda weak :p

I admit to that, but it had to be xxx xxx xx xx xx, without repeated letters. That's the only sentence I could come up with that made at least a little sense...

How about "Sun was OK to me"? You can also replace "Sun" with another word or name.

That's better, thanks.

Pyth, 32
p?kqZ4d@P"It is by a rope."dZ~Z1

Phrase: "It is by a rope."
Entropy: 3.5
How it works:
p means print with specified separator.
The first argument, ?kqZ4d, gives the separator. ?kqZ4d means k if Z==4 else d. k is '', while d is ' '.
The second argument, the value to be printed, is generated by splitting (P) on space (d), and the indexing into that list (@) at Z.
Finally, Z, which is automatically initialized to 0, is incremented by 1 (~Z1).

I could not think of a context where this phase would naturally fit in^^

@flawr "Where did I live the ball?" "It is by a rope."

Golfscript, 53
This one was fun.
{'1'-print}:puts;.'You; are; not; a; duck.'';'/\,=\1+

Phrase: "You are not a duck." (which is completely true; entropy 3.5110854081804286)
Explanation:
The stack will start as '' on the first "run" (since no STDIN is provided). '1's are appended to this to signify how many times the code has been pasted in.
{'1'-print}:puts;             # Hacky stuff (see below)
.                             # Stack: '' ''
'You; are; not; a; duck.'';'/ # Initialize the array of words
\,                            # Get the length of the string of '1's (0)
                              # Stack: '' [words] 0
=                             # Stack: '' 'You'
\1+                           # Stack: 'You' '1'

Now what happens on the second run:
{'1'-print}:puts;             # Hacky stuff (see below)
.                             # Stack: 'You' '1' '1'
'You; are; not; a; duck.'';'/ # Initialize the array of words
\,                            # Get the length of the string of '1's (1)
                              # Stack: 'You' '1' [words] 1
=                             # Stack: 'You' '1' ' are'
\1+                           # Stack: 'You' ' are' '11'

And so on.
"But," you're thinking, "how do you get the 1s to not output?" Ah, that's the fun hacky part. Golfscript implements puts (which is called when the program ends) like this:
{print n print}:puts;

I simply changed it to
{'1'-print}:puts;

So that the 1s are suppressed from the final output.

Ruby, 50
puts'The fat pig can fly.'[0..File.size($0)/12-1]#

This uses its own length to determine how many of the words to print. Its repeats are otherwise ignored by ending in the comment character, #. Phrase borrowed from bitpwner: it's very convenient having a short phrase with the same number of letters in each word.
Since each word+ending is 4 characters, the formula would be, e.g. for 56-length program: (File.size($0)/56)*4 - 1, but I can divide ahead of time, 56/4 = 14, so File.size($0)/14 - 1, saving a few characters. 50 isn't a multiple of 4, but 12 is close enough for the range needed.

Chip, 165+3 = 168 bytes
+3 for flag -w
| ,z `Z`Z  `Z
| |ZZZ>Z>ZZZ>ZZZZ
>((((((((((((((((
|)-)))-)-)))-))))g
|)d)xx-x-)xx-))x)e
||b+))-x-x))-x)xc
|`v))xa(-x(x-((^d
|*`.))d| b | b
|Z~<b( |~Zf|
>~T| | |   |

"I won a red suit" (3.5) (I actually haven't won any such thing) (...yet)
Note the trailing newline, so the concatenated copy appears below the existing code.
Try it online! (the original)
Try it online! (the original, plus all four copies)
This is a bit of a tangled mess. It turned out that the trickiest bit was the termination condition. (My first iteration printed the word(s), followed by an endless stream of null bytes...).
How it works
First the phrase:
12 unique characters + 4 spaces = exactly 3.5 entropies.
And the code:
Each copy prints the first word, then tells the copy below to print the next word. If there is only one instance, there is no second copy, so nothing except the first word is printed.
If there are two copies, both will print the first word simultaneously (the bytes are OR'd together so it's fine), then only the second copy will print the second word.
If all five copies are present, all will print the first word, etc, etc, and the fifth copy will print the last word by itself.
The termination circuit will terminate the program as soon as all copies are not actively printing.

Ruby, 63
+1;puts"See Dick and Jane run!"[/(.*?( |!)){#$.}/]if($.+=1)==$.

Perl, 37
print qw(My IQ is not me!)[$i++].' ';

Similar to what comperendinous had, but taking advantage of perl's qw to save a few more characters.

Rebmu message length + 27
Were we to go with "My IQ is not me!" that would be 43.  But I support this message:
uV?'s[S[{The}{rebellion}{against}{software}{complexity.}]]proTKsPROsp

Equivalent Rebol/Red:
unless value? 's [
    s: [{The}{rebellion}{against}{software}{complexity.}]
]

print/only take s
print/only space

Rebol has 3 basic conditionals: IF, EITHER, and UNLESS.  UNLESS is equivalent to IF NOT but can be more clear: "Always do the following UNLESS this condition happens to be true."
In this case the condition is that we test is to see if the symbol S has been given a value in the current context.  We have to use a quote on it, because attempting to use an unquoted S in a conditional expression would evaluate it and possibly raise an error.  (value? doesn't quote its parameter by default because you might want to have which symbol you are checking be in a variable, e.g. sym: 's then if value? sym [...] would actually check if S was defined, not SYM)
Only the first paste of the program will assign the series of strings to S.  Successive pastes will take a string from the head of the series and pass it to PRINT/ONLY which will print its argument without adding a line feed.
(Note: PRINT/ONLY is a suggested replacement way of saying PRIN, which is being considered in Rebol 3 and Red; a print replacement is now being tested in Rebmu.)

AHK, 44 bytes
i++
Send % SubStr("He is an OK ex",i*3-2,3)

Note the newline at the end. The only clever thing here is that the string is all 3-letter words so we don't have to split anything. Instead, we just pull a substring based on i. Output is to the active screen as if it was typed on the keyboard.

Pxem, 0 bytes: content + 170 bytes: filename.
H(X) = 3.57662

Filename: .o.c.c.zXXOnepigcannotfly.a.o.o.o
Content is empty.

Try it online!
How it works

First .o pops to output, if any
.c.c.zXXOnepigcannotfly.a is done if and only if stack is empty.
.o.o.o to pop top three to output.
A space at last to push a space.

Batch 160 bytes
H(X) = 3.61437
@Set s=Get out by Six pm.
@Set/ai+=0&Set "n=0"&Set "_=%s: ="&Cmd/Von/C "if !n!==!i! Echo(!_!"&Set/An+=1&Cmd/Von/C"if !n!!i!==44 Echo(pm."&Set "_=%"
@Set/ai+=1

Split string on  whitespace  , match split instance count n with execution instance count i to output word.
As a result of substring parsing, the 5th instance will never match during substring modification, so a 0 index is used and the final 'word' of the phrase is output on the 5 instance by matching i = n = 4.

Note: requires a fresh cmd instance to execute between runs when appending the code, as otherwise variable values will persist and affect the output - Alternately, execute the following command in cmd.exe to reset the variables: set /a i=n=0

Japt -S, 17 bytes
Includes unprintables between the backticks.
`âK0dÊŠ…`ò3 ¯°T)

Test it, repeated 5 times
`...`ò3 ¯°T)
`...`            :Compressed string "thecatandhishat"
     ò3          :Partitions of length 3
        ¯        :Slice from index 0 to
         °T      :  Prefix increment T, initially 0
           )     :End slice
                 :Implicit output joined with spaces

Perl, 43 56
print substr'Mine was not Red 5!',4*$i++,4;

I accept that I can't win this one. My original attempt explains why:

@a=('This',' code',' is',' too',' long.');print$a[$i++];

Javascript (53)
I took the text from aditsu as I'm not doing anything fancy with the text, so that the words chosen are somewhat irrelevant for the solution (except for byte count).
var i=i|0;alert("He 0is 0but 0a 0dog".split(0)[i++]);

Does alert count in this case? Edit: Reading the rules it probably doesn't as I'm not joining the strings with spaces. I'll add spaces to make it fair.
Also note that the expensive var is actually relevant in this case.

Can anyone explain why var i|=0; does NOT work here???

@flawr You can't do |= or similar with var. Without var, you get a ReferenceError: i is not defined. var i=i|0 expands to var i=undefined|0, and undefined|0 is apparently 0.

This works because of hoisting. var i=i|0 is equivalent to var i;i=i|0. That's why you don't get the reference error. The reason it will be set to 0 the first time is what @nyuszika7h said.

But this will alert the words separately.

Lua, 77
A pretty simple solution:

i=(i or 0)+1;io.write((i==1 and""or" ")..("Thebigfoxwasup."):sub(3*i-2,3*i))

(H(X)=4.23)

Javascript, 138
g=this;clearTimeout(g.t);g.i|=0;i++;g.t=setTimeout(
    function(){console.log(["I'll","sleep","when","I'm","dead."].slice(0,i).join(' '))},0);

(the additional newline is added for readability only)
Prints I'll sleep when I'm dead. Uses a timer to make sure the output is only printed once

Pure Bash, 51 bytes
a=(All you need is Love!)
printf "${i:+ }${a[i++]}"

H(X) = 3.59447
This could be golfed down a bit more by poaching one of the shorter phrases, but I'm happy to stick with Descartes' Lennon's most famous quote.  (Sorry @Descartes, but all words need to be unique).
Output:
$ ./phrase.sh
All$ cat phrase.sh phrase.sh phrase.sh > phrase3.sh
$ chmod +x phrase3.sh
$ ./phrase3.sh
All you need$
$ cat phrase.sh phrase.sh phrase.sh phrase.sh phrase.sh > phrase.sh
$ chmod +x phrase5.sh
$ ./phrase5.sh
All you need is Love!$

Takes care to insert spaces between words, but no leading or trailing spaces.
Relies on the fact that in bash, undefined variables, when expanded as strings have the value "", but when expanded arithmetically have the value 0.

The 5 words are required to be unique...

Since your code seems versatile enough to deal with any 5 word phrase, I'm sure you can think of one that has the required entropy of 3.5 (too many double letters in this one...).

@githubphagocyte I was hoping you'd give me the benifit of rounding ;-)  Ok, I've fixed it with an extra ! now - seems to do the trick.

PHP 89 78 char
Its a little verbose, and most definitely won't win, but it was fun anyway. Here's what I came up with
Phrase:
code golf is pretty fun
Entropy = 3.82791
Code:
<?
$i=(isset($i)?$i+1:0);
$w=["code","golf","is","really","fun"];
echo $w[$i].";

Golfed:
<?$i=(isset($i)?$i+1:0);$w=["code","golf","is","really","fun"];echo $w[$i].

Python3  - 122 bytes
Open the pod bay doors [HAL]
I guess I'll earn some nerd cred with this one. If only the question would allow one more word...
What my program does is takes the filename (p.py is the base) and checks how many times the base name is iterated. It then takes slices from a string n times. n being the number of ps in the filename.
import sys,re
for i in range(len(re.findall(re.compile('p'),sys.argv[0]))):print('Otpbdphoaoeedyon   r    s'[i::5],end='')

~ $ python p.py
Open

~ $ python pp.py
Open the

~ $ python ppp.py
Open the pod

~ $ python pppp.py
Open the pod bay

~ $ python ppppp.py
Open the pod bay doors

The benefit of the regex is that the program can be called whatever you like and it will still work (providing you change the basename in the code): my original program was called golfed.py.

05AB1E, 21 bytes (Noncompeting)
“€Œ‰‹€‡Øš‹É.“ª#¾è¼?ð?

Try it online!
Uses:
This works for literally anything.
H(x) = 4.02086

Explanation
“€Œ‰‹€‡Øš‹É.“ª#¾è¼?ð?
“€Œ‰‹€‡Øš‹É.“ª        # Pushes "This works for literally anything."
              #       # Split on spaces
               ¾è     # get element at index of counter_variable (default 0)
                 ¼    # Increment the counter_variable
                  ?   # Print the selected element
                   ð? # Prints a space

Didn't see this, posted near the same with “€í€Ü€…‚¿‹·“ hehe

SmileBASIC, 54 bytes
DATA"Does"," anybody"," have"," a"," key?
READ W$?W$;

I would've prefered "The sand can be eaten." but that fails the entropy test somehow.
Of course I could've picked a shorter phrase but that's boring.
The READ keyword reads a value from DATA and stores it in a variable. Using READ again will get the next item, and so on.

Stax, 24
`nH+~mJp@Z_Iy.5!`j|d:/dJ

Run and debug it
Quote: Some animals are more equal.

Quote is from Animal Farm:
“All animals are equal, but some are more equal than others.”

Pyth, 27 bytes
p+@c"Andso,themanis."3Zd=hZ

Once, twice, thrice, four times, and five times. Appending after this begins to repeat the phrase.

Vyxal ṡ, 18 bytes
`λλ⇩İλ¬×ḟɾ∷`3ẇ¥i&›

Try it Online!
Try it Online!Try it Online!
Try it Online!Try it Online!Try it Online!Try it Online!Try it Online!
`λλ⇩İλ¬×ḟɾ∷`       # `thecogandFunJoe`
            3ẇ     # Split into chunks of 3
              ¥i   # Index the register into this
                &› # Increment the register
                   # (ṡ flag) print stack  joined on spaces