text:
Draw an ASCII Lightning Bolt
Introduction
Partly inspired by this StackOverflow question, let's draw an ASCII Lightning Bolt.
Write a program that takes a positive Integer n via STDIN or command line and outputs the ASCII Lightning Bolt below.
Input
Positive Integer n representing the number of lightning zig-zag tiers to draw.
Example Output
n=1
__
\ \
 \ \
  \ \
   \/

n=2
__
\ \
 \ \
__\ \
\  __\
 \ \
  \ \
   \/

n=3
__
\ \
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
  \ \
   \/

n=4
__
\ \
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
  \ \
   \/

.
.
.
etc

Additional notes

You may write a function that takes n as the only argument and
prints or returns the string.
Trailing spaces and new lines are okay.
No leading spaces except where appropriate for the designated
pattern.
Shortest code in bytes wins.

How many of those challenges have we seen so far?

@flawr Too many

Java, 201 196 189 186 182 bytes
Obviously not the best, but it is in Java.
class I{public static void main(String[]a){System.out.print(("__\na a"+new String(new byte[new Byte(a[0])-1]).replace("\0","__a\\  __\\\n a")+"  a   \\/").replace("a","\\ \\\n"));}}

Ah, Java, the language where you've already lost before you start typing the body of your main method.

I do sometimes think that the main shouldn't count towards byte count, and a few languages that have verbose keywords should maybe be allowed macros. Then it'd be interesting

@AlecTeal Totally agree, some questions actually specify that they only require functional snippets, but most do not.

You may write a function that takes n as the only argument and prints or returns the string. So, umm, you should probably do that ;)

It may be 6 months late, but http://codegolf.stackexchange.com/a/64713/42736 or using a function make it shorter.

CJam, 41 bytes
":¡ö cQïO[nu÷&,"255b6b"
 _\/X"f='X/~ri(*\

I can probably squeeze a few more bytes out, but here's some compression. I picked a base which would lead to no unprintables.
Try it online.
The lightning bolt is split into top + middle * (input-1) + bottom, where top, middle, bottom (compressed using base conversion) are
__
\.

  \
.\.\
__\.\
\..__

    \
.\.\
..\.\
...\/

(Spaces are marked with .s)
40 bytes
Thanks to Optimizer
"¹Ñ³Û-+ÎDx^áÐ"254b6b"
_\ 0/"f=)/~ri(*\

40

thanks for the explanation with top + middle * (input-1) + bottom, it reminded me that powershell could multiply strings :P

JavaScript (ES6) 76
Using template string, the 3 newlines are significant and counted.
Test running the snippet (Firefox only)

f=n=>`__
1 1${`__1\\  __\\
 1`.repeat(n-1)}  1   \\/`.replace(/1/g,`\\ \\
`)

// TEST

go=_=>O.innerHTML=f(I.value)

go()
N: <input id=I value=3><button onclick='go()'>Test</button>

