[Question]
  [
Today, November 11th, is known as [Remembrance Day](https://en.wikipedia.org/wiki/Remembrance_Day), [Armistice Day](https://en.wikipedia.org/wiki/Armistice_Day), or [Veterans Day](https://en.wikipedia.org/wiki/Veterans_Day) (depending upon the country), and is a day of reflection and gratitude for members of the military and their service, specifically started to reflect the end of European hostilities in the first World War. Let us reflect on that with a simple ASCII-art output of `11/11`.
Given an input `n`, output an ASCII-art rendition of `11/11` that is `n` units tall. Specifically, each `1` is composed of vertical pipes `||`, the slash is composed of slashes `//`, and each character is two spaces apart. Note that this means varying output widths -- for example, for `n=3` below, see how the "bottom" of the slash is two spaces from the `1` to its left, but is four spaces from the `1` on its right, so that the top of the slash lines up appropriately and is two spaces from the `1` on its right.
```
n = 1
||  ||  //  ||  ||
n = 2
||  ||   //  ||  ||
||  ||  //   ||  ||
n = 3
||  ||    //  ||  ||
||  ||   //   ||  ||
||  ||  //    ||  ||
n = 4
||  ||     //  ||  ||
||  ||    //   ||  ||
||  ||   //    ||  ||
||  ||  //     ||  ||
n = 5
||  ||      //  ||  ||
||  ||     //   ||  ||
||  ||    //    ||  ||
||  ||   //     ||  ||
||  ||  //      ||  ||
```
and so on.
### Input
A single positive integer [in any convenient format](http://meta.codegolf.stackexchange.com/q/2447/42963), `n > 0`.
### Output
An ASCII-art representation of `11/11`, following the above rules and examples. Leading/trailing newlines or other whitespace are optional, provided that the characters line up appropriately.
### Rules
* Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
  
[Answer]
## JavaScript (ES6), 57 bytes
```
n=>" ".repeat(n).replace(/./g,"||  ||  $'//$`  ||  ||\n")
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 24 bytes
```
<ð×„//J¹FD"  ||"2×ÂŠ««,À
```
[Try it online!](http://05ab1e.tryitonline.net/#code=PMOww5figJ4vL0rCuUZEIiAgfHwiMsOXw4LFoMKrwqssw4A&input=NQ)
**Explanation**
```
                          # implicit input n
<ð×                       # push n-1 spaces
   „//J                   # join with "//"
       ¹F                 # input times do:
         D                # duplicate top of stack
          "  ||"2×        # push "  ||  ||"
                  Â       # push "||  ||  "
                   Š      # move the top of the stack down 2 places on the stack
                    ««    # concatenate the top 3 elements of the stack
                      ,   # print with newline
                       À  # rotate top of stack left
```
**Previous 26 byte version**
```
F"||  "2×©ð¹N-<×„//ðN×®RJ,
```
[Try it online!](http://05ab1e.tryitonline.net/#code=RiJ8fCAgIjLDl8Kpw7DCuU4tPMOX4oCeLy_DsE7Dl8KuUkos&input=MQ)
[Answer]
## Perl, 45 bytes
*-9 bytes thanks to @Gabriel Benamy*
47 bytes of code + 1 byte for `-n` flag.
```
say$@="||  "x2,$"x$_,"//",$"x++$.,$@while$_--
```
Run with `-nE` flags :
```
perl -nE 'say$@="||  "x2,$"x$_,"//",$"x++$.,$@while$_--' <<< 5
```
[Answer]
# JavaScript (ES6), ~~88~~ 77 bytes
```
f=(n,i=n)=>i--?`||  ||  ${" ".repeat(i)}//${" ".repeat(n+~i)}  ||  ||
`+f(n,i):""
```
The recursive approach ~~may not be~~ [could not possibly be the shortest](https://codegolf.stackexchange.com/a/99460/42545).
---
`.map` version (88 bytes):
```
n=>[...Array(n)].map((_,i)=>`||  ||  ${" ".repeat(n+~i)}//${" ".repeat(i)}  ||  ||`).join`
`
```
Array comprehension (86 bytes):
```
n=>[for(_ of Array(i=n))`||  ||  ${" ".repeat(--i)}//${" ".repeat(n+~i)}  ||  ||`].join`
`
```
`for` loop version (89 bytes):
```
n=>{for(a="",i=n;i--;a+=s+" ".repeat(i+2)+`//${" ".repeat(n-i+1)+s}
`)s="||  ||";return a}
```
`.replace` version (85 bytes):
```
n=>`||  ||  q  ||  ||
`[r="repeat"](n).replace(/q/g,_=>" "[r](--i)+"//"+" "[r](n+~i),i=n)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 24 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
⁾| Ḥẋ2µ,Ṛðj
⁶ẋṖ;⁾//ṙḶÇ€Y
```
**[TryItOnline!](http://jelly.tryitonline.net/#code=4oG-fCDhuKThuosywrUs4bmaw7BqCuKBtuG6i-G5ljvigb4vL-G5meG4tsOH4oKsWQ&input=&args=MTE)**
### How?
```
⁾| Ḥẋ2µ,Ṛðj - Link 1, join two "11"s with: middle
⁾|          - string literal: "| "
   Ḥ        - double          "||  "
    ẋ2      - repeat twice    "||  ||  "
      µ     - monadic chain separation
       ,    - pair with
        Ṛ   - reversed       ["||  ||  ","  ||  ||"]
         ð  - dyadic chain separation
          j - join with input "||  ||  middle  ||  ||"
⁶ẋṖ;⁾//ṙḶÇ€Y - Main link: n       e.g. 5
⁶            - literal ' '        ' '
 ẋ           - repeat n times     "     "
  Ṗ          - remove last entry  "    "
   ;         - concatenate with
    ⁾//      - literal "//"       "    //"
        Ḷ    - lowered range(n)   [0,1,2,3,4]
       ṙ     - rotate left        ["    //","   // ","  //  "," //   ","//    "]
         Ç€  - call last link (1) as a monad for €ach
           Y - join with line feeds
   
```
[Answer]
## Retina, 29 bytes
```
.+
$* 
.
xx$'//$`  xx¶
x
||  
```
Port of my JavaScript solution. Note the space after `$*` and two spaces after `||`.
[Answer]
# [V](http://github.com/DJMcMayhem/V), 30 bytes
```
4i||  2Bi//  Àé XÀ«ñÄf/é Elx
```
[Try it online!](http://v.tryitonline.net/#code=NGl8fCAgGzJCaS8vICAbw4DDqSBYw4DCq8Oxw4RmL8OpIEVseA&input=&args=NQ)
As usual, here is a hexdump:
```
0000000: 3469 7c7c 2020 1b32 4269 2f2f 2020 1bc0  4i||  .2Bi//  ..
0000010: e920 58c0 abf1 c466 2fe9 2045 6c78       . X....f/. Elx
```
[Answer]
## Batch, 130 bytes
```
@set s=xx//  xx
@set l=@for /l %%i in (2,1,%1)do @call
%l% set s=%%s://= //%%
%l%:l
:l
@echo %s:x=^|^|  %
@set s=%s: //=// %
```
Not a port of my JavaScript solution. Since `|`s are hard to manipulate in Batch, I use `x`s as placeholders and replace them on output, this conveniently also reduces my code size. Starts by setting `s` to the desired output for `n=1` (`n` is passed on the command line), then inserts spaces as necessary to obtain the first line for the actual value of `n`, then loops through printing the string and shifting the slash left by one character each time.
[Answer]
# **[BaCon](http://www.basic-converter.org), 71 bytes**
A complete BASIC program in one line.
```
INPUT n:FOR x=1 TO n:?"||  ||",SPC$(n-x+2),"//",SPC$(x+1),"||  ||":NEXT
```
[Answer]
# Common Lisp, 216 bytes
I'm going to state right off the bat that this is an awful solution to the challenge. Nevertheless, it works, and I'm tired.
```
(defun arm (n) (format t "~{||  || ~v,,,vA//~v,,,vA ||  ||~%~}" (butlast (butlast (butlast (butlast (butlast (butlast (loop for i from 1 to (+ n 1) append `(,(- (+ n 1) i) #\Space #\Space ,i #\Space #\Space))))))))))
```
Usage:
```
* (arm 4)
||  ||     //  ||  ||
||  ||    //   ||  ||
||  ||   //    ||  ||
||  ||  //     ||  ||
```
For some reason, instead of doing anything sane, I decided to approach this with a loop inside a `format` call. This loop iterates through the contents returned by the *other* actual loop construct at the very end, with the last six elements removed (thus the repeated `butlast`s). The contents of the value returned by this loop construct consist of a padding count for the front of the slashes, the padding characters (spaces), the padding count for the back of the slashes, and finally the same padding characters.
I'm rather new to Lisp, and I understand that there is definitely a lot of room for improvement here.
[Answer]
# Python 2, ~~76~~ ~~75~~ 71 Bytes
Still working on a shorter version, not too bad though.
```
n=input()
k='||  ||'
for i in range(n):print k,(n-i)*' '+'//'+' '*-~i,k
```
*thanks mbomb007 for catching an error!*
[Answer]
## R, 86 bytes
Just a simple `for` loop approach:
```
x="||  ||";n=scan();for(i in 1:n)cat(x,rep(" ",2+n-i),"//",rep(" ",1+i),x,"\n",sep="")
```
[Answer]
## [Retina](http://github.com/mbuettner/retina), 40 bytes
```
.+
x $&$* //  x
;{:`x
||  ||
   //
  // 
```
[Try it online!](http://retina.tryitonline.net/#code=LisKeCAkJiQqIC8vICB4Cjt7OmB4Cnx8ICB8fAogICAvLwogIC8vIA&input=NQ)
### Explanation
```
.+
x $&$* //  x
```
This turns the input `N` into
```
x S//  x
```
Where `S` corresponds to `N` spaces.
```
;{:`x
||  ||
```
There are two things happening here. `;{:` indicates that this stage and the last one should be run in a loop until they fail to change the string. `:` indicates that the result of this stage should be printed after each iteration and `;` indicates that the final result of the loop (and therefore of the entire program) should *not* be printed. The stage itself just replaces the `x`s with `|| ||` on the first iteration (and does nothing afterwards), so that we now have the first line of the required output (and print it).
```
   //
  // 
```
Finally, this shifts the `//` one character to the left, provided there are still at least three spaces left of the `//`. Afterwards we return to the previous stage (which now only prints the current line, since there are no more `x`s) and then repeat.
[Answer]
# Ruby, 60 bytes
```
->n{n.times{|i|puts (a='||  || ')+' '*(n-i)+'//  '+' '*i+a}}
```
[Answer]
# C, ~~116 94~~ 89 bytes
```
c,d;f(a){for(d=a;a--;puts("  ||  ||"))for(c=-1;c<d;)printf(a-c++?c?" ":"||  ||  ":"//");}
```
[Try it out on Ideone](http://ideone.com/jNtQ0z)
[Answer]
# Ruby, ~~76~~ ~~74~~ 73 bytes
```
x="||  ||";n=gets.to_i;puts (1..n).map{|i|x+" "*(n-i+2)+"//"+" "*(i+1)+x}
```
As a function it takes ~~73~~ 72 bytes, counting the definition:
```
def f n,x="||  ||";(1..n).map{|i|x+" "*(n-i+2)+"//"+" "*(i+1)+x}*?\n;end
```
[Answer]
# Powershell, 66 bytes
```
$a=read-host;1..$a|%{$s="||  ";$s*2+" "*($a-$_)+"// "+" "*$_+$s*2}
```
[Answer]
# C#, 150 Bytes
Golfed:
```
string A(int n){string a="",b= "||  ||";for(int i=0;i<n;i++)a+=b+"  //  ".PadLeft(5+n-i,'\0')+string.Concat(Enumerable.Repeat(" ",i))+b+"\n";return a;
```
Ungolfed:
```
public string A(int n)
{
  string a = "", b = "||  ||";
  for (int i = 0; i < n; i++)
    a += b + "  //  ".PadLeft(5 + n - i, '\0') + string.Concat(Enumerable.Repeat(" ", i)) + b + "\n";
  return a;
}
```
Testing:
```
Console.WriteLine(new ArmisticeDayChallenge().A(11));
```
Output:
```
||  ||            //  ||  ||
||  ||           //   ||  ||
||  ||          //    ||  ||
||  ||         //     ||  ||
||  ||        //      ||  ||
||  ||       //       ||  ||
||  ||      //        ||  ||
||  ||     //         ||  ||
||  ||    //          ||  ||
||  ||   //           ||  ||
||  ||  //            ||  ||
```
[Answer]
# Groovy, 63 chars/bytes
Here's my attempt with Groovy, using an anonymous closure and simple loops to print the ASCII art to standard output: 
`{n->n.times{println'|| '*2+' '*(n-it-1)+'//'+' '*it+' ||'*2}}`
[You can try it online here](https://groovyconsole.appspot.com/script/5159049351921664). Just click "Edit in console" and then "Execute script".
Trying to do the same and returning a string instead of printing, I couldn't get below 71 bytes: 
`{n->a='';n.times{a+='|| '*2+' '*(n-it-1)+'//'+' '*it+' ||'*2+'\n'};a}`
[Answer]
# Python 3, 78 bytes
```
a="||  ||"
def m(n):
    for e in range(n):print(a," "*(n-e),"//"," "*(e+1),a)
```
Still trying to shorten...
]