Introduzione
Conosciamo tutti la bella S (nota anche come Superman S, Stüssy S, Super S, Skater S, Pointy S, Graffiti S ecc. ecc.): miliardi di scolari in tutto il mondo hanno disegnato questa S e si sono subito sentiti orgogliosi di se stessi. Nel caso in cui “ti sei dimenticato o hai avuto uninfanzia completamente insolita , ecco unimmagine di detta bella S:
Dato un fattore di scala n
come input (dove \ $ 1 \ leq n \ leq 20 \ $), restituisce Cool S in ASCII art.
Come disegnarlo
Dalla pagina di Wikipedia su Cool S:
Risultato
Cool S quando n
= 1 è:
^ / \ / \ / \ | | | | | | \ \ / \ \/ /\ \ / \ \ | | | | | | \ / \ / \ / v
E per diversi valori di n
, devi semplicemente aumentare loutput n
. Per esempio, n
= 2:
^ / \ / \ / \ / \ / \ | | | | | | | | | | | | \ \ / \ \ / \ \/ /\ \ / \ \ / \ \ | | | | | | | | | | | | \ / \ / \ / \ / \ / v
Tieni presente che le sezioni verticali sono due volte più lunghe e la spaziatura tra le linee verticali sono due volte più larghe.
E quando n
= 3:
^ / \ / \ / \ / \ / \ / \ / \ | | | | | | | | | | | | | | | | | | \ \ / \ \ / \ \ / \ \/ /\ \ / \ \ / \ \ / \ \ | | | | | | | | | | | | | | | | | | \ / \ / \ / \ / \ / \ / \ / v
Nota: sebbene non richiesto ired, il codice potrebbe anche essere in grado di supportare n
= 0:
^ / \ \\/ /\\ \ / v
Winning
Vince il programma più breve in byte.
Commenti
Rispondi
Charcoal , 58 53 47 43 41 byte
Nθ≔⊕⊗θδ↗θ/⊗θ↘δ^‖B↓‖M← vMδ⁰⊗θ↗⊕θM⁰δ↗θ/⊗θ⟲T
Volevo solo provare un altro approccio, questo disegna lesterno tramite riflessi (grazie a Neil per aver ampliato lidea) e poi disegna la parte interna. Dato che Charcoal ha :Left
come direzione predefinita per disegnare le linee, utilizzo quella direzione il più possibile per salvare alcuni byte disegnando la S in orizzontale, in questo modo:
/----\ /----\ / \ / \ / \/ \ / / \ / / \ v ----/ /---- ^ \ / / \ / / \ /\ / \ / \ / \----/ \----/
E poi devo solo ruotare la tela di 90 gradi in senso antiorario.
Commenti
- Potresti trovarti su qualcosa lì … 22 byte ti porta tutto il resto …
- @Neil non era ‘ Proprio così, la tua idea necessitava di una piccola correzione, ma in effetti questo è stato un grande miglioramento!
- Sì, ho fatto un errore simile nel mio post originale perché non lho fatto ‘ t controllare correttamente leffetto del ridimensionamento.
- Qualcuno ha detto
Rotate
? Questo mi dà unidea … - @Neil hey, hai ottenuto un bel miglioramento lì! 🙂
Risposta
Python 3 , 255 249 248 209 byte
-6 byte grazie a Kevin Cruijssen
-1 byte grazie a Kevin Cruijssen
-39 byte grazie a Rod e 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")
Ora gestisce n = 0.
Commenti
- Entrambi
o+~d
possono esserem-d
erange(o)
può essererange(m+1)
, quindi puoi rimuovereo=m+1\n
per risparmiare 6 byte. Bella risposta però, +1 da parte mia. - Oh, e un altro byte cambiando
p(s)\np(s[::-1])
inp(s+q+s[::-1])
: 248 byte - Puoi risparmiare 6 byte se utilizzi un solo
print
e altro 4 rimuovendo[]
dajoin([...])
, totalizzando 238 byte - Puoi anche memorizzare
q.join
in una variabile per salvare un byte - 217 . Si è unito a tutti i
q.join
e un paio di altre cose
Answer
Charcoal , 47 42 41 byte
Fv^«↓⊗θ↘⊗⊕θ←↓⊗θ↙⊕⊗θ↖ι↖⊕⊗θ→↑⊗θ↗⊕θMθ⁺⊗θ⊕θ⟲⁴
Provalo online! Il link serve alla versione dettagliata del codice.Spiegazione: traccia le seguenti righe in ordine:
^ / \ / \ / \ | 1 | | 1 | \ 2 / \ 2/ 8\ 2 8 \ 2 7 | 3 7 9 3 6 4 6 4 6 4 5
Dove 5
è il carattere corrente della stringa v^
. Alla fine del primo ciclo il cursore viene quindi posizionato nel punto 9
. Lintera tela viene quindi ruotata in modo da poter disegnare laltra metà di Cool S. (La tela in realtà viene ruotata due volte, ma questo è solo un dettaglio di implementazione.)
Charcoal non supporta RotateCopy(:Up, 4)
ma se lo facesse allora funzionerebbe per 33 byte:
↖^↖⊕⊗θ→↑⊗θ↗⊕θ‖BM↓↙⊗θ→↓⊗θ⟲C↑⁴J⁰¦⁰v
Commenti
- @BetaDecay Mi dispiace. Ho anche sbagliato byte conta comunque …
- Bello, anche n = 0
Risposta
Canvas , 36 32 29 byte
«|*‼l├/L1^╋;╶╵\∔∔│α╶«├:╵╋:↔↕∔
Un sacco di manipolazione dello stack. Spiegazione (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
Risposta
Python 2 , 227 208 207 202 196 181 byte
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"])
Grazie a Jo King per 1 byte; e poi altri 5 byte in totale (tramite n => 2*n
).
Funziona anche per n=0
.
Risposta
C (gcc) , 379 353 344 334 byte
Ho usato un paio di #define
per leliminazione delle sottoespressioni e diversi globali per comunicare tra le funzioni interne. Il ciclo principale va {0,1,2,3,3,2,1,0} per costruire la S.
Grazie a Jonathan Frech per i suggerimenti.
#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;}
Commenti
-
w -r-1
potrebbe essere giocato aw~r
. - Anche se linlining è un byte più corto .
- 344 byte .
- 321 byte
Risposta
C (gcc) , 260 254 byte
-6 byte grazie 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);}
Rundown
Possiamo dividere la forma in parti:
^ Top cap / \ Top slope ||| Sides \\/ Twist, part 1 /\\ Twist, part 2 ||| Sides \ / Bottom slope v Bottom cap
Ciascuna parte può essere descritta da un numero di righe, tre caratteri e tre relazioni con determinati valori che decidono la larghezza del campo su ciascuna riga.
Una prima iterazione è arrivata essere:
#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) }
Le chiamate a g()
la macro assomiglia molto a una tabella che potrebbe essere costruita e ripetuta. Le larghezze dei campi sono talvolta correlate al contatore dellindice e talvolta no. Possiamo generalizzare la larghezza del campo in modo che sia F * i + A
, dove F è un fattore con cui moltiplicare i
e A è un valore da aggiungere alla larghezza. Quindi lultima larghezza della quarta chiamata sopra sarebbe -2 * i + t
, ad esempio.
Così otteniamo:
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.
Alla fine non era molto più breve di una versione ridotta del g()
chiamarne uno, ma più breve è più breve.
Commenti
- @ceilingcat Cheers.
- @ceilingcat Lordine di valutazione indefinito della funzione argomenti mi fanno una pausa.
Risposta
Java, 435 byte
La funzione stessa richiede 435 byte. Cè sicuramente spazio per il miglioramento, “alto livello” analizzando le regole su dove posizionare quale carattere (alla fine la S è punto-simmetrica), e “basso livello”, dal golf classico (magari tirando fuori unaltra variabile o combinando due dei for
loop). Ma è “una prima ripresa con questo linguaggio piuttosto ungolfy:
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);} }
Commenti
- Salve. Le importazioni fanno parte del conteggio dei byte che ‘ temo, quindi la tua risposta attuale è in realtà 478 byte . Puoi tuttavia giocare a golf fino a (guarda caso) i tuoi 435 byte con alcune cose di base per il golf.
- Sono riuscito a giocare un po di più a 405 byte rimuovendo alcune variabili e utilizzando
t=...
un po meno dove salverebbe byte. Se hai domande sulle modifiche che ho apportato, fammelo sapere. 🙂 - Grazie @KevinCruijssen, purtroppo al momento non posso investire altro tempo qui – era solo una cosa ricreativa e considerando la ” verbosità ” di Java, non è comunque un serio concorrente 😉 Considera lidea di aggiungere la tua soluzione come risposta, allora abbiamo almeno una competizione intra-linguistica: -)
Risposta
PHP , 378 374 378 377 376 335 331 328 byte
-3 byte, grazie a manatwork
-4 byte, usato str_pad invece di str_repeat
-41 byte, grazie a manatworks “suggerimenti
-1 byte, unito due incrementi in un + = 2
-1 byte, rimosso superfluo \
-4 byte facendo eco una volta. Ho dimenticato che dovevo passare la stringa nella funzione, quindi questo è più byte
Funziona anche per n = 0.
Commenti
- Poiché la dichiarazione della funzione è piuttosto costosa e usi t () solo due volte, sarebbe più breve senza di essa . Se accanto ai 9 avvisi ricevi anche 1 avviso, puoi rimuovere le virgolette intorno a
'v'
nelecho
. - Potresti utilizzare un loop singolo per le parti oblique superiore e inferiore. Linizializzazione di $ a e $ i potrebbe essere compressa spostandoli al primo utilizzo.
- Oh, e
$i>0
e$m>0
può essere scritto semplicemente come$i
e$m
. - Con spazi finali , come in alcune altre soluzioni.
- Puoi anche spostare la dichiarazione di $ c al suo primo utilizzo. Modifica la
.
concatenazione dopo di essa in,
. Provalo online!
Risposta
Python 3 , 321 307 byte
Grazie a @EsolangingFruit per aver salvato 14 byte
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 byte
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)
Commenti
- Puoi sostituire
'\\','/'
sulla seconda riga con*'\/'
per salvare tre byte. - 307 byte: Provalo online!
- Grazie! @EsolangingFruit! Non ero a conoscenza delle operazioni di bit in Python. Inoltre, lutilizzo di Python2 risparmierebbe alcuni byte a causa della divisione e delle parentesi in
print
- In Python 2,
input()
automaticamenteeval()
è la stringa, quindi puoi saltare anche la chiamataint()
. - Per Python 3, puoi modificare lultima riga in
for l in L:print(*l,sep="")
(non ‘ penso che ci sia un equivalente in Python 2).
Λ