Dibuja el "Cool S"

38

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.1n20

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.

Decaimiento Beta
fuente
El niño de los 90 de ASCII que construye en mí quiere sugerir usar / \ en lugar de ^ para la sugerencia. Se ve más limpio de esa manera, además de mantener la misma inclinación de la pendiente :)
Flater
@Flater único problema es que / \ utiliza dos caracteres, por lo que la línea vertical central tendría que ser compensado que hace que parezca muy desordenado
Decaimiento beta
@BetaDecay: se ve bien en N = 2 y N = 3 (ya que conserva la simetría de puntos), pero estoy de acuerdo con N = 1. También existe la opción de la V invertida:Λ
Flater
2
@JacobGarby: Mi argumento fue estilístico, no golfista :)
Flater

Respuestas:

14

Carbón , 58 53 47 43 41 bytes

Nθ≔⊕⊗θδ↗θ/⊗θ↘δ^‖B↓‖M← vMδ⁰⊗θ↗⊕θM⁰δ↗θ/⊗θ⟲T

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.

Charlie
fuente
Puede que te encuentres con algo allí ... 22 bytes te lleva todo el exterior ...
Neil
@Neil no fue exactamente así, su idea necesitaba una solución menor, ¡pero de hecho esta ha sido una gran mejora!
Charlie
Sí, cometí un error similar en mi publicación original porque no verifiqué el efecto de escalar correctamente.
Neil
¿Alguien dijo Rotate? Eso me da una idea ...
Neil
@Neil oye, ¡tienes una gran mejora allí! :-)
Charlie
13

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.

frosqh
fuente
Ambos o+~dpueden ser m-dy range(o)pueden ser range(m+1), y luego puede eliminarlos o=m+1\npara guardar 6 bytes. Buena respuesta, sin embargo, +1 de mi parte.
Kevin Cruijssen
1
Ah, y un byte más cambiando p(s)\np(s[::-1])a p(s+q+s[::-1]): 248 bytes
Kevin Cruijssen
Puede guardar 6 bytes si se utiliza una sola print, y más 4 mediante la eliminación []de join([...]), totalizando 238 bytes
Rod
También puede almacenar q.joinen una variable para guardar un byte
Rod
217 . Se unió a todos los q.joins, y un par de otras cosas
Jo King
13

Carbón , 47 42 41 bytes

Fv^«↓⊗θ↘⊗⊕θ←↓⊗θ↙⊕⊗θ↖ι↖⊕⊗θ→↑⊗θ↗⊕θMθ⁺⊗θ⊕θ⟲⁴

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:

↖^↖⊕⊗θ→↑⊗θ↗⊕θ‖BM↓↙⊗θ→↓⊗θ⟲C↑⁴J⁰¦⁰v
Neil
fuente
@BetaDecay Lo siento por eso. También tuve el conteo de bytes incorrecto de todos modos ...
Neil
Bien, también tiene n = 0 bien
Beta Decay
6

Lienzo , 36 32 29 bytes

«|*‼l├/L1^╋;╶╵\∔∔│α╶«├:╵╋:↔↕∔

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
dzaima
fuente
3

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.

Chas Brown
fuente
3

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!

ErikF
fuente
w -r-1posiblemente podría jugar golf w~r.
Jonathan Frech
Aunque la alineación es un byte más corta .
Jonathan Frech
344 bytes .
Jonathan Frech
321 bytes
ceilingcat
3

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.

gastropner
fuente
@ceilingcat Cheers.
Gastropner
@ceilingcat El orden de evaluación indefinido de los argumentos de la función me detiene.
Gastropner
2

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);}
}
Marco13
fuente
Hola. Las importaciones son parte del recuento de bytes, me temo, por lo que su respuesta actual es en realidad 478 bytes . Sin embargo, puede jugar golf (por coincidencia) sus 435 bytes actuales con algunas cosas básicas para jugar golf.
Kevin Cruijssen
Pude jugar un poco más de 405 bytes al eliminar algunas variables y usar t=...un poco menos para ahorrar bytes. Si tiene alguna pregunta sobre alguno de los cambios que hice, avíseme. :)
Kevin Cruijssen
Gracias @KevinCruijssen, por desgracia, actualmente no pueden invertir más tiempo aquí - esto era sólo una cosa recreativa, y teniendo en cuenta la "verbosidad" de Java, no un competidor serio de todos modos ;-) Considerar la adición de la solución como una respuesta propia, sin embargo - a continuación, nos al menos tener una competencia en varios idiomas :-)
Marco13
2

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!

Sam Dean
fuente
1
Como la declaración de función es bastante costosa y usa t () solo dos veces, sería más corto sin ella . Si además de los 9 avisos, también recibe 1 advertencia, puede eliminar las comillas 'v'en la final echo.
manatwork
1
Puede usar un solo bucle para las partes oblicuas superior e inferior. La inicialización de $ a y $ i podría compactarse moviéndolos en su primer uso.
manatwork
1
Ah, y $i>0e $m>0puede escribirse simplemente como $iy $m.
manatwork
1
Con espacios finales , como en algunas otras soluciones.
manatwork
1
También puede mover la declaración de $ c a su primer uso. Simplemente cambie la .concatenación después de esto a ,. Pruébalo en línea!
manatwork
1

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!

Pétur
fuente
Puede reemplazar '\\','/'en la segunda línea con *'\/'para guardar tres bytes.
Esolanging Fruit
307 bytes: ¡ Pruébelo en línea!
Esolanging Fruit
¡Gracias! @EsolangingFruit! No estaba al tanto de las operaciones de bit en Python. Además, ahorraría unos pocos bytes para usar Python2 debido a la división y paréntesis enprint
Pétur
En Python 2, input()automáticamente eval()la cadena, para que pueda omitir elint() llamada.
Esolanging Fruit
Para Python 3, puede cambiar la última línea a for l in L:print(*l,sep="")(no creo que haya un equivalente en Python 2).
Esolanging Fruit