[Question]
  [
## Introduction
We all know the cool S (also known as Superman S, Stüssy S, Super S, Skater S, Pointy S, Graffiti S etc. etc.): billions of schoolchildren around the world drew this S and immediately felt proud of themselves. In case you've forgotten or had a *completely uncool childhood*, here is an image of said cool S:
![](https://upload.wikimedia.org/wikipedia/commons/thumb/7/79/%22Cool_S%22.svg/57px-%22Cool_S%22.svg.png)
Given a scale factor `n` as input (where \$1\leq n\leq 20\$), output the Cool S in ASCII art.
## How to Draw It
From the [Wikipedia page](https://en.wikipedia.org/wiki/Cool_S) on the Cool S:
![](https://upload.wikimedia.org/wikipedia/commons/thumb/6/67/%22Cool_S%22_Drawing_Instructions.svg/430px-%22Cool_S%22_Drawing_Instructions.svg.png)
## Output
The Cool S when `n` = 1 is:
```
   ^
  / \
 /   \
/     \
|  |  |
|  |  |
\  \  /
 \  \/
 /\  \
/  \  \
|  |  |
|  |  |
\     /
 \   /
  \ /
   v
```
And for different values of `n`, you simply make the output `n` times bigger. For example, `n`=2:
```
     ^  
    / \
   /   \
  /     \
 /       \
/         \
|    |    |
|    |    |
|    |    |
|    |    |
\    \    /
 \    \  /
  \    \/
  /\    \
 /  \    \
/    \    \
|    |    |
|    |    |
|    |    |
|    |    |
\         /
 \       /
  \     /
   \   /
    \ /
     v
```
Note that the vertical sections are two times longer and the spacing between the vertical lines is two times wider.
And when `n`=3:
```
       ^
      / \
     /   \
    /     \
   /       \
  /         \
 /           \
/             \
|      |      |
|      |      |
|      |      |
|      |      |
|      |      |
|      |      |
\      \      /
 \      \    /
  \      \  /
   \      \/
   /\      \
  /  \      \
 /    \      \
/      \      \
|      |      |
|      |      |
|      |      |
|      |      |
|      |      |
|      |      |
\             /
 \           /
  \         /
   \       /
    \     /
     \   /
      \ /
       v
```
***Note:*** Although not required, your code may also be able to support `n`=0:
```
 ^
/ \
\\/
/\\
\ /
 v
```
## Winning
The shortest program in bytes wins.
  
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 58 53 47 43 41 bytes
```
Ｎθ≔⊕⊗θδ↗θ/⊗θ↘δ^‖Ｂ↓‖Ｍ← vＭδ⁰⊗θ↗⊕θＭ⁰δ↗θ/⊗θ⟲Ｔ
```
[Try it online!](https://tio.run/##jY9PC4JAEMXvfYrwtAtG0TFPhRejIqSugX9GXVh3dZwt@vRbWqmHiE4zzLwf772kiDDRkbQ2UJWhgyljQFZzb7JuGpErFqgEoQRFkDJfm1g@Z825mz4lRxSK2OpchSIvyJ3W/c2ZO/0@onrE1zf1hlL@YS4tE0ImIaGNIQLM5P2lHR57gaiRrXaQ0WA3vbbs1pQVS93FT@s@7bhZJ@jwxbdmfxQLNUUEJ4xUk2ksGfesXdrZVT4A "Charcoal – Try It Online")
I just wanted to try another approach, this draws the outside via reflections (thanks to Neil for expanding the idea) and then draws the inside part. As Charcoal has `:Left` as default direction to draw lines, I make use of that direction as much as possible to save some bytes by drawing the S horizontally, like this:
```
     /----\    /----\     
    /      \  /      \    
   /        \/        \   
  /         /          \  
 /         /            \ 
v     ----/    /----     ^
 \            /         / 
  \          /         /  
   \        /\        /   
    \      /  \      /    
     \----/    \----/     
```
And then I just need to rotate the canvas 90 degrees counterclockwise.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~47~~ ~~42~~ 41 bytes
```
Ｆv^«↓⊗θ↘⊗⊕θ←↓⊗θ↙⊕⊗θ↖ι↖⊕⊗θ→↑⊗θ↗⊕θＭθ⁺⊗θ⊕θ⟲⁴
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8tv0hBQ6ksTklToZqLM6AoM69Ew8olvzxPR8ElvzQpJzVFo1BT0xpFKigzPaMEIe@Zl1yUmpuaVwJRC1Lsm1@WqmHlk5pWgqYVj6kg1ToKyIYhKUVSG1oAUZmJRQyPboiTwE5H0YjDRaEFUF@i@Q5mUqGOQkBOaTGSLRhKQWqD8ksSS1I1TIDs2v//Df/rluUAAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation: Draws the following lines in order:
```
   ^
  / \
 /   \
/     \
|  1  |
|  1  |
\  2  /
 \  2/
 8\  2
8  \  2
7  |  3
7  9  3
6     4
 6   4
  6 4
   5
```
Where `5` is the current character of the string `v^`. At the end of the first loop the cursor is then positioned at point `9`. The entire canvas is then rotated so that the other half of the Cool S can be drawn. (The canvas actually gets rotated twice, but this is just an implementation detail.)
Charcoal doesn't support `RotateCopy(:Up, 4)` but if it did then this would work for 33 bytes:
```
↖^↖⊕⊗θ→↑⊗θ↗⊕θ‖ＢＭ↓↙⊗θ→↓⊗θ⟲Ｃ↑⁴Ｊ⁰¦⁰v
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~255~~ ~~249~~ ~~248~~ 209 bytes
-6 bytes thanks to Kevin Cruijssen
-1 byte thanks to Kevin Cruijssen
-39 bytes thanks to Rod and Jo King
```
n=int(input())
m=2*n
a,b,q,c,l='\ \n/|'
f=m*b
s=q+q.join([f[d:]+c+b*2*d+b+a+f[d:]for d in range(m+1)]+[l+f+l+f+l]*m+[d*b+a+f+a+f[d*2:]+c+d*b for d in range(n)]+[n*b+a+f+a+c+n*b])
print(f,'^'+s+q+s[::-1]+f,'v')
```
[Try it online!](https://tio.run/##XY7LCsIwEEX3@Yrs8pioWHeFfEkaoWmMVppp01ZB8N9jW8GFi4HL4Z7LDK/51uMpZ9QtzrzF4TFzIUjUhURSK6eSalSnWUUrPLwZCTpKRyadIO3vfYvcBONLCw04WUgPDmrYSOhH6mmLdKzxeuERjsKC6SDAdlZGMF5u9a8ii21mYfTPxdXEX7eBJVtBhnF9OSh2ZjBBgsmU5e5oYSFPJnIuPg "Python 3 – Try It Online")
It now handles n=0.
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), ~~36~~ ~~32~~ 29 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
«|＊‼ｌ├／Ｌ１^╋；╶╵＼∔∔│α╶«├：╵╋：↔↕∔
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JUFCJTdDJXVGRjBBJXUyMDNDJXVGRjRDJXUyNTFDJXVGRjBGJXVGRjJDJXVGRjExJTVFJXUyNTRCJXVGRjFCJXUyNTc2JXUyNTc1JXVGRjNDJXUyMjE0JXUyMjE0JXUyNTAyJXUwM0IxJXUyNTc2JUFCJXUyNTFDJXVGRjFBJXUyNTc1JXUyNTRCJXVGRjFBJXUyMTk0JXUyMTk1JXUyMjE0,i=MQ__,v=4)
A whole lot of stack manipulation. (outdated) explanation:
```
«|*                                an array of input*2 "|"s
   ‼                               cast to a 2D object (needed because bug)
    :                              duplicate that (saved for the center line)
     l├                            height+2
       /                           create a diagonal that long
        L1^╋                       and in it, at (width; 1) insert "^"
            ;∔                     append the vertical bars
                               ^
                              /
          so far done:       / 
                            /  
                            |  
                            |  
              ⁸╵                   input+1
                \                  antidiagonal with that size
                 ∔                 appended to the above
                  │                mirror horizontally
                              ^
                             / \
                            /   \
                           /     \
                current:   |     |
                           |     |
                           \     /
                            \   /                                                       |
                   α               get the 2nd to last popped thing - the antidiagonal  |
                    └∔             append it to the vertical line copied way before:    \
                      ⁸«├          input/2 + 2                                            \
                         :╵        duplicate + 1
                           ╋       at (input/2 + 2; input/2 + 3) in the big part insert  ^
                            :↔↕∔   mirror a copy vertically & horizontally and append that to the original
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~260~~ 254 bytes
-6 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat).
```
f(n){int s=2*n++,t=s+1,I[]={1,t,s,n,n,s,t,1},A[]={s,1,1,1,2*t,1,t,t,1,t,1,n,t,t,1,t,t,1,1,1,t,s,1,1},x;for(s=8;s--;)for(n=0;n<I[s];n++,puts(""))for(t=3;t--;)x=s*3+t,printf("%*c",n*("AAAA?BAAAAC@?ABAAACA@AAA"[x]-65)+A[x],"w!!!0]}}}]]00]]}}}]!0_!!"[x]-1);}
```
[Try it online!](https://tio.run/##bY/dSsQwEIWv3afYBIT8TKBpUYQYduNe7TPUIFKo7IVx2YlYKHn2OunqlWbgcPLlDDMZzNswLMsokpxPKW/RtyppDdmjtnDso58tZEBIVEjOFgiVIti1WkWM@FUtpX59/knUblv7Jjd@XAT6B4fGOFkvyTcuPR57jK5OPX9mFJzL9S37zuUanDyqTmc4X2jDUfBbNXBISvBAZ/dU9bDfhWoOYU/K@yma@zupAxngX4yxJpZSYmyauBrWvDC2xqx0Zak/f389JSE38@ZmFAS3112ekzGGS1dp@y/t/tKyfAM "C (gcc) – Try It Online")
## Rundown
We can divide the shape into parts:
```
 ^           Top cap
/ \          Top slope
|||          Sides
\\/          Twist, part 1
/\\          Twist, part 2
|||          Sides
\ /          Bottom slope
 v           Bottom cap
```
Each part could be described by a number of lines, three chars, and three relationships to certain values that decides the field-width at each line.
A first iteration came to be:
```
#define g(x,s,A,B,C)for(i=0;i<x;i++)printf("%*c%*c%*c\n",A,*s,B,s[1],C,s[2]);
f(n)
{
    int s=2*n++,t=s+1,i;
    
    g(1,  "  ^",  1,      1,  t-1)
    g(t, "/ \\",t-i,      1,2*i+1)
    g(s,  "|||",  1,      t,    t)
    g(n,"\\\\/",i+1,      t,t-2*i)
    g(n,"/\\\\",n-i,  2*i+1,    t)
    g(s,  "|||",  1,      t,    t)
    g(t, "\\/ ",i+1,2*t-2*i,    1)
    g(1,  "  v",  1,      1,  t-1)
}
```
The calls to the `g()` macro looks very much like a table could be constructed and looped over. Field-widths are sometimes related to the index counter, and sometimes not. We can generalise the field-width to be `F * i + A`, where F is some factor to multiply `i` with, and A is some value to add to the width. So the last width of the fourth call above would be `-2 * i + t`, for example.
Thus we get:
```
f(n){int s=2*n++,t=s+1,         s = size of "side" parts, t = size of top and bottom slopes
I[]={1,t,s,n,n,s,t,1},          The number of lines per part.
A[]={...},x;                    A[] holds the values to add to each field-width.
for(s=8;s--;)                   Loop through the parts.
for(n=0;n<I[s];n++,puts(""))    I[s] decides how many lines to the part. Ends with newline.
for(t=3;t--;)                   Go through the three chars of each line.
x=s*3+t,                        Calculate offset.
printf("%*c",                   Print the char.
n*("..."[x]-65)+A[x],           Build field-width. The string holds the index factor, A[]
                                holds the offset part.
"..."[x]-1);}                   The char itself is grabbed from the string.
                                Shifted by 1 to eliminated double backspaces.
```
In the end it was not much shorter than a tightened version of the `g()` calling one, but shorter is shorter.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~227~~ ~~208~~ ~~207~~ ~~202~~ ~~196~~ 181 bytes
```
I=n=2*input()
R,L,S,P='/\ |'
k=n*[2*(P+S*n)+P]
exec"k=[R+S+2*S*I+L]+k+-~I%2*[L+S*n+L+S*I+R];I-=1;"*-~n
print'\n'.join(t.center(2*n+3)for t in['^']+k+[a[::-1]for a in k[::-1]]+['v'])
```
[Try it online!](https://tio.run/##JU/BasMwFDv3fYUJDCd20i3uTik@dmAILCS7uS5kmUczj5dg3G2F0V/PYnYRepJ4SPM1nCcUyzC9WSKJT5JkURKlYCPOl5Bm0OZ13uWNpPdH8kvBSWRasLThHcOMNwbsjx0SJ3XLOy5YxxSvDXe8uKk7wXQdczyi4q3Zq0KW@4QVN4TZjxjoEen2YxoxDdvBYrA@FWt@l71PngQyoqYnGt/pXldVUZqo96tO3P9tuKZf1GTL2hy@z@OnJS/@YivYBH9dcRPrkTgPVjrYOZDD89PB@8lH99Xb3sHyACUI2MHj8gc "Python 2 – Try It Online")
Thks to [Jo King](https://codegolf.stackexchange.com/users/76162/jo-king) for 1 byte; and then another 5 bytes total (via `n => 2*n`).
Works for `n=0` as well.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 379 353 344 334 bytes
I used a couple of `#define`s for subexpression elimination and several globals to communicate between the internal functions. The main loop goes {0,1,2,3,3,2,1,0} to construct the S.
Thanks to Jonathan Frech for the suggestions.
```
#define z(a,b...)printf("%*c%*c%*c\n"+a,b);}
#define y(a){for(i=~-a*t;v*i<v*a*!t+t;i+=v)
i,n,p,r,t,u,v;a(){z(6,r+2,94+t*24)b()y(-~r)z(3,-i-~r,47+u,i*2+2,92-u)c()y(r)z(0,~r,124,~r,124,~r,124)d()y(-~n)z(0,i+1,92-u,2*(n-t*i)+1,92,2*(n-!t*i)+1,47+u)(*x[])()={a,b,c,d};f(s){r=2*s;for(p=0;p<8;x[7*t-p++*(2*t-1)](n=s))t=p>3,v=2*!t-1,u=t*45;}
```
[Try it online!](https://tio.run/##VZDRbsIgFIbvfYqqWXIOnDZr7eYWxBdxXiC1SuKwaWmjNvXVO9DtYgkJ//n/7wAHHR@0HufG6lNb7KNV44qT2SXH9Tgv9qWx@@gGinZJkmBVG@tKmL0w/VxfdsZ9hmKY/MFXUNiX5xqMvMeKOdExs@qYYlPHnTBcdjgxZKmimhy11AkF2N/gnWqe0WfOHcty3AFeIb7XeIMFxcYrype8JcOyQGVxizogAXgln6ZZ/n/D4nmEfRCGp48uyhjY2DGDD@NZTn/rcAMCu2y2CCh7PxhpKgZRQoN9LTPWiDBYJV9FtfoQl82SubjinEHmRYpbsLJBdLJaL6jz/NS71ErH8jcxjP7vom9lLASh6oMmfVR1xJjXHUb9JIpC0shUBFlCYNYpeke5swllt0m3GNLwJDEZxnHxAw "C (gcc) – Try It Online")
[Answer]
# [PHP](https://php.net/), ~~378~~ ~~374~~ ~~378~~ ~~377~~ ~~376~~ ~~335~~ ~~331~~ 328 bytes
-3 bytes, thanks to manatwork
-4 bytes, used str\_pad instead of str\_repeat
-41 bytes, thanks to manatworks' suggestions
-1 byte, merged two increments into a +=2
-1 byte, removed superfluous \
~~-4 bytes by echoing once.~~ Forgot I needed to pass the string into the function so this is more bytes
Works for n = 0 as well.
```
function s($b){return str_pad($w,$b);}echo s($i=1+$a=2*$argv[1]).'^
';for(;$i;$j++,$y=$z.$y)echo$z=s(--$i).'/'.s(++$j).'\
';for(;$k<$a;$k++)$x.='|'.s($a).'|'.s($a).'|
';echo$x;for(;$l<=$a/2;)echo s($m++).$c='\\',s($a).$c.s($a-$l++*2).'/
';for(;$m;$n+=2)echo s(--$m).'/'.s($n).$c.s($a).'\
';echo$x.strtr($y,'/\\','\/').s($a+1).v;
```
[Try it online!](https://tio.run/##TZDLboMwEEX3/YourmQ7A0awNVY/pKSVS5OGJDxkyIO0/XY6kIC6GY2tc3yv3OyaIX1peG5PVd4VdfXcSnyob7/pTp4PnX9v3KfEJeBb87vJd/VIFDYmOJus4PzX@TVeKy3enoTZ1l4aFAZ7ogC9xU2jV6OFm21lGKJgMhK6lUTY854t1iGF40mkcNVW/IwQHCP/Noanx64P55hauCgxai5Wsq6RW5FlIrhbyCc9xJFolYzxS2RpUJFNZpvrlXM9VIv5aHkP1vwlnZfoAxGNGSKLhJowipU@m2EY4j8 "PHP – Try It Online")
[Answer]
# Java, 435 bytes
The function itself takes 435 bytes. There is certainly room for improvement, "high level" by analyzing the rules about where to place which character (in the end the S is point-symmetric), and "low-level", by classical golfing (maybe pulling out another variable or combining two of the `for`-loops). But it's a first shot with this rather ungolfy language:
```
import static java.util.Arrays.*;
import static java.lang.System.*;
public class CoolS
{
    public static void main(String[] args)
    {
        print(1);
        print(2);
        print(3);
    }
    static void print(int n){int i,r,d=3+6*n,w=3+n*4,h=6+n*10,m=n+n,v=w/2,k=h-1,j=w-1;char t[],S='/',B='\\',P='|',s[][]=new char[h][w];for(char x[]:s)fill(x,' ');s[0][v]='^';s[k][v]='v';for(i=0;i<1+m;i++){r=i+1;t=s[r];t[v-r]=S;t[v+r]=B;t=s[k-r];t[v-r]=B;t[v+r]=S;}for(i=0;i<m;i++){r=2+m+i;t=s[r];t[0]=t[v]=t[j]=P;t=s[k-r];t[0]=t[v]=t[j]=P;}for(i=0;i<1+n;i++){r=2+m+m+i;t=s[r];t[i]=t[i+1+m]=B;t[j-i]=S;t=s[d-i];t[i]=S;t[v-i]=t[j-i]=B;}for(char x[]:s)out.println(x);}
}
```
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 1024 bytes
```
i'0'-i1+:?!v1-'0'-$a*+1v
v          <           <
>~     :1-2*3+ >1-' 'v       v                                             oa&0~~~<
 v&1:oa*2:~o'^'^?:o  <                                              >~'/'o$:v    <^        <
>>' 'o1-: ?v   v                  >@ '\'o$v v   -1o<           >          v >:?vv^ -1<     ^     <
:^         <   ~                  ~>      \:>:?v       v  >'/'v^o' '^!?:-1<:<  > ' 'o^ >'\'o:1-?v^
- vo' '<:&o'/' < <                ^^?:o' '\  \ >' '/'\'\~$^ > o:?v~1>$  :?v$^   ~!   oa  $+2$-1 < 
^1\1-:?^~'\'oao v                /        \-1<:@@~o/o1-    v^a<  >1+^v:$-2<vo'\'<      ^@~<v             <
 v^?:+1v!?:-1&+2/            /   /        \        \' '^!?:<         <     >$@@:>1-' 'o:?v^      >~'\'o$v^    oa<
       >         ^     /-1   /-1 /        \        \       \:0:<                ^        <   v      -1< :v o' '<^ +1$-2  <      v    -1<
 >~&~1&         >:2*:1->'|'o1>@@:>' 'o1-:?^~@'|'o:?^~ao:  ?^~&?^                 1+2*0     >:>:?!^' 'o^ >>1-: ?^~'/'o:2-?^@@2*ao>' 'o:?^'v'o ;
```
Takes one number `1-99` as input and draws the Cool S.   
The program uses only one stack to store the number of spaces.  
It is almost not golfed, coded just for practice and fun :D   
[Try it online!](https://tio.run/##jVOxjoMwDN35CleKiASKaNLNh5J8CLLEcrpOGU7KdMqv9@yQtrTccBnAgO33/Pz4vH5/3W5XfdbmakcMp2yNPKh1GG3uMjzODLu486UGaI0bLiN4rgJ9z95V/eOktT@XUuYOcm8xrYPDkjRpCpheYf9xfNGTTgorhZl2hD0TTNYghPw3RR9BL1yb60dj0x7aP8MMHkPOxClbBjUIpBexyhGitDYLSounWp5JZ0rMkE4BuS/OAimMiT8yKxY6ZOoMZMmasU9cwjAHeUhk45SFUUBmnrh8KYr7QGLQYr3ivYWshG051QUAqNEpY7ldR3ZhlQIVgV3TUanpHixCNMaSJta1TkKr8LYjZVTGzcx10Y0hxTK/tpKFM1m2WZ25H930DvOEegRNo/nNl17FiJsLZUp6uKFulDafMeL7NrfEiUffrn8g3u94xqPaexZtPLEF@6/uiWC0rMTDxrkldEytL7Z/@gvdwDv2@odN6mWWZldeRJSXEqwJAfjeBzpYy45uOLdWbK4TNfP4anmqvwU6EyhGN6zJb0KRzjrBx@12ufwC "><> – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), ~~321~~ 307 bytes
Thanks to @EsolangingFruit for saving 14 bytes
```
n=int(input())
b,f='\/'
c,l=4*n+3,10*n+6
r=range
h=c//2
L=[c*[' ']for _ in r(l)]
L[0][h],L[-1][h]='^v'
for i in r(h):a=L[h-i];a[i],a[c+~i]=f,b
for i in r(2*n):L[h-~i][0::h]='|'*3
for i in r(n+1):a=L[h+h+i];a[c+~i],a[i:c-1:h]=f,b*2
for i in r(1,l//2):L[l+~i]=L[i][::-1]
print('\n'.join(''.join(i)for i in L))
```
[Try it online!](https://tio.run/##TZBdaoUwEEbfswrfxvxYjZY@pGQH2UFuWryh3qTIKMEWCqVbt4m9FJ9mIOc7mZn1awsLDvuOOuJWR1w/tppSchWThksLxItZPzLkg5BdLk8k6TTi7Y0E7du2J0ZbzyxU4KYlVa9VxCrVM3XE2M7Z4ISxjSyNhpdPIAWKf1CgatTGhia659FGJ0br@U90ehLXM9czpKpw@c12ShXVN7DhzCCXdxsP/PAdqqyMyjeyZLKV9eeMFHNeoKjn41uTZ7BK5WnJmsox4ILw8L5ErOFeI/3PG0r3XQ6/ "Python 3 – Try It Online")
# [Python 2](https://docs.python.org/2/), 303 bytes
```
n=int(input())
b,f='\/'
c,l,r=4*n+3,10*n+6,range
h=c/2
L=[c*[' ']for _ in r(l)]
L[0][h],L[-1][h]='^v'
for i in r(h):a=L[h-i];a[i],a[c+~i]=f,b
for i in r(2*n):L[h-~i][0::h]='|'*3
for i in r(n+1):a=L[h+h+i];a[c+~i],a[i:c-1:h]=f,b*2
for i in r(1,l/2):L[l+~1]=L[i][::-1]
print'\n'.join(''.join(i)for i in L)
```
[Try it online!](https://tio.run/##TZBNasMwEEb3OoV3Y/24tuTShYJuoBsoanFMXamYsRFOoVBydVdKQ/HqG5j3PYZZv7ewoNp3NBG3OuJ63WpKyUVMBs4tkFHMIplnhrwXssvxItKAH@8kmLFVxBo3MgcV@GlJ1VsVsUr1TD2xrvMueGFdI8tg4PULSIHiHxSoHox1oYn@NLjoxeBGfoveTOJy5BRDqguXd67Tuqh@gPVHBrl82Hjgd99dlZVRj40snWxl6tiRYm5VMc/8Jn3uZr3W@ViypvwKOCM8fS4Ra3hkpP9tS/dd9r8 "Python 2 – Try It Online")
[Answer]
# [Regenerate](https://github.com/dloscutoff/Esolangs/tree/master/Regenerate), 180 bytes
```
( {2*$~1}) ^\n(( {#3-1}|$1)/(  $4| )\\\n){#1+1}((\|$1\|$1\|\n){#1})(( $8|)(\\$1\\)( {#10-2}|$1)/\n){$~1+1}(( {#12-1}|$8)/(  $13|)$9\n){$~1+1}$5(( $15|)\\( {#16-2}|$4)/\n){#1+1}$1 v
```
Takes input as a command-line argument. [Try it here!](https://replit.com/@dloscutoff/regenerate)
### Explanation
Hoo boy, this is long. It's not actually super-complicated, though; once you get a few basic principles of golfing in Regenerate, this just uses the same techniques over and over.
```
( {2*$~1})
```
Group 1: Take the command-line argument (`$~1`), multiply it by 2, and add that many spaces.
```
 ^\n
```
Complete the first line with one more space, `^`, and a newline.
```
(...){#1+1}
```
Group 2 generates one line of the `/ \` section. Repeat it (length of group 1, plus 1) times. It contains groups 3 and 4.
```
( {#3-1}|$1)/
```
Group 3: Add spaces, one fewer than the last time we matched group 3; or, if group 3 hasn't been matched before, start with the contents of group 1 (arg \* 2 spaces) instead. After group 3, add a forward slash.
```
(  $4| )\\\n
```
Group 4: Add spaces, two more than the last time we matched group 4; or, if group 4 hasn't been matched before, start with one space instead. After group 4, add a backslash and a newline.
```
((\|$1\|$1\|\n){#1})
```
Group 5 is the whole vertical lines section, which we're capturing because we can reuse it verbatim later. Specifically, this is (length of group 1) repetitions of group 6, which consists of: pipe, group 1, pipe, group 1, pipe, newline.
```
(...){$~1+1}
```
Group 7 generates one line of the `\ \/` section. Repeat it (argument plus 1) times. It contains groups 8, 9, and 10.
```
( $8|)
```
Group 8: Add spaces, one more than the last time we matched group 8; or, if group 8 hasn't been matched before, start with empty string instead.
```
(\\$1\\)
```
Group 9: backslash, group 1, backslash (capture for reuse later).
```
( {#10-2}|$1)/\n
```
Group 10: Add spaces, two fewer than the last time we matched group 10; or, if group 10 hasn't been matched before, start with the contents of group 1 instead. After group 10, add a forward slash and a newline.
```
(...){$~1+1}
```
Group 11 generates one line of the `/\ \` section. Repeat it (argument plus 1) times. It contains groups 12 and 13.
```
( {#12-1}|$8)/
```
Group 12: Add spaces, one fewer than the last time we matched group 12; or, if group 12 hasn't been matched before, start with the most recent contents of group 8 instead. After group 12, add a forward slash.
```
(  $13|)$9\n
```
Group 13: Add spaces, two more than the last time we matched group 13; or, if group 13 hasn't been matched before, start with empty string instead. After group 13, add the contents of group 9 (two backslashes with some spaces in between) and a newline.
```
$5
```
Add the contents of group 5 again (vertical pipes section).
```
(...){#1+1}
```
Group 14 generates one line of the `\ /` section. Repeat it (length of group 1, plus 1) times. It contains groups 15 and 16.
```
( $15|)\\
```
Group 15: Add spaces, one more than the last time we matched group 15; or, if group 15 hasn't been matched before, start with empty string instead. After group 15, add a backslash.
```
( {#16-2}|$4)/\n
```
Group 16: Add spaces, two fewer than the last time we matched group 16; or, if group 16 hasn't been matched before, start with the most recent contents of group 4 instead. After group 16, add a forward slash and a newline.
```
$1 v
```
For the last line, add the contents of group 1, a space, and `v`.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~271~~ ~~261~~ ~~253~~ 230 bytes
-10 bytes by moving `2*` inside `S` macro
-8 bytes by placing `u,d` in the global scope and replacing `(n-u)` with `d`
-23 bytes by abusing the C preprocessor, thanks to @ceilingcat
```
#define S(i,c)printf("%*s"#c,2*i,"");
#define R(m)}for(u=0,d=n*m+1;d--;u++){S(0+
#define V(x,y)S(x,\\\n)R(2-1)0,|)S(n,|)S(n,|\n)R(y)u,\\)S(
u,d;f(n){{S(n+1,^\n)R(2)d,/)V(u+1,1)n,\\)S(d,/\n)R(1)d,/)S(u,\\)V(n,2)d+1,/\n)}S(n+1,v\n)}
```
[Try it online!](https://tio.run/##PZDBasMwDIbP8VOYlIKUOCwuO9XLSzSQkxkMuxk6RBvtPFayPHumJGQXyf7/Tz9IoXoPYZ4P8doTX3ULZAJ@3oi/esiPxT0/BHMqyOQ5OrVTFxhw6j9ukJraxIaLobQuVpVLZYljC3X5j3bwYx7YSvXeM17gVFmsza9IvNdVf2ASRASVTHQ9MI6SxKU1r9scRvOEHSRRLPLGirSadjVbWCM6yRRauMWctpDv5TnLWnp4IwbUo8qWHzmVySYaSDe6dpr0i36WJossSLafwvORzp4950aTnCLLelj7pKb5Dw "C (gcc) – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `C`, 49 bytes
```
\^?d›(\/n꘍øM)\|?꘍m∞?dḊ?›(\\?꘍m?›n-d꘍\/J)W:ṘRJṪ\vJ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJDIiwiIiwiXFxeP2TigLooXFwvbuqYjcO4TSlcXHw/6piNbeKInj9k4biKP+KAuihcXFxcP+qYjW0/4oC6bi1k6piNXFwvSilXOuG5mFJK4bmqXFx2SiIsIiIsIjMiXQ==)
Will add explanation tomorrow.
]