text:
Let's draw some Atari ST bombs!
Introduction
The Atari ST was a rather popular personal computer from the mid 80's to early 90's era, powered by a Motorola 68000 microprocessor. On this machine, the default behavior of the operating system for uncaught CPU exceptions was to display a row of bombs on the screen, as shown in the following picture:

Source: https://commons.wikimedia.org/wiki/File:Row_of_bombs.png
NB: Depending on the OS version, the bomb graphics may vary slightly. But let's take this one as reference.
The number of bombs depends on the exception vector, the most common ones being:

($008) Bus Error : 2 bombs
($00c) Address Error : 3 bombs
($010) Illegal Instruction : 4 bombs

Goal
Your goal is to write a program or function that prints or outputs an ASCII art of such Atari ST bombs.
Input
An integer representing the number of bombs to display. Your code must support the most common values: 2, 3 and 4. Supporting less and/or more bombs is fine, but it is neither required nor subject to a bonus.
Output
The original bomb consists of a 16x16 pixel tile, represented here in both ASCII and binary:
....##..........    0000110000000000
.#.#..#.........    0101001000000000
.......#........    0000000100000000
#..#....#.......    1001000010000000
..#...#####.....    0010001111100000
......#####.....    0000001111100000
....#########...    0000111111111000
...###########..    0001111111111100
...###########..    0001111111111100
..#############.    0011111111111110
..########.####.    0011111111011110
...#######.###..    0001111111011100
...######.####..    0001111110111100
....#########...    0000111111111000
.....#######....    0000011111110000
.......###......    0000000111000000

In this challenge, each ASCII bomb must be stretched to twice its original width for a better rendering. Therefore, it will consist of 16 rows of 32 characters, using ## for 'ON' pixels and two spaces for 'OFF' pixels. All bomb tiles must be put side by side. Leading spaces are forbidden. Trailing spaces are also forbidden, except the ones that are actually part of the bomb tile (i.e. the 31st and 32nd columns) which must be present. You may include no more than one leading line-break and no more than one trailing line-break.
Example
Below is the reference output for two bombs, where mandatory line-breaks are marked as \n and tolerated extra line-breaks are marked as (\n):
(\n)
        ####                            ####                    \n
  ##  ##    ##                    ##  ##    ##                  \n
              ##                              ##                \n
##    ##        ##              ##    ##        ##              \n
    ##      ##########              ##      ##########          \n
            ##########                      ##########          \n
        ##################              ##################      \n
      ######################          ######################    \n
      ######################          ######################    \n
    ##########################      ##########################  \n
    ################  ########      ################  ########  \n
      ##############  ######          ##############  ######    \n
      ############  ########          ############  ########    \n
        ##################              ##################      \n
          ##############                  ##############        \n
              ######                          ######            (\n)

(Of course, other line-break formats such as \r or \r\n may be used just as well.)
Rules
This is code-golf, so the shortest answer in bytes wins. Standard loopholes are forbidden.

I notice you've excluded non-ASCII-art forms, so an Atari ST machine-code function that crashes with the right number of bombs doesn't count.  (The bomb isn't in the font, but the Atari ST has fun/easter-egg glyphs in its native character set, including characters 28–31 that are 4 pieces that form the image of J. R. "Bob" Dobbs from the satirical Church of the SubGenius.  I remember writing a program that spammed those 4 glyphs at random screen positions, as a very early exercise in using text-drawing system calls :)

@PeterCordes - That's right, it must be ASCII. However, you'd be allowed to read the bomb graphics from the ST ROM since there's no rule that prevents you from doing it. (Just mention the TOS version this is supposed to work on.)

Oh WOW, that brings back memories. My first computer was an Atari ST. I remember those bombs with dread.

Aside: "The number of bombs depends on the exception vector" - say what?! Any reason why they couldn't output the actual code/error? (Never had an ST, I'm from the Amiga camp... "Guru Meditation" and all that.)

Jelly, 43 44 bytes
+1 byte - forgot to double the characters (not that anyone noticed!)
“¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P"¦ḊƥṾ’b⁴‘ĖŒṙị⁾ #Ḥs⁴ẋ€³Y

TryItOnline
How?
Preparation was to compress the data as a run-length encoding of the original image:

Count the length of each run of 1s (space) or 0s (hash) in the image, ignoring new lines - yields a list: [4,2,11,1,1,...];
Subtract one from each number - this gives a range of [0,15];
Treat this as a base-16 number (enumerate the values, v, with index i in reverse and sum up 16**i*v = 19468823747267181273462257760938030726282593096816512166437);
Convert this to base-250: [5,119,249,42,...];
Map into Jelly's code page as indexes: ¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P

Now the code evaluates this number, maps the 1s and 0s to space and hash characters*, doubles each, splits into lines and repeats each the appropriate number of times.
* actually the implementation is performed modulo 2 to save bytes, so spaces are odd and hashes are even:
“¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P"¦ḊƥṾ’b⁴‘ĖŒṙị⁾ #Ḥs⁴ẋ€³Y - Main link: n
“¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P"¦ḊƥṾ’                  - base 250 number, as above
                           b⁴                - convert to base 16 (the run length - 1 list)
                             ‘               - increment (vectorises) (the run length list)
                              Ė              - enumerate (pairs each with 1,2,3...)
                               Œṙ            - run length decode
                                              ([1,1,1,1,2,2,3,3,3,3,3,3,3,3,3,3,3,4,5,...])
                                  ⁾ #        - string " #"
                                 ị           - index into (1 based and modular)
                                              (makes a bomb without line feeds)
                                     Ḥ       - double (each char becomes a list of 2 chars)
                                      s⁴     - split into slices of length 16
                                        ẋ€³  - repeat each input, n, times
                                           Y - join with line feeds

05AB1E, 57 55 53 50 bytes
Uses CP-1252 encoding.
•ø6ŒY2l½î€ÈS`L<eÆô‚˜3ª½¨ºE»D2Âô3•b15ôvy1J€D„# è¹×,

Try it online!
Explanation
As the output image only consists of 2 characters we can represent it as a binary number.
We can ignore newlines as every line has the same length.
We can ignore the last char of each row as it the same for all rows.
We use the thinner image as it takes up less space and we can easily duplicate each character later.
Using 1 to represent space and 0 to represent # we get the binary number:
111100111111111101011011111111111111101111111011011110111111110111000001111111111000001111111100000000011111000000000001111000000000001110000000000000110000000010000111000000010001111000000100001111100000000011111110000000111111111100011111
We then convert this to base-10 and then compress it to base 214, the maximum base in 05AB1E. The result of this is:
•ø6ŒY2l½î€ÈS`L<eÆô‚˜3ª½¨ºE»D2Âô3•

The meat of the program then consist of the following:
<base encoded string>
  b                     # convert to binary
   15ô                  # slice into pieces of 15
      v                 # for each slice
       1J               # append a 1
         €D             # duplicate each character
           „#           # push the string "# "
             è          # use the list of binary digits to index into the string
              ¹×        # repeat string input number of times
                ,       # and print with newline

Pyth, 57 56 54 53 51 50 bytes
The code contains unprintable characters, so here's a reversible xxd hexdump.
00000000: 6a2a 4c51 6331 3673 2e65 2a79 6240 2220  j*LQc16s.e*yb@"
00000010: 2322 6b6a 4322 4c49 c142 3c60 0cca 9437  #"kjC"LI.B<`...7
00000020: b383 76bb c246 c86d 4c04 99bd 3614 7022  ..v..F.mL...6.p"
00000030: 3137                                     17

Try it online.

JavaScript (ES6), 159 154 140 136 bytes
Saved lots of bytes thanks to @Hedi and @Arnauld
n=>[..."ￏﾵｿﻶ쀇쀇考萃쐇숇ﱿ"].map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(x.charCodeAt()).repeat(n)).join`
`

That's 104 chars, but (sadly) 136 UTF-8 bytes. The string was generated with this snippet:

console.log([
0b1111111111001111,
0b1111111110110101,
0b1111111101111111,
0b1111111011110110,
0b1111100000111011,
0b1111100000111111,
0b1110000000001111,
0b1100000000000111,
0b1100000000000111,
0b1000000000000011,
0b1000010000000011,
0b1100010000000111,
0b1100001000000111,
0b1110000000001111,
0b1111000000011111,
0b1111110001111111
].map(x=>(65535-x).toString(16)).join(","))

Using .replace instead of [...string].map is equally long:
n=>"ￏﾵｿﻶ쀇쀇考萃쐇숇ﱿ".replace(/./g,x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(x.charCodeAt()).repeat(n)+`
`)

