[Question]
  [
Write a program or a function to print the following cube (if you allow me to call it so) in different sizes:
```
          ^L^L^L^L^L^L^L^L^L^L^L
         //^L^L^L^L^L^L^L^L^L^L^L
        ////^L^L^L^L^L^L^L^L^L^L^L
       //////^L^L^L^L^L^L^L^L^L^L^L
      ////////^L^L^L^L^L^L^L^L^L^L^L
     //////////^L^L^L^L^L^L^L^L^L^L^L
    ////////////^L^L^L^L^L^L^L^L^L^L^L
   //////////////^L^L^L^L^L^L^L^L^L^L^L
  ////////////////^L^L^L^L^L^L^L^L^L^L^L
 //////////////////^L^L^L^L^L^L^L^L^L^L^L
////////////////////^L^L^L^L^L^L^L^L^L^L^L
\\\\\\\\\\\\\\\\\\\\ " " " " " " " " " " "
 \\\\\\\\\\\\\\\\\\ " " " " " " " " " " "
  \\\\\\\\\\\\\\\\ " " " " " " " " " " "
   \\\\\\\\\\\\\\ " " " " " " " " " " "
    \\\\\\\\\\\\ " " " " " " " " " " "
     \\\\\\\\\\ " " " " " " " " " " "
      \\\\\\\\ " " " " " " " " " " "
       \\\\\\ " " " " " " " " " " "
        \\\\ " " " " " " " " " " "
         \\ " " " " " " " " " " "
           " " " " " " " " " " "
```
The shape is made of pairs of characters: `^L`, `"`, `\\`, `//`
### Input:
An integer greater than 1, representing the size of the shape.  
The one showed above has a size of 11 because each side of each face is made of 11 pairs of characters.  
Note that only two faces are fully displayed.
### Output:
A cube of the given size.
Here's another example, with a size of 5:
```
    ^L^L^L^L^L
   //^L^L^L^L^L
  ////^L^L^L^L^L
 //////^L^L^L^L^L
////////^L^L^L^L^L
\\\\\\\\ " " " " "
 \\\\\\ " " " " "
  \\\\ " " " " "
   \\ " " " " "
     " " " " "
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the shortest in bytes wins.
Even though you are not required to do so, it would be nice if you could provide an easy way to check the output of your code
  
[Answer]
# [Python 2](https://docs.python.org/2/), 81 bytes
```
k=n=input()
while 1:k-=1;i=k^k/n;print' '*i+(n+~i)*2*'\/'[k/n-1]+'^ L"'[k<0::2]*n
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9s2zzYzr6C0REOTqzwjMydVwdAqW9fW0DrTNjsuWz/PuqAoM69EXUFdK1NbI0@7LlNTy0hLPUZfPRooqWsYq60ep@CjBOTZGFhZGcVq5f3/b2gIAA "Python 2 – Try It Online")
Reuses some ideas from my answer on [Draw an ASCII hexagon of side length n](https://codegolf.stackexchange.com/a/217375/20260), including using the index `k/n-1` both to select between `/` and `\` in an order where the `\` doesn't need escaping, as well as to terminate the loop with error at the end.
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), ~~27~~ 22 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
｛╷２×/×^L⁸×＋］：↕vL∙ "╋∔ｒ
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjVCJXUyNTc3JXVGRjEyJUQ3LyVENyU1RUwldTIwNzglRDcldUZGMEIldUZGM0QldUZGMUEldTIxOTV2TCV1MjIxOSUyMCUyMiV1MjU0QiV1MjIxNCV1RkY1Mg__,i=NQ__,v=8)
## Explanation
```
{|2×/×^L⁸×+]:↕vL∙ "╋∔r
{          ]           map each i from 1 to n:
 |2×                   decrement and double i
    /×                 repeat "/" that many times
      ^L⁸×             repeat "^L" n times
          +            add that to get one line
            :          copy the top half
             ↕         mirror vertically (mirrors characters)
              vL∙" ╋   replace 'vL' with '" '
                    ∔  and add vertically
                     r center the whole art  
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 78 bytes
```
->n{puts (0...n).map{|i|puts ' '*(j=n+~i)+?/*i*2+'^L'*n;' '*i+?\\*j*2+' "'*n}}
```
Builds an array for the bottom half while printing the top half, then dumps the bottom half at the end. I also tried recursion but it was longer.
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vuqC0pFhBw0BPTy9PUy83saC6JrMGLKauoK6lkWWbp12Xqaltr6@VqWWkrR7no66VZw2SytS2j4nRygIJKigBBWtr/6dFm8b@BwA "Ruby – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 121 bytes
```
s=>(j=n=>' '[b="repeat"]((a=n>=s)?n-s:s+~n)+(a?"//":"\\\\")[b](a?s*2-n:n+1)+(a?"^L":' "')[b](s)+'\n'+(~n?j(--n):''))(s*2)
```
[Try it online!](https://tio.run/##JYtBCoMwEEWvUrLJjCHaugxEL9CeQC0kGlrFTsSRLr16KvWvHu/xJ/d13K/jsmmKQ0jeJrYVTJZsJS@y8VasYQluEx2As1RZxpo0G1Y7oQJXi6IQRrTHBDa@OwxnpSZD6nb2510YeRHyXxmVbEkq2KmeQGtCIyUiHB9MfSSOc8jn@AIPD7e98z6M80mroyF@ALPyiojpBw "JavaScript (Node.js) – Try It Online")
[Answer]
# [K (ngn/k)](https://git.sr.ht/%7Engn/k), 69 bytes
```
{` 0:,/',/$(`" "`"//"`"^L";`" "`"\\\\"`" \"")@'&''(t;|t:+(|!x;!x;x))}
```
[Try it online!](https://ngn.bitbucket.io/k#eJxLs6pOUDCw0tFX19FX0UhQUlBKUNLXBxJxPkrWEG4MEAAphRglJU0HdTV1dY0S65oSK22NGsUKayCq0NSs5eJKUzA0BAC+2xJX)
Not a great fit for the language, but an interesting exercise...
* `(t;|t:+(|!x;!x;x))` build a nested list containing the number of copies of each type of symbol to take. (i.e. spaces from x..0,0..x, slashes from 0..x,x..0, and x copies of `^L` and  `"`).
* `&''` convert to indices, e.g. `3 1 5` => `0 0 0 1 2 2 2 2 2`
* `(`" "`"//"`"^L";`" "`"\\\\"`" \"")` build another nested list (of the same shape), this time containing symbol versions of the output characters. This avoids having to enlist the individual strings and simplifies the list notation a bit. Since they contain special characters (as opposed to being alphanumeric), the contents need to be enclosed in `"`'s, with `"` and `\` also needing to be escaped.
* `(...)@'(...)` retrieve the correct number of copies of each type of symbol
* `,/',/$` stringify the symbols, and raze them into the lines of the output
* `` 0:` print them (this elides the wrapping `"`s and `\` escapes otherwise present)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~28~~ 26 bytes
-2 bytes thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)!
Without [this bug](https://github.com/Adriandmen/05AB1E/issues/181), `»∊¶¡` could be just `∊`.
```
L<·'/×»∊¶¡„^L„ "‚I×Iδи˜ø.c
```
[Try it online!](https://tio.run/##ATgAx/9vc2FiaWX//0w8wrcnL8OXwrviiIrCtsKh4oCeXkzigJ4gIuKAmknDl0nOtNC4y5zDuC5j//8xMQ "05AB1E – Try It Online")
**Commented**:
```
L<·'/×»∊¶¡      # generate the left part
L               # push the range [1..n]
 <              # decrement to get [0..n-1]
  ·             # double each value: [0, 2, ..., 2*(n-1)]
   '/           # push the string '/'
     ×          # for each number in the list, repeat the string this many times
      »∊¶¡      # vertically mirror to get lower left half
„^L„ "‚I×Iδи˜   # generate the right part
„^L             # push the string '^L'
   „ "          # push the string ' "'
      ‚         # pair into a list: ['^L', ' "']
       I×       # repeat each string input times 
         Iδи    # for each string create a list containing the string input times
            ˜   # flatten into a single list
 ø              # zip both parts to get the rows
   .c           # join each row, centralize and join by newlines
```
[Try it with step-by-step output!](https://tio.run/##bVJNSsNAGN17io9uqhJTq7uiBxB6g2Jhkn5tRiYzYeZLS7vqUryAIiJ4B38K7tqlIJ6hF4mTZIJTaTYhmffe9977RhkWcSyKPthnu3zIcpMAJQiayQnCoBuG8rpXngSXm7fg4MLhRhhrTFESkIIJEgxOLfKk62PXHw1Y5ZFAQBYnMGUix56FB3AWQBiG9n18aJlHPrXd@WfHkOZyAu1O20Nt7t2AsdK1uszTCDVwWZEENxSAxgwZ@SqUcAMpk3MgnqLxLX9ub@/W7@uX8tcUNfGYCTGHlGttZ7isQs3sEIFjgoSJscffLp@H/f3Oh/32LhBa@4HQ2gU@NqthvExmPbAqmS2xFA0qhl/eVdWL/XTJq2acOpdZTnVs8Cnfrz@r3Sodwa6ZEbqRECtJjMu6RNwj6ml@PTXbEYwIZePdWIpAF@FvlyuHXvAMIkUJZEyTaSqvrqSa@fphXBNulF13ZdkCAojtpdRM8IU1LUdQnUZzkDgTXPoGi@L8Fw)
Some slightly longer alternatives:
```
L<·'/×»∊¶¡εNI@i„ "ë„^L}I×«}.c
L<·'/×»∊¶¡ε„^LNI@i„ "}I×yì}.c
L<·Â«εNI@i'\×„ "ë'/×„^L}I×«}.c
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 88 bytes
```
param($n)$n..1|%{($l=' '*--$_)+'//'*($j=$n-$_-1)+'^L'*$n
$b=,($l+'\\'*$j+' "'*$n)+$b}
$b
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/vyCxKDFXQyVPUyVPT8@wRrVaQyXHVl1BXUtXVyVeU1tdX19dS0Mly1YlD8jXNQSKxPmoa6nkcakk2eoA1Wqrx8QA@Vna6gpKIHFNbZWkWqDk////TQE "PowerShell – Try It Online")
---
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~104~~ ~~102~~ 92 bytes, Alternative
```
param($n),{$l='//';'^L';$i++}*$n+,{$l='\\';--$i;' "'}*$n|%{.$_}|%{' '*($n-$i-1)+$l*$i+$_*$n}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/vyCxKDFXQyVPU6daJcdWXV9f3Vo9zkfdWiVTW7tWSyVPGyIeE6NuraurkmmtrqCkDhKvUa3WU4mvBVLqCupaQAOAkrqGmtoqOVpArSrxQCW1////NwUA "PowerShell – Try It Online")
The script generates the array of scriptblocks and executes its in the same context. Less golfed:
```
param($n)filter g{' '*($n-$i-1)+$l*$i+$_*$n}
,{$l='//';'^L'|g;$i++}*$n+,{$l='\\';--$i;' "'|g}*$n|%{.$_}
```
[Answer]
# Java 11, ~~148~~ 136 bytes
```
n->{String r="",t=r;for(int i=n;i-->0;t+=" ")r=t+"//".repeat(i)+"^L".repeat(n)+"\n"+r+t+"\\\\".repeat(i)+" \"".repeat(n)+"\n";return r;}
```
-12 bytes thanks to *@OlivierGrégoire*.
[Try it online.](https://tio.run/##hZDBasMwEETv@YpFJwnVTtPSk1C@oMklx7oFVVGCUmdt1utACf52d5OaQgslexDMzluY0SGcQnHYfoyxDl0Hq5DxPAPIyIl2ISZYXyTAhinjHqIWB9A4WQ4zeToOnCOsAcGPWCzPE0heqTv25HYNXW@yR5eLYnnv2HoFypBnq@ZzVVJqU2CdjVVvzz8SRVaoLFnBKplfIFTqL@kocU8I5IbRXaK1/Xst0aaEpyZv4Sj19HfCl1cIZur22XE6lk3PZSsW16ixjPrJXGv@6z/e8BeLG8CDmf5xGL8A)
**Explanation:**
```
n->{                        // Method with integer parameter and String return-type
  String r="",              //  Result-String, starting empty
         t=r;               //  Temp-string, starting empty as well
  for(int i=n;i-->0         //  Loop `i` in the range [input, 0):
      ;                     //    After every iteration:
       t+=" ")              //     Append a space to `t`
    r=...+r+...;            //   Change the result-String to:
                            //    Prepend to the result-String:
      t                     //     The spaces `t`
      +"//".repeat(i)       //     plus '//' repeated `i-1` amount of times
      +"^L".repeat(n)       //     plus '^L' repeated the input amount of times
      +"\n"                 //     plus a newline
                            //    Append to the result-String:
      t                     //     The spaces `t` again
      +"\\\\".repeat(i)     //     plus '\\' repeated `i-1` amount of times
      +" \"".repeat(n)      //     plus ' "' repeated the input amount of times
      +"\n";                //     plus a newline again
  return r;}                //  After the loop, return the result-String
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~42~~ 32 bytes
```
ＮθＧ⌈⊖θ\↓‖Ｃ‖Ｍ↑Ｆθ«Ｐ×^Lθ↘»Ｆθ«Ｐ×" θ↙
```
[Try it online!](https://tio.run/##fYyxDoIwFEVn@IqmU0lwdMFRFhMxhuhGTBAf0KT0lWfBEOPu4Ff6I7VxYTGO995zbtWWVGGpnNtoM9jd0J2BRB@twj2qqUEtkvfrGbMUKoIOtIWLX2PGi4J7KMMRRJLiTfuQQ62gsms0k5hjJomQRHI0vquRmPfZPQyyQVlpSGorDrKDq@CnLY9ZH3ksmH9z2bTWV4//bsHZD3kL9dd1bukWo/oA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｎθ
```
Input the size.
```
Ｇ⌈⊖θ\↓
```
Print a small triangle of `\`s.
```
‖Ｃ‖Ｍ↑
```
Reflect it twice, once horizontally to complete the bottom left block of `\`s, once vertically with mirroring to produce the top left block of `/`s.
```
Ｆθ«Ｐ×^Lθ↘»
```
Print the top right block of `^`s and `L`s.
```
Ｆθ«Ｐ×" θ↙
```
Print the bottom right block of `"`s and spaces.
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), ~~97 93~~ 92 bytes
```
lambda a:sum(zip(*((' '*(x:=a+~i)+'//'*i+'^L'*a,' '*i+r'\\'*x+' "'*a)for i in range(a))),())
```
[Try it online!](https://tio.run/##FclBCsIwEIXhqwxuZiYpdCGCFHoDjxCEEY0OpGmIKVQXXj0mi7f4v5c@5bXG4znl6mdXgyy3u4BM722hryYyRAhoaJ9msT9li@OIRi1eL2hk6J/ajM6h2S3CoSH7NYOCRsgSnw8SZh6IuXYP3T1pLG1pK815Srl34Hr6Aw "Python 3.8 (pre-release) – Try It Online")
Output is a [tuple of lines](https://codegolf.meta.stackexchange.com/a/17095).
*-4 by @Seb*
*-1 by @Danis*
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~160~~ ~~135~~ 130 bytes
Saved 5 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!!
```
p(n,c){for(;n--;)printf(L"\n//\\\\L^ \"  "+c+n%2);}i;t;f(n){for(t=i=1;i;i+=t,t=i>n?i=n,-1:t)p(n-i,9),p(!p(2*n,6-t),p(2*~-i,2-t));}
```
[Try it online!](https://tio.run/##PU7RCsIwDHzfV8SB0K4tYwMVjdUf8BOGMAqTgsaxFXwY89OtKRPvJdzlcjlnbs7F2AvSTk7dcxBIxqDsB0@hE5e8obJsGJcrNDlArpyidS1x9hiwE7QcBetthR69skEzOdHZW9KmOgTJ2cbrvdS9WPWiLkhvTUisLt68qJlwXOR/8Gg9CZlNGTA4F0RSCSxskMfRwg5BKZKwWBKSY2RH6oJ/9def6@c/dc7mLH5cd29vYzSvLw "C (gcc) – Try It Online")
### Explanation (before some golfs)
```
d;p(n,c){                             // p is a helper function that prints     
                                      // n/2 pairs of chars  
  for(d=0;n--;d^=1)                   // loop n times, flipping d between  
                                      //   0 and 1 each time  
    printf(L"                         // print one char of a pair of 
                                      //   chars based on c (then select the  
                                      //   other one on the next loop as d 
                                      //   flips between 0 and 1):  
             //                       //   c==0: '//'  
               \\\\                   //   c==2: '\\'  
                   ^L                 //   c==4: '^L'  
                      \"              //   c==6: '" '  
                                      //   c==7: any number of spaces
                          \n"         //   c==9: p(1,9) prints a newline  
             +c+d);                   // use c and d to select char
}                                     // returns 0 
i;t;f(n){                             // f is the main function    
  for(t=i=1;                          // main loop i goes from 1 to n and  
                                      // back down to 1 again  
    i;                                // loop until i is 0  
    i+=t,                             // bump i up for 1st half and then  
                                      // bump i down for 2nd half  
         t=i>n?i=n,-1:t)              // flip t from 1 to -1 half way thru  
               p(n-i,7),              // print leading spaces   
               p(2*~-i,1-t),          // print left side slashes   
               p(2*n,5-t),            // print right side of cube   
               p(1,9);                // print newline
}                                     //  
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 30 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ḶṚżḤƊØ.xⱮ;€3,5ẋ$;ṚḤ$$ị“/\^"L ”
```
A monadic Link accepting a positive integer which yields a list of lists of characters (a list of lines).
**[Try it online!](https://tio.run/##AUUAuv9qZWxsef//4bi24bmaxbzhuKTGisOYLnjisa474oKsMyw14bqLJDvhuZrhuKQkJOG7i@KAnC9cXiJMIOKAnf/Dh1n//zQ "Jelly – Try It Online")** (The footer calls the Link and joins the resulting lines with newline characters.)
### How?
```
ḶṚżḤƊØ.xⱮ;€3,5ẋ$;ṚḤ$$ị“/\^"L ” - Link: integer, n    e.g. 3
Ḷ                              - lowered range            [0,1,2]
    Ɗ                          - last three links as a monad - f(that):
 Ṛ                             -   reverse                [2,1,0]
   Ḥ                           -   double                 [0,2,4]
  ż                            -   zip together           [[2,0],[1,2],[0,4]]
        Ɱ                      - map with:
     Ø.                        -   bits                   [0,1]
       x                       -   repeat elements        [[0,0],[0,1,1],[1,1,1,1]]
               $               - last two links as a monad - f(n):
           3,5                 -   three pair five        [3,5]
              ẋ                -   repeat (n times)       [3,5,3,5,3,5]
         ;€                    - concatenate each = x     [[0,0,3,5,3,5,3,5],[0,1,1,3,5,3,5,3,5],[1,1,1,1,3,5,3,5,3,5]]
                    $          - last two links as a monad - f(x):
                   $           -   last two links as a monad - f(x):
                 Ṛ             -     reverse              [[1,1,1,1,3,5,3,5,3,5],[0,1,1,3,5,3,5,3,5],[0,0,3,5,3,5,3,5]]
                  Ḥ            -     double               [[2,2,2,2,6,10,6,10,6,10],[0,2,2,6,10,6,10,6,10],[0,0,6,10,6,10,6,10]]
                ;              -   concatenate            [[0,0,3,5,3,5,3,5],[0,1,1,3,5,3,5,3,5],[1,1,1,1,3,5,3,5,3,5],[2,2,2,2,6,10,6,10,6,10],[0,2,2,6,10,6,10,6,10],[0,0,6,10,6,10,6,10]]
                      “/\^"L ” - list of characters = '/\^"L '
                     ị         - index into (1-indexed & modular, i.e. 10->")
                                                     -> ['  ^L^L^L',
                                                         ' //^L^L^L',
                                                         '////^L^L^L',
                                                         '\\\\ " " "',
                                                         ' \\ " " "',
                                                         '   " " "',
                                                        ]
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 27 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
ü╚lTà╨ú%Ñ►F↔33j♦ü♂D▄P;L.⌂î↑
```
[Run and debug it](https://staxlang.xyz/#p=81c86c5485d0a325a510461d33336a04810b44dc503b4c2e7f8c18&i=5%0A10&a=1&m=2)
[Answer]
# [PHP](https://php.net/), ~~134~~ 116 bytes
```
for($f=str_repeat;$i<$n=$argn;)$s=($t=$f(" ",$i++).$f("//",$n-$i).$f("^L",$n)."
").$s.strtr($t,'/^L','\\ "');echo$s;
```
[Try it online!](https://tio.run/##JcyxCsMgFIXhvU8R5IJKjE6djHTrlEcICaFo46IXvc9fa8hy4DvDjye2@YV9Qy4CgqtU9uLRH2QhzpAcHOWbrITqBJCDINjAFMRxlPqCMV1pgnhzWy5KzR6sH1X3HPUuKW62hSu@rgPj0vrPmaHa1p6/jBRzqm16/wE "PHP – Try It Online")
Yes, much shorter to build the string..
**EDIT:** a huge 18 bytes saved thanks to optimization from Dom Hastings
**Old version kept just for the fun:**
# 157 bytes
```
for($f=str_repeat;$i<2*$n=$argn;$s.='//')$i++<$n?printf("%".($n-2+$i)."s%s",$s,$f("^L",$n)."
"):printf("%".(5*$n-$i)."s",$f('\\',4*$n-2*$i).$f(' "',$n)."
");
```
[Try it online!](https://tio.run/##TY3LCsIwEEX3foUMU5KYPqDYjU3pzpWfUJQuGs1mEpJ8v3GKIG6G4cy5d8IrFDMHntZHiXZKOT7iFrY1j@hMf0KacI1PGjG1k@g6odBpbZDmEB1lK6GCViI1vUanWkhVghpTjXy533glhgdQl3994Nrmq8NuimUR9XmH/JDxjo4gfuGxlOHtQ3aeUmmuHw "PHP – Try It Online")
Here is an infamous PHP answer based on `printf`. Couldn't think of an uglier looking piece of code for now, but I'll work on it (starting to think it would be better to build the whole string)!
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 172 bytes
```
(m=MapThread[Join,{DiamondMatrix[#][[1;;#+1,1;;#]],2BoxMatrix[#][[1;;#+1,1;;#+1]]}];Print/@StringJoin@@@(Join[m,4Reverse[m]]/.{0->" ",1->"//",2->"^L",4->"\\\\",8->" \""}))&
```
[Try it online!](https://tio.run/##bcxBC4IwHAXwrxILQnE1NQ@BGCM6RUJYt/kPRk7dYTPWCEH87Lbde5ff4T2e4rYXilv54ktbLIEqSv5@9Ebwhl0GqfF0llwNuim5NXJka2AsyfN1lGAPAE5Pw/i/jBKAGfKbkdoSencT3flPSmngZQpnlfgK8xFMAZDdFG@PaIVw4iAE4dT5vCKcOWsXhA9@UCM0h@FmaQmtuO4E28ew/AA "Wolfram Language (Mathematica) – Try It Online")
**Brief explanation**:
Construct the upper part `m` with [DiamondMatrix](https://reference.wolfram.com/language/ref/DiamondMatrix.html) and [BoxMatrix](https://reference.wolfram.com/language/ref/BoxMatrix.html):
```
m = MapThread[Join, {DiamondMatrix[n][[1 ;; n + 1, 1 ;; n]], 2BoxMatrix[n][[1 ;; n + 1, 1 ;; n + 1]]}]
```
Derive the whole matrix `M` from `m`:
```
M = Join[m, 4*Reverse@m]
```
you can visualize it with:
```
MatrixPlot[M, Frame -> None]
```
when n = 10, it's like this:
[![when n = 10](https://i.stack.imgur.com/ftFhG.png)](https://i.stack.imgur.com/ftFhG.png)
Replace each number from the matrix with corresponding string:
```
M/.{0->" ",1->"//",2->"^L",4->"\\\\",8->" \""}
```
Convert each row to string and print it:
```
Print/@StringJoin@@@%
```
[Answer]
# [Zsh](https://www.zsh.org/) [commit 2a96748](https://github.com/zsh-users/zsh/commit/2a9674862ecaf9b7b1b66178782d47e8445df325), ~~123~~ ~~121~~ 119 bytes
```
alias R=repeat
R "i=a=$1" {s=${(l:--i:)};R b++ s+=//;R a s+=^L;<<<$s}
R a {s=${(l:i++:)};R a-i s+='\\';R a s+=' "';<<<$s}
```
[Try it online!](https://tio.run/##qyrO@P8/MSczsVghyLYotSA1sYQrSEEp0zbRVsVQSaG62FalWiPHSlc300qz1jpIIUlbW6FY21ZfH8hOBLHifKxtbGxUimu5QAIw9Zna2hD1ibqZIFXqMTHqMB3qCkrqUD3///83BQA "Zsh – Try It Online")
This specific version fixes a bug that would otherwise require `i=a=$1` to be in quotes. TIO doesn't have that version obviously, so the linked one is two bytes longer.
[Answer]
# batch ~~317~~ ~~309~~ ~~301~~ ~~291~~ ~~284 bytes~~ 276 bytes
```
Cls&@Set $=@Set 
%$%/Ah=%1*2,z=0
%$%F=@For /L %%a in (1 1 &%$%P=@^<nul set/p&%$%C= @If ,%%y LEQ %1 
%f:a=y%!h!)Do @(%$%/Aw=%1-z
%F%!w!)Do %P%=ESCC
%F%!z!)Do%C%(%P%=//)Else %P%=\\
%F%%1)Do%C%(%P%=^^L)Else %P%^"=ESCC""
%C:EQ=SS%(%$%/A z+=1)Else%C:,=not %%$%/Az-=1
Echo()
```
**Cube.bat**
Notes:
* *must be run from the command line using:* `Echo(cube.bat n|Cmd /V:on`
*where `n` is an integer representing cube size and cube.bat is the filename of the file*
* lines `1` and`3` end wth trailing spaces
* **requires windows 10 with virtual terminal support**
* `ESC` is a stand in for the ANSI escape character, [As it can't be pasted here, the scripts raw paste data can be found here](https://pastebin.com/AaNxX84B).
	+ Or it can be generated by opening the command prompt and typing:
		- `>"%TEMP%\escape.chr" Echo(``ALT`+`027` then pressing `ENTER`
	+ Or output using a for loop with `Echo off`:
		- `(For /F "skip=4 DELIMS=" %a in ('Echo(prompt $E^|cmd')Do Echo(%a) >"%TEMP%\escape.chr"`
Vt sequence `ESCC` *('cursor right')* is used to get around `<nul set /p`'s inability to output leading spaces.
example output:
[![enter image description here](https://i.stack.imgur.com/wNmR3.png)](https://i.stack.imgur.com/wNmR3.png)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 37 bytes
```
Ḷ,Ṛ$ạ’;,ʋ³ẋ@"ɗ€"“ “//“^L”,“ “\\“ "”ẎY
```
[Try it online!](https://tio.run/##y0rNyan8///hjm06D3fOUnm4a@GjhpnWOqe6D21@uKvbQenk9EdNa5QeNcxRAGJ9fSAR5/OoYa4OVCQmBsQAys99uKsv8v///5YA "Jelly – Try It Online")
[Answer]
# [Lua (LuaJIT)](https://luajit.org/), 122 bytes
```
r=n.rep;for i=1,n*2 do print(i<=n+0 and r(' ',n-i)..r("/",i*2-2)..r('^L',n)or r(' ',i-1-n)..r("\\\\",n*2-i)..r(' "',n))end
```
[Try it online!](https://tio.run/##LYxBCsMgFET3OcXHjZr6bRW6ar1Bj1AKUiP8Er5BkvNb03RgFsO8mXmLOG/xQ2vLG79XKgxZsW41sK3TcsulAgVnePSQCiyVeFV0D3y6QOQEVUmQhpG0tVWJszA0evS/JF@PXun@cFCEDvngnl1iP/0PJYgd1ROn1j0gOu@HrKy1urXrFw "Lua (LuaJIT) – Try It Online")
(Above code abuses the TIO's input string-type to save 1 byte, see
[Not abused version](https://tio.run/##LYzBCsIwEETv/Yoll2xKNtKcBO0f@AkiVNvASt2UkHx/TK0DcxjmzaxlorVMb841FHlljgIBxdQ0otbGpWW7hJiAx8FK72GOsCWWjHwdBSaZIaEGbYXYOJdQnZTl3pP/Jf24tcq0/UExDSQHd29S@@V/qEHtqFlkrs0d0eB9FzBHKZ/nktA5Z0yt5y8))
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 68 bytes
```
~:i,.-1%]zip.-1%]{{~" "*\["//""\\\\"]0=*+["^L"' "']0=i*+}%1:0;n*}%n*
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/v84qU0dP11A1tiqzAExXV9cpKShpxUQr6esrKcUAgVKsga2WdrRSnI@SuoKSOpCXqaVdq2poZWCdp1Wrmqf1/78lAA "GolfScript – Try It Online")
Its really messy, but it works and I don't really know a better way to do it.
[Answer]
# Excel, 114 bytes
```
=LET(x,A1,q,SEQUENCE(2*x),b,q>x,r,IF(b,q-x-1,x-q),REPT(" ",r)&REPT(IF(b,"\\","//"),x-r)&REPT(IF(b,"""""","^L"),x))
```
[Link to Spreadsheet](https://1drv.ms/x/s!AkqhtBc2XEHJnB_Q6r1yxIKXAP04?e=DC5Wq8)
[Answer]
# [Regenerate](https://github.com/dloscutoff/Esolangs/tree/master/Regenerate), 84 bytes
```
(( {#2-1}| {$~1-1})(//$3|)(^L){$~1}\n){$~1}(( $6|)(\\{#7-2}|\\{#3})( "){$~1}\n){$~1}
```
Takes the size as a command-line input. [Try it here!](https://replit.com/@dloscutoff/regenerate)
### Explanation
Spaces are replaced with underscores for improved visibility.
Top half:
```
(( {#2-1}| {$~1-1})(//$3|)(^L){$~1}\n){$~1}
(                                    )       Group 1: one row of the top half
 (                )                           Group 2: leading spaces
  _{#2-1}                                      Either one less space than the previous row
         |_{$~1-1}                             or (input-1) spaces if this is the first row
                   (     )                    Group 3: slashes
                    //$3                       Either the previous row's slashes plus two more
                        |                      or empty string if this is the first row
                          (^L)                Group 4: ^L
                              {$~1}           Repeat group 4 (input) times
                                   \n         Newline
                                      {$~1}  Repeat group 1 (input) times
```
Bottom half:
```
(( $6|)(\\{#7-2}|\\{#3})( "){$~1}\n){$~1}
(                                  )       Group 5: one row of the bottom half
 (    )                                     Group 6: leading spaces
  _$6                                        Either the previous row's spaces plus two more
     |                                       or empty string if this is the first row
       (               )                    Group 7: backslashes
        \\{#7-2}                             Either two fewer slashes than the previous row
                |\\{#3}                      or the same number of slashes as in the last match
                                              of group 3 if this is the first row
                        (_")                Group 8: space-quote
                            {$~1}           Repeat group 8 (input) times
                                 \n         Newline
                                    {$~1}  Repeat group 5 (input) times
```
[Answer]
# [Perl 5](https://www.perl.org/) + `-M5.10.0 -pa`, 71 bytes
```
say,$\=y'/^L'\ "'r.$/.$\for map$"x("@F"-$_--)."//"x$_."^L"x"@F",1..$_}{
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVJHJca2Ul0/zkc9RkFJvUhPRV9PJSYtv0ghN7FARalCQ8nBTUlXJV5XV1NPSV9fqUIlXk8pzkepAiSuY6inpxJfW/3/v@W//IKSzPy84v@6BYn/dX1N9QwN9AwA "Perl 5 – Try It Online")
[Answer]
# [Julia](http://julialang.org/), ~~79~~ ~~73~~ 69 bytes
output is a list of lines
```
f(N,a=-N+1:0,b=0:N-1)=@.[" "^-a*"//"^b*"^L"^N;" "^b*"\\"^-2a*" \""^N]
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/P03DTyfRVtdP29DKQCfJ1sDKT9dQ09ZBL1pJQSlON1FLSV9fKS5JSynORynOzxokCOTExADljICSCjFKQOHY/wVFmXklOXl6GmkappqaXEhcQ0NUvhGCC@H9BwA "Julia 1.0 – Try It Online")
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `j`, 26 bytes
```
ʁd\/*m‛^L‛ ""?*ƛw?ẋ;fZvṅøĊ
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=j&code=%CA%81d%5C%2F*m%E2%80%9B%5EL%E2%80%9B%20%22%22%3F*%C6%9Bw%3F%E1%BA%8B%3BfZv%E1%B9%85%C3%B8%C4%8A&inputs=10&header=&footer=)
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), 31 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
Æç'Li^)i'/pXÑÃû
c¡Xd`/\\^ L"`Ãw
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=xucnTGleKWknL3BY0cP7CmOhWGRgL1xcXiBMImDDdw&input=NQ)
```
Æç'Li^)i'/pXÑÃû\nc¡Xd`...`Ãw     :Implicit input of integer U
Æ                                :Map each X in the range [0,U)
 ç                               :  U times repeat
  'Li^                           :    "L" prepended with "^"
      )                          :  End repeat
       i                         :  Prepend
        '/p                      :    "/" repeated
           XÑ                    :    X*2 times
             Ã                   :End map
              û                  :centre pad each element with spaces to the length of the longest
               \n                :Reassign to U
                 c               :Concatenate
                  ¡              :  Map each X in U
                   Xd`...`       :    For each pair of characters in the string, replace all occurrences of the first in X with the second
                          Ã      :  End map
                           w     :  Reverse
                                 :Implicit output joined with newlines
```
]