pengantar

Kita semua tahu S keren (juga dikenal sebagai Superman S, Stüssy S, Super S, Skater S, Pointy S, Graffiti S dll.): Miliaran anak sekolah di seluruh dunia menggambar S ini dan langsung merasa bangga dengan diri mereka sendiri. Jika Anda lupa atau memiliki masa kanak-kanak yang benar - benar tidak keren , berikut adalah gambar dari kata S cool:

Diberikan faktor skala nsebagai input (di mana ), mengeluarkan Cool S dalam bidang ASCII.$1\leq n\leq 20$

Cara Menggambarnya

Dari halaman Wikipedia di Cool S:

Keluaran

Cool S saat n= 1 adalah:

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

Dan untuk nilai yang berbeda n, Anda cukup membuat output nkali lebih besar. Misalnya, n= 2:

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

Perhatikan bahwa bagian vertikal dua kali lebih panjang dan jarak antara garis vertikal dua kali lebih lebar.

Dan kapan n= 3:

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

Catatan: Meskipun tidak diperlukan, kode Anda mungkin juga dapat mendukungn= 0:

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

Kemenangan

Program terpendek dalam byte menang.

Arang , 58 53 47 43 41 byte

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

Cobalah online!

Saya hanya ingin mencoba pendekatan lain, ini menarik luar melalui refleksi (terima kasih kepada Neil untuk memperluas ide) dan kemudian menggambar bagian dalam. Karena Arang memiliki :Leftarah default untuk menggambar garis, saya menggunakan arah itu sebanyak mungkin untuk menghemat beberapa byte dengan menggambar S secara horizontal, seperti ini:

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

Dan kemudian saya hanya perlu memutar kanvas 90 derajat berlawanan arah jarum jam.

Python 3 , 255 249 248 209 byte

-6 byte terima kasih kepada Kevin Cruijssen

-1 byte terima kasih kepada Kevin Cruijssen

-39 byte terima kasih kepada Rod dan 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')

Cobalah online!

Sekarang menangani n = 0.

Arang , 47 42 41 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan: Gambarlah garis berikut secara berurutan:

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

Di mana 5karakter string saat ini v^. Di akhir loop pertama kursor kemudian diposisikan di titik 9. Seluruh kanvas kemudian diputar sehingga bagian lain dari Cool S dapat ditarik. (Kanvas sebenarnya diputar dua kali, tetapi ini hanyalah detail implementasi.)

Arang tidak mendukung RotateCopy(:Up, 4)tetapi jika berhasil maka ini akan bekerja selama 33 byte:

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

Kanvas , 36 32 29 byte

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

Coba di sini!

Banyak manipulasi tumpukan. Penjelasan (kedaluwarsa):

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

Cobalah online!

Thks to Jo King untuk 1 byte; dan kemudian total 5 byte lainnya (via n => 2*n).

Berfungsi untuk n=0juga.

C (gcc) , 379 353 344 334 byte

Saya menggunakan beberapa #defines untuk menghilangkan subekspresi dan beberapa global untuk berkomunikasi antara fungsi internal. Loop utama berjalan {0,1,2,3,3,2,1,0} untuk membangun S.

Terima kasih kepada Jonathan Frech untuk sarannya.

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

Cobalah online!

C (gcc) , 260 254 byte

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

Cobalah online!

Kehabisan

Kita dapat membagi bentuk menjadi beberapa bagian:

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

Setiap bagian dapat dijelaskan oleh sejumlah garis, tiga karakter, dan tiga hubungan dengan nilai-nilai tertentu yang menentukan lebar bidang di setiap baris.

Iterasi pertama muncul menjadi:

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

Panggilan ke g()makro terlihat sangat mirip sebuah tabel yang dapat dibangun dan dilingkarkan. Lebar bidang terkadang terkait dengan penghitung indeks, dan terkadang tidak. Kita dapat menggeneralisasi lebar bidang menjadi F * i + A, di mana F adalah beberapa faktor untuk dikalikan idengan, dan A adalah beberapa nilai untuk ditambahkan ke lebar. Jadi lebar terakhir dari panggilan keempat di atas adalah -2 * i + t, misalnya.

Demikian kita dapatkan:

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.

Pada akhirnya itu tidak jauh lebih pendek dari versi yang diperketat dari g()panggilan, tetapi lebih pendek lebih pendek.

Java, 435 byte

Fungsi itu sendiri membutuhkan 435 byte. Tentu saja ada ruang untuk perbaikan, "tingkat tinggi" dengan menganalisis aturan tentang di mana menempatkan karakter mana (pada akhirnya S adalah titik-simetris), dan "tingkat rendah", dengan bermain golf klasik (mungkin mengeluarkan variabel lain atau menggabungkan dua dari - forloop). Tapi ini adalah bidikan pertama dengan bahasa yang agak tidak menarik ini:

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 byte

-3 byte, terima kasih untuk manatwork

-4 byte, menggunakan str_pad bukan str_repeat

-41 byte, terima kasih atas saran manatworks

-1 byte, menggabungkan dua peningkatan menjadi + = 2

-1 byte, dihapus berlebihan \

-4 byte dengan menggema sekali.Lupa saya harus meneruskan string ke fungsi jadi ini lebih banyak byte

Berfungsi untuk n = 0 juga.

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;

Cobalah online!

Python 3 , 321 307 byte

Terima kasih kepada @EsolangingFruit karena telah menghemat 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))

Cobalah online!

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)

Cobalah online!