Bắt đầu với /\bạn có thể tạo một mô hình tam giác Sierpinki bằng cách thêm một dòng bên dưới sao cho ...

1. Bất kỳ nhánh lỏng lẻo /hoặc \chia lại thành hai nhánh : /\.
2. Bất kỳ sự va chạm của các nhánh \/chết không có gì (nhưng không gian) dưới nó.

Lặp lại các quy tắc này mang lại

     /\
    /\/\
   /\  /\
  /\/\/\/\
 /\      /\
/\/\    /\/\
etc...

( Cảm hứng của ViHart )

Viết chương trình hoặc hàm lấy số nguyên dương N và in N dòng đầu tiên của mẫu này ra thiết bị xuất chuẩn, không có khoảng trắng ở đầu hoặc cuối hơn mức cần thiết.

Ví dụ, nếu đầu vào là 1đầu ra phải

/\

Nếu đầu vào là 2đầu ra phải

 /\
/\/\

Nếu đầu vào là 8đầu ra phải

       /\
      /\/\
     /\  /\
    /\/\/\/\
   /\      /\
  /\/\    /\/\
 /\  /\  /\  /\
/\/\/\/\/\/\/\/\

Và như vậy.

Mã có ít byte nhất sẽ thắng.

GolfScript (42 byte)

~,-1%1\{' '*\.2base{'  /\\'2/=}%n@.2*^}/;;

Bản demo trực tuyến

Điều này khai thác mối quan hệ nổi tiếng giữa tam giác Pascal và tam giác Sierpinki.

CJam, 48 46 byte

