[Question]
  [
**Task description:**
Draw a cube in ASCII art in roughly a cabinet projection.
`Monospaced fonts` often have characters that are about twice as high as they are wide. Since the input is the length of the vertical lines (excluding the corners), horizontal lines are drawn with twice as many characters so that the resulting image is really roughly a cube. The receding lines are drawn at half the length as mandated by a cabinet projection.
Corners of the cube are represented by `+`, horizontal lines by `-`, vertical lines by `|` and diagonal ones use `/`.
Summarizing: Let the input be *n*, then
* A horizontal edge of the cube are drawn with `-` and consists of 2 *n* characters.
* A vertical edge of the cube are drawn with `|` and consists of *n* characters.
* A diagonal edge of the cube are drawn with `/` and consists of *n*/2 characters.
* Corners of the cube are drawn with `+`. Corners are not counted for the length of an edge as detailed above (see examples below as well).
**Input:**
The input, given on standard input, is a single positive, even number *n* (2 ≤ *n* ≤ 30) that gives the length of the vertical lines of the cube. It is followed by a single line break.
**Output:**
The output is a cube on standard output following above rules. Trailing whitespace on the lines is ignored.
**Sample input 1:**
```
2
```
**Sample output 1:**
```
  +----+
 /    /|
+----+ |
|    | +
|    |/
+----+
```
**Sample input 2:**
```
4
```
**Sample output 2:**
```
   +--------+
  /        /|
 /        / |
+--------+  |
|        |  |
|        |  +
|        | /
|        |/
+--------+
```
**ETA:** I now accepted the shortest solution. I will update the accepted answer when a shorter one comes along.
Since some people asked how long the entries of our contestants were:
> 
> 227 – Python  
> 
>  240 – Perl  
> 
>  310 – C  
> 
>  315 – C  
> 
>  326 – VB.NET  
> 
>  459 – C
> 
> 
> 
As well as our own solutions (not ranked with the others):
> 
> 140 – Golfscript  
> 
>  172 – [Ruby](https://codegolf.stackexchange.com/questions/189/drawing-a-cube-in-ascii-art/240#240)  
> 
>  183 – [PowerShell](https://codegolf.stackexchange.com/questions/189/drawing-a-cube-in-ascii-art/236#236)
> 
> 
> 
  
[Answer]
## Python - 248 243 230 227 191
Slightly messy but it basically prints the cube line by line(using a string buffer).
```
t=v=h=input()/2
s,p,b,f,n=" +|/\n"
l=p+"-"*t*4+p;S=s*4*t;k=s*h;K=b+S+b
r=s*t+s+l+n
while t:r+=s*t+f+S+f+s*(h-t)+b+n;t-=1
r+=l+k+b+n+(K+k+b+n)*(v-1)+K+k+p+n
while v:v-=1;r+=K+s*v+f+n
print r+l
```
Thanks to @marcog, for pointing out the first line, @ThomasO for pointing out the second line and to @Juan for making me realise I can combine lines. 
[Answer]
## Golfscript - 96 chars
```
~:<2/:$){' '*}:s~'++'<'--'**:^n$,{.$\-s'//'2s<*:&*@s'|':|n}%^$[$s|n|&|]*$s'+'n$,{n'/'@s|&|}%-1%^
```
Most of the compactness comes from aggressively storing almost everything to a variable (unless you include being written in golfscript).
```
<    n
$    n/2
s    {' '*}     # top of the stack becomes a string of that many spaces
^    '+------+'
&    '      '   # 2n spaces, i.e. 2s<* or <s2*
|    '|'
```
A couple of other small tricks here.
1. `'LR''str'*` -> `'LstrR'`.
2. Since we need to reverse the order of lines in the last array, we opt to do this after generating the text instead of before. This allows us to save one character because the spaces before the `'/'` only needs to go past two stack elements (`@`) instead of 3 (`@ .. \`).
[Answer]
Python - 179
```
h=input()*2
j=d=h/4
q,e,u,p,k="| \n+/"
w=e*d
s=p+'-'*h+p
i=''
o=e+w+s+u
v=q+e*h+q
while j:o+=e*j+k+e*h+k+e*(d-j)+q+u;j-=1;i+=v+e*j+k+u
print o+s+w+q+u+(v+w+q+u)*(d-1)+v+w+p+u+i+s
```
I'd like to note that I took some ideas from JPvdMerwe (Using a string to print once, and the one-liner for that I didn't know was correct syntax in Python).
[Answer]
## fortran 77 -- 484 characters
```
      program z
      read(*,*) i
      g=f('+- ',i/2+1,i,0)
      do k=1,i/2
         g=f('/ |',i/2-k+1,i,k-1)
      end do
      g=f('+-|',0,i,i/2)
      do k=1,i/2-1
         g=f('| |',0,i,i/2)
      end do
      g=f('| +',0,i,i/2)
      do k=1,i/2
         g=f('| /',0,i,i/2-k)
      end do
      g=f('+- ',0,i,0)
      stop
      end
      real function f(c,l,m,n)
      character c(3)
      write(*,*)(' ',j=1,l),c(1),(c(2),j=1,2*m),c(1),(' ',j=1,n),c(3)
      return
      end
```
No real point in providing a "unobsfucated" version. And note that markdown doesn't get along well with the indent requirements.
I tried fortran because of the inline for loops provided by the `write` statement. Obviously they help but don't add up to enough to kill the wordiess of the language. It could be reduce by using freeform input.
**Validation:**
```
 $ wc cube_func_array.f
 22  41 484 cube_func_array.f
 $ gfortran cube_func_array.f
 $ echo 2 | ./a.out
   +----+ 
  /    /|
 +----+ |
 |    | +
 |    |/
 +----+ 
 $ echo 4 | ./a.out
    +--------+ 
   /        /|
  /        / |
 +--------+  |
 |        |  |
 |        |  +
 |        | /
 |        |/
 +--------+ 
```
Thankfully the spec doesn't say what size one should look like:
```
 $ echo 1 | ./a.out
  +--+ 
 +--+|
 |  |+
 +--+ 
```
but other odd sizes are reasonable:
```
 $ echo 3 | ./a.out
   +------+ 
  /      /|
 +------+ |
 |      | +
 |      |/
 +------+ 
```
[Answer]
## PostScript, 237
```
[/n(%stdin)(r)file token()/p{print}/r{repeat}([){{( )p}r}/N{n 2 mul}(]){n 2 idiv}/l{N(+)p{(-)p}r(+)p}/I{(|)p}/X{][p}>>begin
( )X l()=]-1 1{dup[(/)p N[(/)p]exch sub[(|)=}for
l(|
)X]1 sub{I N[I(|
)X}r
I N[I(+
)X]-1 1{I N[I 1 sub[(/)=}for
l
```
History:
* 2011-03-01 01:54 **(427)** First attempt.
* 2011-03-01 02:01 **(342)** `def`ed a few more things that appeared often.
* 2011-03-01 02:24 **(283)** Even more `def`s.
* 2011-03-01 02:42 **(281)** Aaand another `def` that saves two more bytes.
* 2011-03-01 03:01 **(260)** `[` and `]` have nice properties when used as variables :-). Thanks to [KirarinSnow](https://codegolf.stackexchange.com/users/157/kirarinsnow).
* 2011-03-01 03:12 **(246)** Inline line breaks, using a dict instead of numerous `def`s. Thansk again :-).
* 2011-03-01 03:26 **(237)** More thanks to [KirarinSnow](https://codegolf.stackexchange.com/users/157/kirarinsnow).
[Answer]
My own solution, since it has already been beaten to death by Python:
### Windows PowerShell, 183
```
$t=($w=($s=' ')*($o=($n="$input")/2))*4
$r="|$t|"
$s*($a=$o+1)+($q='+'+'--'*$n+'+')
$o..1|%{$s*--$a+"/$t/$($s*$b++)|"}
"$q$w|"
for(;$o-++$x){"$r$w|"}"$r$w+"
--$b..0|%{$r+$s*$_+'/'}
$q
```
[Answer]
## Ruby 1.9, ~~172 165~~ 162 characters
```
w=(s=?\s)*o=(n=gets.to_i)/2;r=(z=?|)+w*4+z
puts s*(o+1)+q=?++?-*2*n+?+,(l=0...o).map{|u|[s*(o-u),w*4,s*u+z]*?/},q+w+z,[r+w+z]*o-=1,r+w+?+,l.map{|u|r+s*(o-u)+?/},q
```
[Answer]
## Ruby - 423 characters
Really don't want to share this since it's such a horrible count, but since I've written it might as well.
```
n=$<.read.to_i
a=(q=Array).new(n+n/2+3){q.new(2*n+n/2+3,' ')<<"\n"}
a[n+1][2*n+n/2+2]=a[0][n/2+1]=a[0][2*n+n/2+1]=a[n/2+1][0]=a[n/2+1][2*n]=a[n+n/2+2][0]=a[n+n/2+2][2*n]=:+
a[0][n/2+2,n*2-1]=a[n/2+1][1,n*2-1]=a[n+n/2+2][1,n*2-1]=[:-]*2*n
a[n/2+2,n].each{|b|b[0]=b[2*n+1]=:|}
a[1,n].each{|b|b[2*n+n/2+2]=:|}
c=n/2
a[1,n/2].each{|b|b[c]=b[2+2*n+c-=1]=:/}
c=n/2
a[n+2,n/2].each{|b|b[2+2*n+c-=1]=:/}
a.flatten.each{|g|print g}
```
Could probably be reduced by quite a bit but I doubt this brute-force approach is going to come anywhere near a decent number of characters so I can't be bothered.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `J`, 61 bytes
```
½:→›\+?-m:£꘍←ƛ\/?꘍m꘍;Ṙ?ɾv\|?꘍vm¥pJ←ʁ←›v←ȮṘJJ꘍?\|*\++←\/*+f+⁋¥
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJKIiwiIiwiwr064oaS4oC6XFwrPy1tOsKj6piN4oaQxptcXC8/6piNbeqYjTvhuZg/yb52XFx8P+qYjXZtwqVwSuKGkMqB4oaQ4oC6duKGkMiu4bmYSkrqmI0/XFx8KlxcKyvihpBcXC8qK2Yr4oGLwqUiLCIiLCI4Il0=)
This was harder than I thought it'd be. -4 thanks to @AaroneousMiller. Woo, beating ascii-art langs!
[Answer]
## PHP, ~~401~~ ~~392~~ ~~382~~ 363 characters:
```
<? $h=fgets(STDIN);$s="str_repeat";$w=$h*2;$d=$h/2;$b=$h;$c=" ";echo$s($c,$h/2+1)."+".$s("-",$w)."+\n";for($i=1;$i<=$d;$i++,$a=--$b){echo$s($c,($h/2+1)-$i)."/".$s($c,$w)."/".$s($c,$i-1)."|\n";}echo"+".$s("-",$w)."+".$s($c,$d)."|\n";for($i=1;$i<=$h;$i++){echo"|".$s($c,$w)."|";echo $a-->0?$s($c,$b).($a>0?"|":"+")."\n":$s($c,$h-$i)."/\n";}echo"+".$s("-",$w)."+\n";
```
I originally did this to see how short I could manage to do this in PHP, as I knew that it would be pretty long. I'm sure it could be reduced, but not by much considering PHP doesn't have many shortcuts.
**Validation:**
  
<http://codepad.viper-7.com/ftYYz9.php53>
  
  
Ungolfed Version: <http://codepad.viper-7.com/4D3kIA>
[Answer]
## Perl, 163
```
$d=<>/2;$s=$"x$d;$H=$s x4;$f="|$H|";$t.=$"
x$d--."/$H/".$"x$_."|\n",$m.="$f$s|\n",$b
=$f.$"x$_."/\n$b"for 0..$d-1;$_="+$H+";
y/ /-/;say" $s$_\n$t$_$s|\n$m$f$s+\n$b$_"
```
Perl 5.10 or later, run with `perl -E '<code here>'`
Respaced version:
```
$d = <> / 2;
$s = $" x $d;
$H = $s x 4;
$f = "|$H|";
$t .= $" x $d-- . "/$H/" . $"x$_ . "|\n",
$m .= "$f$s|\n",
$b = $f . $" x $_ . "/\n$b"
  for 0 .. $d-1;
$_ = "+$H+";
y/ /-/;
say " $s$_\n$t$_$s|\n$m$f$s+\n$b$_"
```
[Answer]
### Perl, 269 269 262 256 245 244 237 226 228 224 217 chars
```
sub p{y/xS/+\//;print;y/+\//xS/}$b=/2;$a=$b;$_=" xx\n";s/ x/  x----/while($a--);until(/^S/){p;s/ [xS]/S /g;s/-x/S|/;y/-/ /}s/ (?= *S)/-/g;y/S/x/;p;y/-x/ |/;p while(--$b);s/.$/x/;while(/ \|/){p;s/..$/S/}y/|S /++-/;p
```
The basic idea is to do everything with regex substitutions. Because two of the characters used (+ and /) are special characters and turn up a lot in the regexes, it's worthwhile using other characters and substituting them to print.
Slightly more legible version:
```
# Subroutine to substitute, print, and unsubstitute as described above
sub p{y/xS/+\//;print;y/+\//xS/}
# Read from stdin and set up the initial line
$b=<>/2;$a=$b;$_=" xx\n";
s/ x/  x----/ while($a--);
# Print the top face
until(/^S/) {
  p;
  s/ [xS]/S /g; # First time round: left + -> /; subsequent times move / left
  s/-x/S|/; # Only relevant first time round the loop
  y/-/ / # Only relevant first time round the loop
}
# Prepare and print the line containing second horizontal line
s/ (?= *S)/-/g;
y/S/x/;
p;
# Now print (n-1)/2 identical lines
y/-x/ |/;
p while (--$b);
# Bring the right edge in
s/.$/x/;
while(/ \|/)
{
  p;
  s/..$/S/
}
# Final line
y/|S /++-/;
p
```
In a sense I'm cheating by using $b as a counter in the intermediate loop - I could instead append whitespace in the loop over $a and then use regex replaces for that loop too - but I'm going to allow that slight deviation from a pure-regex solution.
No doubt some scary person can turn this into a much shorter sed script.
[Answer]
# Lua, ~~294~~ ~~302~~ 292 bytes
Golfed:
```
n=(...)p="+"d=2*n s=" "S=s:rep(d)h=n/2 T=s:rep(h)L="\n"o="/"v="|"a=p..("-"):rep(d)..p r=T..s..a..L for i=0,h-1 do r=r..s:rep(h-i)..o..S..o..s:rep(i)..v..L end r=r..a..T..v for i=1,h do r=r..L..v..S..v..T..(i==h and p or v) end for i=h-1,0,-1 do r=r..L..v..S..v..s:rep(i)..o end print(r..L..a)
```
Ungolfed:
```
n        = n or io.read() or 6
plus     = "+"
doubled  = 2*n
space    = " "
Space    = space:rep(doubled)
halved   = n/2
T        = space:rep(halved)
Line     = "\n"
or_sign  = "/"
vertical = "|"
a        = plus..("-"):rep(doubled)..plus
result   = T..space..a..Line
for i=0,halved-1 do
    result = result .. space:rep(halved-i) .. or_sign .. Space .. or_sign .. space:rep(i) .. vertical .. Line
end
result = result..a..T..vertical
for i=1,halved do
    result = result .. Line .. vertical .. Space .. vertical .. T .. (i==halved and plus or vertical)
end
for i=halved-1,0,-1 do
    result = result .. Line .. vertical .. Space .. vertical .. space:rep(i) .. or_sign
end
print(result .. Line .. a)
```
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 63 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
╴»
±╵⁷／╋╴«３＋⁷
-×+×║⌐１╴├╋；⁷├⁷±╋２⁷⁸⁸├⁷／╋１２╴«├２⁷５×３＋⁷±╵⁰２ｎ｛┤╴|＊+∔╋
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXUyNTc0JUJCJTBBJUIxJXUyNTc1JXUyMDc3JXVGRjBGJXUyNTRCJXUyNTc0JUFCJXVGRjEzJXVGRjBCJXUyMDc3JTBBLSVENyslRDcldTI1NTEldTIzMTAldUZGMTEldTI1NzQldTI1MUMldTI1NEIldUZGMUIldTIwNzcldTI1MUMldTIwNzclQjEldTI1NEIldUZGMTIldTIwNzcldTIwNzgldTIwNzgldTI1MUMldTIwNzcldUZGMEYldTI1NEIldUZGMTEldUZGMTIldTI1NzQlQUIldTI1MUMldUZGMTIldTIwNzcldUZGMTUlRDcldUZGMTMldUZGMEIldTIwNzclQjEldTI1NzUldTIwNzAldUZGMTIldUZGNEUldUZGNUIldTI1MjQldTI1NzQlN0MldUZGMEErJXUyMjE0JXUyNTRC,i=NA__,v=0)
]