Wprowadzenie

Wszyscy znamy fajne S (znane również jako Superman S, Stüssy S, Super S, Skater S, Pointy S, Graffiti S itp.): Miliardy uczniów na całym świecie narysowało to S i natychmiast poczuli się dumni z siebie. W przypadku, gdy zapomniałeś lub miałeś zupełnie niechlujne dzieciństwo , oto zdjęcie wspomnianego fajnego S:

Biorąc pod uwagę współczynnik skali njako dane wejściowe (gdzie ), wypisz Cool S w sztuce ASCII.$1\leq n\leq 20$

Jak to narysować

Ze strony Wikipedii w Cool S:

Wydajność

Cool S when n= 1 wynosi:

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

Dla różnych wartości npo prostu zwiększasz nczasy wyjściowe . Na przykład n= 2:

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

Zauważ, że pionowe sekcje są dwa razy dłuższe, a odstępy między pionowymi liniami są dwa razy szersze.

A kiedy n= 3:

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

Uwaga: Chociaż nie jest to wymagane, Twój kod może również obsługiwaćn= 0:

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

Zwycięski

Najkrótszy program w bajtach wygrywa.

Węgiel , 58 53 47 43 41 bajtów

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

Wypróbuj online!

Chciałem tylko wypróbować inne podejście, które rysuje na zewnątrz poprzez refleksje (dzięki Neilowi ​​za rozwinięcie pomysłu), a następnie rysuje wnętrze. Ponieważ węgiel drzewny ma :Leftdomyślny kierunek rysowania linii, korzystam z niego w jak największym stopniu, aby zaoszczędzić niektóre bajty, rysując literę S poziomo, jak poniżej:

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

A potem muszę obrócić płótno o 90 stopni w kierunku przeciwnym do ruchu wskazówek zegara.

Python 3 , 255 249 248 209 bajtów

-6 bajtów dzięki Kevin Cruijssen

-1 bajt dzięki Kevin Cruijssen

-39 bajtów dzięki 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')

Wypróbuj online!

Teraz obsługuje n = 0.

Węgiel drzewny , 47 42 41 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Objaśnienie: Rysuje następujące linie w kolejności:

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

Gdzie 5jest bieżący znak ciągu v^. Na końcu pierwszej pętli kursor jest następnie ustawiany w punkcie 9. Całe płótno jest następnie obracane, aby można było narysować drugą połowę Cool S. (Płótno faktycznie obraca się dwukrotnie, ale jest to tylko szczegół implementacji.)

Węgiel drzewny nie obsługuje, RotateCopy(:Up, 4)ale gdyby tak się stało, działałoby to dla 33 bajtów:

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

Płótno , 36 32 29 bajtów

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

Wypróbuj tutaj!

Dużo manipulacji na stosie. (nieaktualne) wyjaśnienie:

«|*                                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 bajtów

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

Wypróbuj online!

Dziękuje Jo King za 1 bajt; a następnie kolejne 5 bajtów (via n => 2*n).

Działa n=0również dla.

C (gcc) , 379 353 344 334 bajty

Użyłem kilku #defines do eliminacji podwyrażeń i kilku globałów do komunikacji między funkcjami wewnętrznymi. Główna pętla idzie {0,1,2,3,3,2,1,0} do budowy S.

Podziękowania dla Jonathana Frecha za sugestie.

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

Wypróbuj online!

C (gcc) , 260 254 bajtów

-6 bajtów dzięki pułapkowi cat .

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

Wypróbuj online!

Zniszczony

Możemy podzielić kształt na części:

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

Każda część może być opisana liczbą wierszy, trzema znakami i trzema relacjami do pewnych wartości, które decydują o szerokości pola w każdej linii.

Pierwszą iteracją stało się:

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

Wywołania g()makra wyglądają bardzo podobnie do tabeli, którą można zbudować i zapętlić. Szerokości pól są czasami powiązane z licznikiem indeksu, a czasem nie. Możemy uogólnić szerokość pola, która ma być F * i + A, gdzie F jest czynnikiem, który należy pomnożyć i, a A jest wartością dodaną do szerokości. Tak więc na przykład ostatnia szerokość czwartego wywołania powyżej -2 * i + t.

W ten sposób otrzymujemy:

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.

Ostatecznie nie był on znacznie krótszy niż zaostrzona wersja g()dzwoniącego, ale krótszy jest krótszy.

Java, 435 bajtów

Sama funkcja zajmuje 435 bajtów. Z pewnością jest miejsce na ulepszenia, „wysoki poziom” poprzez analizę zasad dotyczących miejsca, w którym należy umieścić postać (na końcu S jest symetryczny), a „niski poziom”, poprzez klasyczne gry w golfa (być może wyciągnięcie innej zmiennej lub łączenie dwóch forpętli). Ale to pierwszy strzał z tym raczej nieżyczliwym językiem:

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 bajtów

-3 bajty, dzięki manatwork

-4 bajty, użyty str_pad zamiast str_repeat

-41 bajtów, dzięki sugestiom manatworks

-1 bajt, połączył dwa przyrosty w + = 2

-1 bajt, usunięto zbędne \

-4 bajty przez powtórzenie echa. Zapomniałem, że muszę przekazać ciąg do funkcji, więc jest to więcej bajtów

Działa również dla 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;

Wypróbuj online!

Python 3 , 321 307 bajtów

Dzięki @EsolangingFruit za zapisanie 14 bajtów

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

Wypróbuj online!

Python 2 , 303 bajty

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)

Wypróbuj online!