Thảm Sierpinki

23

Ai không yêu một fractal tốt? Các Sierpinski Carpet là một ví dụ điển hình của một fractal.

Để hoàn thành nhiệm vụ này, bạn sẽ được yêu cầu tạo ra một loại thảm nvà in hình ảnh kết quả đến stdout(xem ví dụ dưới đây để định dạng) n, đại diện cho thảm cấp. Các bước có thể được tìm thấy trên bài viết Wikipedia này.

Giá trị này sẽ được lấy từ stdinhoặc tương đương.

Ví dụ: đầu vào 4 sẽ tạo ra thảm cấp 4:

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■
■   ■       ■   ■ ■   ■       ■   ■ ■   ■       ■   ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■                   ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■                   ■ ■ ■       ■ ■ ■
■   ■       ■   ■                   ■   ■       ■   ■
■ ■ ■       ■ ■ ■                   ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■                   ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■
■   ■       ■   ■ ■   ■       ■   ■ ■   ■       ■   ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

Đầu vào 3 sẽ tạo ra thảm cấp 3:

■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■
■   ■       ■   ■
■ ■ ■       ■ ■ ■
■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■

Đầu vào 2 sẽ tạo ra thảm cấp 2:

■ ■ ■
■   ■ 
■ ■ ■

Và đầu vào là 1 sẽ tạo ra thảm cấp 1 (chỉ là hình vuông):

■

Lưu ý khoảng trắng giữa các cột.

Ý tưởng là sử dụng ký tự ■ cho các khối và khoảng trống cho các khoảng trống

Dòng bắt đầu bằng ký tự ■.

Như mọi khi, giải pháp nhỏ nhất sẽ thắng theo số lượng ký tự (do các ký tự không chuẩn).

Ngoài ra, # có thể được sử dụng thay cho ký tự ■ trong các ngôn ngữ không hỗ trợ Unicode.

code-golf  ascii-art  fractal 
— Paul Clavier
nguồn
1
Không phải là ví dụ đầu tiên là cấp thứ ba thay vì thứ hai?
— Trình tối ưu hóa
6
Câu hỏi hay, nhưng họ có phải là những nhân vật đó không? những thứ đó không phải là ASCII, quy định rất nhiều ngôn ngữ. Họ có thể chỉ là không gian và X hoặc O? Tôi thực sự nghĩ rằng hình ảnh của bạn sẽ đẹp hơn với không gian thay vì hình vuông trống.
— Cấp sông St
Thay đổi bọt biển để thảm, cảm ơn.
— Paul Clavier
Điều gì xảy ra nếu ngôn ngữ của bạn không hỗ trợ đầu ra unicode, đó cũng là một thay thế ASCII?
— flawr
1
Các dòng có thể có dấu cách không gian?
— Dennis

Câu trả lời:

15

CJam, 38 37 31 30 28 ký tự

Ồ, chúng tôi đang đếm theo các ký tự, vì vậy hãy giải nén Unicode:

"B胷맋풽巓뱖ᮨ㣙¬䙧੥墱륋청"2G#b129b:c~

Kiểm tra nó ở đây. Chỉ cần đặt mức mong muốn vào trường đầu vào.

Giải trình

Sau khi chuyển đổi cơ sở, đây là

