[Question]
  [
Given any unsigned 16 bit integer, convert its *decimal form* (i.e., base-10) number into a 4x4 ASCII grid of its bits, with the most-significant bit (MSB) at the top left, least-significant bit (LSB) at bottom right, read across and then down (like English text).
## Examples
### Input: 4242
```
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
```
### Input: 33825
```
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
```
## Specific Requirements
1. Input *must* be in decimal (base-10), however you may convert to binary any way you wish (including using language built-ins, if available).
2. Output table format must match *exactly*. This means you must use the specific ASCII characters (`-`, `+`, and `|`) for the table grid lines as shown, each cell's interior is 3 characters, and *true* bits are represented by `#` while *false* is represented by a space ().
3. Leading or trailing whitespace is *not permitted.* Final newline is *required*.
4. Bit order must match the examples as described.
## Allowances
1. Input must be a base-10 number on the command line, standard input, or user input, but *must not* be hard-coded into your source code.
May the clearest shortest code win! :-)
  
[Answer]
# J, 26 bytes
```
('   ';' # '){~4 4$_16{.#:
```
An anonymous verb. Thankfully, J is very good at drawing boxes. Let's try it out:
```
   f =. ('   ';' # '){~4 4$_16{.#:
   f 4242
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
```
As some commenters have mentioned, the way J draws boxes is system-dependent: on some platforms, this code will work under the default settings, but on others, the boxes will be drawn using Unicode line drawing characters. (The commands [`9!:6` and `9!:7`](http://www.jsoftware.com/jwiki/Vocabulary/Foreigns#m9) allow you to query and set the characters to draw boxed values with, respectively.)
[Answer]
# JavaScript (ES6), 102
... or 96 using `return` instead of `console.log`.
Test running the snippet below in an EcmaScript 6 compliant browser.
```
f=n=>{for(o=h=`
+---+---+---+---+
`,z=16;z--;n/=2)o=(z&3?'':h+'|')+` ${' #'[n&1]} |`+o;console.log(o)}
// TEST
console.log=x=>O.innerHTML=x+O.innerHTML
function test(n) { f(n); console.log(n); }
```
```
<input id=I value=4680><button onclick='test(+I.value)'>-></button>
<pre id=O></pre>
```
[Answer]
# [Befunge](http://www.esolangs.org/wiki/Befunge)-93, 196 ~~218~~ bytes
```
&00p12*v>>4>"---+",v v <
v*:*:*:<   | :-1,,,< #
>:*2/10p^  >"+",25*,10g|
     > #v^#         $< @
 25*,^  >4" |",,v ,*<>
v>"#",00g10g-00p 10g
 |`-1g01g00     <>48^
v>" ",10g
>2/10p>"| ",,1-:#^_$>^
```
### To run the program...
1. Go to the [online interpreter](http://www.quirkster.com/iano/js/befunge.html).
2. Paste this code in the big text box.
3. Click `Show`.
4. Input the desired number in the `Input` box.
5. Click `Run`. (Or change `Slow` to something like 5 milliseconds and then click `Show`.)
6. Ta-da!
Output for 4242:
```
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
```
Output for 33825:
```
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
```
## Explanation
Oh goodness, what have I got myself into? Well, here goes! (Irrelevant code is replaced with `.`s.)
### Part 1: Get input (store in 0,0) and calculate 32768 (store in 1,0).
```
&00p12*v>
v*:*:*:< 
>:*2/10p^
```
### Part 2: Print out "+---+---+---+---".
```
>4>"---+",v
  | :-1,,,<
```
### Part 3: Print "+" and a newline and check to see if (1,0) is 0 (i.e. we're done). If so, terminate. Otherwise, continue.
```
 ........... v <
   | ....... # 
   >"+",25*,10g|
v.#         $< @
>4" |",,v ...
```
### Part 4: Get binary digits of input, updating (0,0) and (1,0) as we go along. Print the right things. I take advantage of Befunge's wrap-around behavior.
```
 .....  >4" |",,v ,*<.
v>"#",00g10g-00p 10g
 |`-1g01g00     <>48^
v>" ",10g
>2/10p>"| ",,1-:#^_...
```
### Part 5: Print a newline and go back to the part that prints "+---+---+---+---+". Wrap-around trick is used.
```
     > #.^.         .. .
 25*,^  ......... ...>
................ ...
 .........      .....
........
.................._$>^
```
### Ta-da!
[Answer]
# Julia, ~~156~~ 143 bytes
```
n->(p=println;l="+"*"---+"^4;for i=1:4 p(l,"\n| ",join([j>"0"?"#":" "for j=reshape(split(lpad(bin(n),16,0),""),4,4)[:,i]]," | ")," |")end;p(l))
```
Ungolfed:
```
function f(n::Int)
    # Convert the input to binary, padded to 16 digits
    b = lpad(bin(n), 16, 0)
    # Split b into a 4x4 matrix
    m = reshape(split(b, ""), 4, 4)
    # Store the line separator for brevity
    l = "+" * "---+"^4
    # Print each column of the matrix as a row
    for i = 1:4
        println(l, "\n| ", join([j > "0" ? "#" : " " for j = m[:,i]], " | "), " |")
    end
    # Print the bottom of the table
    println(l)
end
```
[Try it online](http://goo.gl/Z44JNU)
[Answer]
# Python 2, ~~157~~ ~~153~~ ~~151~~ 146 bytes
```
J=''.join;R='+---'*4;i=format(input(),'016b')
print J(R+'+\n|'+J(' '+('#'if int(l)else' ')+' |'for l in i[n*4:-~n*4])+'\n'for n in range(4)),R+'+'
```
Thanks to Morgan Thrapp for saving 4 bytes, and to Jonathan Frech for saving 5.
## Usage
```
$ python test.py
33825
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
```
[Answer]
# GNU sed + dc, 116
Score includes +1 for `-r` flags to `sed`:
```
s/.*/dc -e2o&p/e
:
s/^.{,15}$/0&/;t
s/./| & /g
s/.{16}/\n+---+---+---+---+\n&|/g
y/01/ #/
s/\n([-+]+)(.*)/\1\2\n\1/
```
Test output:
```
$ { echo 4242 ; echo 33825 ; } | sed -rf 16bitgrid.sed
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
$ 
```
---
Alternatively:
# Pure sed, 146
You might think it's cheating to use `sed`'s GNU extension to eval a `dc` command. In that case, we can do this a little differently, according to [this meta-answer](http://meta.codegolf.stackexchange.com/a/5349/11259). Of course the question clearly states that input *must* be in base 10, but here I'm attempting to claim that we can override that for `sed` answers and use unary (base 1) instead.
```
:
s/11/</g
s/<([ #]*)$/< \1/
s/1/#/
y/</1/
t
:a
s/^.{,15}$/0&/;ta
s/./| & /g
s/.{16}/\n+---+---+---+---+\n&|/g
y/01/ #/
s/\n([-+]+)(.*)/\1\2\n\1/
```
### Test output
Using `printf` to generate the necessary unary string:
```
$ printf "%33825s" | tr ' ' 1 | sed -rf 16bitgrid.sed 
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
$ 
```
[Answer]
# Ruby, ~~118~~ 114
```
b="%016b"%gets
l=?++"---+"*4
1.upto(16){|i|puts l if i%4==1
print"| #{b[i-1]==?0?' ':?#} "
puts ?|if i%4<1}
puts l
```
thanks for @w0lf for saving some characters.
[Answer]
# C++11, ~~193~~ ~~191~~ ~~190~~ ~~176~~ 172 bytes
My first solution on codegolf ever, so do not blame me.
```
#include<iostream>
int n,j,i=65536;int main(){std::cin>>n;for(;j<9;){for(int k:{0,0,0,0})if(j%2)printf("| %s",n&(i/=2)?"# ":"  ");else printf("+---");puts(j++%2?"|":"+");}}
```
Ungolfed
```
#include <iostream>
int n, i = 65536, j;
int main()
{
    std::cin >> n;
    for (; j < 9;)
    {
        for(int k:{0,0,0,0})
        {
            if (j % 2)
            {
                printf("| %s", n & (i /= 2) ? "# " : "  ");
            }
            else
            {
                printf("+---");
            }
        }
        puts(j++ % 2 ? "|" : "+");
    }
}
```
Previous version
```
#include <iostream>
using namespace std;
int n, i = 65536, j;
int main()
{
    cin >> n;
    for (; j < 9;)
    {
        for(int k:{0,0,0,0})
        {
            if (j % 2)
            {
                cout << "| " << (n & (i /= 2) ? "# " : "  ");
            }
            else
            {
                cout << "+---";
            }
        }
        cout << (j++ % 2 ? "|\n" : "+\n");
    }
}
```
[Answer]
# Pyth, 37 bytes
```
Jj*3\-*5\+JVc4_m@" #".>Qd16jd.i*5\|NJ
```
Try it online: [Demonstration](http://pyth.herokuapp.com/?code=Jj*3%5C-*5%5C%2BJVc4_m%40%22+%23%22.%3EQd16jd.i*5%5C|NJ&input=4242&test_suite_input=4242%0A33825&debug=0) or [Test Suite](http://pyth.herokuapp.com/?code=Jj*3%5C-*5%5C%2BJVc4_m%40%22+%23%22.%3EQd16jd.i*5%5C|NJ&input=4242&test_suite=1&test_suite_input=4242%0A33825&debug=0)
### Explanation:
```
Jj*3\-*5\+J
  *3\-                       the string "---"
      *5\+                   the string "+++++"
 j                           join second by first string: 
                                "+---+---+---+---+"
J                            save in J
          J                  print J
Vc4_m@" #".>Qd16jd.i*5\|NJ
    m         16             map each d in [0, 1, ..., 15] to:
          .>Qd                 input number Q shifted to the right by d
     @" #"                     and take the ^th char in " #" (modulo 2)
   _                         reverse this list of chars
 c4                          split into 4 groups
V                            for each group N in ^:
                    *5\|       the string "|||||"
                  .i    N      interleave ^ with N
                jd             join chars with spaces and print
                         J     print J
```
[Answer]
# CJam, ~~43~~ 41 bytes
```
'+5*'-3**N+ri2bG0e[4/{" #"f='|5*.\S*N2$}/
```
Definitely golfable, but it's a start I guess. Generates the top row, then for each 4 bits it creates an even row and copies the previous odd row.
[Try it online](http://cjam.aditsu.net/#code='%2B5*'-3**N%2Bri2bG0e%5B4%2F%7B%22%20%23%22f%3D'%7C5*.%5CS*N2%24%7D%2F&input=12066).
[Answer]
# Python 2, ~~122~~ ~~121~~ 120 bytes
```
n=bin(4**8+input())[3:]
i=0
exec"print'| %s |'%' | '.join(' #'[x>'0']for x in n[:4])*i or'+---'*4+'+';n=n[4*i:];i^=1;"*9
```
-1 byte thanks to @xnor's neat `4**8+` trick. The main printing is done by looping 9 times, selecting the appropriate row for odd/even.
[Answer]
## Python 2, 94
```
n=input()
s=();exec"s=(' #'[n%2],)+s;n/=2;"*16
a='+---'*4+'+\n'
print(a+'| %s '*4+'|\n')*4%s+a
```
The idea is to take the pattern
```
+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+
```
except with `%s` in place of blanks and perform tuple substitution. The tuple looks like
```
('#', ' ', ' ', ' ', ' ', '#', ' ', ' ', ' ', ' ', '#', ' ', ' ', ' ', ' ', '#')
```
It is created by taking taking off digits from the input in binary and adding the corresponding symbol to the front of the tuple. An expression with explicit tuple gave equal length.
```
%tuple(' #'[c>'0']for c in bin(input()+4**8)[3:])
```
Thanks to Sp3000 for 2 bytes.
[Answer]
# PowerShell, ~~203~~ ~~188~~ 182 Bytes
```
param($a)$l="+---+---+---+---+";$l;$b=([int64][convert]::ToString($a,2)).ToString(@(,"0"*16)-join'');@(1..16|%{if($b[$_-1]-eq'1'){"| # "}else{"|   "};if($_%4-eq0){"|`n$l`n"}})-join''
```
Edit - saved 15 bytes by changing the order that `|` are drawn, so we can dump the `.TrimEnd("|")` on the output and instead convert the for-loop into a subcode block that produces an array
Edit2 - saved another 6 bytes by eliminating need for saving into the `$o` variable and just outputting with `-join''` directly.
Ooooooooof.
Drawing in PowerShell is *hard*. Working with binary digits in PowerShell is *hard*.
Uses built-ins to `[convert]` the input integer to a string representation in binary, then re-cast back to an `[int64]` so we can re-call `.ToString()` in order to prepend/pad the appropriate number of zeroes. (Note that creating an array of strings and joining them `@(,"0"*16)-join''` is 1 character shorter than the literal string `"0000000000000000"`)
Then, take a simple for-loop `1..16|%{...}` checking each digit to build up our output array, then finally `-join''` that back together.
---
### Previous, 188
```
param($a)$l="+---+---+---+---+";$l;$b=([int64][convert]::ToString($a,2)).ToString(@(,"0"*16)-join'');$o=@(1..16|%{if($b[$_-1]-eq'1'){"| # "}else{"|   "};if($_%4-eq0){"|`n$l`n"}});$o-join''
```
---
[Answer]
# Javascript (ES6), ~~216~~ 207 bytes
Defines an anonymous function.
```
i=>(","+("0".repeat(16)+i.toString(2)).slice(-16).split``.map((v,l,a)=>l%4<1?"| "+a.slice(l,l+4).map(v=>v?"#":" ").join` | `+" |":"").filter(v=>!!v).join`,`+",").replace(/,/g, `
+---+---+---+---+
`).slice(1)
```
Thanks to ETHproductions for tips!
[Answer]
# CJam, 62 bytes
```
"+---|   "4/{4*_c+N+}%4*_0=]sqi2bG0e[ee{~{_9*\4%5*-K+'#t0}&;}/
```
[Try it online](http://cjam.aditsu.net/#code=%22%2B---%7C%20%20%20%224%2F%7B4*_c%2BN%2B%7D%254*_0%3D%5Dsqi2bG0e%5Bee%7B~%7B_9*%5C4%255*-K%2B'%23t0%7D%26%3B%7D%2F&input=4242).
[Answer]
# Pyth, 50 bytes
```
j.i*5]<3*5"+---"ms.i*5\|dc4mj@" #"qd\1*2\ .[Z16.BQ
```
Explanation will have to wait until another time, I'm posting this on my phone!
[Answer]
# Ruby, 102
```
n=gets.to_i
print j="+---"*4+"+
" 
19.downto(0){|i|print i%5>0?"| #{((n>>i*4/5)%2*3+32).chr} ":"|
"+j}
```
**Algorithm**
Print a horizontal divider
Loop 20 times (19..0)
If loop number does not divide by 5, convert into a number in the range 16..0 by multiplying by 4/5. Print a space (ascii 32) or `#` (ascii 32+3=35) preceded by `|`  and followed by a space.
If loop number divides by 5, print a terminating |, newline, and a horizontal divider identical to the first.
[Answer]
# Perl, 103 bytes
```
$_=(($l='+---'x4 .'+
').'| x 'x4 .'|
')x4 .$l;@n=(sprintf'%016b',<>)=~/./g;s/x/$n[$x++]?'#':$"/eg;print
```
Lots of string repetition to make a grid of `x`s, convert the input to binary and then `s///` the `x`s to `#` or `$"` () depending on the flag at the specified position (`$x`).
[Answer]
# PHP, 159 bytes
`bingrid16.php`:
```
<?$r=10;while(--$r){if($r%2){echo str_repeat('+---',4).'+';}else{$c=9;echo'|';while(--$c){echo' '.($c%2?'|':($argv[1]&pow(2,$r*2+$c/2-5)?'#':' '));}}echo"\n";}
```
Usage:
```
php bingrid16.php 4242
```
Nothing fancy, just brute-forced the rendering.
I tried another angle using arrays instead of loops, but it was longer at 224 bytes:
```
<?=implode(array_map(function($r)use($argv){return($r%2?str_repeat('+---',4).'+':'|'.implode(array_map(function($c)use($r,$argv){return' '.($c%2?'|':($argv[1]&pow(2,$r*2+$c/2-5)?'#':' '));},range(8,1))))."\n";},range(9,1)));
```
[Answer]
# [Perl 5](https://www.perl.org/), ~~85~~ 84 bytes
~~84~~ 83 bytes of code + `-p` flag
*-1 byte after Dom reminded me to use a newline*
```
say$\='+'."---+"x4,"
| ",map y/01/ #/r.' | ',/./g for(sprintf"%016b",$_)=~/..../g}{
```
[Try it online!](https://tio.run/##DcFBDoIwEADAu6/YLJhKaLttpNx4gj8wMZgIIVG6aTlIRJ/u6gzf0j2I5H4tz52qlUVjTI3PRuNuA9SPnmEl5wkKSlbBBkqTpRGGmA6Z0zQvA@6db6@oy0vVfcj@0fh@ibQhHJtv5GWKcxZzCtZ5J4Z/ "Perl 5 – Try It Online")
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `j`, 47 bytes
```
b:L16-(0p)4ẇƛƛ‛ #$i`| % `$%;ṅ\|+;\+:3-4*pw5ẋf$Y
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=j&code=b%3AL16-%280p%294%E1%BA%87%C6%9B%C6%9B%E2%80%9B%20%23%24i%60%7C%20%25%20%60%24%25%3B%E1%B9%85%5C%7C%2B%3B%5C%2B%3A3-4*pw5%E1%BA%8Bf%24Y&inputs=4242&header=&footer=)
A big mess
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), ~~40~~ 36 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
This'll need another pass once I'm properly caffeinated!
```
5Æ17î-³i+ÃíUs'#iS)ùG ®û3 i|ÃòG)cf ú|
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=NcYxN%2b4ts2krw%2b1VcycjaVMp%2bUcgrvszIGl8w/JHKWNmIPp8&input=NDI0Mg)
```
5Æ17î-³i+ÃíUs'#iS)ùG ®û3 i|ÃòG)cf ú|     :Implicit input of integer U
5Æ                                       :Map the range [0,5)
  17î                                    :  Repeat the following to length 17
     -³                                  :    "-" repeated 3 times
       i+                                :    Prepend a "+"
         Ã                               :End map
          í                              :Interleave with
           Us                            :  U converted to a string in the following base
             '#i                         :    "#" prepended with
                S                        :    A space
                 )                       :  End base conversion
                  ù                      :  Left pad with spaces to length
                   G                     :    16
                     ®                   :  Map each character
                      û3                 :    Centre pad with spaces to length 3
                         i|              :    Prepend a "|"
                           Ã             :  End map
                            òG           :  Partitions of length 16
                              )          :End interleave
                               c         :Flatten
                                f        :Filter out falsey elements (If the second array being interleaved is shorter than the first, it's padded with null)
                                  ú|     :Left pad each with "|" to the length of the longest
                                         :Implicit output joined with newlines
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 31 bytes
```
\+3-4*\|?b16∆Z\#*2↳ʁ+4ẇṠv"fǏvǏ⁋
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJcXCszLTQqXFx8P2IxNuKIhlpcXCMqMuKGs8qBKzThuofhuaB2XCJmx492x4/igYsiLCIiLCI0MjQyIl0=)
```
        ?                       # Input
         b                      # To binary
          16∆Z                  # Pad to length 16 with 0s
              \#*               # That many #s, for each bit
                 2↳ʁ            # Pad to length 2 with spaces and mirror
      \|            +           # Prepend | to each
                     4ẇṠ        # Divide into rows and stringify each
                        v"f     # Interleave with...
\+3-                            # "+---"
    4*                          # Repeated four times
                           Ǐ    # Append the first line
                            vǏ  # For each line, append the firstt character
                              ⁋ # Join the result by newlines
```
[Answer]
# c99 263 bytes
golfed:
```
main(int argc,char **argv){short i=atoi(argv[argc-1]);char *t="| # ", *f="|   ",*a[16],**p=a,*b="+---+---+---+---+\r\n";while(p<a+16){if((i|0x8000)==i)(*(p++))=t;else(*(p++))=f;i<<=1;}for(p=a;p<a+16;p+=4)printf("%s%s%s%s%s|\n",b,*p,p[1],p[2],p[3]);printf("%s",b);}
```
ungolfed:
```
main(int argc, char **argv)
{
    short i=atoi(argv[argc -1]);
    char *t ="| # ", *f="|   ",*a[16],**p=a,*b="+---+---+---+---+\r\n";
    while (p<a+16)
    {
        if((i|32768)==i)
            (*(p++))=t;
        else
            (*(p++))=f;
        i<<=1;
    }
    for (p=a;p<a+16;p+=4)
        printf("%s%s%s%s%s|\n",b,*p,p[1],p[2],p[3]);
    printf("%s",b);
}
```
I just liked to present a bit shifting variant and felt this is the first time its appropriate (even its costing me some bytes, but C can't this challange in bytes even with a chance so I don't care) to use the argc/argv
[Answer]
# Ruby, 95
Nod to Mhmd for a concise String conversion, but I wanted to try using string methods instead of number methods.
```
->i{puts g='+---'*4+?+;("%016b"%i).scan(/.{4}/){puts$&.gsub(/./){"| #{$&<?1?' ':?#} "}+"|
"+g}}
```
[Answer]
# Ruby, 93
A slightly shorter version using only numeric operations.
```
->i{n=g='+---'*4+"+
";15.downto(0){|m|n+="| #{[' ',?#][1&i>>m]} "
n+="|
"+g if m%4<1}
puts n}
```
[Answer]
## C# 227 Bytes
Golfed:
```
class B{public static string G(short v){string s="",b=System.Convert.ToString(v,2).PadLeft(16,'0');for(int i=9;i>0;){s+=i--%2!=0?"+---+---+---+---+\n":"| "+b[i*2+1]+" | "+b[i*2]+" | "+b[i*2-1]+" | "+b[i*2-2]+" |\n";}return s;}}
```
Indention:
```
class B
{
    public static string G(short v)
    {
        string s="",b=System.Convert.ToString(v, 2).PadLeft(16,'0');
        for(int i=9;i>0;)
            s+=i--%2!=0?"+---+---+---+---+\n":"| "+b[i*2+1]+" | "+b[i*2]+" | "+b[i*2-1]+" | "+b[i*2-2]+" |\n";
        return s;
    }
}
```
First time I'm trying something like this, tips would be welcome!
[Answer]
# Python 3, ~~145~~ 144 Bytes
Inline:
```
a="|";b="+"+"---+"*4+"\n";r=0,1,2,3;(lambda x:print(b+b.join(a+a.join(" %s "%'# '[x&2**(i+j*4)<1]for i in r)+a+"\n"for j in r)+b))(int(input()))
```
With newlines:
```
a="|"
b="+"+"---+"*4+"\n"
r=0,1,2,3
lambda x:print(b+b.join(a+a.join(" %s "%'# '[x&2**(i+j*4)<1]for i in r)+a+"\n"for j in r)+b)
x(int(input()))
```
Edit: Tanks @manatwork for saving 1 byte
[Answer]
# x86-16 machine code, IBM PC DOS, 80 bytes
Binary:
```
00000000: b805 09ba 2801 cd21 fec8 741b be3e 01b1  ....(..!..t..>..
00000010: 04d1 e3c6 0420 7303 c604 2383 c604 e2f1  ..... s...#.....
00000020: ba3c 01cd 21eb dcc3 2b2d 2d2d 2b2d 2d2d  .<..!...+---+---
00000030: 2b2d 2d2d 2b2d 2d2d 2b0d 0a24 7c20 2020  +---+---+..$|
00000040: 7c20 2020 7c20 2020 7c20 2020 7c0d 0a24  |   |   |   |..$
```
Listing:
```
B8 0905         MOV  AX, 0905H              ; AH = DOS write string, AL = row counter 
            ROW_LOOP: 
BA 0128         MOV  DX, OFFSET SEP         ; show separator row 
CD 21           INT  21H                    ; write to console
FE C8           DEC  AL                     ; displayed 5 separators? 
74 1B           JZ   EXIT                   ; if so, exit 
BE 013E         MOV  SI, OFFSET ROW+2       ; start SI at location of first bit in row 
B1 04           MOV  CL, 4                  ; loop count 4 
            BIT_LOOP: 
D1 E3           SHL  BX, 1                  ; shift MSb into CF 
C6 04 20        MOV  BYTE PTR[SI], ' '      ; reset to space char 
73 03           JNC  BIT_DONE               ; if not CF, leave as a space 
C6 04 23        MOV  BYTE PTR[SI], '#'      ; otherwise change to a # 
            BIT_DONE: 
83 C6 04        ADD  SI, 4                  ; increment index 4 bytes 
E2 F1           LOOP BIT_LOOP               ; keep looping through bits 
BA 013C         MOV  DX, OFFSET ROW         ; show bit column row
CD 21           INT  21H                    ; write to console
EB DC           JMP  ROW_LOOP               ; keep looping 
            EXIT: 
C3              RET                         ; return to caller
            SEP DB  '+---+---+---+---+',0DH,0AH,'$'
            ROW DB  '|   |   |   |   |',0DH,0AH,'$'
```
Callable function, input in `BX` output to `STDOUT`.
Example test program:
[![enter image description here](https://i.stack.imgur.com/UJ2uq.png)](https://i.stack.imgur.com/UJ2uq.png)
[Answer]
# [Kotlin](https://kotlinlang.org), 192 bytes
```
{val v=it.toString(2).padStart(16,'0')
fun p(){(0..3).map{print("+---")}
println("+")}
(0..3).map{p()
v.subSequence(it*4,(it+1)*4).map{print("| ${if(it>'0')'#' else ' '} ")}
println("|")}
p()}
```
## Beautified
```
{
    val v = it.toString(2).padStart(16, '0')
    fun p() {
        (0..3).map { print("+---") }
        println("+")
    }
    (0..3).map {
        p()
        v.subSequence(it *4, (it +1) *4).map {print("| ${if (it > '0') '#' else ' '} ")}
        println("|")
    }
    p()
}
```
## Test
```
var b:(Int) -> Unit =
{val v=it.toString(2).padStart(16,'0')
fun p(){(0..3).map{print("+---")}
println("+")}
(0..3).map{p()
v.subSequence(it*4,(it+1)*4).map{print("| ${if(it>'0')'#' else ' '} ")}
println("|")}
p()}
fun main(args: Array<String>) {
    b(255)
}
```
]