Dibuja la “ Cool S ”

Introducción

Todos conocemos la S genial (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 ellos mismos. En caso de que lo hayas olvidado o hayas tenido una infancia completamente deslumbrante , aquí tienes una imagen de dicha S genial:

Dado un factor de escala n como entrada (donde \ $ 1 \ leq n \ leq 20 \ $), genere el Cool S en arte ASCII.

Cómo dibujarlo

De la página de Wikipedia en Cool S:

Salida

El Cool S cuando n = 1 es:

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

Y para diferentes valores de n, simplemente haz que la salida n sea mayor. ejemplo, n = 2:

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

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

Y cuando n = 3:

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

Nota: Aunque no es obligatorio ired, su código también puede ser compatible con n = 0:

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

Winning

El programa más corto en bytes gana.

Comentarios

  • Relacionado: Dibujar una S- Chain
  • El niño de 90 ‘ que construye ASCII en mí quiere sugerir el uso de / \ en lugar de ^ para la sugerencia. Parece más limpio de esa manera, además de que mantiene la misma inclinación de la pendiente 🙂
  • El único problema de @Flater es que / \ usa dos caracteres, por lo que la línea vertical central tendría que estar desplazada, lo que hace que se vea muy desordenada
  • @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. Hay ‘ también la opción de la V invertida: Λ
  • @JacobGarby: Mi argumento era estilístico, no golfista 🙂

Respuesta

Charcoal , 58 53 47 43 41 bytes

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

Pruébelo en línea !

Solo quería probar otro enfoque, este dibuja el exterior mediante reflejos (gracias a Neil por expandir la idea) y luego dibuja la parte interior. Como Charcoal tiene :Left como dirección predeterminada para dibujar líneas, utilizo esa dirección tanto como sea posible para ahorrar algunos bytes dibujando la S horizontalmente, así:

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

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

Comentarios

  • Puede que estés en algo allí … 22 bytes te lleva todo el exterior …
  • @Neil no era ‘ t exactamente así, tu idea necesitaba una pequeña corrección, ¡pero de hecho esto ha sido una gran mejora!
  • Sí, cometí un error similar en mi publicación original porque no ‘ t verifique el efecto de escalar correctamente.
  • ¿Alguien dijo Rotate? Eso me da una idea …
  • @Neil oye, ¡has mejorado bastante! 🙂

Respuesta

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ébelo en línea!

Ahora maneja n = 0.

Comentarios

  • Ambos o+~d pueden ser m-d y range(o) puede ser range(m+1), y luego puedes eliminar o=m+1\n para ahorrar 6 bytes. Sin embargo, buena respuesta, +1 de mí.
  • Ah, y un byte más cambiando p(s)\np(s[::-1]) a p(s+q+s[::-1]): 248 bytes
  • Puedes ahorrar 6 bytes si usas un solo print y más 4 eliminando [] de join([...]), totalizando 238 bytes
  • También puede almacenar q.join en una variable para guardar un byte
  • 217 . Se unió a todas las q.join s, y un par de cosas más

Responder

Carbón , 47 42 41 bytes

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

¡Pruébelo en línea! El enlace es una 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 

Donde 5 es el carácter actual de la cadena v^. Al final del primer ciclo, el cursor se coloca en el punto 9. A continuación, se gira todo el lienzo para poder dibujar la otra mitad del Cool S. (El lienzo en realidad se rota dos veces, pero esto es solo un detalle de implementación).

Charcoal no es compatible con RotateCopy(:Up, 4), pero si lo hiciera, funcionaría para 33 bytes:

↖^↖⊕⊗θ→↑⊗θ↗⊕θ‖BM↓↙⊗θ→↓⊗θ⟲C↑⁴J⁰¦⁰v 

Comentarios

  • @BetaDecay Lo siento. También tenía el byte incorrecto contar de todos modos …
  • Bien, también obtiene n = 0 bien

Responder

Lienzo , 36 32 29 bytes

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

Pruébelo aquí

Mucha manipulación de la pila. Explicación (obsoleta):

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

Respuesta

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ébelo en línea!

Gracias a Jo King por 1 byte; y luego otros 5 bytes en total (a través de n => 2*n).

También funciona para n=0.

Respuesta

C (gcc) , 379 353 344 334 bytes

Usé un par de #define s para la eliminación de subexpresiones y varios globales para comunicarse entre las funciones internas. El ciclo principal va {0,1,2,3,3,2,1,0} para construir la 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ébelo en línea

Comentarios

Respuesta

C (gcc) , 260 254 bytes

-6 bytes gracias a roofcat .

 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ébelo en línea!

Resumen

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 un número de líneas, tres caracteres y tres relaciones con ciertos valores que deciden el ancho de campo en cada línea.

Se produjo una primera iteración 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) }  

