Introducere
Știm cu toții genialul S (cunoscut și ca Superman S, Stüssy S, Super S, Skater S, Pointy S, Graffiti S etc. etc.): miliarde de școlari din întreaga lume au atras acest S și s-au simțit imediat mândri de la sine. În cazul în care ați „uitat sau ați avut o copilărie complet necurată , iată o imagine a lui S cool:
Având în vedere un factor de scară n
ca intrare (unde \ $ 1 \ leq n \ leq 20 \ $), emiteți Cool S în art ASCII.
Cum să o desenezi
Din pagina Wikipedia din Cool S:
Ieșire
Cool S când n
= 1 este:
^ / \ / \ / \ | | | | | | \ \ / \ \/ /\ \ / \ \ | | | | | | \ / \ / \ / v
Și pentru diferite valori de n
, pur și simplu faceți ieșirea n
de ori mai mare. Pentru exemplu, n
= 2:
^ / \ / \ / \ / \ / \ | | | | | | | | | | | | \ \ / \ \ / \ \/ /\ \ / \ \ / \ \ | | | | | | | | | | | | \ / \ / \ / \ / \ / v
Rețineți că secțiunile verticale sunt de două ori mai lungi și spațiul dintre liniile verticale sunt de două ori mai largi.
Și când n
= 3:
^ / \ / \ / \ / \ / \ / \ / \ | | | | | | | | | | | | | | | | | | \ \ / \ \ / \ \ / \ \/ /\ \ / \ \ / \ \ / \ \ | | | | | | | | | | | | | | | | | | \ / \ / \ / \ / \ / \ / \ / v
Notă: Deși nu este obligatoriu ired, codul dvs. poate fi, de asemenea, capabil să accepte n
= 0:
^ / \ \\/ /\\ \ / v
Câștigător
Cel mai scurt program în octeți câștigă.
Comentarii
Răspuns
Cărbune , 58 53 47 43 41 bytes
Nθ≔⊕⊗θδ↗θ/⊗θ↘δ^‖B↓‖M← vMδ⁰⊗θ↗⊕θM⁰δ↗θ/⊗θ⟲T
Am vrut doar să încerc o altă abordare, aceasta atrage exteriorul prin reflecții (mulțumesc lui Neil pentru extinderea ideii) și apoi desenează partea interioară. Întrucât cărbunele are :Left
ca direcție implicită pentru a trasa linii, folosesc acea direcție cât mai mult posibil pentru a salva niște octeți desenând S orizontal, astfel:
/----\ /----\ / \ / \ / \/ \ / / \ / / \ v ----/ /---- ^ \ / / \ / / \ /\ / \ / \ / \----/ \----/
Și apoi trebuie doar să rotesc pânza cu 90 de grade în sens invers acelor de ceasornic.
Comentarii
- S-ar putea să vă aflați în ceva acolo … 22 octeți vă oferă tot exteriorul … = „c56bcfa482”>
nu este exact așa, ideea ta avea nevoie de o corecție minoră, dar într-adevăr aceasta a fost o mare îmbunătățire!
Rotate
? Asta îmi dă o idee … Răspuns
Python 3 , 255 249 248 209 octeți
-6 octeți mulțumită lui Kevin Cruijssen
-1 octet mulțumită lui Kevin Cruijssen
-39 octeți mulțumită lui Rod și 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")
Acum gestionează n = 0.
Comentarii
- Ambele
o+~d
pot fim-d
șirange(o)
poate firange(m+1)
și apoi puteți eliminao=m+1\n
pentru a salva 6 octeți. Răspuns frumos, totuși, +1 de la mine. - Oh, și încă un octet schimbând
p(s)\np(s[::-1])
înp(s+q+s[::-1])
: 248 octeți - Puteți salva 6 octeți dacă utilizați un singur
print
și multe altele 4 eliminând[]
dinjoin([...])
, totalizând 238 de octeți - De asemenea, puteți stoca
q.join
într-o variabilă pentru a salva un octet - 217 . S-au înscris la toate
q.join
și la câteva alte lucruri
Răspuns
Cărbune , 47 42 41 octeți
Fv^«↓⊗θ↘⊗⊕θ←↓⊗θ↙⊕⊗θ↖ι↖⊕⊗θ→↑⊗θ↗⊕θMθ⁺⊗θ⊕θ⟲⁴
Încercați online! Linkul este versiunea detaliată a codului.Explicație: trasează următoarele linii în ordine:
^ / \ / \ / \ | 1 | | 1 | \ 2 / \ 2/ 8\ 2 8 \ 2 7 | 3 7 9 3 6 4 6 4 6 4 5
Unde 5
este caracterul curent al șirului v^
. La sfârșitul primei bucle, cursorul este apoi poziționat în punctul 9
. Întreaga pânză este apoi rotită, astfel încât cealaltă jumătate a Cool S să poată fi desenată. (Pânza este de fapt rotită de două ori, dar acesta este doar un detaliu de implementare.)
Cărbunele nu suportă RotateCopy(:Up, 4)
dar dacă ar face acest lucru, ar funcționa pentru 33 octeți:
↖^↖⊕⊗θ→↑⊗θ↗⊕θ‖BM↓↙⊗θ→↓⊗θ⟲C↑⁴J⁰¦⁰v
Comentarii
- @BetaDecay Ne pare rău pentru asta. Am avut și octetul greșit conta oricum …
- Frumos, devine și n = 0 corect
Răspunde
Canvas , 36 32 29 octeți
«|*‼l├/L1^╋;╶╵\∔∔│α╶«├:╵╋:↔↕∔
O mulțime de manipulări ale stivei. Explicație (învechită):
«|* 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
Răspuns
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"])
Thks to Jo King pentru 1 octet; și apoi încă 5 octeți în total (prin n => 2*n
).
Funcționează și pentru n=0
.
Răspuns
C (gcc) , 379 353 344 334 bytes
Am folosit câteva #define
s pentru eliminarea subexpresiei și mai multe globali pentru a comunica între funcțiile interne. Bucla principală merge {0,1,2,3,3,2,1,0} pentru a construi S.
Mulțumim lui Jonathan Frech pentru sugestii.
#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;}
Comentarii
-
w -r-1
ar putea fi jucat law~r
. - Deși atunci integrarea este cu un octet mai scurt .
- 344 octeți .
- 321 octeți
Răspuns
C (gcc) , 260 254 octeți
-6 octeți grație 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
Putem împărți forma în părți:
^ Top cap / \ Top slope ||| Sides \\/ Twist, part 1 /\\ Twist, part 2 ||| Sides \ / Bottom slope v Bottom cap
Fiecare parte ar putea fi descrisă printr-un număr de linii, trei caractere și trei relații cu anumite valori care decid lățimea câmpului la fiecare linie.
A venit o primă iterație 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) }
Apelurile către g()
macro arată foarte mult ca un tabel care ar putea fi construit și înfășurat în buclă. Lățimile câmpului sunt uneori legate de contorul indexului, uneori nu. Putem generaliza lățimea câmpului pentru a fi F * i + A
, unde F este un factor de multiplicare cu i
, iar A este o valoare de adăugat la lățime. Deci, ultima lățime a celui de-al patrulea apel de mai sus ar fi -2 * i + t
, de exemplu.
Astfel obținem:
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.
La final nu a fost mult mai scurt decât o versiune mai strânsă a g()
apelarea unuia, dar mai scurtă este mai scurtă.
Comentarii
- @ceilingcat Salutări.
- @ceilingcat Ordinea de evaluare nedefinită a funcției argumentele îmi dau o pauză.
Răspuns
Java, 435 octeți
Funcția în sine ia 435 de octeți. Există cu siguranță loc de îmbunătățire, „nivel înalt”, analizând regulile cu privire la locul unde se plasează ce personaj (în cele din urmă S este punct-simetric) și „nivel scăzut”, prin golf clasic (poate scoate o altă variabilă sau combinând două dintre for
-loops). Dar este „prima lovitură cu acest limbaj destul de 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);} }
Comentarii
- Bună ziua. Importurile fac parte din numărul de octeți pe care 478 octeți . poate totuși să-l joc până la (destul de întâmplător) 435 octeți actuali cu câteva lucruri de bază pentru golf.
- Am reușit să joc puțin mai mult la 405 octeți eliminând unele variabile și folosind
t=...
puțin mai puțin acolo unde ar economisi octeți. Dacă aveți întrebări despre oricare dintre modificările pe care le-am făcut, anunțați-mă. 🙂 - Mulțumesc @KevinCruijssen, din păcate, în prezent, nu pot investi mai mult timp aici – acesta a fost doar un lucru recreativ și având în vedere ” verosimilitatea ” din Java, oricum nu este un concurent serios 😉 Luați în considerare adăugarea soluției dvs. ca un răspuns propriu, deși – atunci avem cel puțin o anumită competiție intra-limbaj: -)
Răspuns
PHP , 378 374 378 377 376 335 331 328 octeți
-3 octeți, grație manatwork
-4 octeți, au folosit str_pad în loc de str_repeat
-41 octeți, datorită manatworks „sugestii
-1 octet, a fuzionat două trepte într-un + = 2
-1 octet, eliminat superflu \
-4 octeți prin ecou odată. Am uitat că trebuia să trec șirul în funcție, deci acesta este mai mulți octeți
Funcționează și pentru n = 0.
Comentarii
- Deoarece declarația funcției este destul de costisitoare și utilizați t () doar de două ori, ar fi mai scurt fără ea . Dacă pe lângă cele 9 notificări primiți și 1 avertisment, puteți elimina ghilimelele din jurul
'v'
dinecho
final. - Puteți utiliza o buclă unică pentru părțile oblice superioare și inferioare. Inițializarea $ a și $ i ar putea fi compactată mutându-le la prima utilizare.
- Oh, și
$i>0
și$m>0
poate fi scris simplu ca$i
și$m
. - Cu spații finale , ca și în alte soluții.
- De asemenea, puteți muta declarația de $ c la prima sa utilizare. Trebuie doar să schimbați
.
concatenarea după aceasta în,
. Încercați online!
Răspuns
Python 3 , 321 307 octeți
Mulțumim lui @EsolangingFruit pentru salvarea a 14 octeți
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 octeți
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)
Comentarii
- Puteți înlocui
'\\','/'
pe a doua linie cu*'\/'
pentru a salva trei octeți. - 307 octeți: Încercați online!
- Vă mulțumim! @EsolangingFruit! Nu eram conștient de operațiile de biți din Python. De asemenea, ar economisi câțiva octeți pentru a utiliza Python2 datorită diviziunii și parantezelor din
print
- În Python 2,
input()
automateval()
este șirul, astfel încât să puteți sări peste apelulint()
. - Pentru Python 3, puteți schimba ultima linie la
for l in L:print(*l,sep="")
(nu cred că ‘ cred că există un echivalent în Python 2).
Λ