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
Respuesta
Charcoal , 58 53 47 43 41 bytes
Nθ≔⊕⊗θδ↗θ/⊗θ↘δ^‖B↓‖M← vMδ⁰⊗θ↗⊕θM⁰δ↗θ/⊗θ⟲T
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")
Ahora maneja n = 0.
Comentarios
- Ambos
o+~d
pueden serm-d
yrange(o)
puede serrange(m+1)
, y luego puedes eliminaro=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])
ap(s+q+s[::-1])
: 248 bytes - Puedes ahorrar 6 bytes si usas un solo
print
y más 4 eliminando[]
dejoin([...])
, 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^╋;╶╵\∔∔│α╶«├:╵╋:↔↕∔
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"])
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;}
Comentarios
-
w -r-1
posiblemente se podría jugar al golf enw~r
. - Aunque entonces la inserción es un byte más corto .
- 344 bytes .
- 321 bytes
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);}
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.
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 laecho
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))
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)
Comentarios
'\\','/'
en la segunda línea con *'\/'
para ahorrar tres bytes. print
input()
automáticamente eval()
s la cadena, por lo que también puede omitir la llamada int()
. for l in L:print(*l,sep="")
(no ‘ creo que haya un equivalente en Python 2).
Λ