Las llamadas al g() La macro se parece mucho a una tabla que se podría construir y recorrer. Los anchos de campo a veces están relacionados con el contador de índice y, a veces, no. Podemos generalizar el ancho del campo para que sea F * i + A, donde F es un factor para multiplicar 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 era mucho más corto que una versión ajustada del g() llamando a uno, pero más corto es más corto.

Comentarios

  • @ceilingcat Cheers.
  • @ceilingcat El orden de evaluación indefinido de la función los argumentos me dan una pausa.

Respuesta

Java, 435 bytes

La función en sí 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», mediante el golf clásico (tal vez sacando otra variable o combinando dos de los for -loops). Pero es una primera oportunidad con este lenguaje poco golfista:

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

Comentarios

  • Hola. Las importaciones forman parte del recuento de bytes que ‘ me temo, por lo que tu respuesta actual es en realidad 478 bytes . Sin embargo, puede reducirlo (casualmente) a su actual 435 bytes con algunas cosas básicas para jugar al golf.
  • Pude jugar al golf un poco más a 405 bytes al eliminar algunas variables y usar t=... un poco menos donde ahorraría bytes. Si tiene alguna pregunta sobre los cambios que hice, hágamelo saber. 🙂
  • Gracias @KevinCruijssen. Desafortunadamente, actualmente no puedo invertir más tiempo aquí; esto fue solo una cosa recreativa y considerando la » verbosity » de Java, no es un competidor serio de todos modos 😉 Considere agregar su solución como una respuesta propia, sin embargo, entonces al menos tendremos una competencia intralenguaje: -)

Respuesta

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 manatworks «sugerencias

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

-1 byte, eliminó lo superfluo \

-4 bytes haciendo eco una vez. Olvidé que necesitaba pasar la cadena a la función para que tenga más bytes

También funciona para n = 0.

  

¡Pruébelo en línea!

Comentarios

  • Como la declaración de función es bastante cara y usa t () solo dos veces, sería más corto sin él . Si además de los 9 avisos recibes 1 advertencia también, puedes eliminar las comillas alrededor de 'v' en la echo final.
  • Podrías 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.
  • Ah, y $i>0 y $m>0 se puede escribir simplemente como $i y $m.
  • Con espacios finales , como en algunas otras soluciones.
  • También puede mover la declaración de $ c a su primer uso. Simplemente cambie la . concatenación posterior a ,. ¡Pruébelo en línea!

Respuesta

Python 3 , 321 307 bytes

Gracias a @EsolangingFruit por ahorrar 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ébelo 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ébelo en línea!

Comentarios

  • Puede reemplazar '\\','/' en la segunda línea con *'\/' para ahorrar tres bytes.
  • 307 bytes: Pruébelo en línea
  • ¡Gracias! @EsolangingFruit! No estaba al tanto de las operaciones de bits en Python. Además, ahorraría unos pocos bytes para usar Python2 debido a la división y los paréntesis en print
  • En Python 2, input() automáticamente eval() s la cadena, por lo que también puede omitir la llamada int().
  • 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).
  • Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *