Introducción

Todos conocemos la genial S (también conocida como Superman S, Stüssy S, Super S, Skater S, Pointy S, Graffiti S, etc., etc.): miles de millones de escolares de todo el mundo dibujaron esta S e inmediatamente se sintieron orgullosos de sí mismos. En caso de que hayas olvidado o tenido una infancia completamente desagradable , aquí hay una imagen de dicho genial S:

Dado un factor de escala ncomo entrada (donde ), genera el Cool S en ASCII art.$1\leq n\leq 20$

Cómo dibujarlo

Desde la página de Wikipedia en el Cool S:

Salida

El Cool S cuando n= 1 es:

   ^
  / \
 /   \
/     \
|  |  |
|  |  |
\  \  /
 \  \/
 /\  \
/  \  \
|  |  |
|  |  |
\     /
 \   /
  \ /
   v

Y para diferentes valores de n, simplemente aumenta el ntiempo de salida . Por ejemplo, n= 2:

     ^  
    / \
   /   \
  /     \
 /       \
/         \
|    |    |
|    |    |
|    |    |
|    |    |
\    \    /
 \    \  /
  \    \/
  /\    \
 /  \    \
/    \    \
|    |    |
|    |    |
|    |    |
|    |    |
\         /
 \       /
  \     /
   \   /
    \ /
     v

Tenga en cuenta que las secciones verticales son dos veces más largas y el espacio entre las líneas verticales es dos veces más ancho.

Y cuando n= 3:

       ^
      / \
     /   \
    /     \
   /       \
  /         \
 /           \
/             \
|      |      |
|      |      |
|      |      |
|      |      |
|      |      |
|      |      |
\      \      /
 \      \    /
  \      \  /
   \      \/
   /\      \
  /  \      \
 /    \      \
/      \      \
|      |      |
|      |      |
|      |      |
|      |      |
|      |      |
|      |      |
\             /
 \           /
  \         /
   \       /
    \     /
     \   /
      \ /
       v

Nota: aunque no es obligatorio, su código también puede admitirn= 0:

 ^
/ \
\\/
/\\
\ /
 v

Victorioso

El programa más corto en bytes gana.

Carbón , 58 53 47 43 41 bytes

Ｎθ≔⊕⊗θδ↗θ/⊗θ↘δ^‖Ｂ↓‖Ｍ← vＭδ⁰⊗θ↗⊕θＭ⁰δ↗θ/⊗θ⟲Ｔ

Pruébalo en línea!

Solo quería probar otro enfoque, esto dibuja el exterior a través de reflexiones (gracias a Neil por expandir la idea) y luego dibuja la parte interior. Como el carbón tiene la :Leftdirección predeterminada para dibujar líneas, hago uso de esa dirección tanto como sea posible para guardar algunos bytes dibujando la S horizontalmente, así:

     /----\    /----\     
    /      \  /      \    
   /        \/        \   
  /         /          \  
 /         /            \ 
v     ----/    /----     ^
 \            /         / 
  \          /         /  
   \        /\        /   
    \      /  \      /    
     \----/    \----/     

Y luego solo necesito rotar el lienzo 90 grados en sentido antihorario.

Python 3 , 255 249 248 209 bytes

-6 bytes gracias a Kevin Cruijssen

-1 byte gracias a Kevin Cruijssen

-39 bytes gracias a Rod y 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')

Pruébalo en línea!

Ahora maneja n = 0.

Carbón , 47 42 41 bytes

Ｆv^«↓⊗θ↘⊗⊕θ←↓⊗θ↙⊕⊗θ↖ι↖⊕⊗θ→↑⊗θ↗⊕θＭθ⁺⊗θ⊕θ⟲⁴

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación: Dibuja las siguientes líneas en orden:

   ^
  / \
 /   \
/     \
|  1  |
|  1  |
\  2  /
 \  2/
 8\  2
8  \  2
7  |  3
7  9  3
6     4
 6   4
  6 4
   5

¿Dónde 5está el carácter actual de la cadena v^? Al final del primer bucle, el cursor se coloca en el punto9 . Luego se gira todo el lienzo para que se pueda dibujar la otra mitad del Cool S. (El lienzo se rota dos veces, pero esto es solo un detalle de implementación).

El carbón no es compatible, RotateCopy(:Up, 4)pero si lo fuera, funcionaría para 33 bytes:

↖^↖⊕⊗θ→↑⊗θ↗⊕θ‖ＢＭ↓↙⊗θ→↓⊗θ⟲Ｃ↑⁴Ｊ⁰¦⁰v

Lienzo , 36 32 29 bytes

«|＊‼ｌ├／Ｌ１^╋；╶╵＼∔∔│α╶«├：╵╋：↔↕∔

Pruébalo aquí!

Una gran cantidad de manipulación de pila. (desactualizada) explicación:

«|*                                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

Python 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'])

Pruébalo en línea!

Gracias a Jo King por 1 byte; y luego otros 5 bytes en total (vía n => 2*n).

Funciona para n=0también.

C (gcc) , 379 353 344 334 bytes

Utilicé un par de #defines para la eliminación de la subexpresión y varios globales para comunicarme entre las funciones internas. El bucle principal va {0,1,2,3,3,2,1,0} para construir el S.

Gracias a Jonathan Frech por las sugerencias.

#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;}

Pruébalo en línea!

C (gcc) , 260 254 bytes

-6 bytes gracias a 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);}

Pruébalo en línea!

Atropellar

Podemos dividir la forma en partes:

 ^           Top cap
/ \          Top slope
|||          Sides
\\/          Twist, part 1
/\\          Twist, part 2
|||          Sides
\ /          Bottom slope
 v           Bottom cap

Cada parte podría describirse mediante una serie de líneas, tres caracteres y tres relaciones con ciertos valores que deciden el ancho del campo en cada línea.

Una primera iteración llegó a ser:

#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)
}

Las llamadas a la g()macro se parecen mucho a una tabla que podría construirse y repetirse. Los anchos de campo a veces están relacionados con el contador de índice, y otras veces no. Podemos generalizar el ancho de campo para que sea F * i + A, donde F es un factor con el que multiplicarse i, y A es un valor para agregar al ancho. Entonces, el último ancho de la cuarta llamada anterior sería -2 * i + t, por ejemplo.

Así obtenemos:

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.

Al final no fue mucho más corto que una versión ajustada de la que g()llama, pero más corto es más corto.

Java, 435 bytes

La función en sí misma toma 435 bytes. Ciertamente hay margen de mejora, "alto nivel" mediante el análisis de las reglas sobre dónde colocar qué personaje (al final, la S es simétrica) y "bajo nivel", por el golf clásico (tal vez sacando otra variable o combinando dos de los forbucles). Pero es una primera oportunidad con este lenguaje poco feo:

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);}
}

PHP , 378 374 378 377 376 335 331 328 bytes

-3 bytes, gracias a manatwork

-4 bytes, usó str_pad en lugar de str_repeat

-41 bytes, gracias a las sugerencias de manatworks

-1 byte, fusionó dos incrementos en a + = 2

-1 byte, eliminado superfluo \

-4 bytes haciendo eco una vez. Olvidé que necesitaba pasar la cadena a la función, así que esto es más bytes

Funciona para n = 0 también.

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;

Pruébalo en línea!

Python 3 , 321 307 bytes

Gracias a @EsolangingFruit por guardar 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))

Pruébalo en línea!

Python 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)

Pruébalo en línea!