How it works
Since each row of the raw data can be represented as a 16-bit number, we can store the entire file in a 16-char string. The compression algorithm takes each binary row, flips it and reverses it (since every row in the original ends in a 0, every row in the modified version now starts with a 1), then turns it into a char, and concatenates the resulting characters.
To decompress it, we need to extract the charcode and turn its binary representation into a string of hashes and spaces. This can be done with a recursive function, like so:
(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(x.charCodeAt())

f repeatedly takes the last bit of q, selecting two spaces if it's 1 or two hashes if it's 0, then concatenates that with the result of running f in the rest of q. This is run on x.charCodeAt(), turning the char-code into the correct string of spaces and hashes.
(There was a lot more drama here before, but the 4-byte-saving technique erased all of that.)
After that, we can just repeat the string n times and add a newline. This is the shortest decompression method I have found, but feel free to suggest any possibly shorter methods.
Other attempts at compressing the string:
n=>[48,74,128,265,1988,1984,8176,16376,16376,32764,31740,15352,15864,8176,4064,896].map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(65535-x).repeat(n)).join`
`
n=>"1c,22,3k,7d,1j8,1j4,6b4,cmw,cmw,pa4,oho,bug,c8o,6b4,34w,ow".split`,`.map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(65535-parseInt(x,36)).repeat(n)).join`
`
n=>"30,4a,80,109,7c4,7c0,1ff0,3ff8,3ff8,7ffc,7bfc,3bf8,3df8,1ff0,fe0,380".split`,`.map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")('0x'+x^65535)).repeat(n)).join`
`

The first of these is 153 bytes, so none of them come anywhere near 136...

Could save some bytes with +x?'##':'  ' instead of " #"[x].repeat(2)

@Hedi thanks, I knew there was a way to golf that bit.

Could you directly test the bits of x.charCodeAt() rather than converting it to binary? (I think that would save about 8 bytes.)

@Arnauld It saves 14 bytes, thanks :)

Your compression algorithm sounds almost cryptographic.

@Justin Damn, I was just about to comment that.

MS-DOS .COM file, 84 bytes
OK. Just for fun because I cannot beat the 50 bytes...
Tried under DOSbox as well as under MS-DOS 6.22 in a virtual machine.
Under DOSbox the program works fine however under real MS-DOS the output will not be displayed correctly because DOS requires CR-LF instead of LF at the end of the line.
(However the output is correct.)
A 88 byte variant would use CR-LF at the end of the line.
Here is the file:
0000  be 32 01 fc ad 89 c3 8a  36 82 00 80 ee 30 b9 10
0010  00 d1 c3 18 d2 80 ca 20  80 e2 23 b4 02 cd 21 cd
0020  21 e2 ee fe ce 75 e7 b2  0a cd 21 ad 85 c0 75 d5
0030  cd 20 00 0c 00 52 00 01  80 90 e0 23 e0 03 f8 0f
0040  fc 1f fc 1f fe 3f de 3f  dc 1f bc 1f f8 0f f0 07
0050  c0 01 00 00

The assembler code (in AT&T syntax) looks like this:
start:
      # Read data from "image:"
    mov $image,%si
    cld
      # Read the first 16 bytes
    lodsw
nextLine:
      # Use bx as shift register
    mov %ax, %bx
      # Read the number of bombs
    mov 0x82,%dh
    sub $'0',%dh
nextBombInThisLine:
      # Number of characters
    mov $16, %cx
nextCharacter:
      # Rotate the data# get the next bit to CY
    rol $1, %bx
      # This results in 0x23 ('#') if CY is set, to 0x20 (' ') otherwise
    sbb %dl, %dl
    or $0x20, %dl
    and $0x23, %dl
      # Print result character twice
    mov $2, %ah
    int $0x21
    int $0x21
      # more Characters in this line?
    loop nextCharacter
      # More bombs to draw?
    dec %dh
    jnz nextBombInThisLine
      # Print a newline
#        mov $13, %dl # <- Additional 4 bytes needed for "\r\n"
#        int $0x21    #    at the end of the line!
    mov $10, %dl
    int $0x21
      # Read the next 16 bytes# 0x0000 means: EOF
    lodsw
    test %ax,%ax
    jnz nextLine
      # End of program
    int $0x20
image:
    # Here 34 bytes follow:
    # 16 16-bit-words "bitmap" for the bombs followed
    # by 0x0000 indicating the end of the bitmap

--- Edit ---
I forgot to mention: The program must be started with the following command line:
Name of the COM file + exactly one space character + Number of bombs (1-9)

Nice. We're still lacking a 68000 answer, but this one is getting closer. :-)

objdump -dw output is a good way to show the raw binary, since you see which bytes are which instruction.  I did that for gcd and adler32 answers.  (As well as including commented source code for people to try themselves.)

Python, 223 179 bytes
Second approach:
f=lambda n:'\n'.join(''.join(2*' #'[int(d)]for d in bin(int('0c0052000100908023e003e00ff81ffc1ffc3ffe3fde1fdc1fbc0ff807f001c0'[i:i+4],16))[2:].zfill(16))*n for i in range(0,64,4))

Try it on repl.it!
Rather than creating a list of strings on-the-fly, there is a hard-coded hexadecimal string which is indexed and converted to binary; then each binary digit is turned into either ' ' or '#', which is duplicated and joined together ... etc.
First approach:
s='  ';b='##';f=lambda n:'\n'.join(n*l.ljust(32)for l in[s*4+b*2,(s+b)*2+s*2+b,s*7+b,b+s*2+b+s*4+b,s*2+b+s*3+b*5,s*6+b*5,s*4+b*9,s*3+b*11,s*3+b*11,s*2+b*13,s*2+b*8+s+b*4,s*3+b*7+s+b*3,s*3+b*6+s+b*4,s*4+b*9,s*5+b*7,s*7+b*3])

Try it on repl.it!
This contains a hard-coded list of the strings of each line (not including trailing spaces) created by duplicating either '  ' or '##' a number of times. For each of these strings, they are padded with spaces until 32 characters in length, duplicated n times, then joined with newlines.

You can save a byte by switching to printing an unrolled generator, instead of joining on '\n'. So, lambda n:print(*(''.join(2*' #'[int(d)]for d in bin(int('0c0052000100908023e003e00ff81ffc1ffc3ffe3fde1fdc1fbc0ff807f001c0'[i:i+4],16))[2:].zfill(16))*n for i in range(0,64,4))). Also, you don't have to count the bytes needed to assign the lambda a name. So your score can be 176.

C, 250 240 208 188 bytes
d[]={3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448,0},m,c,*i=d;f(k){for(;*i;i++,puts(""))for(c=k;c--;)for(m=32768;m;write(1,&"##  "[m&*i?0:2],2),m>>=1);}

Switch to using a function.
m,d[]={3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448,0},*i=d;main(c,v)char**v;{for(;*i;puts(""),i++)for(c=atoi(v[1]);c--;)for(m=32768;m;write(1,&"##  "[m&*i?0:2],2),m>>=1);}

Test like this.

main(c,v)char**v;
{
    f(atoi(v[1]));
}

a.exe 2
        ####                            ####
  ##  ##    ##                    ##  ##    ##
              ##                              ##
##    ##        ##              ##    ##        ##
    ##      ##########              ##      ##########
            ##########                      ##########
        ##################              ##################
      ######################          ######################
      ######################          ######################
    ##########################      ##########################
    ################  ########      ################  ########
      ##############  ######          ##############  ######
      ############  ########          ############  ########
        ##################              ##################
          ##############                  ##############
              ######                          ######

You can save a few bytes by using the decimal representations of those hex numbers to lose the 0x.

@Copper Thanks, I managed to shave quite a few bytes also using write in place of putchar.

///, 539 532 + no. of bombs bytes
The first /// answer, displaying 4 bombs. The end four 1's can be replaced with any unary representation of the number of bombs you want to print (11 for 2, 111 for 3)
/-/?|X//y/\/X//xy|//|/\/\///+/%@!|$/bcd|%/efg|@/hij|!/klm|?/nop|b/Bxc/Cxd/Dxe/Exf/Fxg/Gxh/Hxi/Ixj/Jxk/Kxl/Lxm/Mxn/Nxo/Oxp/Pxq/ss|r/tt|s/SS|t/TT|S/  |T/##|1/AX$+-$+?AXyAX$+-cd+?by$+-d+?cycd+-+?dyd+-fg@!?ey+-g@!?fyfg@!-@!?gyg@!-ij!?hy@!-j!?iyij!-!?jyj!-lm?ky!-m?lylm-?mym-opny-poyop|AXA/AA|bB/BB|cC/CC|dD/DD|eE/EE|fF/FF|gG/GG|hH/HH|iI/II|jJ/JJ|kK/KK|lL/LL|mM/MM|nN/NN|oO/OO|pP/PP|A/qtqqs|B/STSTsTqqS|C/qsSTqq|D/TsTqTqsS|E/sTsSrTqS|F/qsrTqS|G/qrrTsS|H/sSrrtTs|I/sSrrtTs|J/srrrTS|K/srrSrS|L/sSrtTStTs|M/sSrtSrs|N/qrrTsS|O/qSrtTq|P/qsStTqs|X/
/1111

Try it online!
If the input must be decimal, the following has 555 548 bytes (where the last digit can be changed to 1, 2, 3 or 4):
/-/?|X//y/\/X//xy|//|/\/\///4/13|3/12|2/11|^/tT|&/rr|*/sS|+/%@!|$/bcd|%/efg|@/hij|!/klm|?/nop|b/Bxc/Cxd/Dxe/Exf/Fxg/Gxh/Hxi/Ixj/Jxk/Kxl/Lxm/Mxn/Nxo/Oxp/Pxq/ss|r/tt|s/SS|t/TT|S/  |T/##|1/AX$+-$+?AXyAX$+-cd+?by$+-d+?cycd+-+?dyd+-fg@!?ey+-g@!?fyfg@!-@!?gyg@!-ij!?hy@!-j!?iyij!-!?jyj!-lm?ky!-m?lylm-?mym-opny-poyop|AXA/AA|bB/BB|cC/CC|dD/DD|eE/EE|fF/FF|gG/GG|hH/HH|iI/II|jJ/JJ|kK/KK|lL/LL|mM/MM|nN/NN|oO/OO|pP/PP|A/qtqqs|B/STSTsTqqS|C/q*Tqq|D/TsTqTq*|E/sT*rTqS|F/qsrTqS|G/q&T*|H/*&^s|I/*&^s|J/s&rTS|K/s&SrS|L/*r^S^s|M/*rtSrs|N/q&T*|O/qSr^q|P/q*^qs|X/
/4

Try it online!
The most important parts of the code are that:
| means //
ABCDEFGHIJKLMNOP mean each line of the bomb respectively
S means 2 spaces
s means 4 spaces
* means 6 spaces
q means 8 spaces
T means ## (2)
t means #### (4)
^ means ###### (6)
r means ######## (8)
& means ################ (16)
Most of the code is making sure that the bombs are printed side-by-side, not on top of each other.

MATL, 64 63 60 59 58 bytes
49:',cxJr(v9hW&waHB`U=NL%)C9[$aoAN'F16ZaQEY"32e!' #'w)liX"

Try it online!
Explanation
The code uses a pre-compressed version of the 16×16 binary matrix. The pre-compressing (not part of the program) used two steps:

Run-length encoding of the matrix read in row-major order (first across, then down).
The resulting run-lengths range from 1 to 16, so the vector of run-lengths minus 1 was converted from base 16 to base 94 (to use all printable ASCII codes except single quote, which is not used because it would need escaping).

The compressed string,
   ',cxJr(v9hW&waHB`U=NL%)C9[$aoAN'

is decompressed from base 94 to base 16:
                                   F16Za

The obtained vector of run-lenghts plus 1 is multipled by 2:
                                        QE

to perform the horizontal stretching.
The vector of run-lenghts contains 49 values. The original numbers to be repeated with those lengths should be [0 1 0 1 ... 0] (49 entries). But instead of that, it's shorter to use the vector [1 2 ... 49], which will be equally valid thanks to modular indexing. So the run-length decoding is
49:                                       Y"

The generated vector containis the runs of 1, 2, ...49, for a total of 512 entries. This is reshaped into a 16×32 matrix:
                                            32e!

and used as modular indices into the string ' #' to produce a single bomb:
                                                ' #'w)

Finally, horizontal repetition by a factor given by the input produces the desired result:
                                                      liX"

PHP, 138 104+32=136 bytes
I had never thought that file was binary safe. I only wish I would have found a more interesting way to store the data; but nothing I tried beat raw binary.
foreach(unpack("v*",file(b)[0])as$v)echo"
",str_repeat(strtr(sprintf("%016b",$v),["  ","##"]),$argv[1]);

read binary data from file, unpack from little endian 16bit to array of int
loop through array: print 16 digit binary to string,
replace 0 with 2 spaces, 1 with ##,
repeat $argv[1] times, print result + newline

run with -r

binary data in file b:
0000000 0c00 5200 0100 9080 23e0 03e0 0ff8 1ffc
0000010 1ffc 3ffe 3fde 1fdc 1fbc 0ff8 07f0 01c0

