text:
Fast inverse square root
Inspired by http://meta.codegolf.stackexchange.com/questions/547/write-a-code-golf-problem-in-which-script-languages-are-at-a-major-disadvantage question on meta, I've decided to make a question which could be problematic for scripting languages.
The goal is to calculate fast inverse square root, just like it was done in Quake III Arena. You will get the floating point number as first argument after program name and you should implement it. Simply doing ** -0.5 is disallowed as it doesn't implement the algorithm.
Your program will be called like this. The 12.34 could be other value.
$ interpreter program 12.34 # for interpreted languages
$ ./a.out 12.34 # for compiled languages

For comparison, this is original Quake III Arena implementation.
float Q_rsqrt( float number )
{
        long i;
        float x2, y;
        const float threehalfs = 1.5F;

        x2 = number * 0.5F;
        y = number;
        i = * ( long * ) &y;                       // evil floating point bit level hacking
        i = 0x5f3759df - ( i >> 1 );               // what the heck?
        y = * ( float * ) &i;
        y = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
//      y = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

        return y;
}

You have to do just one iteration because the second was commented out.
Winning condition: Shortest code.

can you clarify what is meant by You will get the floating point number as first argument after program name and you should implement it. ?

What is 0x5f3759df supposed to be in decimal?

@beary605: the value is discussed pretty extensively on the wikipedia article

@ardnew: Clarified that by examples of calling the program.

I remember this number. First time I saw this, I was amazed. Wasn't it Michael Abrash's discovery?

Curious fact: Till now, the scripting language answers (Tcl, Perl, Julia) beaten all non-scripting ones!

what if the language doesn't work on the IEEE model? You should clarify it.

Perl, 89 85 chars
includes the necessary symbols for declaring and implementing a function
edit: standalone program. receives input parameter as command line argument
$_=unpack'f',pack'i',0x5f3759df-unpack('i',pack'f',$n=shift)/2;
print$_*1.5-$n/2*$_**3

Jelly, 41 bytes
l2Ḟ©.*×+®µ23 .*×“9®ġ’_Hµ‘_Ḟ×Ḟ2*$$µ²×³3_×H

Try it online!
I know this challenge was designed in the hope that golfing languages would have a hard time. In a way, they do; Jelly doesn't have any primitives for looking at the representation of a floating point number in memory. However, it's still possible to solve the challenge via working out "manually" what the representation would look like using the basic definitions of floating point arithmetic, and in fact there's some amount of mathematical interest in doing things "the hard way". Jelly's so much terser than (say) C, that the fact it has to do more work doesn't prevent the program being considerably shorter.
Explanation
The input is a floating-point number, as a number.
In order to run the fast inverse square root algorithm, we need to find how it would be represented in memory.
Jelly doesn't have a way to do that by looking at the bit pattern, but we can do it arithmetically.
First, note that the input must be positive (or its inverse square root would be undefined). As such, it's laid out in memory as follows, from most to least significant:

A zero bit (the sign bit, zero means nonnegative so this will always be zero);
The exponent (dividing the number by 2 to the power of the exponent scales it into the range 1 to 2), represented in 8 bits as its value minus 127;
The mantissa (the result of the above division), represented in 23 bits via subtracting 1, then multiplying by 223.

The results of each of these calculations can be represented directly in Jelly. As such, we could generate the same output as C's convert-float-to-int memory hack does like this:

Calculate the exponent
Calculate the mantissa
Take ((exponent + 127) × 223) + (mantissa × 223 - 1)

However, the last expression shown here simplifies to the following rather simpler form:

223 × (exponent + mantissa + 126)
alternatively, 8388608 × (exponent + mantissa) + 1056964608 (the result of multiplying the above out)

Let's call the exponent + mantissa of the input floating point number em for short.
(The exponent + mantissa of a floating point number uniquely defines it.)
In other words, after the // evil floating point bit level hacking comment, the C program is currently working with i = 8388608 × em + 1056964608.
The next steps in the C program are to halve i, and subtract it from 0x5f3759df (which, in decimal, is 1597463007).
i is (8388608 × em + 1056964608); halving it gives (4194304 × em + 528482304); the subtraction gives (1068980703 - 4194304 × em).
Then, C convert this number back to a floating point number y. Let's call the exponent + mantissa of y em'.
What the C program is therefore effectively doing in the floating point representational hacking is solving the following equation:

