Charcoal , 58 53 47 43 41 bytes

Ｎθ≔⊕⊗θδ↗θ/⊗θ↘δ^‖Ｂ↓‖Ｍ← vＭδ⁰⊗θ↗⊕θＭ⁰δ↗θ/⊗θ⟲Ｔ 

Probeer het online !

Ik wilde gewoon een andere benadering proberen, dit tekent de buitenkant via reflecties (met dank aan Neil voor het uitbreiden van het idee) en tekent vervolgens het binnenkant. Aangezien Charcoal :Left als standaardrichting heeft om lijnen te tekenen, maak ik zoveel mogelijk gebruik van die richting om enkele bytes te besparen door de S horizontaal te tekenen, zoals hier:

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

En dan moet ik het canvas gewoon 90 graden tegen de klok in draaien.

Opmerkingen

• Misschien heb je daar iets gevonden … 22 bytes haalt je alles van buitenaf …
• @Neil het was niet ‘ t precies zo, je idee had een kleine oplossing nodig, maar dit is inderdaad een grote verbetering geweest!
• Ja, ik maakte een soortgelijke fout in mijn oorspronkelijke bericht omdat ik dat niet deed ‘ controleer het effect van correct schalen.
• Zei iemand Rotate? Dat geeft me een idee …
• @Neil hey, je hebt daar een behoorlijke verbetering! 🙂

Python 3 , 255 249 248 209 bytes

-6 bytes dankzij Kevin Cruijssen

-1 byte dankzij Kevin Cruijssen

-39 bytes dankzij Rod en 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")  

Probeer het online!

Het verwerkt nu n = 0.

Opmerkingen

• Beide o+~d kunnen m-d en kan range(m+1) zijn, en dan kun je o=m+1\n verwijderen om 6 bytes te besparen. Leuk antwoord echter, +1 van mij.
• Oh, en nog een byte door p(s)\np(s[::-1]) te veranderen in p(s+q+s[::-1]): 248 bytes
• U kunt 6 bytes besparen als u een enkele print en meer gebruikt 4 door [] te verwijderen uit join([...]), in totaal 238 bytes
• Je kunt q.join ook in een variabele opslaan om een byte op te slaan
• 217 . Heeft zich aangesloten bij alle q.join s, en een paar andere dingen

Charcoal , 47 42 41 bytes

Ｆv^«↓⊗θ↘⊗⊕θ←↓⊗θ↙⊕⊗θ↖ι↖⊕⊗θ→↑⊗θ↗⊕θＭθ⁺⊗θ⊕θ⟲⁴ 

Probeer het online! Link is een uitgebreide versie van de code.Verklaring: Tekent de volgende regels in volgorde:

 ^ / \ / \ / \ | 1 | | 1 | \ 2 / \ 2/ 8\ 2 8 \ 2 7 | 3 7 9 3 6 4 6 4 6 4 5 

Waarbij 5 het huidige teken is van de string v^. Aan het einde van de eerste lus wordt de cursor dan op punt 9 geplaatst. Het hele canvas wordt dan gedraaid zodat de andere helft van de Cool S kan worden getekend. (Het canvas wordt eigenlijk twee keer geroteerd, maar dit is slechts een implementatiedetail.)

Charcoal ondersteunt RotateCopy(:Up, 4) niet, maar als dat wel het geval was, zou dit werken voor 33 bytes:

↖^↖⊕⊗θ→↑⊗θ↗⊕θ‖ＢＭ↓↙⊗θ→↓⊗θ⟲Ｃ↑⁴Ｊ⁰¦⁰v 

Reacties

• @BetaDecay Sorry daarvoor. Ik had ook de verkeerde byte toch tellen …
• Mooi, n = 0 wordt ook goed

Canvas , 36 32 29 bytes

«|＊‼ｌ├／Ｌ１^╋；╶╵＼∔∔│α╶«├：╵╋：↔↕∔ 

Probeer het hier!

Heel veel stackmanipulatie. (Verouderde) uitleg:

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

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"])  

Probeer het online!

Dank aan Jo King voor 1 byte; en dan nog eens 5 bytes in totaal (via n => 2*n).

Werkt ook voor n=0.

C (gcc) , 379 353 344 334 bytes

Ik heb een paar #define s gebruikt voor het elimineren van subexpressies en verschillende globals om te communiceren tussen de interne functies. De hoofdlus gaat {0,1,2,3,3,2,1,0} om de S. te construeren.

Met dank aan Jonathan Frech voor de suggesties.

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

Probeer het online!

Reacties

• w -r-1 kunnen mogelijk worden gegolfd naar w~r.
• Hoewel inlining dan een byte korter is .
• 344 bytes .
• 321 bytes

C (gcc) , 260 254 bytes

-6 bytes dankzij 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);}  