3li(#,{3b1f&2b}%_f{f{&S9632c?S}N}

tương tự như sau, chỉ với ký tự Unicode được viết là 9632c:

3li(#,{3b1f&2b}%_f{f{&S'■?S}N}

Mã này dựa trên quan sát sau: nếu chúng ta nhìn vào tọa độ (x, y) của mỗi ô, thì chúng ta sẽ nhận được một ô trống, bất cứ khi nào cả x và y có 1cùng một vị trí trong biểu diễn cơ sở 3 của chúng. Nếu bạn nghĩ về nó, mẫu lặp lại quy mô nhỏ là chữ số cơ bản 3 chữ số, thì chữ số quan trọng hơn tiếp theo chi phối sự lặp lại quy mô lớn hơn tiếp theo, v.v.

3                                      "Push a 3 on the stack.";
 li(                                   "Read input, convert to integer, decrement.";
    #                                  "Raise to that power. This yields the dimensions.";
     ,                                 "Turn into a range array.";
      {       }%                       "Map the block onto the array.";
       3b                              "Convert to base 3.";
         1f&                           "Bit-wise AND each digit with 1.";
            2b                         "Convert to base 2.";
                _                      "Duplicate this list.";
                 f{          }         "Map this block onto one list, with the second list
                                        as an additional parameter.";
                   f{      }           "Map this block onto the second list, with the first
                                        list's current element as an additional parameter.";
                                       "I.e. this iterates over all coordinate pairs.";
                     &                 "Bitwise AND to check that the base-3 representations
                                        had a 1 in the same position.";
                      S'■?             "Select the right character.";
                          S            "Push a space.";
                            N          "Push a newline";

Nội dung của mảng kết quả được in tự động.

Cảm ơn Dennis vì đã cạo sạch ba byte.

— Martin Ender
nguồn
2
#0<'■S-> #~S'■lưu 1 ký tự.
— Trình tối ưu hóa
Bạn có thể thay thế [1_]a#~bằng 3Yba&.
— Dennis
@Dennis gọn gàng. cảm ơn bạn!
— Martin Ender
@Dennis Tôi cứ quên rằng &tạo ra một giá trị trung thực / giả dối (hoặc thậm chí là nó tồn tại). Có thể có giá trị một bài đăng trong các mẹo của CJam cho cách chính tắc để kiểm tra xem một mảng có chứa một số phần tử hay không.
— Martin Ender
1
@Ypnypn Không. Nó trông dài hơn nhưng đó là vì các ký tự Unicode không phải là không gian. Mã được giải nén có 30 ký tự.
— Martin Ender
7

Matlab (113) (110) (99) (85)

Bạn có thể dùng thử tại đây (Bạn sẽ phải thay thế input('')bằng đầu vào mong muốn của mình.)

Bây giờ 99 nhờ feerum! Và bây giờ xuống còn 85 nhờ RTL!

Chơi gôn 

a=ones(3);a(5)=0;c=1;for i=2:input('');c=kron(c,a);end;disp(char(kron(c,[1,0])*3+32))

Ung dung:

a=ones(3);a(5)=0;c=1;  %creating the template / anchor
for i=2:input('');
    c=kron(c,a);       %recursive iterations
end;
disp(char(kron(c,[1,0])*3+32))


d=[c,c]*0;  %this is all just for adding the additional spaces
d(:,1:2:end)=c;
disp(char(d*3+32));    %converting to spaces (32) and # (35)

Giải trình:

Tôi đang lạm dụng sản phẩm kronecker cho nhiệm vụ này. (Đây là một sản phẩm đặc biệt được xác định cho hai ma trận có kích thước tùy ý. Ví dụ:

A = [1,2] is a 3x2 matrix, B is a nxm matrix.
    [3,4]
    [5,6]

Sau đó 

kron(A,B) = [1*B , 2*B] is a 2n x 2m matrix.
            [3*B , 4*B]
            [5*B , 6*B]

Vì vậy, đây là một ví dụ cho n = 5 (Trong phương pháp đếm cũ là 4);

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   #                                                       #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   #                                                       #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # #                                                       # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   #                                                       #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # #                                                       # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   #                                                       #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   #                                                       #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
— lỗ hổng
nguồn
Cảm ơn, tôi đã không nhận thấy rằng các yêu cầu đã thay đổi. Tôi cũng đã cập nhật mã (tôi chỉ phải thay đổi giá trị bắt đầu của vòng lặp for.)
— flawr
Thay vì d=zeros(size([c,c]))bạn nên sử dụng d=[c c]*0.
— frageum
thật tuyệt, một gợi ý: biến dcó thể tránh được bằng cách lạm dụng kronmột lần nữa : disp(char(kron(c,[1,0])*3+32));,
— RTL
5

Con trăn - 100

r=range(3**~-input())
for i in r:print" ".join("# "[any(i/3**k%3==j/3**k%3==1for k in r)]for j in r)
— Wrzlprmft
nguồn
5

Perl 5: 68 ký tự

n trên stdin.

#!/usr/bin/perl -l
//,print map/2/?"  ":"■ ",map$_+$',@,for@,=grep!/[24-9]/,0..3x<>/10

Một biểu diễn ternary được mã hóa thập phân của danh sách tọa độ được tạo trước tiên trong @,(tên được chọn để không cần khoảng trắng giữa @,và for) sử dụng các chữ số 0, 1 và 3. Bây giờ thêm tọa độ x và y trong miền thập phân sẽ có 2 trong kết quả khi và chỉ khi có hai cái ở vị trí khớp nhau. //được sử dụng để truyền biến mặc định $_từ vòng lặp ngoài ( for) sang biến postmatch $'khi nó bị che bởi mapbiến mặc định trong vòng lặp bên trong.

— hạt dẻ
nguồn
4

Java, 330 283 ký tự

class T{public static void main(String[]a){int n=Integer.valueOf(a[0]);int m=(int)Math.pow(3,n-1);for(n=0;n<m;n++){for(int j=0;j<m;){String s="#";int x=n;int y=j++;while(x>0||y>0){if(x%3==1&&y%3==1){s=" ";}x/=3;y/=3;}p(s);}p("\n");}}static void p(String s){System.out.print(""+s);}}

Param là kích thước bạn muốn. Trừ khi có tối ưu hóa cho thuật toán, tôi đã cố gắng giảm bớt mọi thứ.

Nhờ @StretchManiac xóa i phương thức và dọn dẹp các khai báo giảm bớt một chút công bằng.

Mã có thể đọc được

class T {
    public static void main(String[] a) {
        int n = Integer.valueOf(a[0]);
        int m = (int) Math.pow(3, n - 1);
        for (n = 0; n < m; n++) {
            for (int j = 0; j < m;) {
                String s = "#";
                int x = n;
                int y = j++;
                while (x > 0 || y > 0) {
                    if (x % 3 == 1 && y % 3 == 1) {
                        s = " ";
                    }
                    x /= 3;
                    y /= 3;
                }
                p(s);
            }
            p("\n");
        }
    }

    static void p(String s) {
        System.out.print("" + s);
    }
}
— La bàn
nguồn
Bạn có thể thoát khỏi "công khai" trước khi đến lớp, như đối số chính bạn có thể làm String[]a, và nếu bạn chỉ sử dụng imột lần, thì tốt hơn hết bạn nên loại bỏ phương thức này.
— Căng thẳng Maniac
@StretchManiac cảm ơn vì lời khuyên. Tôi sẽ thực hiện chúng một chút.
— La bàn
3
Tại sao trên trái đất bạn làm ""+strong pphương pháp của bạn ? Đó là ba nhân vật phụ hoàn toàn không có mục đích. Ngay cả khi loại sđó là bất cứ thứ gì bên cạnh String, nó vẫn sẽ hoàn toàn không cần thiết.
— David Conrad
1
Thay đổi nó thành static void p(int s){System.out.print((char)s);}và trong thực hiện chính nó int s=35;, s=32;và p(10);(thay vì p("\n");) và tiết kiệm một vài ký tự hơn.
— David Conrad
Bạn có thể lưu bảy ký tự bằng cách thay đổi Integer.valueOfthànhnew Byte
— Ypnypn
4

Vợt 230 229 225 220

Không phải giờ tốt nhất để chơi gôn.

Chơi gôn

(define(s n)(letrec([t(λ(x y)(if(or(= x 0)(= y 0))"■"(if(=(modulo x 3)(modulo y 3)1)" "(t(floor(/ x 3))(floor(/ y 3))))))][i(expt 3(- n 1))])(for-each displayln(for/list([r i])(string-join(for/list([c i])(t r c))" ")))))

Ung dung:

(define (s n)
  (letrec ([t (λ (x y)
                (if (or (= x 0) (= y 0)) 
                    "■"
                    (if (= (modulo x 3) (modulo y 3) 1)
                        " "
                        (t (floor (/ x 3)) (floor (/ y 3))))))]
           [i (expt 3 (- n 1))])
    (for-each displayln 
              (for/list ([r i])
                (string-join 
                 (for/list ([c i]) 
                   (t r c)) " ")))))
— Matthew Bơ
nguồn
4

C: 123 118 111 104 ký tự

Dựa trên một ý tưởng tương tự như giải pháp perl của tôi. Sau khi thêm một số khoảng trắng:

m=0x55555555;
x;
main(n){
  scanf("%d",&n);
  n=1<<2*--n;
  for(x=n*n;x--;)
    printf(x&x/2&m?"":"%c%c",x&x/n&m?32:35,x&n-1?32:10);
}

Sử dụng hệ thống ternary mã hóa mỗi chữ số với 2 bit. Các giá trị bất hợp pháp (có hai giá trị ở vị trí chẵn) được lọc với x & (x>>1) & 0b01010101. Cả hai tọa độ được lưu trữ trong một giá trị, vì vậy việc kiểm tra màu pixel sẽ giảm xuống x & (x >> 2 * n) & 0b01010101.nđược lưu trữ dưới dạng lũy ​​thừa 2 để thuận tiện.

Chỉnh sửa

Thay thế definebằng một hằng số đơn giản m.

Chỉnh sửa 2

0x5555555mặt nạ có thể được đại diện với (1LL<<32)/3, nhưng chúng ta chỉ cần nnhững bit đó n/3là đủ.

x;
main(n){
  scanf("%d",&n);
  n=1<<2*--n;
  for(x=n*n;x--;)
    printf(x&x/2&n*n/3?"":"%c%c",x&x/n&n/3?32:35,x&n-1?32:10);
}

Chỉnh sửa 3

Tinh chỉnh nhỏ. Một lợi ích 2 char dựa vào scanf được thực thi trước khi tải giá trị của nviệc thực thi --n. Các eol chỉ có thể làm theo #, duh.

x;
main(n){
  n=scanf("%d",&n)<<2*--n;
  for(x=n*n;x--;)
    x&x/2&n*n/3||printf(x&x/n&n/3?"  ":x&n-1?"# ":"#\n");
}
— hạt dẻ
nguồn
3

HTML / JavaScript, 205 ký tự

Obfuscatweet , 205 Chars

document.write(unescape(escape('🁳𨱲𪑰𭀾𬰽𙰦𫡢𬱰𞰧𞱮🐴𞱭👍𨑴𪀮𬁯𭰨𜰬𫠭𜐩𞱦𫱲𚁩🐰𞱩🁭𞱩𚰫𛁤𚀧🁢𬠾𙰩𚑻𩡯𬠨𪠽𜀻𪠼𫐻𚑩𩠨𨰨𪐬𪠫𚰩𚑤𚀧𘰧𚐻𩑬𬱥𘁤𚁳𚑽𩡵𫡣𭁩𫱮𘁣𚁸𛁹𚑻𭱨𪑬𩐨𮁼𯁹𚑻𪑦𚁸𙐳🐽𜐦𙡹𙐳🐽𜐩𬡥𭁵𬡮𘀰𞱸👦𚁸𚐻𮐽𩠨𮐩𯑲𩑴𭑲𫠠𜑽𩡵𫡣𭁩𫱮𘁦𚁡𚑻𬡥𭁵𬡮𘁍𨑴𪀮𩡬𫱯𬠨𨐯𜰩𯑦𭑮𨱴𪑯𫠠𩀨𨐩𮱤𫱣𭑭𩑮𭀮𭱲𪑴𩐨𬰫𨐩𯐼𛱳𨱲𪑰𭀾🁳𭁹𫁥🠪𮱦𫱮𭀭𩡡𫑩𫁹𞠢𠱯𭑲𪑥𬠢').replace(/uD./g,'')))

HTML / JS, 298 ký tự

Do cách HTML chơi với khoảng trắng, một vài ký tự phải được dành riêng cho các char. Ngoài ra, phông chữ mặc định của hầu hết các trình duyệt không phải là Chuyển phát nhanh, vì vậy tôi cũng phải đặt nó thành đó. Khoảng 20 ký tự giá trị của kiểu dáng. Nếu điều này đòi hỏi một phương thức nhập trực tiếp, tôi có thể thêm nó, nhưng thay đổi đầu vào hiện đang đặt n thành một giá trị khác.

Bản giới thiệu

<script>s='&nbsp;';n=4;m=Math.pow(3,n-1);for(i=0;i<m;i++,d('<br>')){for(j=0;j<m;)if(c(i,j++))d('#');else d(s)}function c(x,y){while(x||y){if(x%3==1&&y%3==1)return 0;x=f(x);y=f(y)}return 1}function f(a){return Math.floor(a/3)}function d(a){document.write(s+a)}</script><style>*{font-family:"Courier"

HTML / JS có thể đọc được

<script>
    s='&nbsp;';
    n=4;
    m=Math.pow(3,n-1);
    for(i=0;i<m;i++,d('<br>')){
        for(j=0;j<m;)
            if(c(i,j++))
                d('#');
            else d(s)
    }
    function c(x,y){
        while(x||y){
            if(x%3==1&&y%3==1)
                return 0;
            x=f(x);
            y=f(y)
        }
        return 1
    }
    function f(a){
        return Math.floor(a/3)
    }
    function d(a){
        document.write(s+a)
        }
</script>
<style>
*{font-family:"Courier"
— La bàn
nguồn
3

CJam, 38 35 32 31 ký tự

"■ ""՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~

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

Chạy ví dụ

$ cjam <(echo '"■ ""՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~') <<< 3; echo
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■       ■ ■ ■ 
■   ■       ■   ■ 
■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■

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

"՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~

chuyển đổi chuỗi Unicode từ cơ sở 60.000 ( 6e4b) sang cơ sở 128 ( 128b), chuyển thành Ký tự ( :c) và đánh giá chuỗi kết quả (~ ).

Kết quả là đoạn mã sau được thực thi:

"■ "                                " C := '■ '                                           ";
    li(                             " J := int(input()) - 1                               ";
       {                      }*    " for I in range(J):                                  ";
        z]A*                        "   T := [zip(C)] * 10                                ";
            ):,                     "   U := pop(T)                                       ";
               Sf*                  "   V := [ ' ' * len(u) : u ∊ U ]                     ";
                  4\t               "   U[4] := V                                         ";
                     3/{:+z~}%      "   C := { c : c ∊ zip(concat(u)), u ∊ U.split(3) }   ";
                              zN*  " print '\n'.join(zip(C))                              ";
— Dennis
nguồn
3

Con trăn 3 - 116 113 ký tự

EDIT: Chà, đã sử dụng thủ thuật mà tôi không thích quá nhiều cho bản thân và nén mã 3 byte. Nếu đó là cách tốt nhất có thể, nhưng tôi sẽ làm theo.

exec(bytes('ⱴ㵬❛離₠崧氬浡摢⁡㩺癥污稨✫潦⁲湩琠❝਩潦⁲⁩湩爠湡敧椨瑮椨灮瑵⤨⴩⤱爺瀬氽✨㍛✪Ⱙ⡬嬢⭫‧✠⠪⨳椪⬩⤢琻爽瀫爫昊牯椠椠㩴牰湩⡴⥩','utf-16')[2:].decode('utf-8'))

Nó có thể chứa một số ký tự không thể in được, vì vậy đây là phiên bản có thể in của chuỗi.

'ⱴ㵬❛離₠崧氬浡摢\u2061㩺癥污稨✫\u206b潦\u2072\u206b湩琠❝\u0a29潦\u2072\u2069湩爠湡敧椨瑮椨灮瑵⤨\u2d29⤱爺瀬氽✨㍛✪Ⱙ⡬嬢\u2b6b‧✠⠪⨳椪⬩⤢琻爽瀫爫昊牯椠椠\u206e㩴牰湩⡴⥩'

Không quá tuyệt vời, nhưng ít nhất là đánh bại một số ngôn ngữ.

Những gì nó mở rộng đến:

t=['■ ']
for i in range(int(input())-1):r,p=[k*3for k in t],[k+'  '*(3**i)+k for k in t];t=r+p+r
for i in t:print(i)

Một chút vô dụng trong trường hợp ai đó không thể thấy nó hoạt động như thế nào:

t=['■ ']                                     # iteration 1
for i in range(int(input()) - 1):            # do n-1 more iterations
    r = [k * 3 for k in t]                   # first & last rows are the last carpet x3
    p = [k + '  ' * (3 ** i) + k for k in t] # middle row: last carpet, space, last carpet
    t = r + p + r                            # and put them to the new carpet
for i in t:                                  # print final iteration
    print(i)
— PurkkaKoodari
nguồn
Wow python, thật ấn tượng
— Paul Clavier
2

Bash + coreutils, 105 ký tự unicode

Vì chúng tôi đang đếm các ký tự và không phải byte:

eval `iconv -tunicode<<<潦⡲眨㌽⨪␨ⴱ⤱琬〽琻眼眪琻⬫⤩笻戠ꂖ昻牯⠨㵸╴ⱷ㵹⽴㭷㹸簰祼〾砻㴯ⰳ⽹㌽⤩笻⠠砨㌥ㄭ籼╹ⴳ⤱簩扼尽簠硼〽紻瀻楲瑮⁦␢⁢㬢⠨╴⵷⭷⤱簩敼档㭯੽|cut -b3-`

Ở dạng giải mã của nó:

Bash thuần túy, 143 byte

for((w=3**($1-1),t=0;t<w*w;t++));{
b=■
for((x=t%w,y=t/w;x>0||y>0;x/=3,y/=3));{
((x%3-1||y%3-1))||b=\ ||x=0
}
printf "$b "
((t%w-w+1))||echo
}

Đầu vào được lấy từ các đối số dòng lệnh:

Đầu ra:

$ ./sierpinskicarpet.sh 3
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■       ■ ■ ■ 
■   ■       ■   ■ 
■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
$
— Chấn thương kỹ thuật số
nguồn
2

C #

Chương trình đầy đủ - 237:

using System;class P{static void Main(string[] a){int b=(int)Math.Pow(3,int.Parse(a[0])-1),c,d,e,f;for(c=0;c<b;c++){var g="";for(d=0;d<b;){var h="■";e=c;f=d++;while(e>0|f>0){h=e%3==1&f%3==1?" ":h;e/=3;f/=3;}g+=h;}Console.WriteLine(g);}}}

LINQPad - 166 + Math.Ceiling(Math.Log(a + 1) / Math.Log(10))

int a=3;int b=(int)Math.Pow(3,a-1),c,d,e,f;for(c=0;c<b;c++){var g="";for(d=0;d<b;){var h="■";e=c;f=d++;while(e>0|f>0){h=e%3==1&f%3==1?" ":h;e/=3;f/=3;}g+=h;}g.Dump();}
— William Barbosa
nguồn
Tôi biết đã gần ba năm, nhưng bạn có thể chơi một vài thứ như thế này: using System;class P{static void Main(string[]a){string g,h;for(int b=(int)Math.Pow(3,int.Parse(a[0])-1),c=-1,d,e,f;++c<b;Console.WriteLine(g))for(g="",d=0;d<b;g+=h)for(h="■",e=c,f=d++;e>0|f>0;e/=3,f/=3)h=e%3==1&f%3==1?" ":h;}}( 229 byte / 227 ký tự ) ( ■= 3 byte, vì vậy bạn cũng có thể thay thế nó #để tiết kiệm 2 byte). Tôi chủ yếu đặt mọi thứ bên trong các vòng lặp for để không cần ngoặc nữa.
— Kevin Cruijssen
2

C - 154

Đầu vào từ stdin. Tôi đã cố gắng tìm một cách tốt để tránh một chức năng bổ sung, nhưng không thể đưa ra bất kỳ chức năng nào.

Số lượng nhân vật chỉ bao gồm các không gian cần thiết.

p(l,x,y){
    return l?x/l&y/l&1||p(l/3,x%l,y%l):0;
}
x,y;
main(v){
    scanf("%d",&v);
    v=pow(3,--v);
    for(;y<v;y++,puts(""))
        for(x=0;x<v;)
            printf("%c ",p(v,x++,y)?32:35);
}
— Tất cả
nguồn
1

PHP, 194 ký tự

Các nđối số nhận được đầu tiên trong dòng lệnh.

<?php
function d(&$a,$n,$e,$x,$y){if(--$n)for(;$i<9;)$p=pow(3,$n)|d($a,$n,$e|$i==4,$x+$p*$j,$y+$p*($i-$j)/3)|$j=++$i%3;else$a[$x][$y]=$e?" ":■;}@d($a,$argv[1]);foreach($a as$s)echo join($s),"
";

Có thể đọc được

<?php

function draw(&$array, $n, $empty, $x, $y) {
    $n--;
    if ($n != 0) {
        for ($i = 0; $i < 9; $i++) {
            $j = $i % 3;
            $p = pow(3, $n);
            draw($array, $n, $empty || $i == 4, $x + $p * $j, $y + $p * ($i - $j) / 3);
        }
    } else {
        $array[$x][$y] = $empty ? " " : "#";
    }
}

$array = array();
draw($array, $argv[1], false, 0, 0);
foreach ($array as $line) {
    echo join($line), "\n";
}
— Gedrox
nguồn
1
Nếu bạn sử dụng char ■thay vì #, bạn có thể lưu 2 ký tự bằng cách xóa dấu ngoặc kép.
— Ismael Miguel
1

Scala 230 ký tự

Mã đánh gôn:

object T extends App {def m=math.pow(3,args(0).toInt-1).toInt-1;def p=print _;val x=0 to m;x.map{n=>x.map{j=>if(q(n,j)==1)p(" #");else p("  ")};p("\n");};def q(n:Int,j:Int):Int={if(n>0|j>0)if((n%3&j%3)==1)0 else q(n/3,j/3)else 1}}

Mã bị đánh cắp:

object T extends App {
  def m = math.pow(3, args(0).toInt - 1).toInt - 1;

  def p = print _;
  val x = 0 to m;
  x.map { n => x.map { j => if (q(n, j) == 1) p(" #"); else p("  ")}; p("\n");};

  def q(n: Int, j: Int): Int = {
    if (n > 0 | j > 0) if ((n % 3 & j % 3) == 1) 0 else q(n / 3, j / 3) else 1
  }
}

Chỉ có không gian cần thiết được bao gồm.

— Toán
nguồn
1

V , 21 byte (không cạnh tranh)

é*Àñ}yPgvr PGï3pyGHP

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

Hexdump:

00000000: e92a c0f1 167d 7950 6776 7220 5047 ef33  .*...}yPgvr PG.3
00000010: 7079 4748 50                             pyGHP

V mới hơn thử thách, vì vậy nó phải được đánh dấu là không cạnh tranh. Tuy nhiên, thật tuyệt khi thấy câu trả lời này waaaaay ngắn hơn so với tất cả những người khác, ngay cả khi đếm bằng byte chứ không phải là ký tự.

— DJMcMayhem
nguồn
Chỉ là một lời nhắc nhở; nó không còn không cạnh tranh
— RedClover
1

oK, 40 byte

`0:" #"{(x-1)(,'//3 3#111101111b*9#,)/1}

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

Nó bắt đầu bằng 1, và sau đó vẽ nó trong một lưới (1 1 1;1 0 1;1 1 1), sau đó nó vẽ trong một lưới theo cùng một cách, vv lặp đi lặp lại số lần cần thiết.

— zgrep
nguồn
1

C # (.NET Core) , 162 byte

n=>{var f="";int s=(int)Math.Pow(3,n),z=0;while(z<s*s){int x=z%s,y=z/s,h=1;for(;x>0|y>0;y/=3,x/=3)if(y%3==1&x%3==1)h=0;f+=" #"[h]+(z++%s<s-1?" ":"\n");}return f;}

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

Bị khử

n=>{
    var f="";
    int s=(int)Math.Pow(3,n),z=0;

    while(z<s*s)
    {
        int x=z%s, y=z/s, h=1;
        for(; x>0 | y>0; y/=3, x/=3)
            if(y%3==1 & x%3==1)
                h=0;

        f += " #"[h] + (z++%s<s-1? " " : "\n");
    }

    return f;
}
— Ayb4btu
nguồn
0

R , 92 ký tự

94 byte với ký tự đặc biệt.

write(c(" ","■")[1+Reduce("%x%",rep(list(matrix(c(1,1,1,1,0,1),3,3)),n<-scan()-1),1)],1,3^n)

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

— Giuseppe
nguồn
Tôi chỉ ngạc nhiên khi mọi người vẫn làm điều này 4 năm sau
— Paul Clavier
1
@PaulClavier đó là một thách thức lớn; bạn nên tự hào :)
— Giuseppe
0

Canvas , 17 16 17 ký tự

■；╷［⌐ ＋２×；┌∔∔；３＊＋

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

-1: Được sử dụng ［thay vì ｛xóa cái đầu tiên ；bên trong vòng lặp.
+1: Đã sửa lỗi hành vi ảm đạm: ■hiện tương ứng với cấp 1, như được chỉ định trong bài viết gốc.

— hakr14
nguồn
Đó là cạnh tranh, theo một sự đồng thuận mới hơn.
— Erik the Outgolfer
@EriktheOutgolfer oh, cảm ơn vì đã cho tôi biết!
— hakr14
Và vâng, trong trường hợp này, điểm số là 17, nhưng chúng tôi đếm các giải pháp theo byte, không phải ký tự (Canvas có trang mã).
— Erik các Outgolfer
@EriktheOutgolfer bình thường là có, nhưng thử thách này sử dụng các ký tự, do ■là đa bào. Nói như vậy về phía dưới trong bài viết gốc.
— hakr14
Bạn cần thêm một cho tất cả các đầu vào của bạn. 1 nên trả về một hình vuông (tức là 0 trả về đây)
— Paul Clavier
0

Pip -S , 30 ký tự

"■■ "@MX{{aTB3R2i}MSg}MC3**a/3

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

Ý tưởng cơ bản: xem xét lưới tọa độ trong cơ sở 3. Các lỗ trên thảm xảy ra trong đó 1) một trit trong tọa độ x là 1và 2) trit ở cùng vị trí trong tọa độ y cũng 1.

"■■ "@MX{{aTB3R2i}MSg}MC3**a/3
                                i is 0; a is 1st cmdline arg (implicit)
                        3**a/3  Width/height of the carpet
                      MC        Make a coordinate grid that size and map this function
                                to the coordinate pairs:
                    g            Take each [x y] pair
                  MS             Map this function to each coord and add the results:
         {aTB3   }                Convert to base 3
              R2i                 Replace 2's with 0's
                                  E.g. 15 -> 120 -> 100 and 16 -> 121 -> 101
                                 When we add the results, we get [15 16] -> 201
      MX{            }           Take the max of that list (0, 1, or 2)
"■■ "@                           Use that to index into this string (resulting in a space
                                 iff two 1's coincided to make a 2, or ■ otherwise)
                                Print the resulting nested list with each sublist on its
                                own line and space-delimited (implicit, -S flag)

Giải pháp tương tự, cùng số lượng ký tự nhưng -2 byte: {2N({aTB3R2i}MSg)?s'■}MC3**a/3

— DLosc
nguồn
0

K (ngn / k) , 50 byte

cảm ơn @DLosc đã nhắc nhở tôi nên xuất khoảng trắng giữa các cột

1@"\n"/"# "1_',/'1,''+/''a*/:\:a:+2!!1_(. 0:"")#3;

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

— ngn
nguồn
@DLosc cảm ơn, đã sửa các yêu cầu lạ khác nữa: stdin / stdout thay vì arg / result; off-by-one "level"
— ngn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.