code to generate the file:
$f=fopen(b,wb);foreach(array_map(bindec,explode("
",
"0000110000000000
0101001000000000
0000000100000000
1001000010000000
0010001111100000
0000001111100000
0000111111111000
0001111111111100
0001111111111100
0011111111111110
0011111111011110
0001111111011100
0001111110111100
0000111111111000
0000011111110000
0000000111000000"))as$c)fputs($f,pack("v*",$c));fclose($f);

You can save 2 bytes by using a leading line break rather than a trailing one and thus not having the space after the echo and by using an actual line break rather than the \n.

@user59178 I know. not so verbose please.

CJam, 66 bytes
"^a1{9\b aZ5w7qQAwndIUffO"136b2b1Ser0'#erG/ri*z{:_N}%

Try it online! (note that there are some unprintable characters in the code.)

The bomb in encoded in as a number in binary using 1 for spaces (the leading space as 1 ensures we don't have to pad the binary representations), transposed, and then converted to string in base-136 (which produced the shortest string without wide-characters). These steps can be played with here.
This answer then reverses the encoding, the main trick being to repeat the bomb before transposing, effectively concatenating each line of the bomb at once. The characters in each line can be then be doubled up with newlines inserted for the final output.

C (gcc), 216 204 183 165 134 bytes
b(n,i){for(n*=16,i=--n*16;i--;i%n||puts(""))printf(L"àϸ\x7fc\xfde\xfee`\x1fff\xffe\xffe\x7fcǰᇰ䡀\x80⤀\x600"[i/n]&1<<i%n%16?"##":"  ");}

Try it online!
Written as a standalone program (201 183 151 bytes)
i=16;main(j,l)char**l;{for(;i--;puts(""))for(j=*l[1]*16-769;j--;printf(L"àϸ\x7fc\xfde\xfee`\x1fff\xffe\xffe\x7fcǰᇰ䡀\x80⤀\x600"[i]&1<<j%16?"##":"  "));}

Try it online!
This segfaults if a command line parameter is not supplied.

Python 2: 143 bytes
n=input()
j=2
while j<258:print''.join(2*'# '[b>'0']for b in bin(int('62XI2JG3U2Q0COCDFCZAMC8A9LAP6W1ZMM4A59GC43M49ENF3Z',36))[j:j+16])*n;j+=16

It's at ideone
(I realised that direct encoding of the original bomb in base 36 made for shorter code in Python.)
The string was formed by treating spaces as 1s and hashes as 0s, and then converting to base 36. The program then converts back to binary and slices into lengths of 16 (with an offset of 2 for the '0b' at the front of Python's binary string) , converts to double spaces and double hashes, joins them up, repeats the string n times and prints.

Previous: Python 2, 169 166 163 bytes
n=input()
j=0
while j<512:print''.join(' #'[i%2]*2*(v+1)for i,v in enumerate(int(c,16)for c in'31A00010F07010308024A4885A4A3C2703360245035876A25'))[j:j+32]*n;j+=32

It's at ideone
Almost a port of my Jelly answer.

Inefficient is good if it is shorter. Nice +1

Python 2.7, 144 141 bytes
x=input()
for i in range(16):print"".join(" #"[b<"1"]*2for b in bin(int("5ZCAZKAVTP6J04W4VZJ2BQDH5DASIKRS524V8SWRSIVWZEWC8V",36))[2+i::16]*x)

The bomb is written in binary with 1 for space, the leading 1 removes the need to pad binary representations. The bomb is transposed (much like in my CJam answer) and stored in base 36.
The program decodes the bomb to binary and iterates bits by a step of 16 effectively following the transposition (which is saves bytes over slicing a given line). The resultant line is concatenated, bits are replaced with doubled  or #, and joined into a singe string.

You can drop the leading zero from your base 36 number.

@JonathanAllan: Nice catch. I thought that was an O for some reason...

Batch, 415 bytes
@echo off
set h=#####
set s=
for %%a in ("    ##%s%%s%" " # #  #%s%    " "%s%  #%s%   " "#  #    #%s%  " "  #%h%%s%" "%s% %h%%s%" "    %h%####   " "   %h%%h%#  " "   %h%%h%#  " "  %h%%h%### " "  %h%### #### " "   %h%## ###  " "   %h%# ####  " "    %h%####   " "%s%%h%##    " "%s%  ###%s% ")do call:l %1 %%a
exit/b
:l
set r=
for /l %%i in (1,1,%1) do call set r=%%r%%%~2
set r=%r: =  %
echo %r:#=##%

Note: the line set s= ends in 5 spaces. Accepts the count as a command-line parameter. Simply loops through each line of the bomb (compressed very slightly by removing runs of 5 identical characters) then repeats the bomb as many times as desired before finally duplicating each character.

RProgN, 210 193 Bytes
Saved some bytes by switching 0='  ' 1='##' to 1='  ' 0='  ', this means i don't need to add the extra zeros back. Also, this means that now the B64 string that used to say "MAFIA" does not, This is sad.
'n' = => 64 -B 2 B ] 1 16 sub n rep \ 17 32 sub n rep '
' \ . . '1' '  ' replace '0' '##' replace } a'' = D4D/4/'' a DgQ/AH'' a DAIeAj'' a DgA8AB'' a DwB+AD'' a DcH/wf'' a D+/29/'' a Dz/63/'' a

Explanation
'n' =                   # Associate the input with "n"
=>                      # Push a new function to the stack.
    64 -B               # Take the value from the top of the stack, convert it to an integer from Base64
    2 B                 # Take the value from the top of the stack, convert it from an integer to binary
    ]                   # Duplicate the top of the stack.
    1 16 sub            # Push the substring from the top of the stack between 1 and 16, 1 indexed.
    n                   # Push the input.
    rep                 # Repeat, this gives us 'n' bombs, essentially.
    \                   # Flip the values such that REPEATEDBOMB_ROW TEXT
    17 32 sub           # Push the substring between 17 and 32.
    n                   # Push the input
    rep                 # Repeat
    '                   # Push a new line
'                       # RProgN doesn't actually have escapes, so the raw newline is represented as a newline between qoutes.
    \ . .               # Flip the values so we have LINE1 NEWLINE LINE2, then concatenate them all into one string.
    '1' '  ' replace    # Replace all the 1's in the binary string with two spaces.
    '0' '##' replace    # Replace all the 1's with two '#'s
} a'' =                 # Associate the function with 'a'
D4D/4/'' a              # Bottom two lines,
DgQ/AH'' a              # Next two up,
DAIeAj'' a              # Etc...
DgA8AB'' a              # Once This is done, the memory stack is implicitly printed from top to bottom.
DwB+AD'' a              # As such, the bomb is upside down.
DcH/wf'' a              # Each of these numbers represents two lines, which is why we do the substringing to split it.
D+/29/'' a              # This works out saving a few bytes.
Dz/63/'' a              # Implicitly printed output. Yay.

Pretty long, The expanding, printing and such of the compressed string is 105 of the bytes.
Might be a bit more golfable, but atleast it works.
Input is implicitly on the stack, stack is implicitly printed.
Output
        ####                            ####                            ####
  ##  ##    ##                    ##  ##    ##                    ##  ##    ##
              ##                              ##                              ##
##    ##        ##              ##    ##        ##              ##    ##        ##
    ##      ##########              ##      ##########              ##      ##########
            ##########                      ##########                      ##########
        ##################              ##################              ##################
      ######################          ######################          ######################
      ######################          ######################          ######################
    ##########################      ##########################      ##########################
    ################  ########      ################  ########      ################  ########
      ##############  ######          ##############  ######          ##############  ######
      ############  ########          ############  ########          ############  ########
        ##################              ##################              ##################
          ##############                  ##############                  ##############
              ######                          ######                          ######

Try it!

<style>
  #frame{
    width:60em;
    height:60em;
    border:none;
  }
</style>
<iframe id='frame' src="https://tehflamintaco.github.io/Reverse-Programmer-Notation/RProgN.html?rpn=%27n%27%20%3D%20%3D%3E%2064%20-B%202%20B%20%5D%201%2016%20sub%20n%20rep%20%5C%2017%2032%20sub%20n%20rep%20%27%0A%27%20%5C%20.%20.%20%271%27%20%27%20%20%27%20replace%20%270%27%20%27%23%23%27%20replace%20%7D%20a%27%27%20%3D%20D4D%2F4%2F%27%27%20a%20DgQ%2FAH%27%27%20a%20DAIeAj%27%27%20a%20DgA8AB%27%27%20a%20DwB%2BAD%27%27%20a%20DcH%2Fwf%27%27%20a%20D%2B%2F29%2F%27%27%20a%20Dz%2F63%2F%27%27%20a&input=1">Sorry, You need to support IFrame. Why don't you..?</iframe>

Python 2, 206 205 203 199 191 188 186 184 160 bytes
z=input()
for y in 3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448:print"".join(" #"[e>0]*2for e in map(int,bin(y+8**6)[5:]))*z

Looked at Hex for the number list but it didn't seem to save enough to make it worth the effort. Was hoping to be able to golf the code down but seem to have got as far as I can with this approach. Any additional hints gratefully received.
EDIT
-1 by changing e==1 to e>0. I always forget that one.
-2 by ignoring the length of the binary string, prepending 7 0's and taking only the last 16 elements. Works as there are never more than 7 leading 0's.
-4 because now that I have lost the second reference to the variable b I can use bin(y)[2:] directly in the map function taking it below the magic 200 :-)
-8 by using slice assignment on the second list. Learned something new this evening.
-3 with thanks to @Jonathan
-2 by using c=d=([0]*7+map(int,bin(y)[2:]))[-16:] instead of having c=d;
-2 again thanks to @Jonathan
-24 with thanks to @Linus
Output
python bombs.py
2
        ####                            ####
  ##  ##    ##                    ##  ##    ##
              ##                              ##
##    ##        ##              ##    ##        ##
    ##      ##########              ##      ##########
            ##########                      ##########
        ##################              ##################
      ######################          ######################
      ######################          ######################
    ##########################      ##########################
    ################  ########      ################  ########
      ##############  ######          ##############  ######
      ############  ########          ############  ########
        ##################              ##################
          ##############                  ##############
              ######                          ######

" #"[e>0]*2 will work

DOH! How did I miss that one??? Thanks @ Jonathan

...the parentheses (...) can go too (RE: per my previous comment).

You can take it down to 170 with for y in ...:print"".join(" #"[e>0]*2for e in(([0]*7+map(int,bin(y)[2:]))[-16:]))*z

@Jonathan Thanks again. it's getting late here so I'll save that change for tomorrow so I don't mess it up completely.

if you add 8**6 to a smaller number before converting to binary it will have a length of 21 characters. You can then slice pass the first few bytes and still get the leading 0s... this also skips the 0b. So map(int,bin(y+8**6)[5:]) saves 9 bytes over ([0]*7+map(int,bin(y)[2:]))[-16:].

If you skip the assignments and nest the operations like print"".join(" #"[e>0]*2for e in map(int,bin(y+8**6)[5:]))*z you can get this down to 161 bytes.

PHP, 144 140 139 138 136 bytes
Note: uses Windows-1252 encoding
for(;$j%=32*$argn or$r=intval(substr("01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow",$i++*3,3),36)*print~õ;)echo~ßÜ[$r>>$j++/2%16&1];

Run like this:
echo 2 | php -nR 'for(;$j%=32*$argn or$r=intval(substr("01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow",$i++*3,3),36)*print~õ;)echo~ßÜ[$r>>$j++/2%16&1];'

Or using IBM-850 encoding (135 bytes and prettier result):
echo 2 | php -nR 'for(;$j%=32*$argn or$r=intval(substr(~¤╬£¤══¤╠ö¤╚ø╬òÃ╬ò╦╔Ø╦£Æê£ÆêÅ×╦ÉùÉØèÿ£ÃÉ╔Ø╦╠╦ê¤Éê,$i++*3,3),36)*print~§;)echo~▀M[$r>>$j++/2%16&1];'

        ▓▓▓▓                            ▓▓▓▓
  ▓▓  ▓▓    ▓▓                    ▓▓  ▓▓    ▓▓
              ▓▓                              ▓▓
▓▓    ▓▓        ▓▓              ▓▓    ▓▓        ▓▓
    ▓▓      ▓▓▓▓▓▓▓▓▓▓              ▓▓      ▓▓▓▓▓▓▓▓▓▓
            ▓▓▓▓▓▓▓▓▓▓                      ▓▓▓▓▓▓▓▓▓▓
        ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓              ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
    ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
    ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓
      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓
      ▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓
        ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓              ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓                  ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
              ▓▓▓▓▓▓                          ▓▓▓▓▓▓

Explanation
This doesn't do any binary stuff and doesn't require an external file.
Every 16 bit number is reversed, then encoded as a base-36 number, padded with a leading 0 if necessary, so every 16 bits result in 3 bytes. Concatenating those results in 01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow. The code reverses the process so the bombs are printed correctly N times.
Tweaks

Saved 4 bytes by using only a single for-loop
Saved a byte by printing a single char for each iteration and using string index instead of ternary
Saved a byte by getting resetting $j to zero on line boundaries with %=. This gets rid of parentheses
Saved 2 bytes by using $argn

GCC C 129 bytes
ISO8859/ASCII
f(r,i,d){
    for(;i<32;i+=2,puts(""))
        for(d=15*r;--d;)
             printf((*(int*)&("ÿóÿÿþoÜüðààÀ!ÀCÀCàðø?þ"[i]))&(1<<d%15)?"  ":"##");
}

In one line:
f(r,i,d){for(;i<32;i+=2,puts(""))for(d=15*r;--d;)printf((*(int*)&("ÿóÿÿþoÜüðààÀ!ÀCÀCàðø?þ"[i]))&(1<<d%15)?"  ":"##");}