Probeer het online!

Rundown

We kunnen de vorm verdelen in delen:

  ^ Top cap / \ Top slope ||| Sides \\/ Twist, part 1 /\\ Twist, part 2 ||| Sides \ / Bottom slope v Bottom cap  

Elk deel kan worden beschreven door een aantal regels, drie tekens en drie relaties met bepaalde waarden die de veldbreedte op elke regel bepalen.

Een eerste iteratie kwam te zijn:

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

De aanroepen van de g() macro lijkt heel erg op een tabel die kan worden geconstrueerd en doorlopen. Veldbreedtes zijn soms gerelateerd aan de indexteller, en soms niet. We kunnen de veldbreedte generaliseren naar F * i + A, waarbij F een factor is om i mee te vermenigvuldigen, en A een waarde is om toe te voegen naar de breedte. Dus de laatste breedte van de vierde aanroep hierboven zou bijvoorbeeld -2 * i + t zijn.

Zo krijgen we:

 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.  

Uiteindelijk was het niet veel korter dan een aangescherpte versie van de g() één aanroepen, maar korter is korter.

Reacties

• @ceilingcat Proost.
• @ceilingcat De ongedefinieerde evaluatievolgorde van de functie argumenten geven me een pauze.

Java, 435 bytes

De functie zelf duurt 435 bytes. Er is zeker ruimte voor verbetering, “hoog niveau” door de regels te analyseren over waar welk teken moet worden geplaatst (uiteindelijk is de S puntsymmetrisch), en “laag niveau”, door klassiek golfen (misschien een andere variabele of door twee van de for -loops te combineren). Maar het is “een eerste opname met deze nogal onfrisse taal:

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

Reacties

• Hallo. Imports maken deel uit van het aantal bytes dat ik ‘ m vrees, dus uw huidige antwoord is eigenlijk 478 bytes . U kan het echter naar (toevallig genoeg) uw huidige 435 bytes golfen met enkele basiszaken om te golfen.
• Ik heb wat meer kunnen golfen naar 405 bytes door een aantal variabelen te verwijderen en t=... iets minder waar het bytes zou besparen. Laat het me weten als u vragen heeft over een van de wijzigingen die ik heb aangebracht. 🙂
• Bedankt @KevinCruijssen, helaas kan ik hier momenteel niet meer tijd in investeren – dit was gewoon een recreatieve aangelegenheid, en gezien de ” breedsprakigheid ” van Java, hoe dan ook geen serieuze concurrent 😉 Overweeg om uw oplossing als een eigen antwoord toe te voegen, maar – dan hebben we in ieder geval wat intra-taal concurrentie: -)

PHP , 378 374 378 377 376 335 331 328 bytes

-3 bytes, dankzij manatwork

-4 bytes, gebruikte str_pad in plaats van str_repeat

-41 bytes, dankzij manatworks “suggesties

-1 byte, twee verhogingen samengevoegd tot een + = 2

-1 byte, overtollige verwijderd \

-4 bytes door te echoën een keer. Vergat dat ik de string in de functie moest doorgeven, dus dit zijn meer bytes

Werkt ook voor n = 0.

Probeer het online!

Reacties

• Aangezien functieverklaring vrij duur is en u t () slechts twee keer gebruikt, zou zonder deze functie korter zijn . Als u naast de 9 mededelingen ook 1 waarschuwing accepteert, kunt u de aanhalingstekens rond 'v' in de laatste echo verwijderen.
• U kunt een enkele lus gebruiken voor de schuine boven- en onderkant. De initialisatie van $ a en $ i kan worden gecomprimeerd door ze bij het eerste gebruik te verplaatsen.
• Oh, en $i>0 en $m>0 kan eenvoudig worden geschreven als $i en $m.
• Met spaties aan het einde , zoals in sommige andere oplossingen.
• U kunt de declaratie van $ c ook naar het eerste gebruik verplaatsen. Verander gewoon de . aaneenschakeling erna in ,. Probeer het online!

Python 3 , 321 307 bytes

Met dank aan @EsolangingFruit voor het besparen van 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))  

Probeer het online!

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)  

Probeer het online!

Reacties

• Je kunt '\\','/' op de tweede regel vervangen door *'\/' om drie bytes te besparen.
• 307 bytes: Probeer het online!
• Bedankt! @EsolangingFruit! Ik was niet op de hoogte van bit-bewerkingen in Python. Het zou ook een paar bytes besparen om Python2 te gebruiken vanwege de deling en haakjes in print
• In Python 2, input() automatisch eval() s de string, dus je kunt ook de int() aanroep overslaan.
• Voor Python 3, kun je de laatste regel wijzigen in for l in L:print(*l,sep="") (ik denk niet dat ‘ er een equivalent in Python 2 is).