li(_S*"/\\":T+\{_N@S+TW%/S2**" /"/"\ "f/:+T*}*

Phương pháp đệ quy đơn giản dựa trên các quan sát 1 và 2 trong câu hỏi.

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

Làm thế nào nó hoạt động

li(         " L := int(input()) - 1            ";
_S*         " A := L * ' '                     ";
"/\\":T+    " A += (T := '/\')                 ";
\{          " do L times:                      ";
  _N        "   push A, '\n'                   ";
  @S+       "   A += ' '                       ";
  TW%/      "   B := A.split(reverse(T))       ";
  S2**      "   A := '  '.join(B)              ";
  " /"/     "   B := A.split(' /')             ";
  "\ "f/    "   C := { X.split('\ ') : X ∊ B } ";
  :+T*      "   A := T.join(sum(C, []))        ";
}*          "                                  ";

CJam, 51 byte

li__2mL,1a\{2_@##)1$f*+}/<f{2b_"  /\\"2/f=@@,-S*\N}

Tôi thích cách tiếp cận này tốt hơn, nhưng nó không thể cạnh tranh với phương pháp đệ quy. Ngay cả sau khi loại bỏ 2mL(dẫn đến ít nhất thời gian thực hiện O (2 ⁿ )), tôi vẫn ở mức 48 byte ...

Cách tiếp cận này mã hóa /\khoảng cách 1 và gấp đôi giữa chúng là 0. Xem xét các số nhị phân của mảng kết quả, chúng ta thấy rằng cấu hình của hàng thứ n tương ứng với số nguyên thứ n lớn hơn 1 có thể được biểu thị dưới dạng một sản phẩm của các số Fermat khác nhau (số nguyên có dạng 2 ^{2 k} +1 ).

Làm thế nào nó hoạt động

li__2mL,1a         " push L := int(input()), L, R := range(log(L)/log(2)), A := [1] ";
\{2_@##)1$f*+}/    " for I in R: A += { a × 2**(2**I) : a ∊ A }                     ";
<                  " A := A[:L]                                                     ";
f{                 " for I in R: push L, I                                          ";
  2b_"  /\\"2/     "   push (B := base(I, 2)), B, S := [ '  ' '/\' ]                ";
  f=               "   for J in I: J := S[J]                                        ";
  @@,-S*\N         "   push (L - len(B)) * ' ', J, '\n'                             ";
}                  "                                                                ";

Con trăn 2 - 140 139 127 122 121 118 116

N=input()
b,V,m,n=' V/\\'
s=b*~-N+m+n
R=str.replace
while N:print s;N-=1;s=R(R(R(R(s+b,b+m,V),n+b,V),n+m,b+b),V,m+n)

Dựa trên các thay thế chuỗi tạm thời ( /programming//a/8687380 43219103 ):

1. / > V
2. \ > V
3. \/> __(2 dấu cách)
4. V > /\

Javascript - 117 byte

Giảm thiểu:

T=n=>{S=' '.repeat(n-1);a='/\\';for(t=s=S+a+S;--n;t+='\n'+s)s=s.replace(/\\\//g,'  ').replace(/ \/|\\ /g,a);return t}

Mở rộng:

T = n => {
    S = ' '.repeat( n-1 );
    a = '/\\';
    for( t = s = S + a + S; --n; t += '\n' + s )
        s = s.replace( /\\\//g, '  ' ).replace( / \/|\\ /g, a );

    return t;
}

Đầu ra mẫu (cho n = 20):

                   /\                   
                  /\/\                  
                 /\  /\                 
                /\/\/\/\                
               /\      /\               
              /\/\    /\/\              
             /\  /\  /\  /\             
            /\/\/\/\/\/\/\/\            
           /\              /\           
          /\/\            /\/\          
         /\  /\          /\  /\         
        /\/\/\/\        /\/\/\/\        
       /\      /\      /\      /\       
      /\/\    /\/\    /\/\    /\/\      
     /\  /\  /\  /\  /\  /\  /\  /\     
    /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\    
   /\                              /\   
  /\/\                            /\/\  
 /\  /\                          /\  /\ 
/\/\/\/\                        /\/\/\/\

Bây giờ nếu chỉ tên repeatvà replacehàm không quá dài. : P

Bình thường, 45 byte

K"/\\"Jt+*QdKVQpbJ=JjKsmcd"\ "cj*2dc+Jd_K" /"

Chạy ví dụ

$ pyth -c 'K"/\\"Jt+*QdKVQpbJ=JjKsmcd"\ "cj*2dc+Jd_K" /"' <<< 16
               /\
              /\/\
             /\  /\
            /\/\/\/\
           /\      /\
          /\/\    /\/\
         /\  /\  /\  /\
        /\/\/\/\/\/\/\/\
       /\              /\
      /\/\            /\/\
     /\  /\          /\  /\
    /\/\/\/\        /\/\/\/\
   /\      /\      /\      /\
  /\/\    /\/\    /\/\    /\/\
 /\  /\  /\  /\  /\  /\  /\  /\
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\

Làm thế nào nó hoạt động

                            # Q = eval(input())
K"/\\"                      # K = "/\\"
      Jt+*QdK               # J = (Q * " " + K)[1:]
             VQ             # for N in range(Q):
               pbJ          #     print(J, end="\n")
                            #
=JjK                        #     J = K.join(
    sm                      #         sum(list(map(lambda d:
      cd"\ "                #             d.split("\ "),
            c               #                                                .split(    )
             j*2d           #              " ".join(                        )
                 c   _K     #                                .split(K[::-1])
                  +Jd       #                       (J + " ")
                       " /" #                                                       " /"
                            #     ))))

Hồng ngọc, 90

f=->n{a=["/\\".center(2*n)]
2.upto(n){a<<a[-1].gsub("\\/","  ").gsub(/ \/|\\ /,"/\\")}
puts a}

Giải trình

• Đầu vào được lấy làm đối số cho lambda. Nó được dự kiến ​​là một Integer.
• Sử dụng String#centerđể tạo ra một String "/\"với n - 2không gian ở hai bên và đặt nó vào một Array( a).
• Thêm vào aphần tử cuối cùng avới mọi lần xuất hiện "\/"thay thế " "và mọi lần xuất hiện " /"hoặc " \"thay thế bằng "/\".
• Sử dụng putsđể in từng phần tử atrên dòng riêng của nó.

Haskell, 128 112

g n=unlines$take n$i t([1..n]>>" ")%(i(\l->l++l%i(t.t)(t l>>"  ")%l)["/\\"]!!n)
t=tail
(%)=zipWith(++)
i=iterate

JavaScript (E6) 107 106

Chỉnh sửa: số byte cố định, thực hiện đệ quy.

Không khác nhiều so với câu trả lời JS khác ... ít nhất là câu này 'in' mẫu theo yêu cầu. Lõi đang thay thế '/' '\' bằng '/ \' và tất cả phần còn lại bằng '' trên mỗi dòng mới.

F=(n,o=t='/\\',b=' ')=>
  n--&&
    console.log(b.repeat(n)+o)|
    F(n,(b+o+b).replace(/../g,s=>s==b+b|s=='\\/'?b+b:t))

Kiểm tra trong bảng điều khiển FireFox / FireBug

F(15)

Đầu ra

                  /\
                 /\/\
                /\  /\
               /\/\/\/\
              /\      /\
             /\/\    /\/\
            /\  /\  /\  /\
           /\/\/\/\/\/\/\/\
          /\              /\
         /\/\            /\/\
        /\  /\          /\  /\
       /\/\/\/\        /\/\/\/\
      /\      /\      /\      /\
     /\/\    /\/\    /\/\    /\/\
    /\  /\  /\  /\  /\  /\  /\  /\

Perl 5 - 56 byte

\ 0 có thể được thay thế bằng các ký tự byte thực tế

#!/usr/bin/perl -l
$p="/\\";$_=$"x~$_.$p,y/\0/ /,print,$p^="\0\0$p"for-<>..-1

Nó đang sử dụng thực tế là nếu bạn bỏ qua các khoảng trắng hàng đầu và biểu thị '/ \' là 1 và '' là 0 mẫu trong một hàng nhất định f (n) = f (n-1) ^ (f (n-1) < <1). Tuy nhiên, các tính toán trong mã ở trên được thực hiện trên các chuỗi gần với đầu ra dự kiến ​​(không có khoảng trắng đầu, các khoảng trắng khác được thay thế bằng byte null) nhờ thao tác chuỗi bitwise của perl.

$p="/\\";          # initialize
  $_=$"x~$_.$p,    # loop start, add spaces
  y/\0/ /,         # replace nulls with spaces
  print,           # output
  $p^="\0\0$p"     # calculate next string
for-<>..-1         # loop from -n to -1

Python 2, 84 byte

n=i=input()
while i:print' '*i+''.join("/ \ "[j&i+1>0::2]for j in range(n-i+1));i-=1

Javascript với lambdas, 141 128

141

f=n=>{for(a="25",q=0;++q<n;a=a[r='replace'](/^|$/mg,1)[r](/(.*)$/,"$1\n$1")[r](/..(?=.*$)/g,x=>x%3?11:25));return a[r](/./g,x=>"  /  \\"[x])}

128

f=n=>(t=a=>--n?t(a[r='replace'](/^|$/mg,1)[r](/(.*)$/,"$1\n$1")[r](/..(?=.*$)/g,x=>x%3?11:25)):a)("25")[r](/./g,x=>"  /  \\"[x])

Có thể được kiểm tra tại Firefox (n = 16):

               /\               
              /\/\              
             /\  /\             
            /\/\/\/\            
           /\      /\           
          /\/\    /\/\          
         /\  /\  /\  /\         
        /\/\/\/\/\/\/\/\        
       /\              /\       
      /\/\            /\/\      
     /\  /\          /\  /\     
    /\/\/\/\        /\/\/\/\    
   /\      /\      /\      /\   
  /\/\    /\/\    /\/\    /\/\  
 /\  /\  /\  /\  /\  /\  /\  /\ 
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\

Python 2, 97 byte

i=input()
x=1
while i:i-=1;print " "*i+bin(x)[2:].replace("0","  ").replace("1", "/\\");x^=2*x

Toán học, 86 byte

Column[Row/@Mod[Table[Binomial[n,k],{n,0,#-1},{k,0,n}],2]/.{1->"/\\",0->"  "},Center]&