Run with:
main(c,v)char**v;{f(atoi(v[1]),0)}

Compile source as ISO8859-x (ASCII).
NB óÿÿþÿoÜüðààÀÀ!ÀCàCðøþ? should contain the invisible ASCII Codes but it has been broken due to the way StackExchange presents its content.
Please see the ideaone link for proper test encoding
Alternatively the original ASCII String is at :
https://github.com/claydonkey/AtariBombs/blob/master/ISO8859_REPR2.txt
Explanation
First a conversion of the hex representation of bombs
[f3 ff ad ff fe ff 6f 7f dc 1f fc 1f f0 07 e0 03 e0 03 c0 01 c0 21 c0 43 e0 43 f0 07 f8 0f fe 3f] to UTF-8 (in the UTF-8 version the compiler stores the string as Wide Char Array - 2 or 4 bytes for each character at runtime but this is academic). Whereas UTF-8 characters would be stored as 2-4 bytes, these values are all within  ISO-8859-1 (ASCII) and thus only require 1 byte. Also it is safe to be stored as ISO-8859-x (there are no 0x8_ or 0x9_ values). Therefore the text consumes 32 bytes in ISO-8859 and the routine consumes 135 bytes in total.
(NB wide chars are stored as a 16 bit integer in windows and 32bit in linux but again this is irrelevant to the task at hand)
Caveat:  Not all the characters are displayable (the control characters below 0x20) .They are, however still present . Most web pages are utf-8/ 8859/1253 (https://w3techs.com/technologies/overview/character_encoding/all) so I reckon this is legit(shifting all values below 0x20 to printable ASCII should fix that).

UTF-8
Here is the version closer to the original posting with UTF-8 encoded source.
This consumes 173 bytes. The string itself being 50 bytes of the source.
The routine is also longer as the ASCII bytes are now stored with padding 0's for the 16bit/32bit Wide Chars and have to be shifted instead of casted to uint16_t as above. I have kept this up as it can be verified with ideone which uses UTF-8 encoding.
*w=L"óÿÿþÿoÜüðààÀÀ!ÀCàCðøþ?";
f(r,i,j,m){
    for(i;i<32;i+=2,puts(""))
        for(j=r;j--;)
            for(m=65536;m>1;(m\=2,printf(((w[i]<<8)+w[i+1]&m)?"  ":"##")));}

Run with:
main(c,v)char**v;{f(atoi(v[1]),0)}

If you can set the implicit value to a 16bit integer in your complier you can omit the wchar_t type declaration of the Wide Char. Ideone doesn't complain so I reckon it's good to go.
Try it out on ideone

Impressive. What encoding does this use?

Its compiled on MinGW GCC where a wide character is an uint16. Therefore the encoding is [16-bit type holding UTF-16 Unicode]. However, I think that because the characters are within 0xFF (16bit) they are extended ASCII. + So nothing special

Sorry I have learnt a tad more about the encoding and may have been wrong about it being  stored as UTF-16.please refer to the overhauled answer.

Haskell, 191 181 bytes
f n=h n:f(div n 2)
h n|odd n=' '
h _='#'
g b=mapM_ putStrLn[[f 0xfc7ff01fe00fc207c40784038003c007c007e00ff83ff83bfef6ff7fffb5ffcf!!(x`mod`32`div`2+y*16)|x<-[0..32*b-1]]|y<-[0..15]]

Haskell, 155 bytes
As a function with type Int -> String:
b z=concat$do y<-[0..15];"\n":[if odd$div 0x3800FE01FF03DF83BF87BFC7FFC3FF83FF81FF007C007C401090080004A0030(2^(16*y+x))then"##"else"  "|x<-[1..z]>>[0..15]]

Printing to IO directly will cost 5 bytes (or 6 if we prefer to return IO () rather than IO [()]):
b z=mapM putStr$do y<-[0..15];"\n":[if odd$div 0x3800FE01FF03DF83BF87BFC7FFC3FF83FF81FF007C007C401090080004A0030(2^(16*y+x))then"##"else"  "|x<-[1..z]>>[0..15]]

J, 89 bytes
|:@;@#&(<' #'{~2#|:16 16$}.2#.inv 95#.32x-~3 u:'u,:C>%}UwPXHn_C9wF.|U ap<{jH%O9 9wRThGs')

Encodes the string as a base-95 number, increments each digit by 32, then represents it by an ascii string.
Explanation
This is composed of two main parts. There is the constructing of the bomb, and the actual repetition. Let's for the moment refer to the bomb as b. Then, the code looks like:
|:@;@#&(b)

When called with input k, this is equivalent to:
|: ; (k#b)

b is a boxed bomb, so k#b makes k repetitions of b, ; flattens it vertically, and |: transposes the result. (The bomb b is itself constructed transposed.)
Now, here is the bomb:
<' #'{~2#|:16 16$}.2#.inv 95#.32x-~3 u:'u,:C>%}UwPXHn_C9wF.|U ap<{jH%O9 9wRThGs'

The string following is a base-95 encoded string with an offset of 32, so that all the characters fall into the ASCII range, and thankfully there are no 's that need to be escaped. 3 u: gets the char codes of the string, 32x-~ makes each number an extended number and subtracts 32 from it; 95#. converts to a base-95 number an 2#.inv converts it to a binary digit array. I added a leading 1 to the binary in order to make it a solid number, so I take it off with }.. I shape the array into a 16x16 table with 16 16$ then transpose it using |:. (Possible golf for later: transpose the literal encoded string.) 2# duplicates each character width-wise. We are left with a table of 0s and 1s. ' #'{~ maps 0s to ' ' and 1 to '#'. As thus, we are left with our bomb.
Test case
   |:@;@#&(<' #'{~2#|:16 16$}.2#.inv 95#.32x-~3 u:'u,:C>%}UwPXHn_C9wF.|U ap<{jH%O9 9wRThGs') 3
        ####                            ####                            ####
  ##  ##    ##                    ##  ##    ##                    ##  ##    ##
              ##                              ##                              ##
##    ##        ##              ##    ##        ##              ##    ##        ##
    ##      ##########              ##      ##########              ##      ##########
            ##########                      ##########                      ##########
        ##################              ##################              ##################
      ######################          ######################          ######################
      ######################          ######################          ######################
    ##########################      ##########################      ##########################
    ################  ########      ################  ########      ################  ########
      ##############  ######          ##############  ######          ##############  ######
      ############  ########          ############  ########          ############  ########
        ##################              ##################              ##################
          ##############                  ##############                  ##############
              ######                          ######                          ######

C, 175 bytes
 x[]={48,74,128,265,1988,1984,8176,16376,16376,32764,31740,15352,15864,8176,4064,896};f(z,p){while(z++<16){p=1;while(p<<=1){printf("%s",p&(x[z]<<16|x[z])?"##":" ");}puts("");}}

concatenates each x to itself and makes p overflow to end each line.

ah, I changed printf() to write when golfing and that broke it. test here https://ideone.com/JtHInD

Java, 228 bytes
import static java.lang.System.out;

public class Bombs
{
    public static void main(String[] args)
    {
        new Bombs().d(2);
        new Bombs().d(3);
        new Bombs().d(4);
    }

    void d(int n){String s="";for(int x=16,r=0;r<16*n;x=16,s+=(++r%n==0?"\n":""))while(--x>=0)s+=((new int[]{1536,10496,128,18496,4592,496,2044,4094,4094,8191,8175,4078,4062,2044,1016,224}[r/n])&(1<<x))==0?"  ":"##";out.println(s);}

}

I know it's been a year, but you can golf it to this: n->{String s="";for(int x,r=0;r<16*n;s+=(++r%n<1?"\n":""))for(x=16;x-->0;)s+=((new int[]{1536,10496,128,18496,4592,496,2044,4094,4094,8191,8175,4078,4062,2044,1016,224}[r/n])&(1<<x))<1?"  ":"##";return s;} (205 bytes) Apart from using a Java 8 lambda, I've reduced more bytes by changing: the position of the x=16 (and changed while to for); 2x ==0 to <1; returning s instead of printing it (imports are also part of the byte-count btw..); --x>=0 to x-->0. Still, great answer, so +1!

@KevinCruijssen Thanks (consider posting this as an own answer). I'm not sooo active here on codegolf, and thus am not sure about the rules, but I think that in most cases, only counting the bytes of the function (and ignoring the imports) is allowed.

It's a bit too similar to post as a separated answer, but I can understand if you don't want to edit your answer of over a year ago. :) I'll just leave it in the comment. And I'm afraid imports do indeed count toward the byte-count.

BaCon, 229 227 195 bytes
A contribution in BASIC for sake of nostalgia. The variable 'a' determines the amount of bombs.
a=2:FOR x=0 TO 15:FOR y=1 TO a:FOR i=15 DOWNTO 0:?IIF$(v[x]&INT(POW(2,i)),"##","  ");:NEXT:NEXT:?:NEXT:LOCAL v[]={3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448}

Output:
        ####                            ####
  ##  ##    ##                    ##  ##    ##
              ##                              ##
##    ##        ##              ##    ##        ##
    ##      ##########              ##      ##########
            ##########                      ##########
        ##################              ##################
      ######################          ######################
      ######################          ######################
    ##########################      ##########################
    ################  ########      ################  ########
      ##############  ######          ##############  ######
      ############  ########          ############  ########
        ##################              ##################
          ##############                  ##############
              ######                          ######

C (Atari TOS 2.06 US), 129 124 117 113 bytes
short*a=0xe013b0;main(j,l)char**l;{for(;*a++-224;puts(""))for(j=*l[1]*16-768;j--;printf(*a&1<<j%16?"##":"  "));}

This uses the bomb bitmap from the TOS ROM, which is slightly different from the one in the question. For other versions of TOS, you'll have to adjust the address pointed to by *a. Note that some emulator roms don't include the bomb bitmap!
If you don't provide a command line argument, several high resolution bitmapped bombs may be displayed :-)

Excel VBA, 204 Bytes
Anonymous VBE Immediate window function that takes input from the range [A1] and outputs to the ActiveSheet Object
Cells.RowHeight=48:For i=0To[A1-1]:[A4,B2,C5,D4,D2,E1:F1,G2,H3,I4,G5:K6,E7:M7,D8:N9,C10:J11,K10:O10,O11,L11:N13,K13:K15,L14:L15,M14,D12:I13,J12,E14:G14,F15:G15,H14:J16].Offset(,16*i).Interior.Color=0:Next

Output

Vyxal j, 49 bytes
»ƛ¢y⇧↲⁽¹ŀuḂHŻḊ`I5□‡+vġ¯=<↓ d→YCnȧr»‛# τ16ẇƛ⁰*ƛd;ṅ

Try it Online!

C++11, 252 bytes
#include <iostream>
using namespace std;string d("01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow");int main(){for(int i=0;i!=45;i+=3){int z=stoi(d.substr(i,3),NULL,36);for(unsigned long p=1;p!=1<<31;p<<=1){cout<<(((z<<16|z)&p)?"##":"  ");}puts("");}}

SmileBASIC, 127 bytes
INPUT N
FOR J=0TO 15FOR K=1TO N
FOR I=0TO 14?" #"[1AND ASC("xxxxxxxxxxxxxxx"[I])>>J]*2;
NEXT
NEXT?NEXT

(Screenshot of version without doubled characters)
SB has a square font, so doubling the characters looks bad (and doesn't fit on the screen)
Non-ASCII characters have been replaced by x's.
Hex values: 0008,0002,0610,1F8A,3FC1,7FC1,7FF2,FFF4,FFF8,EFF0,73F0,7FC0,3FC0,1F80,0600
Since SB saves files in UTF-8, some of these count as 2 or 3 bytes.

@Arnauld I don't know much about SmileBASIC, but given that there's a loop FOR K=1TO N with INPUT N, I think it displays the number of bombs given in the input. However, I must say that despite the square font, I believe the characters should still be doubled to keep consistent with the requirements (to avoid an advantage over other answers). You could keep the current one for a nicer-looking solution, but I think you should still add a correct solution.Once you add that, I'll upvote for the creative use of the UTF-8 characters!

@AlexL. Yes, my comment was prior to the code update.

Ruby 2.x (lambda) - 157 bytes
Can probably be golfed further, but I like this version:
->n{puts "0c0052000100908023e003e00ff81ffc1ffc3ffe3fde1fdc1fbc0ff807f001c0".scan(/.{4}/).map{|x|(("%016b"%x.to_i(16)).tr("10","# ").chars.map{|c|c+c}*"")*n}}

Similar idea as the python version(s):
break the string of hexadecimal encoded bombs into sections of 4 characters, convert to binary, translate 1 to # and 0 to , double every character, and print the resulting array.
Note that puts is used to print the array.  This will print the array out one line per element.

Excel VBA, 557 412 321 Bytes
Anonymous VBE immediate window function that takes input from range [A1] and outputs to the VBE immediate window
[B:B]="=REPT(""#"",2*ROW())":[C:C]="=REPT("" "",2*ROW())":a=[C4&B9&C3]:b=[C3&B11&C2]:For Each s In Array([C4&B2&C10],["  ##  ##    ##"&C9],[C7&B1&C8],[B1&C2&B1&C4&B1&C7],[C2&B1&C3&B5&C5],[C6&B5&C5],a,b,b,[C2&B13&C1],[C2&B8&C1&B4&C1],[C3&B7&C1&B3&C2],[C3&B6&C1&B4&C2],a,[C5&B7&C4],[C7&B3&C6]):For i=1To[A1]:?s;:Next:?:Next

Sample Input / Output
[A1]=4
[B:B]="=REPT(""#"",2*ROW())":[C:C]="=REPT("" "",2*ROW())":a=[C4&B9&C3]:b=[C3&B11&C2]:For Each s In Array([C4&B2&C10],["  ##  ##    ##"&C9],[C7&B1&C8],[B1&C2&B1&C4&B1&C7],[C2&B1&C3&B5&C5],[C6&B5&C5],a,b,b,[C2&B13&C1],[C2&B8&C1&B4&C1],[C3&B7&C1&B3&C2],[C3&B6&C1&B4&C2],a,[C5&B7&C4],[C7&B3&C6]):For i=1To[A1]:?s;:Next:?:Next
        ####                            ####                            ####                            ####
  ##  ##    ##                    ##  ##    ##                    ##  ##    ##                    ##  ##    ##
              ##                              ##                              ##                              ##
##    ##        ##              ##    ##        ##              ##    ##        ##              ##    ##        ##
    ##      ##########              ##      ##########              ##      ##########              ##      ##########
            ##########                      ##########                      ##########                      ##########
        ##################              ##################              ##################              ##################
      ######################          ######################          ######################          ######################
      ######################          ######################          ######################          ######################
    ##########################      ##########################      ##########################      ##########################
    ################  ########      ################  ########      ################  ########      ################  ########
      ##############  ######          ##############  ######          ##############  ######          ##############  ######
      ############  ########          ############  ########          ############  ########          ############  ########
        ##################              ##################              ##################              ##################
          ##############                  ##############                  ##############                  ##############
              ######                          ######                          ######                          ######

Alternate Solutions
Cell Based Solution, 412 Bytes
x="=REPT(""":y=""",2*ROW())":[B:B]=x&"#"&y:[C:C]=x&" "&y:?[REPT(C4&B2&C10,A1)]:?[REPT("  ##  ##    ##"&C9,A1)]:?[REPT(C7&B1&C8,A1)]:?[REPT(B1&C2&B1&C4&B1&C7,A1)]:?[REPT(C2&B1&C3&B5&C5,A1)]:?[REPT(C6&B5&C5,A1)]:a=[REPT(C4&B9&C3,A1)]:?a:b=[REPT(C3&B11&C2,A1)]:?b:?b:?[REPT(C2&B13&C1,A1)]:?[REPT(C2&B8&C1&B4&C1,A1)]:?[REPT(C3&B7&C1&B3&C2,A1)]:?[REPT(C3&B6&C1&B4&C2,A1)]:?a:?[REPT(C5&B7&C4,A1)]:?[REPT(C7&B3&C6,A1)]

Array-ASCII Solution, 557 Bytes
f=Space(14):w=Space(12):For Each s In Array("        ####"&Space(20),"  ##  ##    ##"&Space(18),f &"##"&Space(16),"##    ##        ##"&f,"    ##      ##########          ",w &"##########          ","        ##################      ","      ######################    ","      ######################    ","    ##########################  ","    ################  ########  ","      ##############  ######    ","      ############  ########    ","        ##################      ","          ##############        ",f &"######"&w):For i=1To[A1]:?s;:Next:?:Next


text:
Fabulous glamour shot

Found this picture on the web today. Being a lazy programmer, I don't want to actually open google and type a couple of characters. Way too much work! This is such an important task that it should be automated.
Challenge
Everyone knows that the first image in a google search result is always the best. Hence it should be presented to the user.
You are to write a program or function which takes a string as parameter and displays the first image it finds on google when you search for that name + the words glamour shot behind it.
Google search queries
To search for images on google, the url should contain the query parameter tbm=isch and q=query, with query being the name you want to search for.
A valid query string for my name Bas would be www.google.com/search?tbm=isch&q=Bas
Input
Your program or function takes a single parameter of input, which is the name you want to search for on google. This string will consist of the characters [a-z], [A-Z], [0-9] and   (space). This string can be space seperated, to search for a space seperated string on google, one should replace the spaces with +. For example, this is a valid query:
www.google.com/search?tbm=isch&q=Bassdrop+Cumberwubwubwub+glamour+shot
Output
The image can either be drawn to the screen, or saved to a file (in any format).
If the first search result on google is a gif file, you can either show the gif or show any frame of that gif.
Test cases
Run this snippet to see the expected results

f('Bas') // www.google.com/search?tbm=isch&q=Bas+glamour+shot

f('Bassdrop Cumberwubwubwub') // www.google.com/search?tbm=isch&q=Bassdrop+Cumberwubwubwub+glamour+shot

This is code-golf, shortest code in bytes wins!

What characters need to be supported in the input? Do we need to worry about URL encoding?

@Martin Ender [a-z0-9], edited my post. The urls will look like the examples I provided, no encoding needed, just space to +

I guess, A-Z can also appear, judging by your example?

@MartinEnder Yes, it's case insensitive. Forgot to mention

@BassdropCumberwubwubwub woops rookie mistake, I had indeed forgotten to escape the ampersand

There's a surprising number of people posing with guns when you play this game :D

What exactly counts as being drawn to the screen? Would navigating to the source location in IE or Chrome count as being drawn to the screen?

Can I get the thumbnail of the image rather than the image itself?

it is good you included the search queries restricts, otherwise one could just set up a custom short-url website which takes care of it.

PowerShell v4+, 160 bytes
param($a)iwr (((iwr "google.com/search?tbm=isch&q=$($a-replace' ','+')+glamour+shot").links|?{$_.innerhtml-like"*$a*"})[0].innerhtml-split'"')[3] -outf "$a.jpg"

Takes input $a as a string. Does an Invoke-WebRequest (iwr) to the appropriate Google location, using inner-string script block to -replace spaces with + in the input string. We take the .links of that, where the .innerhtml is -like our input string. That yields the links with the proper thumbnail description. Take the first [0] one of those, take its .innerhtml and -split it on quotations. The fourth [3] element is the text inside the img src=" portion, so we do another iwr on that, specifying -outfile to be $a.jpg in the local folder. Since these are just the Google generated thumbnails, they're guaranteed to be jpg.

you can change out google.com with google.nl for -1 byte

Excel VBA +, 465 332 Bytes

NOTE: Uses References to

Microsoft HTML Object Library
Microsoft Internet Controls
Microsoft Scripting Runtime

Golfed:
Full Sub routine that takes input n (short for name) of expected type Variant/String and outputs the first google image search result for the query of that name and glamour shot to an internet explorer window.
Sub g(n)
Set i=New InternetExplorer
l="google.nl/search?tbm=isch&q="&Replace(n," ","+")&"+glamour+shot"
For y=0To 2
i.navigate l
While i.readyState<4
DoEvents
Wend
j=0
Do Until InStr(1,l,IIf(y,"yp","res"))
j=j+1
Set x=i.document.getElementsByTagName(IIf(y,"img","a"))(j)
If y Then l=x.src Else l=x.href
Loop
Next
i.visible=1
End Sub

-2 bytes for removing white space in If InStr(1, a.href, "imgres") Then
-2 bytes for changing .navigate (a.href) to .navigate a.href
-27 bytes for reducing for each a in ... if (...) then ... end if .. next loop to do until ... loop
-10 bytes for condensing imgres to res and encrypted to yp
-8 bytes for removing initalizers for j, k and assuming clean module
-1 byte for changing google.com to google.nl
-3 bytes for replacing Dim i as New ... with Set i=New ...
-8 bytes for removing SHDocVw. class reference
-12 bytes for removing with i block
-7 bytes for removing i.quit - this causes some memory leakage by leaving internet explorer open in the background, as such it is recommended that either the full ungolfed version is used instead or that the internet explorer task is terminated through task manager after use
-6 bytes for moving i.navigate into helper subroutine h
-13 bytes for moving Do Until ... Loop into helper subroutine
-2 bytes by moving j=0 into helper and removing ,j, ,0 (x2)
-11 bytes for converting to an anonymous immediate window function
-8 bytes for reducing helper function calls into for .. next loop
-16 bytes for changing output from Sheets(1) picture object to displaying via the InternetExplorer object
Ungolfed, 1304 Bytes
Option Private Module
Option Compare Text
Option Explicit
Option Base 0

Sub GlamourShot(ByVal name As String)

    Dim ie As New SHDocVw.InternetExplorer, _
        doc As MSHTML.HTMLDocument, _
        link As String, _
        j As Integer, _
        k As Integer

    With ie
        On Error GoTo CloseIE #'prevents memory leak

        Let .visible = True
        Call .navigate("www.google.com/search?tbm=isch&q=" & _
                    Replace(name, " ", "+") & _
                    "+glamour+shot")
        While .readyState <> READYSTATE_COMPLETE Or .Busy
            VBA.DoEvents
        Wend

        Set doc = .document

        Let j = 1
        Do Until InStr(1, link, "imgres") > 0
            Let link = doc.getElementsByTagName("a")(j).href
            Let j = j + 1
        Loop

        Call .navigate(link)
        While .readyState <> READYSTATE_COMPLETE Or .Busy
            VBA.DoEvents
        Wend

        Let k = 1
        Do Until InStr(1, link, "encrypted") > 0
            Let link = doc.getElementsByTagName("img")(k).src
            Let k = k + 1
        Loop

        With ThisWorkbook.ActiveSheet
            Call .Range("A1").Select
            Call .Pictures.Insert(link)
            Call .Activate
        End With
CloseIE:
        Call .Quit
    End With
End Sub

Usage gif

Vimperator, 30 keystrokes
pgi<End> glamour shot<CR>fi222jf<CR>fim2

Alternatively 27 keystrokes if you don't need the highest resolution image:
pgi<End> glamour shot<CR>fi222j;I<CR>

Video: https://youtu.be/t8824UjlYt8

Fortunately the standard search engine in Firefox is google, and Vimperator let you type hints by default. This is longer than it has to be to make sure that it always works regardless of what you search for.
Takes input through the clipboard.

Explanation:
p             Google the contents of the clipboard
gi            Select the search box
<End>         Move the cursor to the end of the text
 glamour shot Type " glamour shot"
<CR>          Press enter to search
fi2           Click the second link that begins with the letter "i" (images)
22j           Go 22 scroll steps down on the page.
              This makes it so that the first row of images are at
              the very top of the screen.

f<CR>         Click the first clickable element, which is the
              first image because we scrolled down

fim2          Click the second link containing "im" (view image)

Thanks to @TaylorScott for finding an edge case.

Does this handle cases when google recommends other search results as is the cases such as this

@TaylorScott It does not, but I am unable to get recommendations in Firefox. Could it be browser dependent?

Nevermind, I got them for a different search

Python 3.6, 247 242 232 maybe 224 bytes
This is a cute attempt to solve this one. It will save a the file as p.png in the current directory.
import sys; import requests as r; from bs4 import BeautifulSoup as s;
n = sys.argv[1]; open('p.png', 'wb').write(r.get(s(r.get(f'https://www.google.com.br/search?tbm=isch&q={n}+glamour+shot').content,'lxml').find_all('img')[1].get('src')).content)

To run it with ease from the command line, just place the above content in a file, such as glamour.py and run:
$ python glamour.py NAME_YOU_WANT

Update 1: Better version with new google url
import sys; import requests as r; from bs4 import BeautifulSoup as s;
n = sys.argv[1]; open('p.png', 'wb').write(r.get(s(r.get(f'http://www.google.nl/search?tbm=isch&q={n}+glamour+shot').content,'lxml').find_all('img')[1].get('src')).content)

Update 2:
I saved a few bytes:

By only importing the get function from the requests module
taking advantage of the new python 3.6 string interpolation f flag without allocating the sys.argv to a variable
eliminating some white spaces
turning it into a one-liner
removing the parser specification from the BeautifulSoup call

The last one is controversial, since it results in a std.output message telling the programmer to specify the parser for cross platform compatibility, so it might be considered unwanted output.
Here is the 224 bytes version:
import sys;from requests import get;from bs4 import BeautifulSoup as s;open('p.png','wb').write(get(s(get(f'http://www.google.nl/search?tbm=isch&q={sys.argv[1]}+glamour+shot').content).find_all('img')[1].get('src')).content)

Here is the 232 bytes version:
import sys;from requests import get;from bs4 import BeautifulSoup as s;open('p.png','wb').write(get(s(get(f'http://www.google.nl/search?tbm=isch&q={sys.argv[1]}+glamour+shot').content, 'lxml').find_all('img')[1].get('src')).content)

But the shorter version could be used if std.out is redirected to /dev/null or something :D

I could probably have a version with urllib + html.parse so that it can run entirely with the standard library.

you can likely use www.google.nl/ or maybe even google.nl instead of https://www.google.com.br/ to save some bytes

for some reason, I have to keep http:// for it to work with requests. But the Brazilian google gave me funnier results, so I loose on fun points :D

Does this handle cases when google recommends other search results as is the cases such as this (you may have to do multiple searches to get suggestions like this to pop up)

I also love how I gain a few bytes thanks to the n = 'something'; f'{n}_here' instead of n = 'something'; '{n}_here'.format(n = n) or n = 'something'; '{}_here'.format(n)

@TaylorScott, i don't know. When I inspected the url for the first time, it had those headers, but I am not sure how they were introduced in the HTML response. Also the first element of the BeautifulSoup iterable where I retrieved all img tags was usually only garbage, so those headers might be there.

@Gui42The best way that I had to ensure that this handled the suggestions was to ensure that the link (src) for the final image contained encrypted (shortened for searching to yp based off of the possible domains)

Let us continue this discussion in chat.

Racket, 284 byes
(require net/url html-parsing sxml racket/draw)(define(g n)(let([g(compose get-pure-port string->url string-append)])(make-object bitmap%(g(car((sxpath"//*[@id='ires']//@src/text()")(html->xexp(g"http://www.google.com/search?tbm=isch&q="(string-replace n" ""+")"+glamour+shot"))))))))

Screenshot:

source: Stack Exchange

license: 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/

sort: votes


text:
pssssssssssssst
Introduction
This is one is pretty straightforward. We will be drawing a snake in ascii. This was inspired by that old snake game where you have to collect the fruit and you continuously grow.
Definition
Given a positive integer N that represents the snake's length, draw a snake so that it has a body of n plus a head and a tail.
Parts:

head:     <, >, ^, v
tail:     @
vertical: |
horizonal: -

All corners should be satisfied with a \ or / respectively. Unless the head ends on a corner in which case the head <, >, ^, v takes priority in the direction the snake is curled. i.e. for the length 1 example, it is turned counter clockwise and so the head is turned that way. For a clockwise solution it would be to the right >.
The snake must start in the middle with its tail but it may go outwards in any direction you choose either clockwise or counter-clockwise. It must also wrap tightly around itself as it expands outwards in a circular fashion.
Example
/--\
|/\|
||@|
|\-/
\--->

Where the @ is the tail and starting position. As seen above the tail starts in the middle, goes up to the left in a counter-clockwise rotation outward.
Here the length is 19 plus a tail and a head.
As another example, here is length 1:
<\
 @

Winning
This is code-golf so the answer that is submitted with the smallest number of bytes wins, with time to be used as a tie breaker.
Have fun!

It's not very clear that I'm not just allowed to draw a straight snake like @---->. You probably intend more strict conditions about the snake shape. Also make clear how much whitespace is or isn't allowed

"The snake must start in the middle with it's tail but it may go outwards in any direction you choose and either clockwise or counter-clockwise"

So I say @ is the middle (possible add some spaces to make it so), declare "to the right" to be the direction and make just the head point down and declare that clockwise. Your terms may seem clear to you, but they are actually ambiguous. I realize you probably mean an as tightly as possible coiled snake, but you should make that clear

@TonHospel Else what kind of challenge is this?

http://codegolf.stackexchange.com/q/55819/21348 related

I haven't seen this :(

Don't worry. That one is a lot harder due to the offsets in that challenge.

Your challenge could use a few more test cases though. Especially the minimum input would be good to know.

can you please give an output for n == 1

I added a N = 1 example and clarified that the head takes priority over a corner

Related (but simpler)

Can we optionally take length including head and tail? The examples would be inputs 21 and 3 respectively

No, sorry :). There are already solutions posted.

Nice first challenge! Welcome to the site!

"Unless the head ends on a corner in which case the head <, >, ^, v takes priority in the direction the snake is curled" Should not the head be curved upwards in the example? It's in a corner.

@EmilioMBumachar are you referring to the N=1 example? The direction being clockwise vs counter-clockwise not N, S, E and W.

@LuisMendo thank you! I lurked for a long time :)

why the hurry? you can wait how long you want to accept an answer (in fact you don't even need to accept one). If you accept an answer, it MAY discourage new answers

@Rod Ok I'll keep it open awhile. I wasn't sure the protocol for these :)

MATL, 85 83 bytes
And I thought that having a spiral builtin would make for short code...
Oli2+XH:UQXItH:+XJh(YsXKoQ3I(4J(5l(H:)0HX^XkU(6H(3M1YL3X!P)'|-\/@' '<v>^'KHq))h0hw)

Try it online!
Explanation
Let N denote the input. We will create a vector of length ceil(sqrt(N+2))^2, that is, the smallest perfect square that equals or exceeds N+2. This vector will be filled with numeric values, rolled into a spiral (that's why its length needs to be a perfect square), and then the numeric values will be replaced by characters.
Let n denote each step starting from 1 at the center of the spiral. The steps where the snake turns are given by n2+1 (that is: 2, 5, 10, ...) for \ symbols and n2+n+1 (that is: 3, 7, 13, ...) for /. The steps between a \ and a / should be -, and those between a / and a \ should be |.
The vector is created such that it contains 1 at the turn points (2,3,5,7,10,13...) and 0 at the rest. The parity of the cumulative sum tells if each entry should be a - or a |. Adding 1 to this result we get a vector containing 1 (for |) or 2 (for -). But this makes the turn points themselves become 1 or 2 too. So the turn points, whose positions we know, are overwritten: positions n2+1 are filled with 3 and positions n2+n+1 are filled with 4. The tail and head are also special cases: the first element of the vector (tail) is set to 5, and the element with index N+2 (head) is set to 6. Finally, elements with indices exceeding N+2 are set to 0.
Taking input N=19 as an example, we now have a vector with length 25:
5 3 4 1 3 2 4 1 1 3 2 2 4 1 1 1 3 2 2 2 6 0 0 0 0

We need to roll this vector into a spiral. For this we use a builtin function that generates a spiral matrix, followed by a reflection and a transposition to produce:
13 12 11 10 25
14  3  2  9 24
15  4  1  8 23
16  5  6  7 22
17 18 19 20 21

Indexing the vector with the matrix gives
4 2 2 3 0
1 4 3 1 0
1 1 5 1 0
1 3 2 4 0
3 2 2 2 6

where 0 corresponds to space, 1 corresponds to |, 2to -, 3 to \, 4 to /, 5 to @, and 6 to the head.
To know which of the four characters ^, <, v, or > the head should have, we use the cumulative sum of turn points that we previously computed. Specifically, the second-last value of this cumulative sum (i.e. the N+1-th value) modulo 4 tells us which character should be used for the head. We take the second-last value of the cumulative sum, not the last, because of the requirement "if the head ends on a corner the head <, >, ^, v takes priority in the direction the snake is curled". For the N=19 example the head  is >.
Now we can build a string containing all the snake characters, including the appropriate character for the head at the sixth position: '|-\/@> '. We then index this string with the above matrix  (indexing is 1-based and modular, so space goes last), which gives
/--\
|/\|
||@|
|\-/
\--->

awesome job! thanks for participating!

Python 2, 250 233 191 bytes
n=input()
l=[''],
a=x=0
b='@'
while a<=n:x+=1;l+=b,;l=zip(*l[::-1]);m=x%2;b='\/'[m]+x/2*'-|'[m];k=len(b);a+=k
l+=b[:n-a]+'>v'[m]+' '*(k-n+a-1),
if m:l=zip(*l[::-1])
for i in l:print''.join(i)

 Saved 39 bytes thanks to @JonathanAllan

repl.it
Draw the snake by rotating the entire snake 90º clockwise and adding the bottom segment, this way the snake will always be anticlockwise.
The new segment will always start with \ and have - as body for even sides and / - for odd sides. The segments sizes (without corners) are 0,1,1,2,2,3... which is floor(side/2).If the segment is the last, it remove the excess characters, add the head and complete with spaces.
desired_size=input()
snake=[['']]
snake_size=side=0
new_segment='@'
while snake_size<=desired_size:
    side+=1
    snake+=[new_segment]
    snake=zip(*snake[::-1])
    odd_side=side%2
    new_segment='\/'[odd_side]+side/2*'-|'[odd_side]
    snake_size+=len(new_segment)
diff=desired_size-snake_size
snake+=[new_segment[:diff]+'>v'[odd_side]+' '*(len(new_segment)-diff-1)]
if odd_side:
    snake=zip(*snake[::-1])

for line in snake:print ''.join(line)

Nice Job! you have the tiebreaker win. Lets see what else people come up with.

Surely this is the ideal language to solve this challenge in.

+1. Only glitch is that when the head is on a corner it is meant to point straight, not around the corner.

Save 16 bytes by indexing into strings like so: '\/'[m], '-|'[m] and '>v'[m]

Save another 8 by using a string instead of a list: '\/'[m]+x/2*'-|'[m] and, l+=b[:n-a]+'>v'[m]+' '*(k-n+a-1)

Save 1 more by removing the space between print and ''.join

Save another 14 using a while loop: http://ideone.com/SfIfeQ

In the ungolfed code, snake should be equal to ([''],), not [['']], technically.

The head orientation after a turn is different respect to examples (see input 1 for instance). I made some effort in my answer to closely follow the examples ... But as OP is happy with that, you have my vote

JavaScript (ES6), 193 201 203 215 220 224
Edit saved 4 bytes thx @Arnauld
Edit2 changed logic, not storing the current increments for x and y, just get them from the current direction
Edit3 having saved a few bytes, I decided to use them for a better management of the blank space
Edit4 8 bytes saved not following exactly the examples about the head direction - like other answers
The current version works with Chrome, Firefox and MS Edge
This answer gives some trailing and leading space (and blank lines).
n=>(t=>{for(x=y=-~Math.sqrt(++n)>>1,g=[i=t];(g[y]=g[y]||Array(x).fill` `)[x]='^<v>|-/\\@'[t?n?i-t?4+t%2:x-y?7:6:t%4:8],n--;i=i>1?i-2:++t)d=t&2,t&1?x+=d-1:y+=d-1})(0)||g.map(x=>x.join``).join`
`

Slightly less golfed
n=>
{
  g = [],
  // to save a few bytes, change line below (adds a lot of spaces)
  // w = ++n,
  w = -~Math.sqrt(++n)
  x = y = w>>1,
  s=c=>(g[y] = g[y] || Array(x).fill(' '))[x] = c, // function to set char in position
  s('@'); // place tail
  for (
     i = t = 0; // t increases at each turn, t%4 is the current direction
     n--;
     i = i > 0 ? i - 2 : t++ // side length increases every 2 turns
  )
     d = t & 2,
     t & 1 ? x += d-1: y += d-1
     s(!n ? '^<v>' [t % 4] // head
          : '|-/\\' [i > 0 ? t % 2 : x-y ? 3 : 2]) // body
  return g.map(x=>x.join``).join`\n`
}

f=
n=>(t=>{for(x=y=-~Math.sqrt(++n)>>1,g=[i=t];(g[y]=g[y]||Array(x).fill` `)[x]='^<v>|-/\\@'[t?n?i-t?4+t%2:x-y?7:6:t%4:8],n--;i=i>1?i-2:++t)d=t&2,t&1?x+=d-1:y+=d-1})(0)||g.map(x=>x.join``).join`
`

function update() {
  O.textContent=f(+I.value);
}

update()
<input type=number id=I value=19 oninput='update()'
 onkeyup='update() /* stupid MS browser, no oninput for up/down keys */'>

You can save a few bytes by replacing (' ') with \ ` and('@')with`@` `

@Arnauld Array(2).fill  ==> [ Array[1], Array[1] ], while Array(2).fill(' ') ==> [' ',' ']

@usandfriends - True. But that should not make any difference once join'ed.

@Arnauld at first I agreed with usandfriends, but it works indeed. Thanks

@TravisJ It doesn't work in Chrome, but Firefox seems to work.

@Adnan current version works with Firefox 49 and Chrome 53. It fails with MSIE 10, did not try 11 or Edge

Ah, I had to enable the Experimental JavaScript flag (chrome://flags/#enable-javascript-harmony) on chrome to make it work. Nice answer though :).

Nice Job! Thanks for participating!

JavaScript (ES7), 200 bytes
(n,s=(n*4+1)**.5|0,i=+`1201`[s%4],d=i=>`-`.repeat(i))=>[...Array(s-2>>2)].reduce(s=>`/-${d(i)}\\
${s.replace(/^|$/gm,`|`)}
|\\${d(i,i+=2)}/`,[`/\\
|@`,`/-\\
|@/`,`@`,`/@`][s%4])+`
\\${d(n-(s*s>>2))}>`

ES6 version for ease of testing:

f=(n,s=Math.sqrt((n*4+1))|0,i=+`1201`[s%4],d=i=>`-`.repeat(i))=>[...Array(s-2>>2)].reduce(s=>`/-${d(i)}\\
${s.replace(/^|$/gm,`|`)}
|\\${d(i,i+=2)}/`,[`/\\
|@`,`/-\\
|@/`,`@`,`/@`][s%4])+`
\\${d(n-(s*s>>2))}>`;
<input type=number min=1 oninput=o.textContent=f(this.value)>

Interesting implementation. I had not thought of doing that. Thanks for contributing and nice job!!

Perl, 111 110 bytes
Includes +1 for -p
Give size on STDIN
snake.pl:
#!/usr/bin/perl -p
s%> %->%+s%\^ %/>%||s/
/
/g+s%.%!s/.$//mg<//&&join"",//g,$/%seg+s/ /^/+y%/\\|>-%\\/\-|%for($\="/
\@
")x$_}{

Awesome! Nice Job! Thanks for contributing!

Batch, 563 bytes
@echo off
if %1==1 echo /@&echo v&exit/b
set w=1
:l
set/ah=w,a=w*w+w
if %a% gtr %1 goto g
set/aw+=1,a=w*w
if %a% leq %1 goto l
:g
call:d
set r=/%r%\
set/ae=h%%2,w=%1-h*w+2
for /l %%i in (1,1,%h%)do call:r
call:d
echo \%r%^>
exit/b
:d
set r=
for /l %%i in (3,1,%w%)do call set r=%%r%%-
exit/b
:r
echo %r:!=^|%
if %e%==0 set r=%r:@!=\/%
set r=%r:@/=\/%
set r=%r:!\=\-%
set r=%r:/@=\/%
set r=%r:/!=-/%
set r=%r:@!=\/%
set r=%r:/\=!@%
set r=%r:/-=!/%
if %e%==1 set r=%r:/\=@!%
set r=%r:/\=@/%
set r=%r:-\=\!%
if %e%==1 set r=%r:/\=/@%

Explanation: Special-cases 1 as the rest of the code requires a snake width of at least two. Next, calculates the largest quarter square (either an exact square or a rectangle 1 wider than it is high) whose area is less than the length of the snake. The snake will be coiled into this rectangle starting at the bottom left corner and ending with the tail in the middle, and the remaining length will run under the bottom of the rectangle. The rectangle is actually generated from simple string replacements; most of the time each line is generated from the previous line by moving the diagonals 1 step, but obviously the tail also has to be dealt with, and there are slight differences depending on whether the height of the rectangle is even or odd.

Awesome! Thanks for contributing!

Python 2.7, A WHOPPING 1230 bytes
I am new to python and code golf but I felt I had to answer my own question and sulk away in shame after the fact. A lot of fun working on it though!
def s(n):
x = []
l = 0
if n % 2 == 1:
    l = n
else:
    l = n + 1
if l < 3:
    l = 3
y = []
matrix = [[' ' for x in range(l)] for y in range(l)]
slash = '\\'
newx = l/2
newy = l/2
matrix[l/2][l/2] = '@'
newx = newx-1
matrix[newx][newy] = slash
#newx = newx-1
dir = 'West'

for i in range(0, n-1):
    newx = xloc(newx, dir)
    newy = yloc(newy, dir)
    sdir = dir
    dir = cd(matrix, newx, newy, dir)
    edir = dir

    if (sdir == 'West' or sdir == 'East') and sdir != edir:
        matrix[newx][newy] = '/'
    else:
        if (sdir == 'North' or sdir == 'South') and sdir != edir:
            matrix[newx][newy] = '\\'
        else:
            if dir == 'East' or dir == 'West':
                matrix[newx][newy] = '-'
            else:
                matrix[newx][newy] = '|'
newx = xloc(newx, dir)
newy = yloc(newy, dir)
sdir = dir
dir = cd(matrix, newx, newy, dir)
edir = dir
print 'eDir: ' + dir
if dir == 'North':
    matrix[newx][newy] = '^'
if dir == 'South':
     matrix[newx][newy] = 'v'
if dir == 'East':
     matrix[newx][newy] = '>'
if dir == 'West':
     matrix[newx][newy] = '<'

p(matrix, l)

def cd(matrix, x, y, dir):
if dir == 'North':
    if matrix[x][y-1] == ' ':
        return 'West'
if dir == 'West':
    if matrix[x+1][y] == ' ':
        return 'South'
if dir == 'South':
    if matrix[x][y+1] == ' ':
        return 'East'
if dir == 'East':
    if matrix[x-1][y] == ' ':
        return 'North'
return dir

def p(a, n):
for i in range(0, n):
    for k in range(0, n):
        print a[i][k],
    print ' '

def xloc(x, dir):
if dir == 'North':
    return x -1
if dir == 'West':
    return x
if dir == 'East':
    return x
if dir == 'South':
    return x + 1
 def yloc(y, dir):
if dir == 'North':
    return y
if dir == 'West':
    return y - 1
if dir == 'East':
    return y + 1
if dir == 'South':
    return y

s(25)

https://repl.it/Dpoy

This can massively be reduced just by removing unnecessary spaces, newlines, comments, functions, etc..

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


text:
Retrieve all possible marks that can be placed in a Sudoku puzzle
Given a Sudoku puzzle, find all possible marks that can be filled into each empty cell.
Test case
Input:
[
    [
        // Top left:
        [
            0, 0, 0,
            3, 4, 0,
            0, 0, 2
        ],
        // Top middle:
        [
            7, 4, 0,
            0, 0, 0,
            0, 0, 3
        ],
        // Top right:
        [
            8, 0, 0,
            1, 7, 0,
            0, 0, 0
        ]
    ],
    [
        // Middle left:
        [
            9, 0, 4,
            7, 0, 0,
            1, 0, 3
        ],
        // Center:
        [
            0, 5, 0,
            0, 0, 0,
            0, 7, 0
        ],
        // Middle right:
        [
            0, 0, 0,
            6, 4, 0,
            0, 0, 0
        ]
    ],
    [
        // Bottom left:
        [
            0, 0, 7,
            6, 3, 0,
            0, 0, 0
        ],
        // Bottom middle:
        [
            0, 0, 5,
            0, 0, 0,
            9, 1, 0
        ],
        // Bottom right:
        [
            0, 0, 0,
            5, 2, 0,
            7, 0, 0
        ]
    ]
]

Output:
[
    [
        // Top left:
        [
            [5], [1, 5, 6, 9], [1, 5, 6, 9],
            [], [], [5, 6, 8, 9],
            [5, 8], [1, 5, 6, 7, 8, 9], []
        ],
        // Top middle:
        [
            [], [], [1, 2, 6, 9],
            [2, 5, 6, 8], [2, 6, 8, 9], [2, 6, 8, 9],
            [1, 5, 6, 8], [6, 8, 9], []
        ],
        // Top right:
        [
            [], [3, 5, 6, 9], [2, 3, 5, 6, 9],
            [], [], [2, 5, 6, 9],
            [4, 9], [5, 6, 9], [4, 5, 6, 9]
        ]
    ],
    [
        // Middle left:
        [
            [], [2, 6, 8], [],
            [], [2, 5, 8], [5, 8],
            [], [2, 5, 6, 8], []
        ],
        // Center:
        [
            [1, 2, 3, 6, 8], [], [1, 2, 6, 8],
            [1, 2, 3, 8], [2, 3, 8, 9], [1, 2, 8, 9],
            [2, 4, 6, 8], [], [2, 4, 6, 8, 9]
        ],
        // Middle right:
        [
            [2, 3], [1, 3, 8], [1, 2, 3, 7, 8],
            [], [], [1, 2, 3, 5, 8, 9],
            [2, 9], [5, 8, 9], [2, 5, 8, 9]
        ]
    ],
    [
        // Bottom left:
        [
            [2, 4, 8], [1, 2, 8, 9], [],
            [], [], [1, 8, 9],
            [2, 4, 5, 8], [2, 5, 8], [5, 8]
        ],
        // Bottom middle:
        [
            [2, 3, 4, 6, 8], [2, 3, 6, 8], [],
            [4, 8], [8], [4, 7, 8],
            [], [], [2, 4, 6, 8]
        ],
        // Bottom right:
        [
            [3, 4, 9], [1, 3, 6, 8, 9], [1, 3, 4, 6, 8, 9],
            [], [], [1, 4, 8, 9],
            [], [3, 6, 8], [3, 4, 6, 8]
        ]
    ]
]

Output visualisation; the small numbers:

Rules

This is a code-golf. The shortest answer in bytes (or equivalent) wins.
Input can be in array or string format.
Input must be in the order presented above (top-left, top-middle, top-right, etc...)
Output can be in array or string format, as long as the output can logically represent the expected result.
Output must be in the same order as the input (top-left, top-middle, top-right, etc...)
Output does not need to be prettified.
Code must be applicable to any valid incomplete Sudoku grid.
Standard golfing rules apply.

Additional Notes:
You get additional fake internet points if your program or function uses the result to solve the Sudoku puzzle to the point where cell values can no longer be logically solved. For example, the very first cell in the test case can only ever possibly contain the number 5, so it should be considered when filling in the other values. This is just for fun and additional challenge, otherwise the shortest answer wins regardless of whether or not this criterion is met.

How flexible is the input format? Could it be for instance an array of 9 strings? (such as ["000340002", "740000003", ...])

Input is flexible, refer to the changes I made in my question rules.

Where you say "The result is to be in the form of a four-dimensional array containing the row, column, cell and possible numbers respectively" do you mean, "The result is to be in the form of a four-dimensional array containing the band, nonet, cell (ordered by row then column) and possible numbers respectively"? This seems to be what you have in your test case.

Is a single string going left-to-right, top-to-bottom allowed as input? Like this? And output in the same order?

To expand on my suggestion, this is a fairly standard sudoku format supported by various software packages.

How are you determining which numbers are valid for each spot? The image and text output do not match, and the image is incorrect since it has 5 listed as a candidate where there is a 5 filled in (6th column from the left, 2nd row from the top) on the same column.

The example output seems incorrect. [1, 5, 6, 7, 8, 9] should be the output for x=1,y=2. (Or, do we have to consider the fact that the 7 can only be there?)

@orlp Yes, I will allow that format.I will update my question with that.

@miles Yes, the output and image do both appear to be incorrect. That's a mistake on my part.

If we're not applying logic to work out which cells can and can't be solved, what is the question actually asking us to do?

@PeterTaylor given a valid incomplete sudoku puzzle, retrieve all possible marks in all empty cells.

What is the distinction you're drawing between that and solving the puzzle?

@PeterTaylor Solving the puzzle means filling in the empty cells with the correct values, as opposed to retrieving all possible marks that can be placed within the empty cells.

So under what circumstances can an incorrect value be placed in a cell? Stop repeating yourself and start defining your terms.

@PeterTaylor Standard rules of Sudoku. A value is incorrect when the same value exists on the same cell row or column in the entire grid, or in any cell within the same 3x3 cells of the grid section. An incorrect value should never be placed in a cell, as was clearly mentioned in the question.

C (gcc), 193 bytes
#define F(x)for(x=0;x<9;++x)
char s[99];main(k,r,c){gets(s);F(r)F(c){
int d[99]={};F(k)d[s[r*9+k]]=d[s[k*9+c]]=d[s[r/3*27+k/3*9+c/3*3+k%3]]=1;
F(k)s[r*9+c]<48&&!d[49+k]&&putchar(49+k);puts("");}}

Assumes input in the following format (same sudoku as above):
..74.8..34....17...2..3...9.4.5....7.....64.1.3.7......7..5...63....52....91.7..

And outputs in the following format:
5
1569
1569

1269

3569
23569

5689
etc

JavaScript (ES6), 208 196 190 188 186 bytes
g=>g.map((B,i)=>[...B].map((s,x)=>+s||[..."123456789"].filter(n=>(t=i=>(k=g[i].search(n)%m)<a|k>b)(j=i%3,m=3,a=b=x%3)&t(j+3)&t(j+6)&t(j=i-j,m=9,a=x-a,b=a+2)&t(j+1)&t(j+2)&t(i,a=0,b=8))))

Input:
An array of 9 strings (one per box, from top-left to bottom-right).
Output:
An array of 9 arrays, where each item consists of either the original number at this position or an array of characters representing the possible digits.
Formatted and commented
g => g.map((B, i) =>              // for each box B at position i in the grid:
  [...B].map((s, x) =>            // for each cell s at position x in this box:
    +s ||                         // if there already is a number at this position, use it
    [..."123456789"].filter(n =>  // else, for each digit n in [1 .. 9]:
      (t = i =>                   // t() = helper function that looks for the digit n inside
        (k = g[i].search(n) % m)  // a given box i and returns a truthy value if its
        < a | k > b               // position modulo m is not in the range [a .. b]
      )(                          //
        j = i % 3,                // test the top box in the current column, using:
        m = 3,                    // modulo = 3 and
        a = b = x % 3             // range = [x % 3 .. x % 3]
      ) &                         //
      t(j + 3) &                  // test the middle box in the current column
      t(j + 6) &                  // test the bottom box in the current column
      t(                          //
        j = i - j,                // test the left box in the current row, using:
        m = 9,                    // modulo = 9 and
        a = x - a, b = a + 2      // range = [floor(x / 3) .. floor(x / 3) + 2]
      ) &                         //
      t(j + 1) &                  // test the middle box in the current row
      t(j + 2) &                  // test the right box in the current row
      t(i, a = 0, b = 8)          // finally test the current box, using:
    )                             // modulo = 9 (unchanged) and
  )                               // range = [0 .. 8] (thus testing the entire box)
)                                 //

Demo

let f =

g=>g.map((B,i)=>[...B].map((s,x)=>+s||[..."123456789"].filter(n=>(t=i=>(k=g[i].search(n)%m)<a|k>b)(j=i%3,m=3,a=b=x%3)&t(j+3)&t(j+6)&t(j=i-j,m=9,a=x-a,b=a+2)&t(j+1)&t(j+2)&t(i,a=0,b=8))))

console.log(f([
  "000340002",
  "740000003",
  "800170000",
  "904700103",
  "050000070",
  "000640000",
  "007630000",
  "005000910",
  "000520700"
]));

Python 2, 178 bytes
lambda s,R=range(9):[[[(s[Y][X][i]<1)*[q+1for q in R if~-(q+1in sum([[s[j/3][X][j%3*3+i%3],s[Y][j/3][j%3+i/3*3]]for j in R],[])+s[Y][X])]for i in R]for X in R[:3]]for Y in R[:3]]

An anonymous function that takes a 3-dimensional array of ints and returns a 4-dimensional array of ints.

JavaScript (ES6), 185 bytes
a=>a.map((b,r)=>b.map((d,c)=>d.map((e,i)=>e.map((g,j)=>[1,2,3,4,5,6,7,8,9].filter(v=>a.every(b=>b[c].every(e=>e[j]-v))&b.every(d=>d[i].every(g=>g-v))&d.every(e=>e.every(g=>g-v))&!g)))))

Takes as input an array of three rows of an array of three columns of a three by three array of cells of integers, and returns a five-dimensional array where all the integers have been replaced by arrays.

Haskell, 135 bytes
(%)=mod
x!y=x-x%y
f a=[[j|j<-[1..9],and[a!!k/=j|k<-[i!3-i!9%27+p%3+p!3*3|p<-[0..8]]++[i!9..i!9+8]++[i%9,i%9+9..80]],a!!i<1]|i<-[0..80]]

Defines a function f from lists of 81 Ints to lists of lists of Ints;
IO is like orlp's answer, except it uses [0,1,2,3,4,5,6,7,8,9] instead of ".123456789".
dianne saved a couple of bytes.


text:
Smallest Hamming distance to a palindrome containing a substring
This was inspired by a now removed CS.SE question.
Task
Given two non-empty input strings A and B, output the smallest distance from A to a palindrome that contains B as a substring. Distance is defined by the number of character replacements (Hamming distance).
Restrictions

Sensible input: a palindrome exists. This means |A| ≥ |B|.
A and B contain only lower ASCII characters, lowercase and uppercase are distinct (as are all other characters).
If your language cannot deal with ASCII characters, you may use integers (or some other reasonable data type) as well, and you may choose to limit the range to 128 elements.
You may take input from stdin, function arguments, command line arguments, etc.
You may give the result on stdout, return value, etc.
You do not need to give a working palindrome, the smallest distance to one is sufficient.

Examples
A                   B            Output
thilloaoyreot       hello        4 (thelloaolleht)
benjonson           stack        9 (stackcats)
neversaynever!      odd          9 (neveroddoreven)
ppcggcpp            gg           0 (ppcggcpp)
stars               tat          1 (stats)

Scoring
This is code golf, shortest code in bytes wins.

Pyth, 19 bytes
hSmsnVQd/#z_I#^+Qzl

Demonstration
Extreme brute force approach. Generate all strings of the appropriate length with characters in either string, filter for palindromes and for containing the second input, map to hamming distance from first string, output smallest.
Explanation:
hSmsnVQd/#z_I#^+Qzl
hSmsnVQd/#z_I#^+QzlQ     Variable introduction
                         Q = string A, z = string B.
               +Qz       Concatenate A and B
              ^   lQ     Form every string of length equal to len(A)using
                         characters from the concatenation.
             #           Filter on
           _I            Invariance under reversal (palindrome)
         #               Filter on
        / z              Nonzero occurences of B
  m                      Map to
    nV                   !=, vectorized over
      Qd                 A and the map input
   s                     Sum (gives the hamming weight)
hS                       Min

Something like this is what I thought of, but decided O((m+n)^n) was too O(bad). :D

Pyth, 45 bytes
hSmsnVQdf}zTsmm+hc2KsXcd+Bklz1z_hc2PKh-lQlz_B

Try it online. Test suite.
I'm still not exactly satisfied with how this turned out. But at least it's quite hard to understand without an explanation now. (Success, I guess?)
Explanation

Take in A as Q and B as z.
m…_BQ Compute the following for both A and its reverse as d:

m…h-ldlz Compute the following for all k from 0 to len(A) - len(B) inclusive:

+Bklz Get the pair k, k + len(B).
cd Split d at those indices.
X…1z Replace the second (middle) part with B.
Ks Concatenate the pieces and save to K. B is now inserted at position k in A or its reverse.
hc2 Split the resulting string in two and keep the first piece. This gives half of the string with the possible middle character.
hc2PK Remove the last character and do the same split, keeping the first piece. This gives half of the string without the possible middle character.
+…_ Add the reverse of the shorter piece to the longer piece. We now have a palindrome.

s Concatenate the results for A and its reverse.
f}zT Remove all strings that don't contain B.
m Compute the following for all the resulting strings d:

nVQd Get the pairwise inequality with A. This gives True for pairs that need to be changed.
s Sum the list. This gives the Hamming distance.

hS Take the minimum result.

JavaScript (Firefox 30+), 152 146 bytes
(A,B)=>Math.min(...[...Array(A[l='length']-B[l]+1)].map((_,i)=>[for(c of q=A.slice(j=t=0,i)+B+A.slice(i+B[l]))t+=(c!=A[j])+(c!=q[q[l]-++j])/2]|t))

Brute force approach: generate each possible overlap of A and B, make each into a palindrome, calculate Hamming distances from A, and take the smallest of the resulting distances.
Probably could be golfed a bit more...
Test snippet

f=(A,B)=>Math.min(...[...Array(A[l='length']-B[l]+1)].map((_,i)=>[for(c of q=A.slice(j=t=0,i)+B+A.slice(i+B[l]))t+=(c!=A[j])+(c!=q[q[l]-++j])/2]|t))
g=(A,B)=>console.log("A:",A," B:",B," f(A,B):",f(A,B))

g("thilloaoyreot", "hello")
g("benjonson", "stack")
g("neversaynever!", "odd")
g("ppcggcpp", "gg")
<input id=A value="amanaplanacanalrussia">
<input id=B value="panama">
<button onclick="g(A.value,B.value)">Run</button>