Einführung

Wir alle kennen das coole S (auch bekannt als Superman S, Stüssy S, Super S, Skater S, Pointy S, Graffiti S usw. usw.): Milliarden von Schulkindern auf der ganzen Welt haben dieses S gezeichnet und fühlten sich sofort stolz auf sich. Für den Fall, dass Sie Ihre Kindheit vergessen haben oder eine völlig unkühle hatten , hier ein Bild von diesem coolen S:

Geben Sie bei einem Skalierungsfaktor nals Eingabe (mit ) das Cool S in ASCII-Grafik aus.$1\leq n\leq 20$

Wie zeichnet man es

Auf der Wikipedia-Seite zum Cool S:

Ausgabe

Das Cool S wenn n= 1 ist:

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

Und für verschiedene Werte von nmachst du einfach die Ausgabezeiten ngrößer. Zum Beispiel n= 2:

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

Beachten Sie, dass die vertikalen Abschnitte zweimal länger sind und der Abstand zwischen den vertikalen Linien zweimal größer ist.

Und wann n= 3:

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

Hinweis: Obwohl nicht erforderlich, unterstützt Ihr Code möglicherweise auchn= 0:

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

Gewinnen

Das kürzeste Programm in Bytes gewinnt.

Charcoal , 58 53 47 43 41 Bytes

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

Probieren Sie es online!

Ich wollte nur einen anderen Ansatz ausprobieren, dies zeichnet das Äußere über Reflexionen (danke an Neil für die Erweiterung der Idee) und zeichnet dann den inneren Teil. Da Charcoal die :LeftStandardrichtung zum Zeichnen von Linien hat, nutze ich diese Richtung so weit wie möglich, um einige Bytes zu sparen, indem ich das S horizontal zeichne, wie folgt:

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

Und dann muss ich nur die Leinwand um 90 Grad gegen den Uhrzeigersinn drehen.

Python 3 , 255 249 248 209 Bytes

-6 Bytes dank Kevin Cruijssen

-1 Byte dank Kevin Cruijssen

-39 Bytes dank Rod und 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')

Probieren Sie es online!

Es behandelt jetzt n = 0.

Charcoal , 47 42 41 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung: Zeichnet die folgenden Linien in der angegebenen Reihenfolge:

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

Wo 5ist das aktuelle Zeichen der Zeichenfolge v^. Am Ende der ersten Schleife befindet sich der Cursor dann an einem Punkt 9. Die gesamte Leinwand wird dann gedreht, so dass die andere Hälfte des Cool S gezeichnet werden kann. (Die Zeichenfläche wird tatsächlich zweimal gedreht, dies ist jedoch nur ein Implementierungsdetail.)

Charcoal unterstützt dies nicht, RotateCopy(:Up, 4)aber wenn dies der Fall wäre, würde dies für 33 Bytes funktionieren:

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

Canvas , 36 32 29 Bytes

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

Probieren Sie es hier aus!

Eine ganze Menge Stack-Manipulation. (veraltete) Erklärung:

«|*                                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'])

Probieren Sie es online!

Danke an Jo King für 1 Byte; und dann noch 5 Bytes insgesamt (über n => 2*n).

Funktioniert auch für n=0.

C (gcc) , 379 353 344 334 Bytes

Ich habe ein paar #defines zur Eliminierung von Unterausdrücken und mehrere globale Zeichen verwendet, um zwischen den internen Funktionen zu kommunizieren. Die Hauptschleife geht {0,1,2,3,3,2,1,0}, um das S zu konstruieren.

Vielen Dank an Jonathan Frech für die Vorschläge.

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

Probieren Sie es online!

C (GCC) , 260 254 Byte

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

Probieren Sie es online!

Heruntergewirtschaftet

Wir können die Form in Teile teilen:

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

Jeder Teil könnte durch eine Anzahl von Zeilen, drei Zeichen und drei Beziehungen zu bestimmten Werten beschrieben werden, die die Feldbreite bei jeder Zeile bestimmen.

Eine erste Iteration war:

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

Die Aufrufe des g()Makros sehen in etwa so aus, als ob eine Tabelle erstellt und durchlaufen werden könnte. Feldbreiten beziehen sich manchmal auf den Indexzähler und manchmal nicht. Wir können die Feldbreite verallgemeinern F * i + A, wobei F ein Faktor ist, imit dem multipliziert werden soll, und A ein Wert ist, der der Breite hinzugefügt werden soll. So wäre -2 * i + tzum Beispiel die letzte Breite des vierten Aufrufs oben .

So erhalten wir:

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.

Am Ende war es nicht viel kürzer als eine verschärfte Version der g()aufrufenden, aber kürzer ist kürzer.

Java, 435 Bytes

Die Funktion selbst benötigt 435 Bytes. Es gibt sicherlich Raum für Verbesserungen, "hohes Niveau" durch Analyse der Regeln, wo welcher Charakter zu platzieren ist (am Ende ist das S punktsymmetrisch), und "niedriges Niveau" durch klassisches Golfen (vielleicht eine andere Variable herausziehen oder) Kombination von zwei forSchleifen). Aber es ist ein erster Schuss mit dieser eher ungolfischen Sprache:

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

PHP , 378 374 378 377 376 335 331 328 Bytes

-3 Bytes dank manatwork

-4 Bytes, verwendet str_pad anstelle von str_repeat

-41 Bytes, dank manatworks 'Vorschlägen

-1 Byte, zwei Inkremente zu einem + = 2 zusammengeführt

-1 Byte, überflüssiges \ entfernt

-4 Bytes durch einmaliges Echo. Ich habe vergessen, dass ich den String an die Funktion übergeben musste, damit dies mehr Bytes sind

Funktioniert auch für n = 0.

function s($b){return str_pad($w,$b);}echo s($i=1+$a=2*$argv[1]).'^
';for(;$i;$j++,$y=$z.$y)echo$z=s(--$i).'/'.s(++$j).'\
';for(;$k<$a;$k++)$x.='|'.s($a).'|'.s($a).'|
';echo$x;for(;$l<=$a/2;)echo s($m++).$c='\\',s($a).$c.s($a-$l++*2).'/
';for(;$m;$n+=2)echo s(--$m).'/'.s($n).$c.s($a).'\
';echo$x.strtr($y,'/\\','\/').s($a+1).v;

Probieren Sie es online!

Python 3 , 321 307 Bytes

Vielen Dank an @EsolangingFruit für die Einsparung von 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))

Probieren Sie es 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)

Probieren Sie es online!