(1068980703 - 4194304 × em) = (8388608 × em' + 1056964608), which simplifies to:
12016095 = 4194304 × em + 8388608 × em'
em' = (12016095 - 4194304 × em) ÷ 8388608 = (12016095 × 2-23) - em / 2

Now, to convert this into Jelly. We have a nice arithmetic definition of em and of em', so we can translate it directly. First, here's how to calculate em:
l2Ḟ©.*×+®
l2                 Logarithm of the input, base 2
  Ḟ                Round down to the integer below (produces the exponent)
   ©               Store the exponent in a variable
    .*             Take (½ to the power of the exponent)
      ×            Multiply by {the original value, by default}
       +®          Add the value of the variable (i.e. the exponent)

The original value multiplied by ½ to the power of the exponent is equal to the original value divided by 2 to the power of the exponent, i.e. the mantissa, so this is em.
Getting em' is very straightforward from here, if we want it. However, we're going to need to convert the exponent+mantissa format back into a floating point number.
This can be done unambiguously (the exponent's always an integer, the mantissa runs from 1 inclusive to 2 exclusive).
However, to extract the exponent, we're going to want to floor and subtract 1. As such, it's actually shorter to generate em' -1.

em' = (12016095 × 2-23) - em / 2, so
em'-1 = (3627487 × 2-23) - em / 2

We can encode this formula in Jelly directly:
µ23 .*×“9®ġ’_H
µ                  set this point as the new default for missing arguments
 23                restart with 23
    .*             ½ to the power of that (i.e. 2 to the power -23)
      ×            times
       “9®ġ’       3627487 (compressed representation)
            _H     minus half {the value as of the last µ command}

Incidentally, we need the space because 23. is a single token in Jelly (which evaluates to 23½).
The next step is to convert from em'-1 to an actual floating point number y. We can extract the exponent using Ḟ; then the mantissa is em'-1 + 1 - the exponent.
To produce the floating point number, we want to calculate mantissa × 2exponent:
µ‘_Ḟ×Ḟ2*$$
µ                  set this point as the new default for missing arguments
 ‘                 increment (producing em'-1 + 1)
  _Ḟ               subtract the exponent (producing the mantissa)
    ×              multiply by
     Ḟ2*           2 to the power of the exponent
        $$         parse the previous three links as a group

Finally, we just need to handle the line marked // 1st iteration.
This is just regular arithmetic, so encodes into Jelly really easily.
The formula is:

y × (1.5 - (x2 × y²)), where x2 is half the original input; this is shorter to express as
y ÷ 2 × (3 - (x × y²)), where x is the original input.

And here's how it looks in Jelly:
µ²×³3_×H
µ                  set this point as the new default for missing arguments
 ²                 square
  ×³               multiply (×) by the original input (³)
    3_             subtract (_) from 3
      ×H           multiply by half {the value as of the last µ command}

Verification
Running this program on the input 2 produces the output 0.7069300386983334. This is the same value (allowing for differences in the float-to-string conversion) as produced by this VBA answer, and not equal to the mathematically correct value for 2-0.5.

FORTRAN, 124 113 Chars
saved 11 Bytes thanks to rafa11111
I know that this question is rather old, but it deserves a FORTRAN answer. It cannot outgolf Perl or Jelly, but it is at least not the worst.
character*9 c
equivalence(r,i)
call getarg(1,c)
read(c,*)y
r=y
i=Z'5f3759df'-ishft(i,-1)
print*,r/2*(3-y*r*r)
end

The hardest thing is to get command line arguments into FORTAN. Fortunately there is getarg() as alias for get_command_argument(). Note the use of an equivalence statement to avoid type casting. r and i are simply the same bytes but can be addressed as different datatypes. Since FORTRAN pointers cannot be casted into another datatypes like in C this is the way to go in FORTRAN.

Welcome to the site!

You can suppress the first line, since, as there is no module being declared in the same source code, to define a 'program' is irrelevant. In the line before 'end' you can change '.5*' for '/2'. It saves 11 bytes ;)

The people upvoting the Fortran answer are the ones who came looking not for code golf, but for a fast inverse square root routine. ;-)

vba, 171
Type x
q As Long
End Type
Type z
w As Single
End Type
Function q(n)
Dim i As x,y As z
x=n/2
y.w=n
LSet i=y
i.q=&H5F3759DF-i.q/2
LSet y=i
q=y.w*(1.5-x*y.w*y.w)
End Function

finding a way to do the pointer cast was the hardest part. unfortunately, as there is no real direct way, I had to define my own type, which added to the length of the program
call from the immediate window with ?q(number)
result:

?2^-0.5
   0.707106781186548
  ?q(2)
   0.706930038698333

+1 for the ridiculosity of using a BASIC dialect to golf a performance-related problem.

Smaller solution: Type x:q&:End Type:Type z:w As Single:End Type:Function q(n):Dim i As x,y As z:x=n/2:y.w=n:LSet i=y:i.q=&H5F3759DF-i.q/2:LSet y=i:q=y.w*(1.5-x*y.w*y.w):End Function

@toothbrush, symbol for single is !. If I try either type declaration change in Excel, I get an error: Compile Error: Statement invalid inside Type block

Portable C99, 114 bytes
float g(f,t,e)float f,t;{t=1.93243-frexp(f,&e);t-=.5*(e&1);t=ldexp(t+(t<1),-(e>>1)-(t<1));return(1.5-.5*f*t*t)*t;}

Try it online!
A solution in a more portable subset of C99. Uses frexp and ldexp from math.h instead of bit twiddling. Has very slight rounding errors. Here's a documented version that should be exact:
float my_rsqrt(float f) {
    int e;
    float r = frexp(f, &e);

    // Subtract from magic mantissa.
    int prev_mode = fegetround();
    fesetround(FE_UPWARD);
    r = (0x0.3759dfp1f + 1.5f) - r;
    fesetround(prev_mode);

    // Handle LSB of exponent that spills into mantissa.
    if (e & 1) r -= 0.5f;

    // Handle overflow.
    if (r < 1.0f) {
        r += 1.0f;
        e += 2;
    }

    // Scale with adjusted exponent.
    r = ldexp(r, -(e>>1));

    return r * (1.5f - 0.5f * f * r * r);
}

C#, 157 chars
Horrible for golfing, but why not...
class C{unsafe static void Main(string[]a){var n=float.Parse(a[0]);var i=*(int*)&n/-2+0x5f3759df;var y=*(float*)&i;System.Console.Write(y*1.5f-y*n/2f*y*y);}}

Readable version:
class C
{
    unsafe static void Main( string[] a )
    {
        var n = float.Parse( a[0] );
        var i = *(int*) &n / -2 + 0x5f3759df;
        var y = *(float*) &i;
        System.Console.Write( y * 1.5f - y * n / 2f * y * y );
    }
}

C, 173 chars
Might as well put code golfed version of example above. Could be less if I would ignore portability.
#include<stdio.h>
#include<stdint.h>
main(int _,char**a){float n,g;sscanf(a[1],"%f",&n);int32_t o=0x5f3759df-(*(long*)&n>>1);g=*(float*)&o;printf("%g\n",g*(1.5-(n/2*g*g)));}

Java, 175 bytes
I decided to give this question a Java answer since it didn't have one, and then it got tweeted and bumped while I was golfing... weird.
As a lambda, 101 bytes:
f=n->{float y=Float.intBitsToFloat(0x5f3759df-(Float.floatToIntBits(n)>>1));return y*(1.5f-n/2*y*y);}

As a full program, 175 bytes:
class Q{public static void main(String[]a){float n=Float.parseFloat(a[0]),y=Float.intBitsToFloat(0x5f3759df-(Float.floatToIntBits(n)>>1));System.out.print(y*(1.5f-n/2*y*y));}}

Darn it, two bytes more than portable C. It's the darn Float.floatToIntBits()&Float.intBitsToFloat(), for Java doesn't like it when you try to say "You know this float that I just defined? Make it an int. You know that int I just defined? Make it a float."

Julia, 96 characters
F=Float32;\ =reinterpret;n=parse(F,ARGS[]);y=F\(0x5f3759df-UInt\n>>1);print(y*(1.5f0-(n/2*y*y)))

Julia (function), 73 characters
n->(\ =reinterpret;y=Float32\(0x5f3759df-UInt\n>>1);y*=(1.5f0-(n/2*y*y)))

Needs to be run on a 32-bit system for UInt to mean UInt32. Unfortunately, there isn't a similar alias for Float32, and if I tried to just parse(ARGS[]), it would be Float64.

X86-64 Machine Code, Microsoft Calling Convention - 65 61 bytes
48 8B 4A 08          mov         rcx,qword ptr [rdx+8]
48 83 EC 28          sub         rsp,28h
E8 C5 FD FF FF       call        strtof (07FF62D2A1642h)
48 83 C4 28          add         rsp,28h
66 0F 7E C0          movd        eax,xmm0
D9 E8                fld1
D9 E8                fld1
D8 C0                fadd        st,st(0)
D8 F9                fdivr       st,st(1)
DC C1                fadd        st(1),st
50                   push        rax
D8 0C 24             fmul        dword ptr [rsp]
5A                   pop         rdx
D1 F8                sar         eax,1
B9 DF 59 37 5F       mov         ecx,5F3759DFh
2B C8                sub         ecx,eax
51                   push        rcx
D9 04 24             fld         dword ptr [rsp]
D9 C0                fld         st(0)
DE C9                fmulp       st(1),st
DE C9                fmulp       st(1),st
DE E9                fsubp       st(1),st
D8 0C 24             fmul        dword ptr [rsp]
D9 14 24             fst         dword ptr [rsp]
58                   pop         rax
C3                   ret

Might be a little shorter in 32 bit. About 20 bytes used in string conversion.
-4 bytes by using strtof

Tcl, 110 bytes
rename binary B
proc R n {B s [B f f $n] i i
B s [B f i [expr 0x5f3759df-($i>>1)]] f y
expr $y*1.5-$n/2*$y**3}

Try it online!

Tcl, 112 bytes
rename binary B
proc R n {B s [B f f $n] i i
B s [B f i [expr 0x5f3759df-($i>>1)]] f y
expr $y*(1.5-$n/2*$y*$y)}

Try it online!

Tcl, 113 bytes
rename binary B
proc R n {B s [B f f $n] i i
B s [B f i [expr 0x5f3759df-($i>>1)]] f y
expr $y*(1.5-$n*.5*$y*$y)}

Try it online!

Tcl, 129 bytes
rename binary B
proc R n {B scan [B format f $n] i i
B scan [B format i [expr 0x5f3759df-($i>>1)]] f y
expr $y*(1.5-$n*.5*$y*$y)}

Try it online!
Tcl, 133 bytes
proc R n {binary scan [binary format f $n] i i
binary scan [binary format i [expr 0x5f3759df-($i>>1)]] f y
expr $y*(1.5-$n*.5*$y*$y)}

Try it online!
Tcl, 142 bytes
proc R n {binary scan [binary format f $n] i i
set i [expr 0x5f3759df-($i>>1)]
binary scan [binary format i $i] f y
expr $y*(1.5-$n*.5*$y*$y)}

Try it online!

Failed try to outgolf myself


text:
Underhanded launcher
Your goal is to write a super-secret program which launches another (independent) program. You don't have to provide the payload in your answer, it can be any program name your program will launch.
However, the challenge is to keep this behavior a secret. Upon casual inspection of the code, it should be impossible or very hard to notice that your program actually executes a foreign program. Bonus if this "hidden feature", once discovered, can reasonably be explained away as an unintentional bug. This is why the code has to be as clear as possible, and everything should have an alibi for being there, otherwise someone inspecting your code might become suspicious.
Remember, this is not a code-golf, but an underhanded contest.

Your code has to be clear and readable.
The causes of the change have to be hidden. Even if discovered, they should look more like bugs than malice.

You should provide an explanation, best in spoiler.

 like this

The winner will be selected as the highest voted answer not sooner than 10 days after the first valid answer. Yes, I know it's subjective, but this is the only criteria adequate for underhanded contests.
Voters should value the standard "underhanded" qualities, like how clear the code is and how well hidden the reason is.
I made this competition for compiled languages, but you can also use interpreted languages if you find two different notable interpreters for it.

Usually, underhanded contests specify the "legitimate" task the program should perform. It helps focus the efforts.

I'm voting to close this question as off-topic because underhanded challenges are no longer on-topic on this site. http://meta.codegolf.stackexchange.com/a/8326/20469

Tcl
Simple.
proc main {} {
    set fd [open filenames.txt]
    while {[gets $fd line] ne ""} {
        set other [open $line w]
        puts $other [clock format [clock seconds]]
    }
}
main

 Ilmari Karonen is right:
 If you supply a filename with a | as first character, it will treat the rest as command. IIRC for Perl it has to be at the end.

+1. Ps. The same trick works also in Perl, and in any other language that has a suitable "magic open" feature.

“IIRC for Perl it has to be at the end.” – Actually it has to be placed according to the intended direction of data transfer. http://pastebin.com/ZnTr7ezg

Intresting. I used this "feature" a lot with webmin's custom commands. Need a list of all domains in a dropdown? Use this feature.

JavaScript
if(document.location.href = 'http://www.example.com') foo();

 "document.loaction.href = 'http;//www.example.com'" sets the page location to "http;//www.example.com" instead of testing for the page location to be "http;//www.example.com".

It's an interpretted language, so here are two interpretters: SpiderMonkey and Google Chrome.

That's actually pretty obvious. It's known as "the world's last bug," due to an old joke that the WWIII would start due to some C code in the form If (AlertValue = RED) LaunchNukes();

source: Stack Exchange

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

sort: votes


text:
Who's that Pokémon?
Input: an integer N between 1 and 151
Output: the Nth Pokemon.
Rules

You may use one data file.
You may not use any already made data decompression algorithms.  This includes libraries and other programs.
Your program may not access files other than itself and your data file.

Scoring
Your score is the sum of the length of your code and data file.
Helpful Stuff
Here's a list of the first 151 pokemon separated by semicolons to help you generate your data file.  Your output should exactly match the Nth entry of this line:
Bulbasaur;Ivysaur;Venusaur;Charmander;Charmeleon;Charizard;Squirtle;Wartortle;Blastoise;Caterpie;Metapod;Butterfree;Weedle;Kakuna;Beedrill;Pidgey;Pidgeotto;Pidgeot;Rattata;Raticate;Spearow;Fearow;Ekans;Arbok;Pikachu;Raichu;Sandshrew;Sandslash;Nidoran (f);Nidorina;Nidoqueen;Nidoran (m);Nidorino;Nidoking;Clefairy;Clefable;Vulpix;Ninetales;Jigglypuff;Wigglytuff;Zubat;Golbat;Oddish;Gloom;Vileplume;Paras;Parasect;Venonat;Venomoth;Diglett;Dugtrio;Meowth;Persian;Psyduck;Golduck;Mankey;Primeape;Growlith;Arcanine;Poliwag;Poliwhirl;Poliwrath;Abra;Kadabra;Alakazam;Machop;Machoke;Machamp;Bellsprout;Weepinbell;Victreebell;Tentacool;Tentacruel;Geodude;Graveler;Golem;Ponyta;Rapidash;Slowpoke;Slowbro;Magnemite;Magneton;Farfetch'd;Doduo;Dodrio;Seel;Dewgong;Grimer;Muk;Shellder;Cloyster;Gastly;Haunter;Gengar;Onix;Drowsee;Hypno;Krabby;Kingler;Voltorb;Electrode;Exeggute;Exeggutor;Cubone;Marowak;Hitmonlee;Hitmonchan;Lickitung;Koffing;Weezing;Rhyhorn;Rhydon;Chansey;Tangela;Kangaskhan;Horsea;Seadra;Goldeen;Seaking;Staryu;Starmie;Mr. Mime;Scyther;Jynx;Electabuzz;Magmar;Pinsir;Tauros;Magikarp;Gyarados;Lapras;Ditto;Eevee;Vaporeon;Jolteon;Flareon;Porygon;Omanyte;Omastar;Kabuto;Kabutops;Aerodactyl;Snorlax;Articuno;Zapdos;Moltres;Dratini;Dragonair;Dragonite;Mewtwo;Mew

Is Bubblegum allowed?

@PyRulez Yes, so long as you don't use any of its built-in data decompression. So good luck breaking SHA256.

If our language has a builtin for returning the list of pokemon, can we use it without a byte addition?

@cairdcoinheringaahing If you're talking about pyke's builtin, I feel that goes against the spirit of the challenge, however I guess it would be non-competing anyway.

I just noticed this challenge, had written up the answer and then noticed the date for it :P
I'm kind of disappointed I didn't get to use my language's one otherwise useless feature

J (93 + 787 = 880)
Edit: other capitalisation method that capitalizes 'Mr. Mime' correctly.
Can probably be shortened, I've almost never written J before. It works on a similar principle as the PHP example.
You need the 'p' file in the same directory as you run this, the file can be downloaded from: http://frankenstein.d-n-s.org.uk/p. It is 787 bytes.
u:p-32*96<p*|.!.1[32=p=.(}.p#~(".1!:1[1)=+/\31=p=.#._5>\,#:a.i.1!:1<'p'){(97+i.26),a.i.'.()'' '

The file is encoded in a five-bit format, as follows:
0-25: A-Z
26: .
27: (
28: )
29: '
30: <space>
31: separator

The file also starts with a separator, to make the list 1-based.
The J code works as follows:

(97+i.26),a.i.'.()'' ': a string where the index N is the ASCII character
{: select from this list the values generated by the expression below
1!:1<'p': read the 'p' file
,#:a.i.: get the file as bits
_5>\: group the bits in groups of five
p=.#.: transform each group of bits into a number and assign to p
+/\31=p: a list of the size of p where each value N means the value at that position in p belongs to the N-th pokemon.
(".1!:1[1)=: read a number from the keyboard and see where in p the characters for that pokemon are.
}.p#~: look them up in p, and remove the first item (which is the separator).
p-32*96<p*_1|.(!.1)32=p=.: Assign the output to p again, and subtract 32 from p where p is bigger than 96 and to the right of a space. Which is cumbersome. According to the J documentation there should be a capitalize function but it's not there on my system.
u:: look them up as unicode.

I'm getting Ulbasaur for the first pokemon.  Am I running it correctly?  I've never used J before.  Also, Mr. Mime should be capitalized.

@cardboard_box: I've changed the capitalisation method so that Mr. Mime works (at the cost of 9 characters). The Ulbasaur was a typo in the data file, that has also been fixed.

It looks like the link is dead.

Bash 1182 chars
read n;echo {Bulba,Ivy,Venu}saur Char{mander,meleon,izard} {Squi,Warto}rtle Blastoise Caterpie Metapod Butterfree Weedle Kakuna Beedrill Pidge{y,otto,ot} Rat{tata,icate} {Sp,F}earow Ekans Arbok {Pika,Rai}chu Sands{hrew,lash} Nido{ran%\(f\),rina,queen,ran%\(m\),rino,king} Clefa{iry,ble} Vulpix Ninetales {Jigglyp,Wigglyt}uff {Zu,Gol}bat Oddish Gloom Vileplume Paras{,ect} Veno{nat,moth} Diglett Dugtrio Meowth Persian {Psy,Gol}duck Mankey Primeape Growlith Arcanine Poliw{ag,hirl,rath} {A,Kada}bra Alakazam Mach{op,oke,amp} Bellsprout {Weepin,Victree}bell Tentac{ool,ruel} Geodude Graveler Golem Ponyta Rapidash Slow{poke,bro} Magne{mite,ton} Farfetch\'d Dod{uo,rio} Seel Dewgong Grimer Muk {Shelld,Cloyst}er Gastly Haunter Gengar Onix Drowsee Hypno Krabby Kingler Voltorb Electrode Exeggut{e,or} Cubone Marowak Hitmon{lee,chan} Lickitung {Koff,Weez}ing Rhy{horn,don} Chansey Tangela Kangaskhan Horsea Seadra Goldeen Seaking Star{yu,mie} Mr.%Mime Scyther Jynx Electabuzz Magmar Pinsir Tauros Magikarp Gyarados Lapras Ditto Eevee {Vapore,Jolte,Flare,Poryg}on Oma{nyte,star} Kabuto{,ps} Aerodactyl Snorlax Articuno Zapdos Moltres Dra{tini,gon{air,ite}} Mew{two,}|tr %\  \ \\n|sed $n!d

That is a really cool idea.

PHP 919 (925) bytes
As with Peter Taylor's answer, I also cannot post my solution directly, so instead i'll post a program that generates it:
<?php
$data = <<<EOD
PD9mb3IoJG89J5SWUHYPaY6dSs/pjsJBMS1pRDc1yZ3AUcQkNcnZsYIkJDXtpa4UB4mOMNH8zbDbcDhcKD
VYu89cFyjRlBm8GSjMiFSxCNHitpn8Kdi43B+XUkX2gVjN8LQEmEkF5D2zE9gbTD3z6djUJQAVFXwlXV/o
kVwnsV1rW5J9zpssN3JXdW5LjAS3DYTcBtV/YUdtoAfGC+ztsoc1LxQamD5lmQMaes37flJcGvg7CdkS+s
1bhZLjAQQtmL5tS3rN+2eS7LeROnX9nOCRRWhRQhFkBDSN0igwMUwem4BNYVrkxZuAzUEiRDG+KFODVqV0
KDAvpLM747wC0AwYUVkELsVsBA5vyThUQQtiKFRBK6EYnBC7oMiAkJtYbXOZk9scdPF3hTJEh7hhZ4yDEG
FHzJ1vSfxkDVkd8fz+u6ConHVH7Y3SHFtgq20M22ALpO40xMC9vmictX6lf+2VfqV1EBctRRwZ38RceT3E
G2l5PcTVTFahWEdGGYhjKSwy5lBYAn944VmhWNQRkvXDw5SAkpV/URm0SZPBOPweZUGwDlODERHEwt0VfK
X9WG+kp9tbe+d8oLvu1uw9+6ExyFwZe6LogoTF7oG3RCiUm0GTcJsmcyxJmdRR68Oi7P4NmQ6ZlwxE8djR
DtfANTjRZBOvWE281RLRDtPJY05E4k10BkvfCRwNLKssXh4GHB+SgBFEwsDbHsSxMdhmCBExsfvZKLzEEY
uZ26SXfutBOR1rezc8/XmT6HkcHciTBwTSxD1cJ+XBcmyjis2S7ClZLZJMTG2bngTs7VtCN3VSaQUAcuPQ
VR9yY0+ntSTcnhcdZ4n4JtzDwPHZJEl9pZJsONV96ad1jpV5eVhpldF8r7WcMeRd8hSxMXjVEcZEPZsdLg
SSd+4kNY7L7Bkbdy10VDVuJdtfGOyG7yydwJux2SFcAiz7QSIEa8BxAoQIFUFCRJt+G6KkoZ3d8fzBPZhO
xG2eaIwfvrGb54zZ7mgfGPA0Qp6I5NSund9SSw5MUD8M0wAmzywmSF2N/CZbw8V1JEZF42LIXJmLeIM5uU
wnOzc4OD4kbjspJGY9c3BsaXQonywkeC49Y2hyKDMxJiR2PSsrJGklOCUzPzgqJHZeb3JkKCRvWyRuKytd
KTokdj4+NSleiyk7ZWNob35zdHJ0cigkZlsrZmdldHMoU1RESU4pXXygLICEgYOCLNfY1tHfKTsNCg==
EOD;
print base64_decode($data);
?>

Sample I/O:
$ php generator.php > out.php

$ echo 12 | php out.php
Butterfree

$ echo 32 | php out.php
Nidoran (m)

$ echo 83 | php out.php
Farfetch'd

$ echo 122 | php out.php
Mr. mime

$ echo 151 | php out.php
Mew

How it works (spoiler):

This code operates on the observation that there are only 32 unique characters, including a separator - if you're not counting capitals. This immediately implies a 5:8 encoding; only 5 bits are needed to represent each byte.

I accomplish this in the following manner:

++$i%8%3

When this value is non-zero, a new byte is read, and when zero, the next byte is generated from the previously read bytes. The 3rd, 6th, and 8th byte are generated in this manner, and then the process repeats.

The bit distribution follows accordingly. If for example you wanted to produce the string:

abcdefgh

The bits for each are distributed among the 5 source bytes in the following fashion:

hccaaaaa|cccbbbbb|hffddddd|fffeeeee|hhhggggg

After generating c, only the top most bit of h remains, after generating f, the top two bits of h remain, and after reading g, h remains in its entirety (I save a few shift operations by using xored values instead, for example the value I load for the second byte is the value I want xor a<<3, but that's the gist of it).

This produces characters on the range of [0,31]. By xoring by any character on the range [96,127], all characters will be mapped to that range (I chose 116, because it resulted in the least amount of escape sequences). After that, it's a simple matter of translating the 5 characters that don't belong there with their appropriate replacements, and capitalizing the first letter. This code requires three bytes to do so: oring the (previously generated as such) bit inverted string with char 160, and then bit inverting back.  A small caveat: the second m in 'Mr. mime' is not capitalized by this method. This could be repaired by replacing the method described above with the ucwords() function, at the cost of 6 bytes, resulting in a code length of 925, instead of 919.

GolfScript (1040 bytes)
Unfortunately I can't directly post the program, so I'll provide a link and the base64-encoded text:
fignACc1Nix7XFsxJF0nJysvXCdCdWxiNzYKSXZ5czY0dXM2CjJtMWQvMm0tZSsyaXozZCpxdSZ0
bCVXMyRydGwlQmw3JGlzJUMjMHBpImUhcB8KQnV0dDBmcmUlHmRsJUtha3VuYQpCZWVkHWxsG3kb
b3QkG290GiN0I2EaI2ljIyVTcGUzGQpGZTMZCkVrMXMYcmJvaxxpa2EXdRphaRd1KjFkc2hyZXcq
MWRzbDdoFWYpFnIUYRZxdWU1FW0pFnIUbxZrExEmeRFibCVWdWxwaXgKThRlIRJzCkoQcHVmZgpX
EHR1ZmYKWnViIw8OYiMKT2RkaXNoD2xvb20KVmkScGx1bSVQMzccMzdlY3Q0LCM0b21vdGgNaWcS
dHQNdWd0HW8MZRl0aBwwc2kxHHN5ZHVjaw8OZHVjawwxa2V5HB1tZQslR3IZbAloGHJjMRQlUAhh
ZxwIaCZsHAgHdGgYYgcGYWRhYgcYbGFrYXphbQUXb3AFF29rImEXYW1wCkItbHNwcm91dAoecBRi
LWwKVmljdHJlZWItbARvDgRydS0PZR91ZCVHB3YtL0cOZW0cLHkhGgtpZDdoKmwZcG9rJVNsGWJy
bwVnbmVtCSJhZ25ldCtGM2ZldBdcJ2QNH3VvDR8dbyplLQ1ld2csZw8dbS9NdWsqaC1sZC9DbG95
c3QvRzd0bHkKSGF1bnQvRzVnMwpPbml4DXIZc2UlSHlwbm8GB2JieQYTbC9WDiRyYgpFEmN0ch8D
dAMkcgpDdWIsIjMZYWsKSAltLBIlSAltLBcxCkxpY2sJdW5nBm9mZhMKHnoTGmh5aAJuGmh5ZCtD
aDFzZXkKVDFnLWEGMWc3a2gxCkgCc2VhKmVhZAcPDmRlNSplYWsTKnQzeXUqdDNtaSJyLiBNaW0l
U2N5dGgvSnlueApFEmMhYnV6egVnbTMcFHMmClQ2b3MFZ2lrM3APeTNhZG9zCkwLB3MNCSQKRWV2
ZSVWCwJlK0oOdGUrRmwzZSwcAnlnK09tMXl0JU9tN3QzAQFwcxgwH2FjdHlsKm4CbGF4GHJ0aWN1
bm8KWgtkb3MMDnRyZXMNB3QUaQ0HZyxhJg0HZywJImV3dHdvDGV3AAZhYnUkAG9yACVFeGVnZ3UA
ClQ1IWMADGEACksAcmEADml3AGl0AAoAYXAACk0ACkQAb2wACkcAaWdnbHkACkMSZmEAbGUAFGcA
aW4AFnIxICgACk5pZG8AY2gACkEAb3cAClIAHGlkZ2UAClAAcmkAV2VlAG9kACAAdGEAJU0AYXQA
dG8AZQoAaXIAXCcAKAApAApTACwKAG9uAGVsAC4AMAoAZXIAYW4AQ2gzAGFyAApWNQBlbgBhdXIA
YXMnJwAnLz0qfS9uLz0=

It uses a grammar-based approach with rules separated by NUL characters and a simple expansion approach, followed by splitting on newlines and selecting the desired line. Input is via stdin. No external file is used.
In more detail
I have written a Java program which applies several grammar-generating strategies and two grammar-to-GolfScript generation strategies and outputs a lot of GS programs to reconstruct a string. In this particular case the winning combination was a greedy grammar builder with a threshold of 2, and the remap engine. The greedy grammar builder starts with a grammar
<0> ::= "Bulbasaur\nIvysaur\nVenusaur\n..."

and repeatedly looks for the repeated sequence of terminals and non-terminals in the right hand sides which, when pulled out into a rule defining a new non-terminal, produces the greatest decrease in the total number of terminals and non-terminals in the grammar. The threshold is the cutoff point at which the decrease is considered no longer worth it.
The non-terminals are topologically sorted and then numbered from 0 up. If they overlap any character values which are also terminals, the remap engine creates a new rule mapping to that terminal. (E.g. if there are rules 0 to 37 and the space character occurs, it will map 38 to the space character and then update the RHS of all rules to use 38 instead of 32). The right hand sides of the rules are then concatenated, separated by NULs, and a small piece of hand-written GolfScript to expand the grammar is appended.

+1 Would you say a bit more about your approach?

brainfuck, 9337 bytes
Pretty sure I will find a shorter solution ^^
--->->>>>->>->>>-->->>>>->>>-->->>>>>->>>-->->>->>>->>>>>-->->>->>>>>>>>-->->>->>>>->>>-->->>>>>>>>-->->->>>>>>>>-->->>->>>>>>>-->->->>>>>>>-->->>>->>>>-->->>>>>>>>>>-->->>>>>>-->->->>>>->-->->>>>>>>>-->->>>>>>-->->>>>>>>>>-->->>>>>>>-->->->>>->>->-->->->>>>->>>-->->>>->>>>-->->>->>>>-->->>->>>-->->>>>>-->->>>->>>>-->->->>>>>-->->->>>>>>>>-->->->>>>>->>>-->->>>>>->>-->-->>-->-->->>>>>>>->-->->>>>>>>>>-->->>>>>->>-->-->>-->-->->>>>>>>>-->->>>>>>>>-->->>>>->>>>-->->>>>->>>>-->->>>>>>-->->>>>>->>>>-->->>>>>>>>>>-->->>>>>>>>>>-->->>>->>-->->>>>->>-->->>>>>>-->->>>>>-->->>>>>>>>>-->->->>->>-->->->>->>>>>-->->>>>>->>-->->>>>>>>>-->->>>>>>>-->->>>>>>>-->->>>>>>-->->>>>>->>-->->>>>>>>-->->>>>>>>-->->->>>>>-->->>>>>->>>-->->>>>>>>>-->->>>->>>>>-->->>>>>->>-->->>>>>>>>>-->->>>>>>->>>-->->>>->-->->->>->>>->-->->>->>->>->>-->->->>>>>-->->->>>>>>-->->->>>->>>-->->>>>>>>>>>-->->>>>>>>>>>-->->>>>>>>>>>>-->->>>>->>>>>-->->>>>->>>>>>-->->>>>>>>-->->>->>>>>>-->->>>>>-->->>>>>->-->->->>>>->>>-->->>>>>>>>-->->>>>>>>-->->->>>>>>>>-->->->>>>>>>-->->->>>>>>>-->>-->->>>>>-->->>>>>>-->->>>>-->->>>>>>>-->->>>>>>-->->>>-->->>>>>>>>-->->>>>>>>>-->->->>>>>-->->->>>>>>-->->>>>->>-->->>>>-->->>>>>>>-->->>>>>-->->>->>>>-->->>>>>>>-->->>>>>>>-->->>>>>>>>>-->->>>>>>>>-->->>>>>>>>>-->->>>>>>-->->->>>>->>-->->>>>>>>>>-->->>>>>>>>->>-->->>>>>>>>>-->->>>>>>>-->->>>>>>>-->->>>>>>>-->->>>>>>-->->>->>>>>-->->->>>>>->-->->->>>->>>>->>-->->>>>>->-->->>->>>->-->->>>>>>>-->->>->>>>>-->->>->>>>-->->>->>>>>-->->>-->-->->>>>-->->>>>>>>-->->>>>-->->>>>>->>>>>-->->->>>->>-->->>>>>>-->->->>>>>-->->->>>>->>>-->->>->>->>>>-->->->>>->>-->->>>>>-->->>>>>-->->->>>>>>>-->->>>>>>>-->->>->>>>>-->->>>>>>>-->->>->>>>>-->->>->>>->>-->->->>>>>-->->->>>>>>>-->->>>>>->>>>>-->->>>>>->>-->->>>>>>>>-->->->>>>>-->->>>>>>>-->->>->>>>>-->->>->>>>->>>-->->>->>>>>>>-->->>>>>>-->->>>+[-[>+++++++<-]<+++]>---->->->-->--->+++>->+++>->->--->>->>->+++>->->--->++>--->-->->->+++>->->--->->--->+++>->-->+++>-->--->--->->--->->--->+++>->-->--->-->--->-->-->--->->--->+++>->-->>+++>->--->--->+>->->-->->->-->--->--->++>+++>->->-->->->-->--->--->->-->+++>->->-->-->->--->--->->+++>->--->->->-->--->--->+>--->->+++>->-->--->--->->->->->--->->--->->--->--->--->++>--->--->--->-->--->--->>+++>-->->-->+++>--->->--->--->--->->-->-->-->--->+>-->--->--->--->>--->+>-->--->--->--->-->->->-->--->+>-->--->--->--->-->->--->+>+++>->->+++>->+++>--->+>+++>->-->--->+++>->--->--->+>->--->+++>->-->>--->>--->+++>->-->>--->->-->+++>-->->--->->->--->-->-->--->+>-->-->+++>--->--->->--->+>+++>-->--->--->->--->+>+++>-->--->->--->->--->>--->+>+++>-->--->->-->+++>->--->--->+>-->--->-->->+++>-->+>++>--->++>--->+>-->--->-->->-->-->+++>--->+>-->--->-->->->--->--->-->--->+>-->--->-->->+++>-->+>++>-->++>--->+>-->--->-->->-->-->-->--->+>-->--->-->-->-->-->--->--->->-->--->--->+++>-->->>--->->-->--->--->+++>--->-->--->--->++>->-->->-->>--->+>-->-->--->->+++>-->--->->--->>-->--->--->-->>->->--->--->--->++>-->--->--->-->>->->--->--->--->++>->--->+++>->--->>-->-->--->+++>->--->+>--->--->-->->--->--->>-->-->-->-->--->++>-->-->--->->-->->-->--->--->+>+++>->+++>->--->+>+++>->+++>->--->--->->--->++>--->-->-->-->+++>->--->++>--->-->-->-->-->->--->--->->-->--->-->--->->->--->->->--->->->-->-->--->+>--->-->>->--->--->+>--->->->-->+++>-->--->+>->>--->->--->-->--->>-->-->--->->--->-->--->+>+++>-->-->--->>--->+>->-->-->--->+++>->--->--->>->-->>-->-->->--->--->->->--->+++>-->-->-->--->--->+>-->-->-->>+++>--->--->+>-->-->-->>--->-->->-->--->+>-->-->-->>->+++>->--->--->->--->->+++>--->>+++>--->+++>--->->+++>--->->-->+++>-->+++>>+++>-->--->+>+++>--->--->-->->--->+>+++>--->--->-->-->--->--->+>+++>--->--->+++>-->->--->->--->-->-->->->->-->->->--->++>--->--->->-->-->--->--->-->-->--->++>-->--->->->--->--->--->--->-->-->--->++>--->-->->+++>--->-->-->-->--->++>--->-->->+++>--->->->--->-->--->>--->-->--->->--->--->--->>->+++>->--->-->--->->--->>-->-->--->-->--->+>-->-->>->+++>--->+>+++>->-->--->+++>->--->--->+>-->-->>->-->-->--->--->+>-->-->>--->->-->--->+>+++>--->-->--->-->-->->--->--->+>+++>--->-->--->->-->-->--->>+++>->--->--->->--->--->++>--->--->->-->--->->-->--->->-->--->->-->-->--->+>--->--->-->--->->--->>--->-->-->--->--->>->-->-->--->->--->+>->-->--->+>--->--->-->-->--->--->->--->->-->-->>->->--->->--->>+++>->->-->>--->>+++>->-->->--->->--->>--->-->--->+++>->--->+>-->-->>--->->->-->>->--->--->--->>>->-->-->--->>->+++>--->--->>--->>-->-->--->-->--->->--->++>-->-->->-->->--->--->->-->--->--->->->-->--->--->--->->>--->--->--->->->--->--->->>--->--->--->->->-->->--->->->--->-->-->--->--->+>+++>->-->>+++>-->--->>-->->-->-->-->-->--->--->--->>-->->-->-->-->--->--->+++>-->--->>-->--->-->-->->->-->--->--->>-->--->--->-->-->--->--->++>--->--->>-->-->--->--->+>--->>--->-->->-->--->+>--->>--->-->-->--->->--->+++>-->->--->>--->++>+++>-->--->--->-->+++>--->>+++>-->--->+++>->-->--->+++>-->--->>-->->->--->+++>--->+>--->+++>--->->+++>--->>-->-->--->--->--->-->--->+>--->+++>-->-->-->--->--->+>->+++>->>->--->+>->+++>->-->-->--->--->+>->+++>+>+>-->-->--->--->+>--->>->--->--->->--->>>-->>--->->-->--->--->->+++>--->->>>--->+>+++>--->-->+++>->--->+>-->-->->-->->--->++>+++>->->-->->--->+>+++>--->-->-->+++>->->--->>>+++>->+++>--->-->->--->>+++>->->+++>->--->->-->->->-->--->->--->->--->--->--->++>+++>->-->->--->-->-->--->>-->-->->--->-->-->--->>-->+++>->--->-->-->--->+>-->->>--->-->-->--->+>-->+++>-->>->--->--->+>-->+++>->->+++>->--->>+++>--->->->-->--->>+++>--->->->-->->->--->->--->->-->--->+++>--->->>-->--->+>-->-->->-->+++>>--->->->->-->--->->-->-->--->++>+++>->--->-->->--->+>-->-->->->--->->--->->->+++>->-->-->-->--->->->+++>--->-->-->+++>-->->--->->->+++>--->-->-->-->->--->--->+>--->>->>-->--->+>--->>+[-[>+++++++<-]<++++]>---->>++>>--->+++>>+++>++>->--->>+++>->>+++>++>->--->->>++>++>>+++>++>->--->+>+++>+++>->+>+++>++>->>->--->+>+++>+++>->+>>>>+++>++>--->+>+++>+++>->--->>+++>->->--->+++>-->++>--->->+>>>--->>+++>->+>+++>->+>>>--->>>+++>>+>+++>--->>>--->+>+++>+>>->--->--->>--->--->>+>+++>--->+++>->--->>++>+>+>>->+>->>>--->>>>->>>--->++>+++>->++>++>+++>--->>>>->->--->>>--->>--->->++>>->--->>--->->++>>+++>+>+>+++>--->>--->->++>>+++>+>--->++>+++>+>+>+++>+>+++>--->++>+++>+>--->-->+++>+>>--->+++>--->>+++>->+++>--->--->--->>+++>->+++>--->--->+++>->+++>++>>--->->->--->+++>->--->>--->->+++>-->+++>++>--->++>+++>--->-->+++>++>--->+++>+++>++>->>+++>->>--->--->+++>+++>++>->>>+++>>+++>--->-->--->->+++>->+++>++>+>++>+>+++>--->-->--->->+++>->--->++>+++>--->-->--->->+++>-->++>>>++>--->-->--->->+++>->+++>++>+>++>+>+++>--->-->--->->+++>->--->++>+++>--->-->--->->+++>->--->++>++>--->+>>>+>+++>--->->->--->+>>>+>+++>--->>>--->->++>>--->--->-->--->-->--->++>>+>+++>>>>--->+>--->++>++>>->--->++>+>+>--->>--->++>++>>->+>++>+>+>--->+++>++>--->+++>+>--->-->+++>>--->+++>+>--->->->->--->>+++>--->-->>+++>+++>+>--->->--->>>--->>++>+>>--->>+++>->+++>>--->>+++>->+++>>>-->+>--->->>++>+++>++>+++>+>--->->>++>+++>+>+++>+>+++>--->++>--->++>>>+>+>--->++>++>++>+>->--->+++>--->--->>+++>--->+>+++>--->>>->>--->+++>++>--->>>->->++>-->->--->-->+++>>->++>-->->--->--->+++>++>->>->--->>->--->+>>+++>--->>--->-->->+++>--->>--->+>+++>--->->->-->+++>++>--->++>>--->>+++>>--->--->+++>++>--->>+++>>--->--->+++>--->->>--->>+++>>--->--->->+++>+>+++>--->->--->->+++>--->++>+++>->+++>--->->+++>--->->>+++>->+++>>+++>+>--->--->+++>-->+++>+++>--->--->--->+++>-->+++>+++>->>--->--->+++>-->+++>+++>+>--->--->>>>>>--->->+++>++>+>--->>>>--->--->++>--->>>>--->->--->-->+>->>>--->>>>--->--->>++>+>+++>-->+++>+++>>--->--->>++>+>+++>-->->++>>>--->-->>+++>->++>->>--->-->->+++>+++>>>>->--->-->+++>>>+>--->>+++>++>->+>+++>--->++>+++>--->--->->+++>>+++>--->+++>>+++>--->--->+++>->>--->+++>>+++>--->--->->+++>--->--->+++>++>++>>+>--->+>>--->--->+++>++>++>>+>+++>++>--->--->+++>->+>>+>-->+++>+>->--->++>+++>->++>+++>--->++>+++>->->--->+++>--->+++>>>>--->++>>--->++>+++>++>++>--->-->->--->+>>->--->--->++>->--->+++>+++>>>>->>->--->+>>+++>->>+>>->--->-->+++>>+>>->--->->+++>++>++>+>>->--->-->>++>++>+++>->--->->++>--->-->--->++>->+++>--->>>>--->->->--->++>+++>--->++>->+++>--->--->->--->++>--->++>++>>>->--->->+++>>+>+++>->--->--->+++>>>-->+>->+++>->>--->+++>-->>++>++>++>+>>--->+++>-->>++>++>++>+>+++>->--->+>++>--->+++>++>>--->--->+++>->+++>--->+++>->--->->--->+>+>+++>++>>>>--->->--->+>+>+++>++>-->+++>+++>++>--->+++>--->-->->--->+>++>++>++>--->++>+++>+>+>--->++>++>--->>>>>--->++>++>--->++>+++>->+++>+++>->++>--->++>+++>->->+++>++>--->+>+++>+++>++>>>->--->--->+++>++>++>>>+++>--->++>+++>++>++>+++>>->+++>+++>++>--->->+++>->>>+++>--->+++>>+++>->->+++>--->-->+++>>->>>++>--->+++>>+++>->--->++>++>--->+++>+>+++>->->++>--->+++>+>+++>->+>--->>--->--->->+>+>--->--->+>>--->+++>-->->+>+++>>->--->+>->++>-->--->+++>>>-->+>+++>--->++>>>--->--->+++>++>+>+++>->--->>--->++>>--->->--->--->+++>++>->+++>>--->--->+++>++>--->->+++>->--->--->-->->+++>->+++>->+++>>--->+++>+++>--->->+++>>--->++>--->+>+>+++>--->+++>>+++>>>--->->+++>--->+++>->>+++>++>--->+>+++>>+>>+++>++>--->--->>+++>->>+++>++>--->>+++>->->++>+++>++>--->->+>+++>++>->+>>--->->+>+++>>+>+++>->--->++>+++>--->++>+>+++>--->++>+++>--->++>+>+++>--->>--->->>->+++>->+++>-->+>->>--->+++>++>+++>->>+++>-->--->->->+>--->-->++>++>+++>--->+++>+++>--->->+++>>--->--->+++>>+>->>>--->++>->+++>+>--->++>--->--->++>->+++>++>+++>++>+++>--->->--->++>->+++>++>+++>++>--->+>>--->--->>--->+>--->+++>--->--->>--->+[-<++++]<<<,[>[>+<-]>[<++++++++++>-]<<<++++++++[>------<-]>[>+<-],]>-[>>[>]+[<]<-]>>[>]>[.>]

Try it online!

q/kdb, 789+77 = 866 bytes
Solution:
/ encoding pokemon.txt into 'q' text file (not added to byte count, not golfed)
`:q 0:enlist "c"$2 sv'8 cut (raze 3_'0b vs'4h$(asc distinct p)?p:lower first read0`:pokemon.txt),000000b

/ checking length of q file (note: file is written with trailing newline \r\n, so could/should be 787 bytes)
hcount `:q
789

/ decoding q and look-up of value
@[;0;upper](";"vs(" '().;",.Q.a)2 sv'5 cut -6_(,/)0b vs'4h$"\n"sv(0:)`:q)@-1+

Examples:
q)@[;0;upper](";"vs(" '().;",.Q.a)2 sv'5 cut -6_(,/)0b vs'4h$"\n"sv(0:)`:q)@-1+45
"Vileplume"
q)@[;0;upper](";"vs(" '().;",.Q.a)2 sv'5 cut -6_(,/)0b vs'4h$"\n"sv(0:)`:q)@-1+151
"Mew"
q)@[;0;upper](";"vs(" '().;",.Q.a)2 sv'5 cut -6_(,/)0b vs'4h$"\n"sv(0:)`:q)@-1+1
"Bulbasaur"

Explanation:
The strategy (like other solutions) is to encode each 8 bit character in 5 bits, this is done by creating a smaller alphabet of 32 characters, finding the indices of each letter in the input list (0..31) and then encoding these as 5-bit numbers (which need to be joined and converted to 8-bit chars to be written down in Q).
The decoding is just doing the opposite of this, the alphabet is known to be " '().;abcdefghijklmnopqrstuvwxyz", so split the input into batches of 5 bits and convert back into integers, index into the alphabet. Split this on ; and then index into it with user input (subtract 1 due to 0-indexing), and (re)capitalise the first letter.
@[;0;upper] (";" vs " '().;abcdefghijklmnopqrstuvwxyz"2 sv'5 cut -6_raze 0b vs'4h$ "\n" sv read0 `:q)@-1+ / ungolfed decoder
                                                                                -1+ / same as doing 'x-1', subtract 1 from input
                                                                                @    / index in to item on the left
            (                                                                                )     / do all this together
                                                                                read0 `:q      / read text file 'q'
                                                                                "\n" sv                / join back newlines (as q breaks text files on newlines)
                                                                               4h$                        / cast char array to bytes
                                                                         0b vs'                           / convert each byte to binary (boolean list)
                                                                    raze                                  / flatten list
                                                                 -6_                                      / drop the 6 padding bits added to align 5/8-bits
                                                           5 cut                                          / chop into lists of 5-bit lengths
                                                      2 sv'                                               / convert each boolean list back to an integer
                    " '().;abcdefghijklmnopqrstuvwxyz"                                                    / index into our lookup table at each index
             ";" vs                                                                                / break this string up at semicolons
 @[;0;upper]                                                                                / apply 'upper' to each first character in the result

Notes:
An extra 13 bytes (879) if we need to capitalise the second M of Mr. Mime:
{@[x;0,1+x ss" ";upper]}(";"vs(" '().;",.Q.a)2 sv'5 cut -6_(,/)0b vs'4h$"\n"sv(0:)`:q)@-1+

