Giới thiệu

Chúng ta đều biết S tuyệt vời (còn được gọi là Superman S, Stüssy S, Super S, Skater S, Pointy S, Graffiti S, v.v.): hàng tỷ học sinh trên khắp thế giới đã vẽ S này và ngay lập tức cảm thấy tự hào về bản thân. Trong trường hợp bạn đã quên hoặc có một tuổi thơ hoàn toàn không đẹp , đây là hình ảnh của S tuyệt vời nói:

Cho một yếu tố quy mô nnhư là đầu vào (trong đó ), sản lượng Cool S trong nghệ thuật ASCII.$1\leq n\leq 20$

Làm thế nào để vẽ nó

Từ trang Wikipedia trên Cool S:

Đầu ra

Cool S khi n= 1 là:

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

Và đối với các giá trị khác nhau n, bạn chỉ cần làm cho nthời gian đầu ra lớn hơn. Ví dụ: n= 2:

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

Lưu ý rằng các phần dọc dài hơn hai lần và khoảng cách giữa các dòng dọc rộng hơn hai lần.

Và khi n= 3:

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

Lưu ý: Mặc dù không bắt buộc, mã của bạn cũng có thể hỗ trợn= 0:

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

Chiến thắng

Chương trình ngắn nhất tính bằng byte thắng.

Than , 58 53 47 43 41 byte

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

Hãy thử trực tuyến!

Tôi chỉ muốn thử một cách tiếp cận khác, điều này vẽ ra bên ngoài thông qua sự phản chiếu (cảm ơn Neil vì đã mở rộng ý tưởng) và sau đó vẽ phần bên trong. Vì Char than có :Lefthướng mặc định để vẽ các đường, tôi sử dụng hướng đó càng nhiều càng tốt để lưu một số byte bằng cách vẽ S theo chiều ngang, như sau:

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

Và sau đó tôi chỉ cần xoay tấm vải 90 độ ngược chiều kim đồng hồ.

Python 3 , 255 249 248 209 byte

-6 byte nhờ Kevin Cruijssen

-1 byte nhờ Kevin Cruijssen

-39 byte nhờ Rod và 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')

Hãy thử trực tuyến!

Bây giờ nó xử lý n = 0.

Than , 47 42 41 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải thích: Vẽ các dòng sau theo thứ tự:

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

Đâu 5là ký tự hiện tại của chuỗi v^. Ở cuối vòng lặp đầu tiên, con trỏ sẽ được định vị tại điểm 9. Toàn bộ khung vẽ sau đó được xoay để nửa kia của Cool S có thể được vẽ. (Canvas thực sự được xoay hai lần, nhưng đây chỉ là một chi tiết triển khai.)

Than không hỗ trợ RotateCopy(:Up, 4)nhưng nếu có thì nó sẽ hoạt động với 33 byte:

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

Canvas , 36 32 29 byte

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

Hãy thử nó ở đây!

Toàn bộ rất nhiều thao tác ngăn xếp. (lỗi thời) giải thích:

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

Hãy thử trực tuyến!

Thks để Jo King cho 1 byte; và sau đó tổng cộng 5 byte (thông qua n => 2*n).

Làm việc cho n=0là tốt.

C (gcc) , 379 353 344 334 byte

Tôi đã sử dụng một vài #defines để loại bỏ subexpression và một số toàn cầu để liên lạc giữa các chức năng nội bộ. Vòng lặp chính đi {0,1,2,3,3,2,1,0} để xây dựng S.

Cảm ơn Jonathan Frech cho những lời đề nghị.

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

Hãy thử trực tuyến!

C (gcc) , 260 254 byte

-6 byte nhờ vào trần nhà .

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

Hãy thử trực tuyến!

Chạy xuống

Chúng ta có thể chia hình dạng thành các phần:

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

Mỗi phần có thể được mô tả bằng một số dòng, ba ký tự và ba mối quan hệ với các giá trị nhất định quyết định độ rộng trường tại mỗi dòng.

Một lần lặp đầu tiên đã đến:

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

Các cuộc gọi đến g()macro trông rất giống một bảng có thể được xây dựng và lặp lại. Độ rộng trường đôi khi có liên quan đến bộ đếm chỉ mục và đôi khi không. Chúng ta có thể khái quát độ rộng trường thành F * i + A, trong đó F là một số yếu tố để nhân ivới và A là một số giá trị để thêm vào chiều rộng. Vì vậy, chiều rộng cuối cùng của cuộc gọi thứ tư ở trên sẽ là -2 * i + t, ví dụ.

Vì vậy, chúng tôi nhận được:

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.

Cuối cùng, nó không ngắn hơn nhiều so với phiên bản thắt chặt của g()cuộc gọi, nhưng ngắn hơn thì ngắn hơn.

Java, 435 byte

Các chức năng chính nó mất 435 byte. Chắc chắn có chỗ để cải thiện, "cấp độ cao" bằng cách phân tích các quy tắc về nơi đặt nhân vật (cuối cùng là S đối xứng điểm) và "cấp thấp", bằng cách chơi golf cổ điển (có thể rút ra một biến khác hoặc kết hợp hai trong số các for-loops). Nhưng đó là phát súng đầu tiên với ngôn ngữ khá vô văn hóa này:

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, nhờ thao tác

-4 byte, được sử dụng str_pad thay vì str numpeat

-41 byte, nhờ các đề xuất của manatworks

-1 byte, đã hợp nhất hai số gia thành + = 2

-1 byte, loại bỏ không cần thiết \

-4 byte bằng cách lặp lại một lần. Quên tôi cần chuyển chuỗi vào hàm để đây là nhiều byte hơn

Hoạt động với n = 0 là tốt.

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;

Hãy thử trực tuyến!

Python 3 , 321 307 byte

Cảm ơn @EsolangingFnut đã lưu 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))

Hãy thử trực tuyến!

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)

Hãy thử trực tuyến!