PowerShell, 72 63 bytes
Stupid Windows and your \r\n... This could have been 67 59 bytes!
%{$a="\ \
";"__
$a"+" $a`__$a\  __\
"*($_-1)+" $a  $a   \/"}

For code golf, I think \r\n still counts as \n, since it does the same thing

Pyth, 60 54 bytes (Thanks @isaacg)
My first attempt at Pyth, probably very bad.
"__
\ \ "VtQ" \ \
__\ \
\  __\ ")" \ \
  \ \
   \/

Verify it here.

Welcome to Pyth! By the way, Pyth allows literal newlines in its strings, which would be 1 character shorter than \n. Also, the first \\ in the program could be just a \ .

PHP - 84 79 78 bytes
<?php
define('N',3); // <- didnt count these bytes as TS said I could take var N as input
?>
<?="__
\ \
 \ \ ".str_repeat("
__\ \
\  __\
 \ \ ",N-1)."
  \ \
   \/"

View the result source or wrap in
 to check results. The newlines are required in the code.
The -1 could be moved to the define, but I considered that a cheat.
1st improvement: replace \n with actual newlines
2nd: Since I can define a var, I used a CONTANT, safes the $. +an unneeded space in str_repeat
3rd: Accidentally removed the -1, but saved a byte by using <?= instead of echo.

><> (Fish), 409 bytes
Run by fish.py bolt.fish --value n where bolt.fish is the program name and n is your positive integer input.
\
\         "__"       a
\         "\ \"      a
\         " \ \"     a
\r1-:?!vr "__\ \"    a
\     !0  "\  __\"   a
\     !6  " \ \"  a04.
>r   9a.  "__\ \"    \
      /   "\  __\"  \
       /  " \ \"   \
        / "  \ \" \
         /"   \/"\
                 aaaaa
|o|!~r           /
         \        /
        \          /
       \            /
      \              /

It's not short, but it looks cool. My attempt was to try to make it look like a lightning strike. Also, it always errors on completion.

CJam, 50 bytes
"__
\ \
"q~(" \ \
__\ \
\  __\
"*" \ \
"_S\"   \/"

Try it here

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

With comments:
Initialise n and character set with i as counter
Memory = in♪\ _/
,<++++++++++++++++[>--->+>++++++>++>++++++>+++<<<<<<-]>->--->---->>->-

Draw top of lightning bolt
<..<<<.>.>.<.<.>>.<.>.<.<.<

Draw lightning bolt zigzags
[>>>>..<<.>.<.<.>.>..>..<<.<.>>.<.>.<.<.<-]

Draw lightning bolt tip
>>>..<.>.<.<.>>...<.>>>.

Okay, how this Brainfuck answer beating Java and C#?

Woah, nice golfing, especially in BF!

Awk, 101+8 bytes
101 characters, plus 8 for -v n=$1 to get integer from shell.
'{l="\\ \\";print"__\n"l"\n "l;for(i=1;i<n;++i)print"__"l"\n\\  __\\\n "l}END{print"  "l"\n   \\/"}'

New to this SE site, unclear if those parameters should count.
Ungolfed
awk
-v n=$1
'{
  l="\\ \\";
  print "__\n"l"\n "l;
  for(i=1; i<n; ++i)
    print "__"l"\n\\  __\\\n "l
}
END
{
  print "  "l"\n   \\/"
}'

Usage example:
lightning() { echo | awk -v n=$1 '{l="\\ \\";print"__\n"l"\n "l;for(i=1;i<n;++i)print"__"l"\n\\  __\\\n "l}END{print"  "l"\n   \\/"}'; }
lightning 3
__
\ \
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
  \ \
   \/

Here is the consensus on counting command-line flags. So I think you've done that right.

Let's formulate it as “calculated that right”, because definitely not done right. If the variable assignment is put after the code, there is no need for the -v  part. Not mentioning that the whole variable idea is unnecessary, just like the separate END block. 89 characters: {l="\\ \\";print"__\n"l"\n "l;for(;--$1;)print"__"l"\n\\  __\\\n "l;print"  "l"\n   \\/"} http://pastebin.com/NCznF9kH

Python 97 82 78char:
print(("__\nl l"+"__l\  __\\\n l"*~-input()+"  l   \/").replace('l','\ \\\n'))

This is my first code golf
@(^_^)@
Test here

This is python 3? Will that input() work for integers?

Perl, 69+1
69 characters, plus 1 for the -n command line switch to fetch input from stdin.
$s="\\ \\$/";print"__$/$s $s".("__$s\\  __\\$/ $s"x--$_)."  $s   \\/"

Usage example:
perl -ne '$s="\\ \\$/";print"__$/$s $s".("__$s\\  __\\$/ $s"x--$_)."  $s   \\/"' <<<"2"
__
\ \
 \ \
__\ \
\  __\
 \ \
  \ \
   \/

Some improvements possible: perl -pe'$_="__\ns s"."__s\\  __\\\n s"x--$_."  s   \\/";s!s!\\ \\\n!g'. Also \n can be replaced with a literal line break for another 3 character saved.

Javascript (ES6), 86
Not gonna win, but I love 1-line solution and I hate slashes.
f=n=>atob("X18KXCBc"+"CiBcIFwKX19cIFwKXCAgX19c".repeat(n-1)+"CiBcIFwKICBcIFwKICAgXC8")

Cool!  What it is doing?

@rpax I used base64 encoding to avoid \ and \n . Have a look at atob documentation

C, 101 bytes
My not so original implementation in c
f(n){puts("__\n\\ \\");for(;--n;puts(" \\ \\\n__\\ \\\n\\  __\\"));puts(" \\ \\\n  \\ \\\n   \\/");}

C#, 166 bytes
class I{static void Main(string[]a){System.Console.Write(("__\na a"+"".PadLeft(int.Parse(a[0])-1).Replace(" ",@"__a\  __\
 a")+@"  a   \/").Replace("a",@"\ \
"));}}

EDIT 1: improved the result from 186B to 173B
EDIT 2: saved 1B by using PadLeft instead of PadRight
EDIT 3: saved 8B by dropping PadLeft's second parameter and using verbatim string literals

Nice... You can do away with the public at the start, and instead of using a char array, you can use String.PadRight(int, char), which is shorter and will let you use an ascii char which doesn't need escaping.

Some tweaks:

drop the second parameter to PadLeft(); it's implied (-4)
change 2 of the strings to verbatim (the OP says newlines are fine, and we only need \n, not full \r\n, so -4)

End result:
class I{static void Main(string[]a){System.Console.Write(("__\na a"+"".PadLeft(int.Parse(a[0])-1).Replace(" ",@"__a\  __
a")+"  a   \/").Replace("a",@"\
"));}}
[I can't display newlines in comments, but you can edit the original answer!]

Nice tips, it was hard to verbatim formatting in order :)

C#, 221 Bytes
class C{static void Main(string[]n){int e=System.Int32.Parse(n[0]);var o=@"__{0}\ \{0} \ \{0}";while(e>1){o+=@"__\ \{0}\  __\{0} \ \{0}";e--;}System.Console.WriteLine(o + @"  \ \{0}   \/{0}",System.Environment.NewLine);}}

This isn't the best, or the smallest answer, but I figured I'd give it a try.
Fsacer's answer is much shorter and I think you should check it out.
I just decided to do this just as an alternative method really.

Hey, here I easily dropped it to 182B. Code: class C{static void Main(string[]n){var e=int.Parse(n[0]);var o=@"__{0}\ \{0} \ \{0}";while(e-->1){o+=@"__\ \{0}\  __\{0} \ \{0}";}System.Console.Write(o+@"  \ \{0}   \/{0}","\n");}}

Nice, and just curious, but why did you change the type of e from int to var? It's still 3 characters :P

No reason, maybe because I love var keyword :)

Python 3, 126 118 117 bytes
Just something to get us started with.
n=int(input())
p=print
p('__\n\\ \\')
for i in[0]*~-n:p(r''' \ \
__\ \
\  __\
''',end='')
p(r''' \ \
  \ \
   \/
''')

If you don't need the loop variable, you can iterate trough [0]*(n-1) to get n-1 iterations. You can also write (n-1) as ~-n.

You can save one byte by changing i in [0] to i in[0].

Welcome! A single line print in the loop is also shorter: for i in[0]*~-n:p(' \\ \\\n__\\ \\\n\\  __\\').

C, 119 108 bytes
p(t){for(;t;t/=4)putchar(" \\_\n"[t%4]);}main(c){for(p(13434);p(836),--c;p(57154842));p(265488);puts("/");}

First attempt, 150 bytes
v(a){putchar(a);}s(b){b--?v(32),s(b):v(92);}l(b){s(b);s(1);v(10);}main(c){for(puts("__\n\\ \\");l(1),--c;puts("__\\ \\\n\\  __\\"));l(2);s(3);v(47);}

main is accepting an int argument, so run like this: ./lightning . . . to pass 4 as argument.

105 bytes

Python 2, 76 bytes
print'__\n\ \\\n \ \\\n'+r'''__\ \
\  __\
 \ \
'''*~-input()+'  \ \\\n   \/'

Just print the first three lines, then print the next three lines n-1 times, and then print the final 2 lines. All in one go.
And here is a nice try at an alternative that (unfortunately) uses exactly the same number of bytes:
print('__\n| |'+'__|\  __\\\n |'*~-input()+'  |   \/').replace('|','\ \\\n')

Have you tried using %s formatting for the middle part?

@Sp3000 I need braces around it to make it work with the *, that gives me 77 bytes - or not inlining it, but that costs 79 bytes. :(

F#, 98 characters, 105 bytes
let l n=(@"__♪◙\z"+String.replicate(n-1)@" \z__\z\  __\♪◙"+ @" \z  \z   \/").Replace("z"," \\\n")

Pascal: 149 142 141 137 characters
var n:Word;begin
Read(n);Writeln('__'#10'\ \'#10' \ \');for n:=2to n do Writeln('__\ \'#10'\  __\'#10' \ \');Write('  \ \'#10'   \/')end.

After all, Pascal's only golfing strength is that backslashes need no escaping…

for n:=2 to n do also works.

Thank you, @randomra. I think was ~18 years ago when I was aware of this possibility… Nice to remember it.

CJam 54 Chars
not the shortest, but since i started CJam today, im happy with it.
rd(:T;{'__}:W~N{'\:XSXN}:V~SV{WVXSSWXNSV;N}T*SSVSSSX'/

Try it

Google Sheets, 60 Bytes
Anonymous worksheet function that takes input from range [A1] and outputs to the calling cell.
="__
\ \
 \ \
"&REPT("__\ \
\  __\
 \ \
",A1-1)&"  \ \
   \/

Perl 5, 58 + 1 (-n) = 59 bytes
say'__
\ \
 \ \
'.'__\ \
\  __\
 \ \
'x--$_.'  \ \
   \/'

Try it online!

Java, 183 180 bytes
class L{public static void main(String[]a){String b="__\n\\ \\\n \\ \\\n";for(int i=1;i<new Long(a[0]);++i)b+="__\\ \\\n\\  __\\\n \\ \\\n";System.out.print(b+"  \\ \\\n   \\/");}}

Lua, 110 bytes
function l(n)print("__\n\\ \\\n \\ \\\n"..string.rep("__\\ \\\n\\  __\\\n \\ \\\n",n-1).."  \\ \\\n   \\/")end

SpecBAS - 135 104 bytes
The apostrophe in PRINT statements moves cursor to a new line.
SpecBAS lets you incorporate ASCII characters in a string via way of #n, so have built in some carriage returns (ASCII 13).
Built a string up using carriage returns and other characters, then used REP$ to repeat it the required number of times.
1 LET b$="\ \": INPUT n: PRINT "__"'b$+REP$(#13" "+b$+#13"__"+b$+#13"\  __\",n-1)'" ";b$'"  ";b$'"   \/"

PHP 155
$l=PHP_EOL;echo$l;echo "__$l";for($i=0;$i<$argv[1];$i++){if($i>=1)echo "__\\ \\$l\\  __\\$l";else echo "\\ \\$l";echo " \\ \\$l";}echo "  \\ \\$l   \\/$l";

Ungolfed Version
$n = $argv[1];

echo PHP_EOL;
echo '__'.PHP_EOL;
for($i=0;$i<$n;$i++)
{
    if($i>=1) {
        echo '__\\ \\'.PHP_EOL.'\\  __\\'.PHP_EOL;

    }
    else
    {
        echo '\\ \\'.PHP_EOL;
    }
    echo ' \\ \\'.PHP_EOL;

}
echo '  \\ \\'.PHP_EOL;
echo '   \\/';
echo PHP_EOL;

Your code can be further improved, got it down to 121 bytes. echo$l=PHP_EOL,"__$l";$g="\\ \\$l";for($i=0;$i<$argv[1];$i++){echo($i?"__$g\\  __\\$l":$g)," $g";}echo"  $g",'   \\/',$l;

In addition: remove the $i=0; remove the brackets for the for loop; increment the counter inside the loop (echo($i++?"…).

Retina, 46 bytes
.+
__#r r$0x  r   \/
1x

1
__r\  __\# r
r
\ \#

Takes input as unary.
Each line should go to its own file and # should be changed to newline in the files. This is impractical but you can run the code as is, as one file, with the -s flag, keeping the # markers. You can change the #'s to newlines in the output for readability if you wish. E.g.:
> echo -n 11|retina -s lightning|tr # '\n'
__
\ \
 \ \
__\ \
\  __\
 \ \
  \ \
   \/

The algorithm is very simple. The pairs of lines (regex - substitute pairs) do the following substitution steps:

Surround input with the top and bottom of the lightning.
Subtract 1 from the unary input.
Change every unary digit into the middle part of the lightning.
Decompress the compressed \ \ parts of the lightning to get the desired output.

Try it online! (includes decimal conversion) but I was able to do it in 45 bytes: Try it online! (includes decimal conversion).

Powershell, 59 bytes
'__
\ \'
,' \ \
__\ \
\  __\'*--$args[0]
' \ \
  \ \
   \/'

Test script:
$f = {

'__
\ \'
,' \ \
__\ \
\  __\'*--$args[0]
' \ \
  \ \
   \/'

}

&$f 1
&$f 2
&$f 3
&$f 4

Output:
__
\ \
 \ \
  \ \
   \/
__
\ \
 \ \
__\ \
\  __\
 \ \
  \ \
   \/
__
\ \
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
  \ \
   \/
__
\ \
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
__\ \
\  __\
 \ \
  \ \
   \/

Explanation:
This script is traditional top+middle+bottom. There is only one smart thing: the comma before the middle string force to repeat an array element rather than a string. Therefore, each middle is displayed on a new line.

x86_16 machine code - 84 bytes
8B CB      MOV CX, BX
49         DEC CX
B4 09      MOV AH, 09H
        HEAD:
BA 02 01   MOV DX, OFFSET LIGHTNING_HEAD
CD 21      INT 21H
85 C9      TEST CX, CX
74 09      JE TAIL
        BODY:
BA 1F 01   MOV DX, OFFSET LIGHTNING_LOOP_STR
CD 21      INT 21H
E3 02      JCXZ TAIL
E2 F7      LOOP BODY
        TAIL:
BA 12 01   MOV DX, OFFSET LIGHTNING_TAIL
CD 21      INT 21H
B8 00 4C   MOV AX, 4C00H
CD 21      INT 21H

LIGHTNING_HEAD      DB 05FH, 05FH, 00AH, 00DH, 05CH, 020H, 05CH, 00AH, 00DH, 020H
                    DB 05CH, 020H, 05CH, 00AH, 00DH, 024H
LIGHTNING_TAIL      DB 020H, 020H, 05CH, 020H, 05CH, 00AH, 00DH, 020H, 020H, 020H
                    DB 05CH, 02FH, 024H
LIGHTNING_LOOP_STR  DB 05FH, 05FH, 05CH, 020H, 05CH, 00AH, 00DH, 05CH, 020H, 020H
                    DB 05FH, 05FH, 05CH, 00AH, 00DH, 020H, 05CH, 020H, 05CH, 00AH
                    DB 00DH, 024H

Tested using DOSBox

CSASM v2.1.2.3, 144 bytes
func main:
in ""
conv i32
pop $a
push "__\n\\ \\\n \\ \\\n"
push "__\\ \\\n\\  __\\\n \\ \\\n"
dec $a
push $a
mul
add
push "  \\ \\\n   \\/"
add
print
ret
end

Commented:
func main:
    ; Get the input, convert it to an integer then store it in the accumulator
    in ""
    conv i32
    pop $a

    ; Push the first section of the lightning bolt
    push "__\n\\ \\\n \\ \\\n"

    ; Duplicate the middle section of the lightning bolt
    push "__\\ \\\n\\  __\\\n \\ \\\n"
    dec $a
    push $a
    mul

    ; Append the duplicated sections
    add

    ; Append the third section of the lightning bolt
    push "  \\ \\\n   \\/"
    add

    ; Print the result
    print
    ret
end


text:
Parse Query Parameters
The challenge is this:
You are given a url that is as follows:
http://sub.example.com/some/dir/file.php?action=delete&file=test.foo&strict=true
There can be either http or https, there can be any number of subdomains or directories, and the end file can have any name.
You are to create a full program (that can be compiled/interpreted) that when given a key will return the correct value and if no key is found it will return an empty string.
For example:
> https://example.com/index.php?action=delete
...> get(action) #=> delete
> https://this.example.com/cat/index.php?action=delete
...> get(action) #=> delete
> http://example.com, https://action.example.com/actionscript/action.jpg
...> get(action) #=> none
> https://example.com/index.php?genre=action&reaction=1&action=2
...> get(action) #=> 2

There are no language restrictions and score is calculated a 1 point for every byte. Smallest score wins.
To clarify:

You do not need to handle URL encoding
The script only needs to run once and produce a result
The script can take any input form: STDIN, Prompt, even passed as a function argument

Example:
Javascript, 101 105 bytes
function p(k){var m;return((m=location.href.match(new RegExp('.*[&\?]'+k+'=([^&]*).*')))!==null?m[1]:'');}

What about URL encoding? If I recall correctly there are at least two different RFCs on that, which are not compatible. Should we support URL encoding at all, and if so, in which form?

You do not need to support URL encoding, the only thing you have to do is get the value of the key encoded or not.

Does the program need to run in an input/output loop and keep producing  results, or can it just read a URL and a key on STDIN and produce the result once?

Once is all that is needed.

Can we assume that the given input will be a valid query key? Or could it contain & or = as well? (In which case we'd always return an empty string.)

You can assume that the query will always be valid.

Your example wouldn't actually work. Input keys action ction and n would all return delete.

I think this question needs more test cases. Could you please add the expected results for each of the following URLs (all with query key action): http://example.com, https://action.example.com/actionscript/action.jpg, https://example.com/index.php?genre=action&reaction=1&action=2

Fixed at the cost of 4 bytes.

Can we assume that the path doesn't contain ampersands and the query string doesn't contain additional question marks? Your example code seems to do that.

You can assume that the url will look exactly like the four examples above.

Still fuzzy: it's not clear where the url is from. In your JS example you use the current document url, that is of no use for other languages AND not easy even in JS for testing

My example focuses purely on the browser (as it's all I have). My example doesn't necessarily have to translate to other languages but is to sort of show what I want achieved. As for testing you just pop it in the JS console and use p() to query the key.

I've often seen parameters duplicated such as https://www.google.com/search?q=foo&q=foobar (search google, change the query in the input box, search again, note the value of the URL) - how should http://example.com/foo.cgi?action=foo&action=bar be handled?

You only need to return a value, for the purpose of this challenge the only thing you have to work with is the four urls above.

What is expected if url has multivalued query parameters ? e.g. http://localhost:8080/NameService/Tokens?name=Bob&name=Aaron&name=Brendon

It appears you unaccepted the shortest answer and accepted a longer one. Since this is a code golf competition, the answer with the smallest byte count should win, which in this case is Maltysen's Pyth answer.

It seems I clicked something I did not mean to while browsing this on my mobile phone. I shall correct this right away.

Pyth - 22 21 18 bytes
Uses the obvious method of constructing a dictionary and using } to check existence. Thanks to @FryAmTheEggman for the error handling trick.
#@.dcR\=cecw\?\&zq

Can probably be golfed a little more. Doing explanation now. Added explanation:
#                 Error handling loop
 @                Implicitly print dict lookup
  .d              Dictionary constructor, takes list of pairs
   cR\=           Map split with "=" as the second arg
    c    \&       Split by "&"
     e            Last in sequence of
      c           Split
       w          Second input
       \?         By "?"
 q                Quit loop

Try it online here.

#@.dcR\=cecw\?\&zq seems to work. Not 100% this works all the time, but basically it uses try/catch to check for the dictionary containing the element.

@FryAmTheEggman oh that's really smart. Thanks.

Retina, 30 27 bytes
!`(?<=^\1 .*[?&](.*)=)[^&]+

This is a full program that expects the key and the URL to be space-separated on STDIN, e.g.
action http://sub.example.com/some/dir/file.php?action=delete&file=test.foo&strict=true

This is essentially just a (.NET-flavoured) regex, which matches the correct value by checking that the preceding key is equal to the first string in the input (using a backreference). The only thing that's a bit odd about the regex is that .NET matches lookbehinds from right to left, which is why the "backreference" actually references a group that appears later in the pattern. The !` instructs Retina to print the actual match (if there is one) instead of the number of matches.
For those who don't regex, here is an annotated version. Read the lookbehind from the bottom up, because that's how it's processed:
(?<=        # A lookbehind. Everything we match in here will not be returned as part of
            # actual match. Start reading this from the corresponding parenthesis.
  ^         # Ensure we're at the beginning of the input, so that we've checked
            # against the entire input key.
  \1        # Backreference to the key to check that it's the one we've asked for.
  [ ]       # Match a space.
  .*        # Consume the rest of the URL.
  [?&]      # Match a ? or a & to ensure we've actually captured the entire key.
  (         # End of group 1.
    .+      # Match the key.
  )         # Capturing group 1. Use this to keep track of the key.
  =         # Make sure we start right after a '='
)           # Start reading the lookbehind here.
[^&]+       # Match the value, i.e. as many non-& characters as possible.

Very intuitive.

@BenjaminWilliams Added more detail to the explanation. (And fixed a small bug.)

@BenjaminWilliams This is not the shortest answer and shouldn't be the accepted one. (As this is [tag:code-golf].)

JavaScript (ES6) 64
Edit Saved 1 byte thx @ismael-miguel
A function with url and key as parameters.
Test running the snippet in Firefox.

f=(u,k,e='')=>u.replace(RegExp(`[?&]${k}=([^&]*)`),(m,g)=>e=g)&&e

// TEST
out=x=>O.innerHTML += x+'\n';

test=[
   'https://example.com/index.php?action=delete',
   'https://this.example.com/cat/index.php?action=delete',
   'http://example.com',
   'https://action.example.com/actionscript/action.jpg',
   'https://example.com/index.php?genre=action&reaction=1&action=2'
]

test.forEach(u=>out('Url '+u+'\nValue ['+f(u,'action')+']'))

Save 1 byte by replacing your regex with `[?&]${k}=([^&]*)`

Perl, 25 bytes
/[?&]$^I=([^&]*)/;$_=$1

This reads the URL from STDIN and the key as an argument to -i. It also requires the -p switch. I've added two bytes to the count to account for i and p.
Example
$ perl 2>&- -e'/[?&]$^I=([^&]*)/;$_=$1' -piaction <<< 'http://example.com/?action=delete'
delete

I don't think you need to add 1 byte for the -i flag, since it is used to pass the 2nd part of the input.

-i is normally used to provide a backup extension, so it isn't a standard input method. Counting it seemed fair, and I'm not winning any prizes anyway.

Bash - 55 53
2 bytes saved thanks to izabera
[[ $1 =~ [?\&]$2=([^&]*) ]]
echo ${BASH_REMATCH[1]}

Takes the URL as the first arg and the key to find as the second.
bash url.sh "https://this.example.com/cat/index.php?action=delete&foo=bar&spam=eggs" spam

[?\&]$2=([^&]*)

PHP 4.1, 4336 bytes
There's no mention to do not use built-in function, so, here is my go:
<?=parse_str(parse_url($U,6))?0:$$P;

This restricts the use of the keys U and P on your URL.
You can pass the data as you please (POST, GET, COOKIE, ...), being the key U the url and P the parameter.
Thank you, @manatwork for this shorter version!
Also, an alternative, without the previous restrictions:
<?=parse_str(parse_url($U,6),$A)?0:$A[$P];

Old versions:
<?parse_str(parse_url($U,6),$A);echo$A[$P];

If you are fine with not being able to use the keys U and P:
<?parse_str(parse_url($U,6));echo$$P;

That's generally considered a standard loophole

@TobySpeight There's generally saying that standard loopholes are disallowed, which isn't the case.

@TobySpeight: That link doesn't go where you think it does. (You missed the meta..)

Thanks, Dennis.  I missed the edit window, so here's my replacement: "That's generally considered a standard loophole"

@Ismael - not disallowed, just not very interesting.  Sorry.

@TobySpeight I'm aware of that. But it isn't motivating when every challenge has CJam and APL and Pyth taking the top with answers that are 10-40 bytes long for challenges that take more in a 'normal' language.

@Ismael - agreed.

There may be interesting points even when using built-in functions. Especially with such verbose language like PHP. BTW, without explicit echo is shorter: <?=parse_str(parse_url($U,6),$A)?:$A[$P]; or <?=parse_str(parse_url($U,6))?:$$P;

@manatwork That does't work on PHP4.1, but <?=parse_str(parse_url($U,6))?0:$$P; works as expected. That's because the syntax false?:default is only available from PHP5.3 and up. But I will include your examples.

Oh. 5.3 being released 6 years ago, I tend to forget such compatibility notes.

@manatwork I had to test it 3 times to be sure before saying something crazy. When in doubt, you can try http://sandbox.onlinephpfunctions.com/, which has multiple versions from 4.4.9 (the only PHP4 version) up to the latest ones. If you think I should change the way I present the answer, feel free to do so.

@TobySpeight Sorry the long delay. Only now, after a very long time, I've noticed something. You shouold check this comment: http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default/1078#comment5470_1078. It has 4x more upvotes that the proposed loophole. I think this may not be considered a loophole.

Python, 87 bytes
The script takes the first url as the first argument and the key as the second.
 import re,sys;print re.search(r'[?|&]'+sys.argv[2]+'+=([a-z.]+)',sys.argv[1]).group(1);

Sample output:
>> runfile('test.py', args='http://sub.example.com/some/dir/file.php?action=delete&file=test.foo&strict=true file')
>> test.foo

CJam, 22 bytes
l'?'&er"&="l*/1>s'&/0=

Try it online in the CJam interpreter.
How it works
l      e# Read a line from STDIN.
'?'&er e# Replace question marks with ampersands.
"&="l* e# Place the second line from STDIN between '&' and '='.
/      e# Split the first string at occurrences of the second.
1>s    e# Discard the first chunk.
'&/0=  e# Discard everything following an ampersand.

Pyth, 25 bytes
|smecd\=fqhcT\=zcecw\?\&"

Expects the input on two lines, the key followed by the URL.
Explanation
                   cw\?     Split the second input (the URL) by "?"
                  e         The end (the parameter list)
                 c     \&   Split the parameter list by "&"
        f                   Filter each parameter T
            cT\=            Split by "="
           h                The first part (the key)
          q     z           Equals the first input (the search key)
  m                         Map each valid parameter d
    cd\=                    Split d by "="
   e                        The value
 s                          Print as a string
|                        "  Otherwise, if the key isn't found, print nothing

Try it here

Bash, 37
a=${2#*\?};eval "${a//&/;};echo \$$1"

Pass the key in the first argument and the URL in the second.
Strips everything off up to and including the first ?, then treats the remainder as a series of assignments (RFC 1738 URLs can't contain spaces or any of the shell metacharacters, so this works).  Finally, print the requested result; by default, strings not found are assumed empty.
Limitation - any key that already exists in the environment may be 'found' when not present in the input.

Javascript, 235 228 203 190 bytes
Takes the URL as the first input and the key as the second.
b=document.createElement('a'),b.href=prompt(u={}),a=b.search;if(a!=""){t=a.substring(1).split("&");for(i=t.length;i--;){p=t[i].split("=");u[p[0]]=p[1]}}c=u[prompt()];alert(c==undefined?"":c)

Interesting! I would like to offer up my 156 byte solution if you are okay with that.

Go ahead, I guess.

function p(k){var i,q=[],r=location.href.split('?')[1].split('&');for(i=0;i<r.length;i++){q=q.concat(r[i].split('='));}return(i=q.indexOf(k))>-1?q[i+1]:'';}

The question does seem to be asking that the url be taken from the input.

I went an clarified that in the question.

Rebol - 97
e:["&"| end]p: func[u a][parse u[thru"?"any[copy k to"=""="copy v to e e(if k = a[return v])]]{}]

Ungolfed:
e: ["&" | end]

p: func [u a] [
    parse u [
        thru "?"
        any [
            copy k to "=" "=" copy v to e e
            (if k = a [return v])
        ]
    ]
    {}
]

Example usage (in Rebol console):
>> p "http://sub.example.com/some/dir/file.php?action=delete&file=test.foo&strict=true" "action"
== "delete"

>> p "https://example.com/index.php?action=delete" "action"
== "delete"

>> p "https://this.example.com/cat/index.php?action=delete" "action"
== "delete"

>> p "http://example.com, https://action.example.com/actionscript/action.jpg" "action"
== ""

>> p "https://action.example.com/actionscript/action.jpg" "action"
== ""

>> p "http://example.com" "action"
== ""

>> p "https://example.com/index.php?genre=action&reaction=1&action=2" "action"
== "2"

K, 24
{((!)."S=&"0:*|"?"\:x)y}

.
{((!)."S=&"0:*|"?"\:x)y}["https://example.com/index.php?genre=action&reaction=1&action=2";`genre]
"action"

Explanation:
The function takes two parameters, the url x and the key y
First we split the url on the ? character.
k)"?"\:"https://example.com/index.php?genre=action&reaction=1&action=2"
"https://example.com/index.php"
"genre=action&reaction=1&action=2"

Then we take the last element using *| (first reverse)
k)*|"?"\:"https://example.com/index.php?genre=action&reaction=1&action=2"
"genre=action&reaction=1&action=2"

Process the string using 0:. The LHS of 0: is a three character string, where the first is the datatype of the key (S for symbol, I for int etc), the second is the key-value delimiter (= in this case) and the third is the record delimiter (& here).
k)"S=&"0:*|"?"\:"https://example.com/index.php?genre=action&reaction=1&action=2"
genre    reaction action
"action" ,"1"     ,"2"

Turn this into a dictionary using !
k)(!)."S=&"0:*|"?"\:"https://example.com/index.php?genre=action&reaction=1&action=2"
genre   | "action"
reaction| ,"1"
action  | ,"2"

Then do a lookup on this dictionary for whichever key you're looking for.
k)((!)."S=&"0:*|"?"\:"https://example.com/index.php?genre=action&reaction=1&action=2")`genre
"action"

Turn it into a function using {} and replace the url string with x and the lookup key with y, then pass the url and key in as paramters (func[param1;param2;...;paramN])
k){((!)."S=&"0:*|"?"\:x)y}["https://example.com/index.php?genre=action&reaction=1&action=2";`genre]
"action"

Please include some text explaining your code. The post is recommended for deletion since you didn't.

If you want an explanation you just have to ask. Explanations are not required, so please don't recommend a post of mine or anyone else's for deletion for this reason again

Someone else recommended it. I was a reviewer. Also, code-only answers have always been discouraged.

Gema: 44 38 characters
Expects first the parameter name then the URL on separate lines.
\B\L*\n=@set{p;$1}
\I$p\=/[^&]+/=$1
?=

Sample run:
bash-4.3$ gema -p '\B\L*\n=@set{p;$1};\I$p\=/[^&]+/=$1;?=' <<< $'action\nhttps://example.com/index.php?genre=action&reaction=1&action=2'
2

C, 123 bytes
char*f(char*s,char*n){for(char*x=n;*s&&(*x||*s!='=');x=*x++==*s++?x:n);return *s=='='?(n=strstr(s++,"&"))?(*n=0)?s:s:s:"";}

Note: this function assumes you aren't passing a constant char to it.

JavaScript, 40 bytes
u=>q=>new URL(u).searchParams.get(q)||``

Test it

source: Stack Exchange

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

sort: votes


text:
Coding hex board game
Introduction
Hex is a strategy board game played on a hexagonal grid, theoretically of any size and several possible shapes, but traditionally as an 11×11 rhombus. Other popular dimensions are 13×13 and 19×19 as a result of the game's relationship to the older game of Go. According to the book A Beautiful Mind, John Nash (one of the game's inventors) advocated 14×14 as the optimal size.

Game Rules
Each player has an allocated color, conventionally Red and Blue or White and Black. Players take turns placing a stone of their color on a single cell within the overall playing board. The goal for each player is to form a connected path of their own stones linking the opposing sides of the board marked by their colors, before their opponent connects his or her sides in a similar fashion. The first player to complete his or her connection wins the game. The four corner hexagons each belong to both adjacent sides.
Coding Rules

You may use any program or language. Do not use any third party libraries or modules (full or in part) that implements the same game. The rest are fine.
Players are computer and user.
You may choose the size of the grid.
You may use either CLI or GUI for output (see points).
Your code should not exceed 5120 bytes.

Points

+(5120 - bytes) / 100 golfing points
+50 points for making GUI
+50 for two player mode
+75 for best-move-prediction#
+50 for undo-move

# Tell the user, if they wish, their next best move.
Super bot challenge

+150 points if your bot is undefeatable. Add this points ONLY IF you are absolutely certain of your bot's 100% winning capability. If any user defeats your bot and reports it all your points will be taken away (zero points). The person reporting this must either post a screenshot or input sequences based on the implementation of game. They will be awarded +150 points, if they have posted an answer.

Why is the best move prediction 75 points but the unbeatable bot 150 points? Don't these two tasks amount to solving and implementing the same problem? Also, if we don't go for these bonuses, can the bot just be entirely stupid? Like making random moves or flood-filing the board from one corner?

@MartinBüttner I believe the 75 point may refer to the capability of the program to output what would be the best move for you, according to it's AI, it doesn't require it to truly be the best theoretical possible move.

@MartinBüttner Yes, the bot can make completely stupid moves. Telling the user, their next best move takes some additional code. Based on your AI this may or may not be a separate thing.

@MartinBüttner I forgot to mention that the "stupid moves" will not count as "Best Moves" even though they can be a regular move. "Best Moves" are those moves that, when played consecutively, will maximize the user's winning probability to its highest value.

It can be proved that an unbeatable strategy exists. Therefore any code that can give the optimal next move is automatically unbeatable when playing first. Since you have confirmed that "best move" does mean an optimal move, Martin Büttner's point about best move and unbeatable bot being the same task does appear to be true.

@trichoplax Yes, you are correct, but there is 25 point difference because the additional code required to add the prediction feature  would take way some points (golfing points), even though the algorithms may be the same. So it is a balance between golfing points and prediction points.

What are the restrictions on size?  Is making a 1x1 board allowed?  How about 3x3?  9x9 (the largest board for which an explicit solution has been found)?

@2012rcampion See coding rules #3

Well then, that makes the "super bot challenge" pretty trivial...

@2012rcampion What if the user moves first? They will beat your bot.

You do not specify the order of the players, or that we must let the user choose the order.  Also, since it has been (nonconstructively) proven that the first player can always force a win (on any size board), then if you require that the bot must be able to win when it moves second, then it is impossible for anybody to get the 150 point bonus.

@2012rcampion You are allowed to make a 1x1 grid and you are qualified for the super bot challenge. You'll get 150 points. (even though it won't be very fun to play)

HTML5 and JavaScript, 12.72 + 50 + 50 + 50 = 162.72 points
Hi, this is my very first code golf, but I think, the following code works quite well (it's a full HTML page, 3848 bytes).

<meta charset="utf-8"><title>Hex</title><canvas style="position:absolute;top:0px;left:20px" width="850" height="600" id="o"></canvas>
<input type="button" onClick="I()" value="New game">

Multiplayer: <input id="mp" type="checkbox" onClick="Mp()">
<input type="button" onClick="U()" value="Undo">

Expanded

    <meta charset="utf-8">
    <title>Hex</title>

    <canvas style="position:absolute; top:0px; left:20px" width="850" height="600" id="output">Canvas not supported...</canvas>

<input type="button" onClick="init()" value="New game">

Multiplayer: <input id="mp" type="checkbox" onClick="chgMP()">
<input type="button" onClick="undo()" value="Undo">

Explanation
The code uses the HTML5's canvas-tag to display the game (14x14 board). You can undo the last step and play against another player (enable Multiplayer) or the computer, but its AI is still very weak (it just uses a random position to place the next field). The entire graphical design is based on your screenshot.

Would this work as a Stack Snippet, so people can play the game direct from your answer?

There's an explanation of Stack Snippets here

...and a sandbox for trying it out here

This question is not a code-golf; it's a code-challenge. You don't need to post your byte count, you need to post your score according to the scoring criteria listed by the OP. Thanks.

Just so you know, your score is 160.54 (5120-4066/100 + 50 + 50 + 50). You should try and go for the unbeatable bot :)

Amazing graphics! Brilliant.

I noticed a tiny bug. If you let the computer to win, the line that connects the winning hexagons sometimes skips some of them and go straight to the other side.

Thank you very much for all your tips and changes! I edited my answer (the heading now contains the points and I removed some unnecessary spaces from the code).
@RenaeLider I found the source of this tiny bug, it should be fixed now.

@Vioz- OK, challenge accepted! I will try to create a better bot in the next days :)

Mathematica, 419.16 points
m = False;
Manipulate[
 ClickPane[
  Dynamic@Graphics[
    GraphicsComplex[
     Join @@ Array[{{2, 1}, {0, Sqrt[3]}}.{##} &, {9, 5}], {Red,
      Polygon[{5, 25, 21, 41}], Blue, Polygon[{5, 21, 25, 41}],
      EdgeForm[Gray], If[m, Red, Gray],
      Polygon[{22, 27, 28, 24, 19, 18}]}],
    PlotLabel ->
     Column[{If[m, "Red Wins", "Red to Move"],
       Row@{"Best move is: ",
         Which[m, "(There are no legal moves remaining)", p == 1,
          "(Computer's turn)", ! m, "1,1"]}}, Alignment -> Center]],
  If[p == 2, m = True] &], {{p, 1, "# of players"}, {1, 2}},
 Row@{Button["Start", If[p == 1, m = True]],
   Button["Undo", If[p == 2, m = False]], Button["Reset", m = False]}]

Except for the use of GraphicsComplex, this code is entirely ungolfed.
Controls

The # of players selector chooses the number of players.  Note that there is a bug that allows you to change between 1-player (human vs. cpu) and 2-player (human vs. human) while a game is in progress.
Start lets the computer start playing in 1-player mode.
Undo takes back the last player's move in 2-player mode.
Reset sets the board back to the starting position.
Clicking on a hex when it is a human's turn plays in that hex.  Note that there is a bug that allows a click outside the playing field to select hex 1,1.

Red always goes first, and in 1-player mode Red is always controlled by the computer.  The computer always plays perfectly.
Points

704 bytes: 44.16 points (This can be golfed down significantly.)
GUI: 50 points (It's worth it to add a gui if you can do it in under 5k (50 * 100) characters... yeah, Mathematica can do that.)
Two-player mode: 50 points (The second player never gets to go, but that's just too bad.)
Best-move display: 75 points (There is only one possible move, so this is trivial.  Note that it is always displayed: the requirement is "if they wish" not "iff they wish.")
Undo: 50 points (Since there is only one possible move, there is only one possible action to undo: also trivial.)
Super bot challenge: 150 points (Since I have programmed the computer to always play first, there is no sequence of inputs that can cause it to lose.)

You rascal... you did it, didn't you!

If only someone could find a bug that will bring your bot to the knees... Smithers, release the hounds...

@Renae I did =)  I might actually extend this to a 3x3 or 4x4 game if I have time later in the week.  The gameplay would still be pretty trivially solved, but it might actually be 'fun' to play (the same way tic-tac-toe is 'fun').

You may choose the size of the grid Invalid because a single cell is not a grid.

@edc65 It is a grid... a trivial 1x1 grid, but a grid nonetheless.  (If the OP wants to disallow this strategy I assume he will alter or add a requirement.  Until then I'm counting it.)

@2012rcampion It is alright, I won't delete this answer. Also, I am not a "he". (girl power)

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


text:
Evaluating Parentheses and Brackets as Integers
Write a program that takes in a string of the four characters ()[] that satisfies these points:

Every left parenthesis ( has a matching right parenthesis ).
Every left bracket [ has a matching right bracket ].
Matching pairs of parentheses and brackets won't overlap. e.g. [(]) is invalid because the matching brackets are not fully contained in the matching parentheses, nor vice-versa.
The first and last characters are a matching pair of parentheses or brackets. So ([]([])) and [[]([])] are valid but []([]) is not.

(A grammar for the input format is <input> ::= [<input>*] | (<input>*).)
Each pair of matching parentheses and brackets evaluates to a non-negative integer:

The values of pairs inside matching parentheses are all summed. The empty  match () has value 0.
The values of pairs inside matching brackets are all multiplied. The empty match [] has value 1.

(The sum or product of one number is that same number.)
For example, ([](())([][])[()][([[][]][][])([][])]) can be broken down and evaluated as 9:
([](())([][])[()][([[][]][][])([][])])    <input>
(1 (0 )(1 1 )[0 ][([1 1 ]1 1 )(1 1 )])    <handle empty matches>
(1 0   2     0   [(1     1 1 )2     ])    <next level of matches>
(1 0   2     0   [3           2     ])    <and the next>
(1 0   2     0   6                   )    <and the next>
9                                         <final value to output>

Another example:
[([][][][][])([][][])([][][])(((((([][]))))))]    <input>
[(1 1 1 1 1 )(1 1 1 )(1 1 1 )((((((1 1 ))))))]
[5           3       3       (((((2     )))))]
[5           3       3       ((((2       ))))]
[5           3       3       (((2         )))]
[5           3       3       ((2           ))]
[5           3       3       (2             )]
[5           3       3       2               ]
90                                                <output>

Your program needs to evaluate and print the integer represented by the entire input string. You can assume the input is valid. The shortest code in bytes wins.
Instead of a program, you may write a function that takes in a string and prints or returns the integer.

Asking on behalf of the Python submission for clarification: Program only, or are functions/return value okay?

Might be good to edit the question then. In a previous question, I was told that functions are not valid if it says "write a program" in the question.

CJam, 23
q"])(""1]:*0]:+["4/ers~

With BIG credits to Dennis! Try it online
Explanation:
The program converts the input to a CJam expression then evaluates it.
[…] becomes […1]:* (append 1 and multiply)
(…) becomes […0]:+ (append 0 and add)
q              read input
"])("          characters we want to replace
"1]:*0]:+["    replacement strings, concatenated
4/             split into strings of length 4: ["1]:*" "0]:+" "["]
er             replace (transliterate) the 3 characters with the 3 strings
s              convert the result (mixed characters and strings) to string
~              evaluate

Transliteration saves 4 bytes: q"])(""1]:*0]:+["4/ers~

@Dennis whaaa! That's insane, you can do that??

You are asking me? :P

@Dennis How would the creator of CJam know about such feature's existence??

Common Lisp - 98
(lambda(s)(eval(read-from-string(#1=ppcre:regex-replace-all"\\["(#1#"]"(#1#"\\("s"(+")")")"(*"))))

Replace ( by (+
Replace [ by (*
Replace ] by )
Read from string
Eval

This requires cl-ppcre library to be loaded in current lisp image.
Explanation
Functions * and + are variadic and return their neutral value when given no arguments.
For your examples, the evaluated lisp form are the following ones:
(+ (*) (+ (+)) (+ (*) (*)) (* (+)) (* (+ (* (*) (*)) (*) (*)) (+ (*) (*))))
=> 9

and
(* (+ (*) (*) (*) (*) (*)) (+ (*) (*) (*)) (+ (*) (*) (*))
   (+ (+ (+ (+ (+ (+ (*) (*))))))))
=> 90

Without regexes - 183 bytes
(lambda(s)(do(r(x(coerce s'list))c)((not x)(eval(read-from-string(coerce(reverse r)'string))))(setq c(pop x))(push(case c(#\[ (push #\* r)#\()(#\] #\))(#\( (push #\+ r) #\()(t c))r)))

C'mon, Lisp - 16 bytes (experimental)
+((<r*([<r)]<rRE

Other languages are so terse that I am tempted to make my own golfing language based on Common Lisp, for shorter string manipulations. Currently there is no spec, and the eval function is the following one:
(defun cmon-lisp (expr &rest args)
  (apply
   (lambda (s)
     (let (p q)
       (loop for c across expr
             do (case c
                  (#\< (push (pop p) q))
                  (#\r
                   (let ((a1 (coerce q 'string)) (a2 (coerce p 'string)))
                     (setf p nil
                           q nil
                           s
                             (cl-ppcre:regex-replace-all
                              (cl-ppcre:quote-meta-chars a1) s a2))))
                  (#\R
                   (setf s
                           (if (string= s "")
                               nil
                               (read-from-string s))))
                  (#\E (setf s (eval s)))
                  (t (push c p))))
       s))
   args))

Tests:
(cmon-lisp "+((<r*([<r)]<rRE" "([] [] ([] []))")
=> 4

there is an implicit argument called s and two stacks, p and q.
characters in source code are pushed to p.
< : pops from p and pushes to q.
r : replaces in s (must be a string) from characters in q to charactes in p; result is stored in s; p and q are emptied.
R : read from string s, store result in variable s.
E : eval form s, store result in s.

Funyy how lisp is used to do something with brackets here.

@SydKerckhove You comment just make me think of an appropriate Clojure answer. Thanks alot!

Pyth, 35 34 33 bytes
L?*F+1yMbqb+YbsyMbyvsXzJ"])"+R\,J

Demonstration.
1 byte thanks to @Jakube.
We start by parsing the input. The input format is close to Python, but not quite. We need commas after each parenthesized or bracketed group. The comma at the end of a bracketed group is unnecessary, but harmless. To accomplish this, we use this code:
vsXzJ"])"+R\,J
  X               Translate
   z              in the input
     "])"         the characters "])"
    J             which we will save to J to
             J    J
         +R\,     with each character mapped to itself plus a ",".
 s                Combine the list to a string.
v                  Evaluate as a Python literal.

This will leave an extra , at the end of the string, which will wrap the whole object in a tuple, but this is harmless, because the tuple will be summed, and so have a value equal to its element.
Now that the string is parsed, we must find its value. This is done using a user defined function, y, which is called on the parsed object. the function is defined as follows:
L?*F+1yMbqb+YbsyMb
L                     Define a function, y(b), which returns the following:
 ?       qb+Yb        We form a ternary whose condition is whether the input, b,
                      equals the inputplus the empty list, Y. This is true if
                      and only if b is a list.
      yMb             If so, we start by mapping y over every element of b.
  *F+1                We then take the product of these values. The +1 ensures
                      that the empty list will return 1.
                yMb   Otherwise, we start by mapping y over every element of b.
               s      Then, we sum the results.

@Jakube Right, the unary summation has no effect.

Emacs lisp, 94
The format looks very lispy, so I thought a simple transformation might work:
(defun e()(format-replace-strings'(("("."(+")("["."(*")("]".")")))(eval(read(buffer-string))))

The intermediate format looks something like (for the example in the question):
(+(*)(+(+))(+(*)(*))(*(+))(*(+(*(*)(*))(*)(*))(+(*)(*))))

We're helped by the fact that addition and multiplication already do what we want with an empty argument list.
Degolfed, and interactive, for you playing pleasure:
(defun paren_eval()
  (interactive "*")
  (format-replace-strings '(("(" . "(+")
                            ("[" . "(*")
                            ("]" . ")")))
  (eval (read (buffer-string)))
)

I should have read more closely - the Common Lisp solution takes exactly the same approach!

We need more Emacs Lisp answers!. Btw, I did not count but you could golf it a little more by using a lambda, taking a string as a parameter and removing interactive  (instead of buffer-string, use read-from-string).

Clojure - 66 bytes
Notice that ([] (()) ([] []) [()] [([[] []] [] []) ([] [])]) is a valid Clojure form. So:
#(letfn[(g[x](apply(if(list? x)+ *)(map g x)))](g(read-string %)))

This is an anonymous function taking a string, reading it and giving to g.
The local g function apply + or * to the result of the invocation of g on sub-elements of its arguments.
The base case of the recursion is a little subtle: it is reached when x in an empty sequence; (map g x) returns nil, and apply returns the neutral value for the operation.

Retina, 111 bytes
[\([](1+x)[]\)]
$1
\[]
1x
\(\)
x
(\[a*)1(?=1*x1*x)
$1a
a(?=a*x(1*)x)
$1
(\[1*x)1*x
$1
)`(\(1*)x(?=1*x)
$1
[^1]
<empty line>

Gives output in unary.
Each line should go to its own file but you can run the code as one file with the -s flag. E.g.:
> retina -s brackets <input_1
111111111

Explanation comes later.

Java, 349 characters
A simple recursive approach. Expects the string to be the first argument used to call the program.
import java.util.*;class K{int a=0,b;String c;public static void main(String[]a){K b=new K();b.c=a[0];System.out.print(b.a());}int a(){switch(c.charAt(a++)){case'(':b=0;for(int a:b())b+=a;break;case'[':b=1;for(int a:b())b*=a;}a++;return b;}List<Integer>b(){List d=new ArrayList();char c;while((c=this.c.charAt(a))!=']'&&c!=')')d.add(a());return d;}}

Expanded:
import java.util.*;

class K {
    int a =0, b;
    String c;
    public static void main(String[] a){
        K b = new K();
        b.c = a[0];
        System.out.print(b.a());
    }
    int a(){
        switch (c.charAt(a++)){
            case '(':
                b =0;
                for (int a : b())
                    b += a;
                break;
            case '[':
                b =1;
                for (int a : b())
                    b *= a;
        }
        a++;
        return b;
    }
    List<Integer> b(){
        List d = new ArrayList();
        char c;
        while ((c= this.c.charAt(a)) != ']' && c != ')')
            d.add(a());
        return d;
    }
}

Perl 5, 108
Done as an interpreter rather than rewrite-and-eval. Not a great showing, but fun to write anyway.
push@s,/[[(]/?[(ord$_&1)x2]:do{($x,$y,$z,$t)=(@{pop@s},@{pop@s});
[$t?$x*$z:$x+$z,$t]}for<>=~/./g;say$s[0][0]

Un-golfed:
# For each character in the first line of stdin
for (<> =~ /./g) {
    if ($_ eq '[' or $_ eq '(') {
        # If it's an opening...
        # ord('[') = 91 is odd, ord('(') = 40 is even
        push @stack, [ ( ord($_) & 1) x 2 ];
        # so we will push [1, 1] on the stack for brackets and [0, 0] for parens.
        # one of these is used as the flag for which operator the context is, and
        # the other is used as the initial (identity) value.
    } else {
        # otherwise, assume it's a closing
        ($top_value, $top_oper) = @{ pop @stack };
        ($next_value, $next_oper) = @{ pop @stack };
        # merge the top value with the next-to-top value according to the
        # next-to-top operator. The top operator is no longer used.
        $new_value = $next_oper
            ? $top_value * $next_value
            : $top_value + $next_value
        push @stack, [ $new_value, $next_oper ];
    }
}

say $stack[0][0]; # print the value remaining on the stack.

Python, 99
I tried a variety of methods but the shortest I could get was basically just a replacement and eval. I was pleasantly surprised to find that I could leave all the trailing ,s, as Python can parse [1,2,] and the final trailing comma just puts the whole thing in a tuple. The only other non-straightforward part would be the ord(c)%31%7 to seperate out the different characters (it evaluates to 2,3,1,0 for (,),[,] respectively)
F=lambda s:eval(''.join(["],1),","reduce(int.__mul__,[","sum([","]),"][ord(c)%31%7]for c in s))[0]

This does not work as a program, does it? The question asks for a program, so I don't think providing a function meets the requirements. At least that's what people told me last time I submitted a function when it said "program" in the question. :)

JavaScript (ES6), 116 bytes
s=>+[...s].reduce((t,c)=>((x=c==']')||c==')'?t[1].push(t.shift().reduce((a,b)=>x?a*b:a+b,+x)):t.unshift([]),t),[[]])

Java, 301
a bit of a different approach than TheNumberOne's answer, although mine is also recursive in nature. Input is taken from the command line. The void method saves a few bytes when removing the characters that are no longer needed.
enum E{I;String n;public static void main(String[]r){I.n=r[0];System.out.print(I.e());}int e(){int v=0;if(n.charAt(0)=='('){for(s("(");n.charAt(0)!=')';)v+=e();s(")");}else if(n.charAt(0)=='['){v=1;for(s("[");n.charAt(0)!=']';)v*=e();s("]");}return v;}void s(String c){n=n.substring(1+n.indexOf(c));}}

expanded:
enum EvaluatingParenthesesAndBrackets{
    AsIntegers;
    String input;
    public static void main(String[]args){
        AsIntegers.input=args[0];
        System.out.print(AsIntegers.evaluate());
    }
    int evaluate(){
        int value=0;
        if(input.charAt(0)=='('){
            for(substringAfterChar("(");input.charAt(0)!=')';)
                value+=evaluate();
            substringAfterChar(")");
        }
        else if(input.charAt(0)=='['){
            value=1;
            for(substringAfterChar("[");input.charAt(0)!=']';)
                value*=evaluate();
            substringAfterChar("]");
        }
        return value;
    }
    void substringAfterChar(String character){
        input=input.substring(1+input.indexOf(character));
    }
}

Python, 117 110 109 bytes
def C(s,p=[0]):
 m=r=s[p[0]]=='[';p[0]+=1
 while s[p[0]]in'[(':t=C(s,p);r=r*t*m+(r+t)*(1-m)
 p[0]+=1;return r

One aspect I was struggling with is that the function basically has two return values: the product/sum, and the new position in the string. But I need a function that returns only the result, so returning a tuple does not work. This version uses a "reference" argument (list with one element), to pass the position back from the function.
I have a shorter version (103 bytes) that uses a global variable for the position. But that will only work on the first call. And a function that only works once seems a bit fishy. Not sure if it would be acceptable for code golf.
The algorithm is straightforward recursion. I tried a number of variations for the expression that updates the product/sum. I came up with a few versions that were exactly the same length, but none of them shorter.
I sort of expected that the approach that turns this into an expression that gets evaluated would probably win. But as they say: "To iterate is human, to recurse divine."

Functions now explicitly allowed :)

@Calvin'sHobbies Got a rules question that I was generally wondering about, but that might come into play here: If a solution is implemented as a function, does this imply that the function can be called more than once in a single run? For example, if it used a global variable that is only initialized correctly on the first call, would that be... wrong?

@Retro I'd say yes, it is wrong. The function should work any number of times without reinterpreting it.


text:
Create a basic autocorrecting spell checker
In this challenge, you have to implement a basic spell checker and autocorrector. Your program will use the first input as a source for a dictionary of words, and will use that to autocorrect the second input, finding a close match to some incorrectly spelt words, outputting the result
Specifications

You will receive two inputs, one is a sentence/paragraph you use as a source for your spell checker, and the other includes wrong words (they can be correct too) which you have to correct using the first input.
Possible mistakes: Missing one letter (e.g. helo), one extra letter (e.g. heello), substitution of one character (e.g. hilp instead of help), transposition of two adjacent characters (e.g. hlep instead of help).
In other words, the mistake and the original word have to have a Damerau–Levenshtein distance of one.
You can separate the inputs in any reasonable format. For example, instead of using a newline, you can use a pipe sign to separate them. (|) However, watch out so you don't use something like letters because they are used in the 1st input.
It's possible for a word to have neither an identical word nor a word with 1 distance from the first input. You will have to leave them unchanged.
You don't need to do anything with punctuation. That is, I won't test words that are followed by a punctuation. (E.g. From the first example, I won't ask the correction of 'blod')
Challenge is case insensitive, both the input and output. Meaning that if 'The' is used in the 1st input and the 2nd input is 'teh' you can change it to 'The', 'teh', 'teH', and similar cases.
If a word is in the first input, but also has a distance of 1 with one of the other words, do not correct it.
If there are two words with the same distance, you can output either of them. (E.g. 'en' can change into 'on' and 'in' if the words are both in the first input.) You can also output both of them, but you'll have to use a slash between them. (E.g. 'en' can be corrected into 'in/on')
You can assume words are just sequences of letters separated by spaces.
You can use STDIN or the closest alternative in your language.
Standard loophole rules apply.
This is code-golf, so the shortest code wins.

Examples
Input:
A criminal strain ran in his blood, which, instead of being modified, was increased and rendered infinitely more dangerous by his extraordinary mental powers.

increasd mnetal

Output:
increased mental

Input:
The fact is that upon his entrance I had instantly recognized the extreme personal danger in which I lay.

I recognizid dnger en

Output:
I recognized danger in

In the second example, recognize does not occur in the source text (recognized does). Is that intentional? Also, which punctuation characters can the input contain?

Not a duplicate, but what a weird coincidence

@Zgarb Sorry, it wasn't intentional. I meant recognized, thanks. Punctuation will appear, however as said in the specifications, you don't need to do anything with punctuation, for example I won't ask "blood" from the first input because it's followed by a punctuation mark.

@trichoplax Yep, I was really shocked when I saw that. I posted 12 mins earlier than that. (Though they aren't duplicates of each other, they cover different things.)

CJam, 90 87 bytes
qelN%Sf%~f{1$:W,,_:_2ewWf{\~e\}\Wf{' t_S-}W,),Wf{1$m<S\+m>}++Sf/26,'af+\ff*:+\&\a+0=}S*

Try it online in the CJam interpreter.

I think this has a problem with words ending with an identical word. (E.g. 'Bathe' will change into 'The')

@JNV: I hope I can fix that. I've rolled it back to a previous version for now.


text:
Write a compact spelling checker
Here is a list of 1000 basic English words. Yes, I'm aware that there are only 997 words in the list! It was taken from Wiktionary so blame them!
Your task is to write a program that accepts a word and returns TRUE or FALSE (or 0 or 1) depending on whether the word is in the list or not. You must use the spelling as it appears in the list, so it is colour, not color (sorry Americans!). As far as I am aware, there is only one word in the list that uses a capital letter: I. This means that i (Roman numeral for 1) should return FALSE. All other words may be spelt with an initial capital letter, i.e. Colour should return TRUE.
Rules for letter cases: Your program should return TRUE for any word that has just the first letter capitalised. If the entire word is capitalised, e.g. COLOUR it's your choice whether it is correct or not, as long as it is found in the word list in its lowercase form. If you accept COLOUR you must accept all other words entirely in capitals. If you don't accept COLOUR you must not accept any other word entirely in capitals. Any other mixture of lower and upper case e.g. coLoUR should return FALSE. As stated above only I is correct, not i. Briefly, both lowercase colour and titlecase Colour must be TRUE, uppercase COLOUR may be either TRUE or FALSE and any other mixed case must be FALSE.
Standard rules apply, you may not use external libraries or spelling libraries built into your language, etc. If you use any external files, such as reading the word list via the internet, you must include that number of bytes in your score. Reading the uncompressed word list will add 5942 to your score.
Your code must be at least 95% accurate, including both false positives and false negatives. So if you have 30 false positives and 20 false negatives there are 50 errors in total which is acceptable (even though there are only 997 words, 94.98% accurate if you're being pedantic). One more false positive or false negative invalidates your code. You must post all the errors for verification. Don't make people guess where the errors are!
Shortest code in bytes wins. Add 10 points for each error. Please post a non-golfed version of your code as well so that other people can try to break it / verify that it works. If you can provide a link to a working online version that would be great! The list is 5942 bytes long so ideally you want your code to be shorter than that.
Start your post with the following:
<Language> - Bytes: <num>, False +ves: <num>, False -ves: <num> = Score: <num>
Score = bytes + 10 × (false_pos + false_neg)
I might provide a list of false positives to check against as people post answers.

What is the space where false positives can come from? All strings? It's hard to count false positives if you don't know what to check.

@isaacg Assume the input is always a single word, all ASCII [A-Za-z]. I'm pretty sure there are only single words in the list, no non-alphabetic characters.

Sorry, I wasn't clear. I meant what if daskjhaasudftaigusdfasdfasdasuhdfasdfasdfasdad happens to be accepted by the program - is that a false positive? Or is there some specific, finite list of words we can check to count false positives?

I will compile a list of specific, known false positives as the challenge progresses, i.e. "checking the word XXX break's Fred's code". Since this is supposed to be a spelling checker and there's nothing to stop real people from typing garbage the program should accept all garbage words and output FALSE. If a garbage string doesn't produce a false positive on anyone's code (or it only produces a false positive on an entry that has too many false positives anyway) that word won't be added to the list.

If Colour returns TRUE, what about cOlOUr?

@Sp3000 Would you accept that as correctly spelt in a book or an email? I'll go as far as COLOUR which is optional. That is to say COLOUR may produce TRUE or FALSE depending on the intent of the programmer. COLOR must always produce FALSE. Any other weird capitalisation must produce FALSE as well. So, colour and Colour must be TRUE, COLOUR may be either TRUE or FALSE (but consistently across all words) and color, Color, COLOR, CoLoUr etc. must always produce FALSE.

The list only contains 997 unique words — help and smoke both appear twice

@squeamishossifrage Well done for spotting that! I'll update!

Not a duplicate, but what a weird coincidence

@trichoplax I know! I specifically checked for duplicates before writing this question and that question was posted while I was writing this one!

Re: If a garbage string doesn't produce a false positive on anyone's code (or it only produces a false positive on an entry that has too many false positives anyway) that word won't be added to the list. — this approach is really going to put people off submitting entries before a list appears. As things stand, my answer is the only one that will generate false positives, so your list will consist exclusively of words that my code can't handle. Seems a bit unfair...

I think the list of tests for false positives will need to be at least as large as the list of valid words. Otherwise it will be easier/shorter to encode the list of invalid words.

@RetoKoradi Anyone can invalidate your code by proving more than 50 false positives so I don't think this is a concern.

True. But then they can update their code again to exclude those. So in the end, you will still have 1000 words. Also, I have a feeling that if anybody systematically searches for false positives for a given solution, any solution that has false positives will have at least 50 of them. I doubt that solutions with false positives are viable, at least as long as somebody puts an effort into finding enough words that break them.

@CJDennis That sounds more like [tag:cops-and-robbers] than [tag:code-golf]

If it's obvious that more than 50 words will break the code they don't need to be specified individually. It's only if someone has a fuzzy solution and is running close to the wind. A few extra words might be enough to break their code.

Pastebin uses DOS line breaks, so the file they host is 6937 bytes.  You can recreate the 5942 size by converting it. (MD5 of the 5942 file is 673911d27b213a0812598bf3b6b6c9ee)

Python - Bytes: 4411, False +ves: 0, False -ves: 0 = Score: 4411
import base64,zlib,sys;T=eval(zlib.decompress(base64.b64decode("[encoded data, 4228 characters]")));t=T;f=1
for c in sys.argv[1]:
 C=c.lower()
 if c in t:t=t[c]
 elif f and C in t:f=0;t=t[C]
 else:t={}
print""in t

This is a python program that expects one command line argument, the word. From the list of words I constructed a trie, zlib'ed the argument and finally encoded it with base64. If the word is in the trie, the program prints True, otherwise it prints False. I wanted to create a spell checker that has 100% accuracy.
I could substantially decrease the number of characters, by not encoding the zlib'ed string (specifically, zlib'ed string is 1113 characters shorter than base 64 encoded), but I wanted to have a code that you can copy/paste directly.
Examples
$python check.py colour
True

$python check.py Colour
True

$python check.py coLoUr
False

$python check.py color
False

$python check.py Color
False

$python check.py I
True

$python check.py i
False

The trie is traversed with characters of the word, each time getting a new trie from the key of current character. If the word is in the trie, then a "" must be present in the final trie.
Ungolfed version
import base64, zlib, sys

TRIE = eval(zlib.decompress(base64.b64decode("[encoded data, 4228 characters]")))

trie = TRIE
first = True
for character in sys.argv[1]:
    CHARACTER = character.lower()
    if character in trie:
        trie = trie[character]
    elif first and CHARACTER in trie:
        first = False
        trie = trie[CHARACTER]
    else:
        print False
if "" not in trie:
    print False
print True

Construction of base 64 encoded, zlib'ed trie
f = file("dictionary","r")
END = ""
TRIE = {}

def addWord(word):
    trie = TRIE
    for character in word:
        trie = trie.setdefault(character, {})
    trie.setdefault(END, 0)

for line in f.readlines():
    l = line.replace("\n", "")
    addWord(l)

import zlib, base64
compressed = zlib.compress(str(TRIE).replace(" ", ""), 9)
print base64.b64encode(compressed)

LOL no :) ... it's a typo

Are you trying to edit your answer more times than I edited the question?

@squeamishossifrage the else:break would not work... If you would query with word coloura, which obviously is not a word, the program would return 0. That is because in the last step, the trie would be {"":0}. It would not find "a", but it would find "" and return 0.

@Nejc I deleted my comment after noticing the same thing. However, I think else:t={};break and print""in t might work. The final newline is also unnecessary

The list is also 11 bytes shorter now so you might want to recompress.

No, print False won't do it — "armpit" results in False False False True

@squeamishossifrage yes I noticed... I went for your suggestion about t={} I just didn't add a break, because t={}. It just scans the whole word until the end, even though at that point we know it won't get accepted.

You should go ahead and drop the 1113 bytes by getting rid of the base64 encoding, and add a hexdump for copy-and-pasteability.

PHP - Bytes : 2892 2811, False +ves: 0, False -ves: 0 = Score: 2892 2811
<?php
preg_match_all('/(\D*)(\d)/i',bzdecompress(base64_decode('QlpoOTFBWSZTWaILilgAAfKNgH/gACA////wYAhL71trq71ortD2Kw3J6ZeWvTF3c6Iqf6JkTCYTSNA0jU0Ip4AQJpJptVPE1MAip+DRU/VPTRNDQAAGqexCJpMp6mlPUepsp6jJjDIwJpgTIYmjAanoCBMpMJ6mptQMj1jt+3vz889/XMld2kXPhiMgQJwBAfi+ycsvZ/qwWRmQhcQKUtRAd1Ml+2zpBLJ53aoUhCPzfLzu5B1M9wnUYtgN3XbcTTBwP2QBBNCNgoD1wqkkr1osQpQHMkCUltCBliCKmXjaYDDfmTdJGizbGn/jWpIrDGpStVeTiOoFn8ASoSseHaSYC7Iau2KMXZxZB2YWpMqFlT2CSKmkxEJM0V8ag9ed+DsN1gWzRpewuHHh4x4i3rjLGY3I/WC4K6a3BuLkQ69xFrEiu9q1OzrY6cFKZVAxSSz2kdqQkN6S7rrFy1jY9434MVTgwnycz59BHrxqJuDrqSSuplpG3a2b7wzptRP6DFxkZtHRNEk0Kvylx7uMCR5PfcixfGSLa9vGX0uhpyJ8yr5O9dVp/rdzjGxl1VknpS1qNRj7DXd7j2jB98PSQbMCRNp6WowFajA48z07uAXxnHJBfe+uaUQYUWGuvHgUyUgJ3Uplz2pezKQfKyid0FBGcDTSpgrJnCLni6Xxm+FOpkxqYUl6EwcTGr+mLHv0E9ta1EEHnlvQ0W7pFSedZSNRiqYYrwu1V1rhIgVGXnVEiVl1SaIJn4VGIhkNcokNKUEAZ3V6lkt3U0zGOCJ6sgewrPTdrR2XdvNM5VoQ2/i6Dwg821JoHMEgvxeNEoeZC3MlWCqrWsN11tXs4C2hywWYbh66y8nqQEIVGMjLCxflqTuiQ6xi+Lc5qol6G4jOrRL1qmudnsZ5YEsIhyGlxLhYcyrYwd6aGxjA9i4sKH4RMkQWyYfwOY9GvF8dNrPHeq7Duob6HI3FVOH/ea8Yjd0UxEhMAtIJDwripa08CH9Ow12wXz0o8AnofjobjMfb9vIM0Yg2nYYbHImZt0CtoLq3UNUDatyIl1+HxNa/yeOM3HfeeJ/2yI+imsSJbRBXo5UBwfsKKjEbShUG0tnGwfENhPuAUdu/I7eorWqjDsr0+mR1vUut48dR86azlqOphtcjDuwwCriVSUCUS/10+6/qWJrbMPDmyYgfcMpHvaq69PpVyGTsnz+nXn6nHy/o9Pk0QXP2hjoYJxQtxqRapXzr7rrbEu9ybP5Tt7QJs2KujKagvI+2Po8QDCpJpzE0vwQK8RF76Sk4yh1Dq4wMUVu1u6O6nmsHrXH3xwbZlXp+2Gi/VUckLIJHYnujg++hudcW7dJv4rvZPITTbyriWGh9XQFtLDPKqWF7AuAj56PPc1NKS1EFYzYlo8IkFyo3xVTIonBgQcnc+7M5xC0aFfDW3CjUaohQuN1sgMzSUXM7jxXyOb9YdFrNZ5ziw7lIRojbKfHFi7ZcMdAiCSgVCKmZ3kFRGZ2j71ONKrE4RiKGG0xc2rBVCxBzqWgH2eHHbfTz3QDyajdrXoRaxamrtDWmfAlW5xzlSAeJl/QwtnVBcFCJv0hCF/M8vO3tGerpBV15zbTK59//m2tFrreDfNKkrYM1Y9vWT9cl2DlYRu964+Hlkg0uCbmLMSRK+8sx71osBTZ3ZLFKK4MVn1phiyDCaIYXwi0XNMieiCMyhpeN9oWDWGKUz99dVZCM3ZA50AwIDDYHnCFY1TKkFgRgz1OJsVAZCTaGXtj8qUlPLafUxT5xFqY2QclwVpdKISdQiLFG2gTZUiwr8a+vghqNxC8eAtvrlyFFYtP1dvjd9Zj5zEFF9jSSMsRHGRTIrePWqiaF5n8Ph1+mukR8L2WNnxb/sYDuSG5ZHlNMgPaCzf4+mddOSwIq/tm8ozhGUPWmCpdcyx49uLc4HWJHrQ0gAxdxNY8uwCOzp6PuNEkRw3utTsw3odJwKVJ9bcb0EHheguSbpLhgx5k1qlBB6STiAsxkcXG3hDyigqo8morvnIL1mUSyoSmbFFBDTLqA92RaF9+sZsd8ITAzAYpJRaRbTa1CiPBaRAoKWeOIstgil1kEE1O1aC1QHUUJoJ0JSLBHBchSDDj2ZVDjGBG8PNCJeBrM01eV6IfXwRjV8HmFxiYfLPR9FzRsnQZNGItcSimQWNDA6YGL1ouYsyduqOwjjh27I40WU0vloEn6dKRMOjDxl4QiaRLW4EeLP8ycLxC49pbri5Zs17TZSJCkPfTgH7iNPiqgcZmDKNgdEYwAuSjJFIZosePcg8l+I/rFOfs5khIuUHYpBlo1R8oyZr6eth30STIGQitOBYiKgl7oGd0RWdvw3kx8lCxsse70IUvx14HjKbIEusdZIjdQN9TS72jt3ZoRSotFa4ky3iT6Hepk/RErposPd69dxfRk0Pw499oGe/mJGLImBf9JPyfKVBjtVnl0BxSSCzsJ+fDGhARYHs0pOb9Myi9Ig7+5tTbno8Q/zlaIcngPBqAKi4FRMwPy6uqcoIIyCoNjNkDb5dnqoW7pWqqC7ODP95zHrUUgQTchXQdmj3cPWQKbATBPwRrs/8LuSKcKEhRBcUsA')),$b,2);$w='';foreach($b as$p){$l[]=strrev($w.=$p[1]);$w=substr($w,0,strlen($w)-$p[2]);}echo 1-!array_intersect([$argv[1],lcfirst($argv[1])],$l);

Ungolfed (slightly):
<?php
$z='QlpoOTFBWSZTWaILilgAAfKNgH/gACA////wYAhL71trq71ortD2Kw3J6ZeWvTF3c6Iqf6JkTCYTSNA0jU0Ip4AQJpJptVPE1MAip+DRU/VPTRNDQAAGqexCJpMp6mlPUepsp6jJjDIwJpgTIYmjAanoCBMpMJ6mptQMj1jt+3vz889/XMld2kXPhiMgQJwBAfi+ycsvZ/qwWRmQhcQKUtRAd1Ml+2zpBLJ53aoUhCPzfLzu5B1M9wnUYtgN3XbcTTBwP2QBBNCNgoD1wqkkr1osQpQHMkCUltCBliCKmXjaYDDfmTdJGizbGn/jWpIrDGpStVeTiOoFn8ASoSseHaSYC7Iau2KMXZxZB2YWpMqFlT2CSKmkxEJM0V8ag9ed+DsN1gWzRpewuHHh4x4i3rjLGY3I/WC4K6a3BuLkQ69xFrEiu9q1OzrY6cFKZVAxSSz2kdqQkN6S7rrFy1jY9434MVTgwnycz59BHrxqJuDrqSSuplpG3a2b7wzptRP6DFxkZtHRNEk0Kvylx7uMCR5PfcixfGSLa9vGX0uhpyJ8yr5O9dVp/rdzjGxl1VknpS1qNRj7DXd7j2jB98PSQbMCRNp6WowFajA48z07uAXxnHJBfe+uaUQYUWGuvHgUyUgJ3Uplz2pezKQfKyid0FBGcDTSpgrJnCLni6Xxm+FOpkxqYUl6EwcTGr+mLHv0E9ta1EEHnlvQ0W7pFSedZSNRiqYYrwu1V1rhIgVGXnVEiVl1SaIJn4VGIhkNcokNKUEAZ3V6lkt3U0zGOCJ6sgewrPTdrR2XdvNM5VoQ2/i6Dwg821JoHMEgvxeNEoeZC3MlWCqrWsN11tXs4C2hywWYbh66y8nqQEIVGMjLCxflqTuiQ6xi+Lc5qol6G4jOrRL1qmudnsZ5YEsIhyGlxLhYcyrYwd6aGxjA9i4sKH4RMkQWyYfwOY9GvF8dNrPHeq7Duob6HI3FVOH/ea8Yjd0UxEhMAtIJDwripa08CH9Ow12wXz0o8AnofjobjMfb9vIM0Yg2nYYbHImZt0CtoLq3UNUDatyIl1+HxNa/yeOM3HfeeJ/2yI+imsSJbRBXo5UBwfsKKjEbShUG0tnGwfENhPuAUdu/I7eorWqjDsr0+mR1vUut48dR86azlqOphtcjDuwwCriVSUCUS/10+6/qWJrbMPDmyYgfcMpHvaq69PpVyGTsnz+nXn6nHy/o9Pk0QXP2hjoYJxQtxqRapXzr7rrbEu9ybP5Tt7QJs2KujKagvI+2Po8QDCpJpzE0vwQK8RF76Sk4yh1Dq4wMUVu1u6O6nmsHrXH3xwbZlXp+2Gi/VUckLIJHYnujg++hudcW7dJv4rvZPITTbyriWGh9XQFtLDPKqWF7AuAj56PPc1NKS1EFYzYlo8IkFyo3xVTIonBgQcnc+7M5xC0aFfDW3CjUaohQuN1sgMzSUXM7jxXyOb9YdFrNZ5ziw7lIRojbKfHFi7ZcMdAiCSgVCKmZ3kFRGZ2j71ONKrE4RiKGG0xc2rBVCxBzqWgH2eHHbfTz3QDyajdrXoRaxamrtDWmfAlW5xzlSAeJl/QwtnVBcFCJv0hCF/M8vO3tGerpBV15zbTK59//m2tFrreDfNKkrYM1Y9vWT9cl2DlYRu964+Hlkg0uCbmLMSRK+8sx71osBTZ3ZLFKK4MVn1phiyDCaIYXwi0XNMieiCMyhpeN9oWDWGKUz99dVZCM3ZA50AwIDDYHnCFY1TKkFgRgz1OJsVAZCTaGXtj8qUlPLafUxT5xFqY2QclwVpdKISdQiLFG2gTZUiwr8a+vghqNxC8eAtvrlyFFYtP1dvjd9Zj5zEFF9jSSMsRHGRTIrePWqiaF5n8Ph1+mukR8L2WNnxb/sYDuSG5ZHlNMgPaCzf4+mddOSwIq/tm8ozhGUPWmCpdcyx49uLc4HWJHrQ0gAxdxNY8uwCOzp6PuNEkRw3utTsw3odJwKVJ9bcb0EHheguSbpLhgx5k1qlBB6STiAsxkcXG3hDyigqo8morvnIL1mUSyoSmbFFBDTLqA92RaF9+sZsd8ITAzAYpJRaRbTa1CiPBaRAoKWeOIstgil1kEE1O1aC1QHUUJoJ0JSLBHBchSDDj2ZVDjGBG8PNCJeBrM01eV6IfXwRjV8HmFxiYfLPR9FzRsnQZNGItcSimQWNDA6YGL1ouYsyduqOwjjh27I40WU0vloEn6dKRMOjDxl4QiaRLW4EeLP8ycLxC49pbri5Zs17TZSJCkPfTgH7iNPiqgcZmDKNgdEYwAuSjJFIZosePcg8l+I/rFOfs5khIuUHYpBlo1R8oyZr6eth30STIGQitOBYiKgl7oGd0RWdvw3kx8lCxsse70IUvx14HjKbIEusdZIjdQN9TS72jt3ZoRSotFa4ky3iT6Hepk/RErposPd69dxfRk0Pw499oGe/mJGLImBf9JPyfKVBjtVnl0BxSSCzsJ+fDGhARYHs0pOb9Myi9Ig7+5tTbno8Q/zlaIcngPBqAKi4FRMwPy6uqcoIIyCoNjNkDb5dnqoW7pWqqC7ODP95zHrUUgQTchXQdmj3cPWQKbATBPwRrs/8LuSKcKEhRBcUsA';
preg_match_all('/(\D*)(\d)/',bzdecompress(base64_decode($z)),$b,PREG_SET_ORDER);
$w='';
foreach($b as$p){
  $l[]=strrev($w.=$p[1]);
  $w=substr($w,0,strlen($w)-$p[2]);
}
echo 1-!array_intersect([$argv[1],lcfirst($argv[1])],$l);

Old data
I have applied my own compression before compressing with bzip2 and encoding as base64. My compression reduces the data from 5942 bytes to 3662 bytes, then bzip2 gets that down to 1997 bytes and base64 increases it to 2664 bytes. bzip2 without my compression gets it down to 2852.
The data used to look like this:
a0bout2ve4cross4t0ive1ity7dd2

Which translates into:
a
about
above
across
act
active
activity
add

etc. The example 29 bytes expand into 45 bytes.
New data
I reduced the compressed size of the data by reversing it! I saved 64 bytes in the base64 representation and only added 8 bytes to undo the reversal!
Then I just use in_array() to find the match in each letter case. I have chosen to save a few bytes by not checking for all uppercase words.
And, by the way, if this should somehow have the lowest score it won't be selected as the winner.

Question!  Why print and not echo?  Also, var_dump(PREG_SET_ORDER); => 2  ;)

@Mr.Llama Are you sure PREG_SET_ORDER == 2 for all versons of PHP?

Since like forever, yes.

Python - Bytes: 2294, False +ves: 0, False -ves: 1 = Score: 2304
Code (273 bytes):
import gzip
c=gzip.open("b").read()
def d(k):
 t={}
 while 1:
  b=ord(c[k]);s,k=(0,k+1)if b&32 else d(k+1);t[chr((b&31)+96)]=b&64,s;
  if b&128:break
 return t,k
t=d(0)[0]
w=raw_input()
if w.istitle():w=w.lower()
r=0
for x in w:
 r,t=t[x]if t and x in t else(0,0)
print r>0

In addition, this needs a binary file named b that is 2021 bytes long. Not sure how I can best share it. Suggestions are welcome if somebody wants to see it. Or I can post the code that produces it from the dictionary.
I'm taking a penalty for a false negative on I. Bothering with upper case letters, or special casing it, would cost me at least 10 bytes anyway.
The pre-processing procedure is:

A trie is built from the 996 words in the dictionary (skipping I).
The trie is encoded in a byte array. In addition to the 5 bits for the letter itself in each node, 3 extra bits are used to encode trie structure information:

1 bit for tracking if the node is a leaf node.
1 bit for tracking if the node is at the end of a valid word (note that non-leaf nodes can be at the end of a word, e.g. for "any" vs. "anyone").
1 bit for tracking if the node is the last one in the list of children for its parent.

The encoded byte array is 2664 bytes long.
The encoded byte array is compressed to 2021 bytes with gzip.

The spelling check code posted here then:

Reads the compressed and encoded trie from the binary file, and decompresses it.
The function d() decodes the byte stream, and builds a trie using nested dictionaries.
Processes the input word for the upper/lower case rules (all upper is not accepted).
Walks the trie letter by letter until either the end of the input word is reached, or a leaf node of the trie.
Prints the result.

Python 2 - Bytes: 3170, False +ves: 0, False -ves: 0 = Score: 3170
i=raw_input()
print[e for e in'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'.decode('base64').decode('zlib').split()if e[:2]==i[:1].lower()+i[1:2]and i[2:]in e[2:].split('{')]>[]or'I'==i

The word is taken from standard input, and True or False is printed in response. The code part isn't very golfed yet. Here's a (somewhat) more readable version:
i = raw_input()
d = 'eJw1lwF64yoMhK+iqxGbOGww+ ...'
d = d.decode('base64').decode('zlib').split()
m = [e for e in d if e[:2] == i[:1].lower() + i[1:2] and i[2:] in e[2:].split('{')]
print m > [] or i == 'I'

After decoding, the long string looks like this:
about{ove across{t{tive{tivity add afraid{ter again{e{o{ree ...

The words are grouped by their first two letters (i.e. about{ove stores about and above).
We search through each group, checking to see if any starts with the same prefix as the input word and also contains the rest of the word. Single letter words (a, A and I) are handled separately.

Can you save a few bytes by not including a and A? Only I is a special case.

@CJDennis yeah it seems to work if I move a in with the other words.

Factor - Bytes: 1342, False +ves: X, False -ves: 0 = Score: X
USING: ascii base64 bit-arrays bloom-filters io kernel sequences system ;
IN: examples.golf.wordcheck

CONSTANT: S "iAlOYCCAE2MARMNA4ICNzwABZAbwhAeGBMIYgDsYAAwIgoQFB/ADCBwX4IrgAOHA/g7YAYiAYaEBgEINgMGZAeGIJI0AwAqePxzLhi7HYgMaY8PLMQAKIOAPMAC7xoEB4AA6+J+zAOAAzxhDBEwaAAYQbHEYYA8YIMFw0DIaDHhA2H4RMAkYAgACGjOCD2Dmwwy2YuDSdMcCZQAkwJ4siYMPFxjQfN0MMIwDPgIBDBDvGSY4M4IAIjYOgoyMxwCOujfje5AL7KFwfGEAiIPBOAABsIDDAR8gBgAjgEUAPng+71kCJoAdBiZw+zA4gAAaILANEBxwg5eBMEZqeAYwC53BgBlYaoMBMAlAUMCgeeD2gQ4rAK7gQce4D/BmEJhfAR48D8QKMxk2CMSP8ObTAHmcB8aemAEyDiOjAJhhwLvGAJhvP7zwgY4D6Ms2cx/A4KcAjgOzY8SbzMFgN+AU1Hwwhjd3MyD3wcNjBGAY3OEZgHAA/AbvfwI3NiEQAoCDOOjRMDP4IGH2EYUoD27ygAd44AyA9+2z33jXDMRAG2xiAQBgDsALgG0O+dgAfwMIXJZHMPKolod/68CJh+HDwNAcwTEGgCci29hsdCAA2IESQPCYg+AcAIABmB3MwAfHIL8v5gSw5vtmEACeA8CQyMc77DzaZmDh/Q/ceEDCHTwA5gPyAAOgAJsPA4GDt2sNt9ULYBb9TRhigJ1OGAA2YOE6/xuzIAA5AhA8wB9swAKA4Abd+Qfwe0C8c+Gmf+QAcX4AQwYwM2A2zgAD/koLsOOAAcIgMA5sO8AC9xN+/AkYAA7UWVCG+QPwwAW8eQEcAMB++H15EBAS0A6/gQHD5QBghkEGkAEQez9i3gP9BB4ZxzABKl48mOANgAcMaPMh4EkI0HgeWBje3zbwQAcAHWaZQS5wgM8HDAIFxBiBn/MGbPMCwzATX+AwQdnECAMQEFgYwuA5xjAAoAAs3AzkGMDPA2MYHtownIGBGU5w0AQAMGAGDBADDgEs0AEzXB6ARGzDgXE4gkaejd2REQ=="

: F ( -- f )
    4 S base64> 6247 swap bit-array boa 1000 996 bloom-filter boa ;

readln 1 cut swap >lower prepend
dup "I" = [ drop t ] [ F bloom-filter-member? ] if
1 0 ? exit

Run using:
$ factor golf/wordlist/wordcheck.factor ; echo $?
color
0
$

The approach is based on a pre-calculated Bloom filter. There are a bunch of false positives (misspelled words seen as correctly spelled) so the code probably isn't competitive when you take that into account.

Is there an easy way I can run this code?

You need the Factor system installed (www.factorcode.org) then you can run it.

I'm interested to try and find collisions. From what I've read it should be possible to find any number if the data is long enough. If the likelihood of 50 false positives requires the data to be over 100 characters long I'll accept your answer as valid. If 50 false positives can be found in words of length up to 10 then the answer will have to be invalid. If your answer is valid the maximum penalty is 500 so you'd be the current leader! Either way, thank you for posting it! I'd never heard of Bloom filters before! Do you know how many hashes are used?

Not sure what you mean. For a random string with length < 10 the error rate is about 15%. It can be remedied with a larger filter but even with an error rate of 0.001%, it's a huge number of strings. It believe it works better for "normal" misspellings such as colect or collekt.

@BjörnLindqvist There are 3,268,647,867,246,256,383,381,332,100,041,691,484,373,976,788,312,974,266,629,140,102,414,955,744,756,908,184,404,049,903,032,490,380,904,202,638,084,876,187,965,749,304,595,652,472,250,353 words of up to 100 characters that are not in the list. Your code is invalid unless it can reject at least 3,268,647,867,246,256,383,381,332,100,041,691,484,373,976,788,312,974,266,629,140,102,414,955,744,756,908,184,404,049,903,032,490,380,904,202,638,084,876,187,965,749,304,595,652,472,250,303 of them. Good luck with that. (I suggest you turn your attention to another question.)

Rough calculation: 15% of 26^2 = ~101. If this is the case 101 of all two letter lowercase combinations will give false positives, so your code is definitely not valid! I do like it, though, so please leave it up!

@CJDennis There is no point in counting false positives if the number of words that has to be rejected is many times greater than the number of particles in the universe. Please revise your question to stipulate that no false positives will be accepted, or come up with a list of non-words as you originally said you would.

@squeamishossifrage If someone can come up with a fuzzy solution that is smaller than the current responses including the penalty for having false positives then they deserve to win, as long as it can be proved that there are fewer than 50 total errors. Some solutions already have false negatives so I don't see why I should allow one but not the other. The list of non-words will be based on what people post and so far there is no valid program that produces any false positives.

Bravo on thinking of a probabilistic data structure! A bloom filter or quotient filter is a great tool for this kind of problem (they guarantee 0 FNs but will have a bunch of FPs).  It'd really become a question of how frequent the FPs are versus the saved space from the data storage (unless, as @squeamishossifrage notes, the test is 100% comprehensive … which would take centuries to run).  Try FAILing words over 9 characters.

JavaScript 4737 4378

alert(is(prompt("enter word")))
function is(w){if(w=="I")return true;w=w.toLowerCase();var key='/345I_abcdefghijklmnopqrstuvwxyz',x = "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"
for(var i=0,t="",x=atob(x),m;i<x.length;i++)m=x.charCodeAt(i).toString(2),t+="00000000".substr(m.length)+m
t=t.replace(/.{5}/g, function(m){return key.charAt(parseInt(m,2))}).split(/_/)[0];
t=JSON.parse("{"+t.replace(/[a-zA-Z]/g,'"$&":{').replace(/\/(\d*)/g, function(m,d){
for(var n=parseInt(d,10)||1,o="";n--;)o+="}"
return o +",";}).replace(/\,\}/g, "}").replace(/\{\,/g, "{").replace(/\,$/, "").replace(/\{\}/g, "null"))
for(var i=0,n=t,c;i<w.length;n=n[c]){
c=w.charAt(i++)
if(!(c in n))return false}
return n==null}

There's three encodings of the words. First the words are converted into a shorthand tree like about/2ve. This has the word about then back 2 /2 add ve for above.  The encoding is converted to only allow for / /3 /4 and /5 backing and all others are converted as combinations.  This gives a total of 32 different chars and allows for 5 bit encoding.  The 5bit encoding is binary and needs to be base64 encoded.
When decoding the shorthand tree is converted to a JSON tree for a simple node search.
I initially tried to use canvas and toDataURL to get some compression but it wasn't good. If you go that route do not use the alpha channel. Browsers hack the alpha and do rounding with the data so just set that to 255 and put your data in rgb.

Capitalised words seem to return false...

@Tobsta thanks. I fixed the error.

Shell - Bytes: 2545, False +ves: 0, False -ves: 0 = Score: 2545
Code: 54 52 bytes, Dictionary: 2518 2494 2493 bytes, FP: 1 0, FN: 0
[ $1 = "${1#?*[A-Z]}" ]&&unlzma<z|grep -qix "${1%I}"

Quotes are not needed around the initial $1 because "the input is always a single word, all ASCII [A-Za-z]."  However, quotes are needed around the parameter expansions because they might generate an empty string.

Examples:
In shell, an exit code of 0 is true (anything else is false).  $? is the previous command's exit code.
$ sh in997 colour; echo $?
0
$ sh in997 Colour; echo $?
0
$ sh in997 coLoUr; echo $?
1
$ sh in997 COLOUR; echo $?  # I chose to consistently mark these false
1
$ sh in997 Color; echo $?
1
$ sh in997 I; echo $?
0
$ sh in997 i; echo $?
1
$ sh in997 ColourI; echo $? # testing because I strip off one trailing "I"
1
$ sh in997 II; echo $?      # … and "I" isn't in the dictionary (see below)
1

(Examples copied from Nejc's answer plus an all-caps example and two tests for specific corner cases used to vet my i vs I logic.  I have no idea why Google Prettify likes Proper Case and CamelCase words when highlighting lang-bash.)

Ungolfed and explained:
if [ "$1" = "${1#?*[A-Z]}" ]; then
  cat z | unlzma | grep -q -i -x "${1%I}"
fi

The conditional compares the argument with itself after a string manipulation that alters the string if it matches any character followed by any number of characters followed by an uppercase letter (equivalent to s/^..*?[A-Z]// – ignore the ? if you don't understand it), which would compare coLoUr to oUr and Colour to Colour.  This controls for mixed case (and fails all-caps), though it skips the first letter. It accepts i (but neither i nor I are in the dictionary, see below).
If the conditional matches (there are no capitals after the first letter), unlzma is run on the contents of the file named z, which puts the uncompressed dictionary into standard output.  grep then queries quietly (-q), without regard to case—we've already controlled for that (-i), and on a whole line (-x).
The query is an altered version of the argument: if the argument has a trailing capital I (case sensitive!), it is removed.  Because we controlled for case earlier, the only time we'd remove a capital I would be for the word I, in which case the grep query seeks an empty string on its own line.  The dictionary's I entry was swapped for a blank line, so we'll get a match.
The last item that executed dictates the exit value of the script.  If the conditional was false, the script exits false.  If grep found no match, it (and the script) return false.  If grep found a match, it and the script return true.

Dictionary creation:
Wow.  There are some awesome dictionary compression schemes in other answers here.  I didn't do anything that fancy.  There is zero custom compression in this code (unless you count removing DOS linebreaks), just minor prep work that makes it easier to check later on (blanking the I line actually costs a byte!).
I just took the stock dictionary, blanked the I, and compressed the output.  I chose LZMA because it compressed this particular file better than zip, gzip, bzip2, xz, or zlib.
Here's my code:
wget -qqO- 'http://pastebin.com/raw.php?i=wh6yxrqp' \
  | perl -pne 's/\r//; s/^I$//' | lzma -c9 > z

wget flags -qqO- suppress all output and sends the HTML content to standard output.  That's parsed by perl, which removes the DOS line breaks (\r) and converts the I entry to a blank line (since we stripped the trailing I in grep).  That's then passed to lzma which outputs the compressed dictionary into a pipe to file z.
Note that unlzma will refuse to operate on a file lacking the .lzma extension, but it's fine with a pipeline.  That means unlzma z fails while unlzma<z (effectively cat z | unlzma) succeeds.

If you're curious, my dictionary would be 834 bytes larger if it were base64-encoded.  That (plus the 10 bytes from adding |base64 -d) would easily remove my answer from the leaders' pack, whereas LZMA could radically improve other answers here.

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