Python 3, 178+1253=1431 bytes
import re
def f(l,N,p='',n=0,w=''):
 for s in open(l,'r',1,'utf-8').read().split('\0'):t=re.match('\d*',s)[0];n=int(t or n);w=w[:n]+s[len(t):];p+=w[:-1]*(ord(w[-1])==N)
 return p

Credit to wizzwizz4 for their Bookworm decompression function: Parse the Bookworm dictionary format
Must pass the filename and the desired Pokemon number to the function. Returns a string containing the Pokemon.
Ex.: f('pokemans', 1') returns 'Bulbasaur'.
The file uses BookWorm compression, but since the Pokemon must be in alphabetical order for this to work, they all end with a character whose ordinal matches their number (Ex. Nidorino appears as "7o!", "7o" being the compressed string "Nidorino" and "!" being \33). Items are delineated by the null byte \0, since Pokemon chars start at \1.
Due to the complexity of decompressing BookWorm, this is actually worse than taking the basic hard-coded list, then splitting and indexing it. But it's a novel answer, so I thought I'd post it anyway.
Hex dump of 'pokemans' file:

 41 62 72 61 3f 00 31 65 72 6f 64 61 63 74 79 6c
 c2 8e 00 6c 61 6b 61 7a 61 6d 41 00 72 62 6f 6b
 18 00 32 63 61 6e 69 6e 65 3b 00 74 69 63 75 6e
 6f c2 90 00 30 42 65 65 64 72 69 6c 6c 0f 00 32
 6c 6c 73 70 72 6f 75 74 45 00 31 6c 61 73 74 6f
 69 73 65 09 00 75 6c 62 61 73 61 75 72 01 00 32
 74 74 65 72 66 72 65 65 0c 00 30 43 61 74 65 72
 70 69 65 0a 00 31 68 61 6e 73 65 79 71 00 33 72
 69 7a 61 72 64 06 00 34 6d 61 6e 64 65 72 04 00
 35 65 6c 65 6f 6e 05 00 31 6c 65 66 61 62 6c 65
 24 00 35 69 72 79 23 00 32 6f 79 73 74 65 72 5b
 00 31 75 62 6f 6e 65 68 00 30 44 65 77 67 6f 6e
 67 57 00 44 69 67 6c 65 74 74 32 00 32 74 74 6f
 c2 84 00 30 44 6f 64 72 69 6f 55 00 33 75 6f 54
 00 31 72 61 67 6f 6e 61 69 72 c2 94 00 36 69 74
 65 c2 95 00 33 74 69 6e 69 c2 93 00 32 6f 77 73
 65 65 60 00 31 75 67 74 72 69 6f 33 00 30 45 65
 76 65 65 c2 85 00 31 6b 61 6e 73 17 00 6c 65 63
 74 61 62 75 7a 7a 7d 00 35 72 6f 64 65 65 00 31
 78 65 67 67 75 74 65 66 00 37 6f 72 67 00 30 46
 61 72 66 65 74 63 68 27 64 53 00 31 65 61 72 6f
 77 16 00 6c 61 72 65 6f 6e c2 88 00 30 47 61 73
 74 6c 79 5c 00 31 65 6e 67 61 72 5e 00 32 6f 64
 75 64 65 4a 00 31 6c 6f 6f 6d 2c 00 6f 6c 62 61
 74 2a 00 33 64 65 65 6e 76 00 34 75 63 6b 37 00
 33 65 6d 4c 00 31 72 61 76 65 6c 65 72 4b 00 32
 69 6d 65 72 58 00 32 6f 77 6c 69 74 68 3a 00 31
 79 61 72 61 64 6f 73 c2 82 00 30 48 61 75 6e 74
 65 72 5d 00 31 69 74 6d 6f 6e 63 68 61 6e 6b 00
 36 6c 65 65 6a 00 31 6f 72 73 65 61 74 00 79 70
 6e 6f 61 00 30 49 76 79 73 61 75 72 02 00 4a 69
 67 67 6c 79 70 75 66 66 27 00 31 6f 6c 74 65 6f
 6e c2 87 00 79 6e 78 7c 00 30 4b 61 62 75 74 6f
 c2 8c 00 36 70 73 c2 8d 00 32 64 61 62 72 61 40
 00 32 6b 75 6e 61 0e 00 32 6e 67 61 73 6b 68 61
 6e 73 00 31 69 6e 67 6c 65 72 63 00 6f 66 66 69
 6e 67 6d 00 72 61 62 62 79 62 00 30 4c 61 70 72
 61 73 c2 83 00 4c 69 63 6b 69 74 75 6e 67 6c 00
 4d 61 63 68 61 6d 70 44 00 34 6f 6b 65 43 00 35
 70 42 00 32 67 69 6b 61 72 70 c2 81 00 33 6d 61
 72 7e 00 6e 65 6d 69 74 65 51 00 35 74 6f 6e 52
 00 32 6e 6b 65 79 38 00 72 6f 77 61 6b 69 00 31
 65 6f 77 74 68 34 00 32 74 61 70 6f 64 0b 00 77
 c2 97 00 33 74 77 6f c2 96 00 31 6f 6c 74 72 65
 73 c2 92 00 72 2e 20 4d 69 6d 65 7a 00 75 6b 59
 00 30 4e 69 64 6f 6b 69 6e 67 22 00 34 71 75 65
 65 6e 1f 00 72 61 6e 20 28 66 29 1d 00 39 6d 29
 20 00 35 69 6e 61 1e 00 37 6f 21 00 32 6e 65 74
 61 6c 65 73 26 00 30 4f 64 64 69 73 68 2b 00 31
 6d 61 6e 79 74 65 c2 8a 00 33 73 74 61 72 c2 8b
 00 31 6e 69 78 5f 00 30 50 61 72 61 73 2e 00 35
 65 63 74 2f 00 31 65 72 73 69 61 6e 35 00 69 64
 67 65 6f 74 12 00 35 6f 74 74 6f 11 00 79 10 00
 32 6b 61 63 68 75 19 00 6e 73 69 72 7f 00 31 6f
 6c 69 77 61 67 3c 00 35 68 69 72 6c 3d 00 72 61
 74 68 3e 00 32 6e 79 74 61 4d 00 72 79 67 6f 6e
 c2 89 00 31 72 69 6d 65 61 70 65 39 00 73 79 64
 75 63 6b 36 00 30 52 61 69 63 68 75 1a 00 32 70
 69 64 61 73 68 4e 00 74 69 63 61 74 65 14 00 33
 74 61 74 61 13 00 31 68 79 64 6f 6e 70 00 33 68
 6f 72 6e 6f 00 30 53 61 6e 64 73 68 72 65 77 1b
 00 35 6c 61 73 68 1c 00 31 63 79 74 68 65 72 7b
 00 65 61 64 72 61 75 00 33 6b 69 6e 67 77 00 32
 65 6c 56 00 31 68 65 6c 6c 64 65 72 5a 00 6c 6f
 77 62 72 6f 50 00 34 70 6f 6b 65 4f 00 31 6e 6f
 72 6c 61 78 c2 8f 00 70 65 61 72 6f 77 15 00 71
 75 69 72 74 6c 65 07 00 74 61 72 6d 69 65 79 00
 34 79 75 78 00 30 54 61 6e 67 65 6c 61 72 00 32
 75 72 6f 73 c2 80 00 31 65 6e 74 61 63 6f 6f 6c
 48 00 36 72 75 65 6c 49 00 30 56 61 70 6f 72 65
 6f 6e c2 86 00 31 65 6e 6f 6d 6f 74 68 31 00 34
 6e 61 74 30 00 33 75 73 61 75 72 03 00 31 69 63
 74 72 65 65 62 65 6c 6c 47 00 32 6c 65 70 6c 75
 6d 65 2d 00 31 6f 6c 74 6f 72 62 64 00 75 6c 70
 69 78 25 00 30 57 61 72 74 6f 72 74 6c 65 08 00
 31 65 65 64 6c 65 0d 00 33 70 69 6e 62 65 6c 6c
 46 00 7a 69 6e 67 6e 00 31 69 67 67 6c 79 74 75
 66 66 28 00 30 5a 61 70 64 6f 73 c2 91 00 31 75
 62 61 74 29 00

1286 Bytes when using a simple string instead of a file (Try it online)[https://bit.ly/2O0pZK0]. But the idea of the file compression is nice.

Pure Bash (no coreutils), 1173 bytes
read n;set {Bulba,Ivy,Venu}saur Char{mander,meleon,izard} {Squi,Warto}rtle Blastoise Caterpie Metapod Butterfree Weedle Kakuna Beedrill Pidge{y,otto,ot} Rat{tata,icate} {Sp,F}earow Ekans Arbok {Pika,Rai}chu Sands{hrew,lash} Nido{ran\ \(f\),rina,queen,ran\ \(m\),rino,king} Clefa{iry,ble} Vulpix Ninetales {Jigglyp,Wigglyt}uff {Zu,Gol}bat Oddish Gloom Vileplume Paras{,ect} Veno{nat,moth} Diglett Dugtrio Meowth Persian {Psy,Gol}duck Mankey Primeape Growlith Arcanine Poliw{ag,hirl,rath} {A,Kada}bra Alakazam Mach{op,oke,amp} Bellsprout {Weepin,Victree}bell Tentac{ool,ruel} Geodude Graveler Golem Ponyta Rapidash Slow{poke,bro} Magne{mite,ton} Farfetch\'d Dod{uo,rio} Seel Dewgong Grimer Muk {Shelld,Cloyst}er Gastly Haunter Gengar Onix Drowsee Hypno Krabby Kingler Voltorb Electrode Exeggut{e,or} Cubone Marowak Hitmon{lee,chan} Lickitung {Koff,Weez}ing Rhy{horn,don} Chansey Tangela Kangaskhan Horsea Seadra Goldeen Seaking Star{yu,mie} Mr.\ Mime Scyther Jynx Electabuzz Magmar Pinsir Tauros Magikarp Gyarados Lapras Ditto Eevee {Vapore,Jolte,Flare,Poryg}on Oma{nyte,star} Kabuto{,ps} Aerodactyl Snorlax Articuno Zapdos Moltres Dra{tini,gon{air,ite}} Mew{two,};echo ${!n}

Try it online!
Uses brace expansion like this answer, but uses only bash builtins read, set, and echo. set sets the command line arguments to those given, so that, for instance, $1 is Bulbasaur. ${!n} is an indirect expansion, which expands into the variable of the variable with the name of $n.

the {Bulba,Ivy,Venu}saur feature is one of my favourite things about bash, makes it easy to add extensions to files like  cp file{,.bak}

JavaScript, 1277 1276 bytes
n=>";Bulbasaur;Ivysaur;Venusaur;Charmander;Charmeleon;Charizard;Squirtle;Wartortle;Blastoise;Caterpie;Metapod;Butterfree;Weedle;Kakuna;Beedrill;Pidgey;Pidgeotto;Pidgeot;Rattata;Raticate;Spearow;Fearow;Ekans;Arbok;Pikachu;Raichu;Sandshrew;Sandslash;Nidoran (f);Nidorina;Nidoqueen;Nidoran (m);Nidorino;Nidoking;Clefairy;Clefable;Vulpix;Ninetales;Jigglypuff;Wigglytuff;Zubat;Golbat;Oddish;Gloom;Vileplume;Paras;Parasect;Venonat;Venomoth;Diglett;Dugtrio;Meowth;Persian;Psyduck;Golduck;Mankey;Primeape;Growlith;Arcanine;Poliwag;Poliwhirl;Poliwrath;Abra;Kadabra;Alakazam;Machop;Machoke;Machamp;Bellsprout;Weepinbell;Victreebell;Tentacool;Tentacruel;Geodude;Graveler;Golem;Ponyta;Rapidash;Slowpoke;Slowbro;Magnemite;Magneton;Farfetch'd;Doduo;Dodrio;Seel;Dewgong;Grimer;Muk;Shellder;Cloyster;Gastly;Haunter;Gengar;Onix;Drowsee;Hypno;Krabby;Kingler;Voltorb;Electrode;Exeggute;Exeggutor;Cubone;Marowak;Hitmonlee;Hitmonchan;Lickitung;Koffing;Weezing;Rhyhorn;Rhydon;Chansey;Tangela;Kangaskhan;Horsea;Seadra;Goldeen;Seaking;Staryu;Starmie;Mr. Mime;Scyther;Jynx;Electabuzz;Magmar;Pinsir;Tauros;Magikarp;Gyarados;Lapras;Ditto;Eevee;Vaporeon;Jolteon;Flareon;Porygon;Omanyte;Omastar;Kabuto;Kabutops;Aerodactyl;Snorlax;Articuno;Zapdos;Moltres;Dratini;Dragonair;Dragonite;Mewtwo;Mew".split`;`[n]

Try it online! Node.Js because there's no plain JS

You can get rid of the brackets around the (n) and you can use .split\;`` instead too to save 4 bytes

I think my phone is choking on the TIO URL, but you can save a byte by prefixing the string with ; and indexing from n, not n-1

-83 Bytes, now: 1,193 Bytes - You can try it here - I just adapted @Chris Pure Bash variant with node.js brace expasion.

@pixma140 Cool! Dratini/Dragonair/Dragonite are the only ones with braces inside braces. Also you can change the quotes (') to double-quotes (") and change the escaped quote (\') to a single quote (') for Farfetch'd.

I understand the part with the deletion of the escaped \'. But I don't get what you mean with the double braces. This is the version with the -1 Byte. Do you want to create a new repl.it document with your double brace change, save it and update your CG answer here to JavaScript (Node.js), xxx Bytes?

@pixma140 I meant this: {Dra{tini,gon{air,ite}}} which would match Dratini, Dragonair, or Dragonite. Here's a simple tree graph: https://i.imgur.com/tfJCTaW.png

I see, but do you mean that there is any possibility to shorten this, or do you just think that this is just a cool thing? I am a little stuck.

@pixma140 Nah, I just think it's a cool thing. I might be able to shorten it someday, maybe?

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

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


text:
Shortest power set implementation
Problem definition
Print out the powerset of a given set. For example:
[1, 2, 3] => [[], [1], [2], [3], [1, 2], [1, 3], [2, 3], [1, 2, 3]]

Each element is to be printed on a separate line, so the above example would be printed as:
[]
[1]
[2]
...
[1, 2, 3]

Example code (in D, python example here):
import std.stdio;

string[][] powerset(string[] set) {
    if (set.length == 1) {
        return [set, []];
    }

    string[][] ret;
    foreach (item; powerset(set[1 .. $])) {
        ret ~= set[0]~item;
        ret ~= item;
    }

    return ret;
}

void main(string[] argv) {
    foreach (set; powerset(argv[1 .. $]))
        writeln(set);
}

Input
Elements will be passed as arguments. For example, the example provided above would be passed to a program called powerset as:
powerset 1 2 3

Arguments will be alphanumeric.
Rules

No libraries besides io
Output does not have to be ordered
Powerset does not have to be stored, only printed
Elements in the set must be delimited (e.g. 1,2,3, [1,2,3] and ['1','2','3'] are acceptable, but 123 is not

Trailing delimiters are fine (e.g. 1,2,3, == 1,2,3)

Best is determined based on number of bytes

The best solution will be decided no less than 10 days after the first submission.

Closely related to http://codegolf.stackexchange.com/questions/6380

Related: http://codegolf.stackexchange.com/q/51468/21348

If only this challenge was updated to allow the defaults, like returning and functions. Python would be 54 bytes: lambda L:reduce(lambda r,x:r+[s+[x]for s in r],L,[[]]).

I'm not agree in only print... Why not allow to have the data, the variable too.. Than why print in column and not in row?

Mathematica 16
Code
Subsets is native to Mathematica.
Column@Subsets@s

The code (without column) can be verified on WolframAlpha. (I had to use brackets instead of @; they mean the same thing.
Usage
s={1,2,3}
Column@Subsets@s

This method (55 chars) uses the approach suggested by @w0lf.
s #&/@Tuples[{0,1},Length@s]/.{0:>Sequence[]}//Column

Breakdown
Generate the tuples, composed of 0 and 1's of length Length[s]
Tuples[{0, 1}, Length@s]

{{0, 0, 0}, {0, 0, 1}, {0, 1, 0}, {0, 1, 1}, {1, 0, 0}, {1, 0, 1}, {1,
     1, 0}, {1, 1, 1}}

Multiply the original list (vector) by each tuple:
s # & /@ Tuples[{0, 1}, Length@s]

{{0, 0, 0}, {0, 0, 3}, {0, 2, 0}, {0, 2, 3}, {1, 0, 0}, {1, 0, 3}, {1,
     2, 0}, {1, 2, 3}}

Delete the 0's. % is shorthand for "the preceding output".
%/. {0 :> Sequence[]}

{{}, {3}, {2}, {2, 3}, {1}, {1, 3}, {1, 2}, {1, 2, 3}}

Display in column:

@tjameson I had serious doubts about whether I should post it, but I thought some people might find it interesting to know it is built-in.

I find it interesting :)

Can you leave off the s and put the input at the end of the line?

15 bytes: Subsets/*Column makes an anonymous function that takes a list and returns the display in columns.

C, 118 115
Whilst can save approx 20 chars with simpler formatting, still not going to win in code golf terms either way.
x,i,f;
main(int a,char**s){
    for(;x<1<<a;x+=2,puts("[]"+f))
        for(i=f=0;++i<a;)x&1<<i?f=!!printf("%c%s","[,"[f],s[i]):0;
}

Testing:
/a.out 1 2 3
[]
[1]
[2]
[1,2]
[3]
[1,3]
[2,3]
[1,2,3]

Nice. Some tips: K&R style (main(a,s)char**s;{...}), f|=x&1<<i&&printf is shorter than ?:.

Just figured out what's behind x+=2 (and where did s[0] go). Really nice trick.

Refusing to golf your answer because it's "still not going to win in code golf terms either way." makes the answer not a serious contender for the winning criteria of the challenge.

GolfScript, 22 18 characters
~[[]]{{+}+1$%+}@/`

Another attempt in GolfScript with a completely different algorithm. Input format is the same as with w0lf's answer. (online test)

+1 Great solution! Mine is refactored for readability :-P

GolfScript (43 chars)
This may seem quite long, but it's the first solution to follow the spec: input is from command-line arguments, and output is newline-delimited.
"#{ARGV.join('
')}"n/[[]]\1/{`{1$+.p}+%}%p;

E.g.
$ golfscript.rb powset.gs 1 2 3
["1"]
["2"]
["2" "1"]
["3"]
["3" "2"]
["3" "1"]
["3" "2" "1"]
[]

Quotes aren't necessary, if that makes a difference.

@tjameson, the quotes come from using the shortest possible way to print. The fact that those values are strings rather than integers comes from the inability of GolfScript to access command-line arguments directly: it has to rely on the interpreter doing an eval in Ruby and putting the result in a string.

awk (82)
{for(;i<2^NF;i++){for(j=0;j<NF;j++)if(and(i,(2^j)))printf "%s ",$(j+1);print ""}}

assume saved in file powerset.awk, usage
$ echo 1 2 3 | awk -f powerset.awk

1
2
1 2
3
1 3
2 3
1 2 3

ps if your awk doesn't have and() function, replace it with int(i/(2^j))%2 but adds two to the count.

(2^j) -> 2^j saves you 2 bytes; the .awk file also works without a trailing \n, so you could shave off another byte.

JavaScript, 98
Sadly, a good chunk is spent on output formatting.
for(n in a=eval(prompt(i=p=[[]])))
    for(j=i+1;j;)
        p[++i]=p[--j].concat(a[n]);
alert('[]'+p.join('\n'))

Input
Takes a JavaScript array. (e.g. [1,2,3])
Output
[]
1
1,2
2
2,3
1,2,3
1,3
3

Python 70 67 bytes
def p(a,*v):
 i=0;print v
 for n in a:i+=1;p(a[i:],n,*v)
p(input())

Input is taken in the same manner as for ugoren's solution. Sample I/O:
$ echo [1,2,3] | powerset.py
()
(1,)
(2, 1)
(3, 2, 1)
(3, 1)
(2,)
(3, 2)
(3,)

Try it online!

You can save some with def p(a,*v) and then p(a[i:],n,*v). Output becomes somewhat uglier, but still OK.

Very clever, thanks for the tip.

For the down-voter (over 7 years later), this is obviously Python 2.

J, 19 chars
   (<@#~#:@i.@(2&^)@#)

   (<@#~#:@i.@(2&^)@#) 1 2 3
┌┬─┬─┬───┬─┬───┬───┬─────┐
││3│2│2 3│1│1 3│1 2│1 2 3│
└┴─┴─┴───┴─┴───┴───┴─────┘

The ascii boxing in the output is called boxing and provides heterogen collection (for different length of arrays here).

Golfscript 48
~:x,:§2\?,{[2base.,§\-[0]*\+x\]zip{~{}{;}if}%p}%

This program uses the binary representations of numbers from 0 to length(input) to generate powerset items.
Input
The input format is the Golfscript array format (example: [1 2 3])
Output
The output is a collection of arrays separated by newlines, representing the power set. Example:
[]
[3]
[2]
[2 3]
[1]
[1 3]
[1 2]
[1 2 3]

Online Test
The program can be tested online here.

Awesome, but could you delimit with newlines?

@tjameson I managed to output delimited by newlines while keeping the same character count. Please see the update to my answer.

Python (74 70 chars)
def p(a,v):
 if a:i,*a=a;p(a,v);p(a,v+[i])
 else:print v
p(input(),[])

for input as 1,2,3 or [1,2,3], output is:
[]
[3]
[2]
[2, 3]
[1]
[1, 3]
[1, 2]
[1, 2, 3]

[a[0]] = a[:1]

with input 1,2,3 a[:1] not works. tuple+list not allowed. Exist better solution

Isn't i,*a=a Python 3? It doesn't work on my 2.7.1.

Nor on 2.7.2. That might explain why I've never seen that trick before... most code golf servers run 2.7.x.

Ruby, 39
$*.map{p *$*.combination($.)
$.+=1}
p$*

Mathematica 53
Column@Fold[#~Join~Table[x~Join~{#2},{x,#}]&,{{}},#]&

Haskell (96)

import Control.Monad
import System.Environment
main=getArgs>>=mapM print.filterM(\_->[False ..])

If importing Control.Monad isn't allowed, this becomes 100 characters:

import System.Environment
main=getArgs>>=mapM print.p
p z=case z of{[]->[[]];x:y->p y++map(x:)(p y)}

C# 164
Man this is hard in C#!
void P<T>(T[]c){foreach(var d in c.Aggregate<T,IEnumerable<IEnumerable<T>>>(new[]{new T[0]},(a,b)=>a.Concat(a.Select(x=>x.Concat(new[]{b})))))Console.WriteLine(d);}

Scala, 81
def p[A](x:Seq[A]){x.foldLeft(Seq(Seq[A]()))((a,b)=>a++a.map(b+:_)).map(println)}

APL (26)
Reads input from keyboard because there's no argv equivalent.
↑⍕¨(/∘T)¨↓⍉(M/2)⊤⍳2*M←⍴T←⎕

Usage:
      ↑⍕¨(/∘T)¨↓⍉(M/2)⊤⍳2*M←⍴T←⎕
⎕:
      1 2 3
3
2
2 3
1
1 3
1 2
1 2 3

Explanation:

T←⎕: read input, store in T
M←⍴T: store length of T in M
(M/2)⊤⍳2*M: generate the bit patterns for 1 upto 2^M using M bits.
↓⍉: split the matrix so that each bit pattern is separate
(/∘T)¨: for each bit pattern, select those sub-items from T.
↑⍕¨: for output, get the string representation of each element (so that it will fill using blanks and not zeroes), and format as a matrix (so that each element is on its own line).

JavaScript (ES6) 76
Partially copied from this one: https://codegolf.stackexchange.com/a/51502/21348
Using a bitmap, so it's limited to no more than 32 elements.
Run the snippet in Firefox to test.

f=l=>{
  for(i=0;i<1<<l.length;i++)
    console.log(l.filter(v=>[i&m,m+=m][0],m=1))
}

// TEST

// Redefine console to have output inside the page
console = { log: (...p) => O.innerHTML += p.join(' ') + '\n' }

test=()=>{
  var set = I.value.match(/[^ ,]+/g)
  O.innerHTML='';
  f(set);
}

test()
#I,#O { border: 1px solid #aaa; width: 400px; padding:2px}
Insert values, space or comma separated:

<input id=I value='1 2 3'> <button onclick="test()">-></button>

K, 14 bytes
{x@&:'!(#x)#2}

Generate all 0/1 vectors as long as the input, gather the indices of 1s and use those to select elements from the input vector. In practice:
  {x@&:'!(#x)#2} 1 2 3
(!0
 ,3
 ,2
 2 3
 ,1
 1 3
 1 2
 1 2 3)

This is a bit liberal with the output requirements, but I think it's legal. The most questionable part is that the empty set will be represented in a type dependent form; !0 is how K denotes an empty numeric vector:
  0#1 2 3      / integers
!0
  0#`a `b `c   / symbols
0#`
  0#"foobar"   / characters
""

Explanation
The (#x)#2 builds a vector of 2 as long as the input:
  {(#x)#2}1 2 3
2 2 2
  {(#x)#2}`k `d `b `"+"
2 2 2 2

When monadic ! is applied to a vector, it is "odometer":
  !2 2 2
(0 0 0
 0 0 1
 0 1 0
 0 1 1
 1 0 0
 1 0 1
 1 1 0
 1 1 1)

Then we use "where" (&) on each (') vector to gather its indices. The colon is necessary to disambiguate between the monadic and dyadic form of &:
  &0 0 1 0 1 1
2 4 5

  {&:'!(#x)#2} 1 2 3
(!0
 ,2
 ,1
 1 2
 ,0
 0 2
 0 1
 0 1 2)

If we just wanted combination vectors, we'd be done, but we need to use these as indices into the original set. Fortunately, K's indexing operator @ can accept a complex structure of indices and will produce a result with the same shape:
  {x@&:'!(#x)#2} `a `c `e
(0#`
 ,`e
 ,`c
 `c `e
 ,`a
 `a `e
 `a `c
 `a `c `e)

Elegant, no?

This is no longer valid, as "odometer" in oK now generates a flipped matrix. It can be corrected at the cost of a single byte: {x@&:'+!(#x)#2}. Unrelated: a shorter equivalent of (#x)#2 is 2|~x.

Python 2, 64 bytes
Using comma-separated input:
P=[[]]
for i in input():P+=[s+[i]for s in P]
for s in P:print s

Pyth, 4 bytes (using builtin) or 14 bytes (without)
As noted by @Jakube in the comments, Pyth is too recent for this question. Still here's a solution using Pyth's builtin powerset operator:
jbyQ

And here's one without it:
jbu+Gm+d]HGQ]Y

You can try both solutions here and here. Here's an explanation of the second solution:
jb       # "\n".join(
 u       #  reduce(
  +G     #   lambda G,H: G+
   m     #    map(
    +d]H #     lambda d: d+[H],
    G    #     G),
  Q      #   input()
  ]Y     #   [[]]))

brainfuck, 94 bytes
+[[<+>>+<-]++[>-<------]>-[>]<<[>>+>]>,]++++++++++[[[<]<]+[-[>[.>]]<[<]>+[>]>]<<
.[<<[<]>-]++>]

Formatted:
+
[
  [<+> >+<-]
  ++[>-<------]>-[>]
  <<[>>+>]
  >,
]
++++++++++
[
  [[<]<]
  +
  print
  [
    -[>[.>]]
    <[<]
    >+[>]
    >
  ]
  <<.
  increment
  [
    <<[<]
    >-
  ]
  ++>
]

Expects input of the form 9,10,11 without a trailing newline, and outputs subsets in the same format, sometimes with a trailing comma. The first line printed will always be empty, signifying the empty set.
Try it online.
The basic idea is to place a bit next to each element, then repeatedly increment the binary number while printing the corresponding subset before each increment. (A bit indicates whether an element is in the subset.) A sentinel bit to the left of the array is used to terminate the program. This version actually creates an exponential number of sentinels to save some bytes; a more efficient 99-byte solution that only uses one sentinel can be found in the revision history.
Each bit is encoded as one plus its value; i.e., it can be either 1 or 2. The tape is laid out with the bit before each element and a single zero cell between adjacent elements. The comma is included on the tape for non-final elements, so we can conveniently just print elements without doing any extra work to handle delimiters.

Jelly, 6 bytes
ŒPŒṘ€Y

Try it online!
ŒṘ€Y are string formatting.

APL (Dyalog Classic), 13 bytes
⍪,⊃∘.,/⎕,¨⊂⊂⍬

Try it online!
Output:
 1 2 3
 1 2
 1 3
 1
 2 3
 2
 3

There's a blank line at the end to represent the empty set.
Explanation:
⎕ evaluated input
⎕,¨⊂⊂⍬ append an empty numeric list after each element
∘., Cartesian product
/ reduction (foldr)
⊃ disclose (necessary after reduction in APL)
At this point the result is an n-dimensional 2-by-...-by-2 array, where n is the length of the input.
, flatten into a vector
⍪ turn the vector into an upright 2n-by-1 matrix, so each subset is on a separate line

Haskell, 80 78 bytes
import System.Environment
main=getArgs>>=mapM(print.concat).mapM(\a->[[a],[]])

Try it online!

The I/O requirements are horrible, however people are interpreting them quite loosely. If you change to taking input via stdin you could save 15 bytes, see this.

Python 2, 63 bytes
def f(s,p=[[]]):
 for e in s:
  for u in p:p=p+[u+[e]]
 print p

Try it online!

Note that the spec (unnecessarily) requires each element to be output on its own line.

JavaScript (ES6), 68 bytes
a=>alert(a.reduce((a,x)=>[...a,...a.map(y=>[...y,x])],[[]]).join`
`)

Demo

let f =

a=>alert(a.reduce((a,x)=>[...a,...a.map(y=>[...y,x])],[[]]).join`
`)

f([1,2,3])

Why the alert?

@Shaggy The challenge explicitly asks to print each element on a separate line -- which would probably frowned upon with our current standards. Most answers seem to stick to this rule.

Ah, fair enough; I interpreted "print" as "output".

Japt -R, 5 1 byte
Sadly, Japt's built-in for getting the powerset of an array doesn't include the empty array or this would be 1 byte. It does now!
à

Try it (the empty line at the end is the empty set or you can run it with the -Q flag instead to visualise the sub-arrays)

Brachylog, 4 bytes
⊇ᵘẉᵐ

Try it online!
  ẉ     Write on its own line
 ᵘ ᵐ    every unique
⊇       subset of the input.

Since this doesn't seem to have been a downvote-every-golflang incident, I'm interested in knowing what's wrong with my answer in particular...

Zsh, 31 bytes
Accidentally cut my previous byte-count in half answering another prompt...
for i;a=({$i,}\ $^a)
<<<${(F)a}

Try it online!
Delimiter is one or more spaces, we abuse trailing delimiters extensively here.

Pyth, 1 byte
y

Since Pyth has implicit Q (input variable) at the end of programs, this is basically just power set of the input. I don't think this violates any rules (although 'No libraries besides io' is a bit vague)
Try it online!

PHP, 102 bytes
<?php
function p($a){
$b=[[]];foreach($a as $c)foreach($b as $d)$b[]=array_merge([$c],$d);return $b;
}

Go, 118 bytes
package m
func p(a ...int)[][]int{b:=[][]int{{}}
for _,c:=range a{for _,d:=range b{b=append(b,append(d,c))}}
return b}

Nekomata, 1 byte
S

Attempt This Online!
S finds a subset of a list.
By default, Nekomata prints all possible results separated by newlines.

Thunno 2, 3 bytes
ʠ¶j

Try it online!
Explanation
ʠ¶j  # Implicit input
ʠ    # Take the powerset
 ¶j  # Join on newlines
     # Implicit output

Python, 93 87 chars
Python makes formatting simple, because the required input/output matches its native format.
Only supports items which are Python literals (e.g. 1,2,'hello', not 1,2,hello).
Reads standard input, not parameters.
f=lambda x:x and f(x[1:])+[x[:1]+a for a in f(x[1:])]or[()]
for l in f(input()):print l

print f(input()) shorter

@AMK, the requirement is for each element to be printed in one line. But list can indeed be removed (if also replacinf [[]] with [()].

print'\n'.join(f(input())) saves two characters

@beary605, doesn't work, f() contains tuples, not strings.

Python 2, 74 bytes
def f(x):
    for i in reduce(lambda s,e:s+[i+[e] for i in s],x,[[]]):print i

Haskell 89 chars
import System.Environment
main=getArgs>>=mapM print.p
p[]=[[]]
p(x:y)=(map(x:)$p y)++p y

Getting parameters is long :/

one more char can be shaved off with map(x:)(p y)++p y and yet two more chars above that with [(x:),id]<*>p y. Apparently <*> is in the Prelude now. (filterM isn't).

Ruby Array method combination (from 1.9 ) [50 chars]
0.upto(ARGV.size){|a|ARGV.combination(a){|v| p v}}

R, 63
y=lapply(seq(v),function(x)cat(paste(combn(v,x,s=F)),sep="\n"))

Here, v represents a vector.
Usage:
v <- c(1, 2, 3)
y=lapply(seq(v),function(x)cat(paste(combn(v,x,s=F)),sep="\n"))
1
2
3
c(1, 2)
c(1, 3)
c(2, 3)
c(1, 2, 3)

Mathematica, 51
More cheating:
Column@ReplaceList[Plus@@HoldForm/@#,x___+___->{x}]&

Use with @{1,2,3}.

Your code should take the set as input, not just hardcode it. Also, since this is code golf, you should include the byte count of the code (and probably remove the unnecessary spaces).

Since this contest is long over, the post was more for the idea, but I've edited it.

Matlab (46)
v=input(''),for i=1:numel(v),nchoosek(v,i),end

the input must be of the form [% % % ..] where % is a number

Perl 6, 22 bytes
say words.combinations

The built in combinations method will give all N-combinations of a list, ie. the powerset. Arguments provided via STDIN
% echo 1 2 3 | ./powerset.p6
(() (1) (2) (3) (1 2) (1 3) (2 3) (1 2 3))

Japt -R, 5 bytes
à i[]

Try it online!

Beat you to it! :p Also, note the (unnecessary) requirement of each element being on its own line.

Common Lisp, 117 bytes
(labels((p(l &aux(x(car l)))(if x`(,@#1=(p(cdr l)),@(mapcar(lambda(m)(cons x m))#1#))'(()))))(mapcar'print(p(read))))

Input is a list of element, in output the sets are printed as lists (empty list is equal to NIL)
Try it online!
If the answer can be a function that returns the result, then:
Common Lisp, 90 bytes
(defun p(l &aux(x(car l)))(if x`(,@#1=(p(cdr l)),@(mapcar(lambda(m)(cons x m))#1#))'(())))

Try it online!

Coconut, 90 bytes
def p(l)=(fmap((+)$(l[:1]),p(l[1:])))+p(l[1:])if l else[[]]
fmap(print,p(input().split()))

I think I had something one byte shorter but I lost it after experimenting more.
Try it online!

PHP, 78 bytes
for(;$i<1<<$argc;$i+=2)for(print$c=_;$argc>$c+=1;)$i&1<<$c&&print"$argv[$c],";

prints a comma after each element and an underscore before each subset. Run with -nr or try it online.

05AB1E, 2 bytes
æ»

Try it online.
Output is space-delimited (i.e. 1 2 3). If you want it as actual lists (i.e. [1, 2, 3]), add €¸ before the »:
æ€¸»

Try it online.
Explanation:
æ     # Take the powerset of the (implicit) input-list
   »  # Join the lists by newlines (and each inner list by spaces)
      # (and output the result implicitly)

 €¸   # Wrap each inner list into a list
      # (i.e. [[1],[1,2]] → [[[1]],[[1,2]]])

Python 2, 58 bytes
S=lambda A:A and[u+[A[0]]for u in S(A[1:])]+S(A[1:])or[[]]

Try it online!

PostScript, 80 bytes
00000000: 921a 2f6c 923e 9233 3088 0132 206c 2065  ../l.>.30..2 l e
00000010: 7870 2031 92a9 7b2f 6e92 3e92 335b 3088  xp 1..{/n.>.3[0.
00000020: 016c 2031 92a9 7b6e 2032 926a 3192 3d7b  .l 1..{n 2.j1.={
00000030: 921b 9201 9258 7d7b 9275 7d92 552f 6e20  .....X}{.u}.U/n
00000040: 6e88 ff92 0f92 337d 9248 5d3d 3d7d 9248  n.....3}.H]==}.H

Usage: gsnd -c 1 2 3 -- powerset.ps gives output
[]
[3]
[2]
[3 2]
[1]
[3 1]
[2 1]
[3 2 1]

Un-tokenized version:
count /l exch def
0 1 2 l exp 1 sub{
    /n exch def
    [
    0 1 l 1 sub{
        n 2 mod 1 eq{
            counttomark add index
        }{
            pop
        }ifelse
      /n n -1 bitshift def
    }for
    ] ==
}for