시 에르 핀 스키 카펫

23

누가 좋은 프랙탈을 좋아하지 않습니까? 시어 핀 스키 카펫은 프랙탈의 고전적인 예이다.

이 작업을 완료하려면 카펫 유형을 생성 엔하고 결과 카펫을 레벨 카펫을 나타내는 stdout(아래 예제 참조)에 인쇄해야합니다 엔. 이 Wikipedia 기사 에서 단계를 찾을 수 있습니다 .

이 값은 stdin이와 동등하거나 동일합니다.

예를 들어, 입력 4는 레벨 4 카펫을 생성합니다.

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

3을 입력하면 레벨 3 카펫이 생성됩니다.

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

2를 입력하면 레벨 2 카펫이 생성됩니다.

■ ■ ■
■   ■ 
■ ■ ■

그리고 1을 입력하면 레벨 1 카펫 (정사각형)이 생성됩니다.

■

열 사이의 공백에 유의하십시오.

아이디어는 블록에 공백을위한 공간과 문자를 사용하는 것입니다.

행은 ■ 문자로 시작합니다.

항상 그렇듯이, 가장 작은 솔루션은 문자 수 (비표준 문자로 인해)로 승리합니다.

또는 유니 코드를 지원하지 않는 언어에서 ■ 문자 대신 #을 사용할 수 있습니다.

code-golf  ascii-art  fractal 
— 폴 클라비에
소스
1
첫 번째 예제가 두 번째가 아닌 세 번째 수준이 아닙니까?
— Optimizer
6
좋은 질문이지만, 그런 캐릭터 여야합니까? 그것들은 ASCII가 아니므로 많은 언어를 배제합니다. 그들은 공간과 X 또는 O 일 수 있습니까? 실제로 빈 사각형 대신 공백으로 이미지가 더 잘 보일 것이라고 생각합니다.
— Level River St
스폰지로 카펫으로 교체했습니다.
— Paul Clavier
언어가 유니 코드 출력을 지원하지 않으면 ASCII 대안도 있습니까?
— flawr
1
줄에 후행 공백이있을 수 있습니까?
— Dennis

답변:

15

CJam, 38 37 31 30 28 자

글쎄, 우리는 문자 수를 세고 있으므로 유니 코드의 압축을 풉니 다.

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

여기에서 테스트하십시오. 원하는 레벨을 입력 필드에 넣으십시오.

설명

기본 변환 후

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

다음과 같이 유니 코드 문자가 다음과 9632c같습니다.

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

이 코드는 다음 관찰을 기반으로합니다. 각 셀 의 좌표 (x, y) 를 보면 x 와 y 가 모두 1밑이 3 인 표현에서 같은 위치에 있을 때마다 빈 셀이 나타납니다. 당신이 그것에 대해 생각하면, 소규모 반복 패턴은 3 자릿수의 중요한 숫자이며, 다음으로 큰 숫자는 다음의 큰 규모의 반복을 지배합니다.

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";

결과 배열의 내용이 자동으로 인쇄됩니다.

3 바이트를 줄여 준 Dennis에게 감사합니다.

— 마틴 엔더
소스
2
#0<'■S-> #~S'■1 문자를 저장합니다.
— Optimizer
당신은 대체 할 수 있습니다 [1_]a#~로 3Yba&.
— Dennis
트윗 담아 가기 고맙습니다!
— Martin Ender
@Dennis 나는 &진실 / 거짓 가치 를 생산 한다는 사실을 잊어 버립니다 . 배열에 일부 요소가 포함되어 있는지 여부를 테스트하는 표준 방법에 대해서는 CJam 팁에 게시 할 가치가 있습니다.
— Martin Ender
1
@Ypnypn Nope. 더 길어 보이지만 유니 코드 문자는 모노 스페이스가 아니기 때문입니다. 압축 해제 된 코드는 30 자입니다.
— Martin Ender
7

MATLAB (113) (110) (99) (85)

여기서 시도해보십시오 ( input('')원하는 입력 으로 바꿔야 합니다.)

지금 feersum 덕분에 99! RTL 덕분에 이제 85로 줄었습니다!

골프 : 

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

언 골프 드 :

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)

설명:

이 작업을 위해 크로네 커 제품을 남용하고 있습니다. (임의의 크기가 지정된 두 행렬 각각에 대해 정의 된 특수 제품입니다. 예 :

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

그때 

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

여기 n = 5에 대한 예가 있습니다 (이전 계산 방법에서는 4입니다).

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   #                                                       #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   #                                                       #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # #                                                       # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   #                                                       #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # #                                                       # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   #                                                       #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   #                                                       #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
— 플레어
소스
감사합니다. 요구 사항이 변경되었음을 알지 못했습니다. 또한 코드를 업데이트했습니다 (for 루프의 시작 값을 변경해야했습니다).
— flawr
대신 d=zeros(size([c,c]))을 사용해야합니다 d=[c c]*0.
— feersum
좋은 제안 : 변수 d는 kron한 번 더 학대함으로써 피할 수 있습니다 : disp(char(kron(c,[1,0])*3+32));,
— RTL
6

하스켈 114 108

s 1=["# "]
s n=k j++k(map(>>" ")j)++k j where j=s$n-1;k i=j%i%j
(%)=zipWith(++)
main=interact$unlines.s.read
— 자랑스런 Haskeller
소스
5

파이썬 – 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)
— rz 르프
소스
5

펄 5:68 자

stdin의 n

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

숫자 0, 1, 3을 사용하여 좌표 목록의 10 진수로 코딩 된 3 진 표현이 먼저 생성됩니다 @,(선택한 이름 @,과 사이에 공백이 필요 없음 for). 이제 10 진수 도메인에 x 및 y 좌표를 추가하면 2가됩니다. 일치하는 위치에 두 개가있는 경우에만 결과에. 내부 루프 의 기본 변수로 음영 처리 된 경우 기본 변수를 외부 루프 ( )에서 사후 일치 변수 //로 전파하는 데 사용됩니다 .$_for$'map

— nutki
소스
4

자바, 330 283 자

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은 원하는 크기입니다. 알고리즘에 대한 최적화가 없다면, 모든 것을 없애려고 노력했습니다.

@StretchManiac 덕분에 메소드를 제거하고 i선언을 정리하여 공정한 결과 를 얻었 습니다.

읽을 수있는 코드

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);
    }
}
— 나침반
소스
수업 전에 "공개"를 제거 할 수 있습니다. 주된 인수로 할 수 있습니다. 한 번만 String[]a사용 i하는 경우 메소드를 제거하는 것이 좋습니다.
— 스트레칭 미치 광
팁 주셔서 감사합니다 @StretchManiac. 나는 그것들을 약간 구현할 것이다.
— Compass
3
왜 지구상 ""+s에서 당신의 p방법으로합니까? 그것은 전혀 목적이없는 세 가지 추가 문자입니다. 의 유형이 s이외 String인 경우에도 여전히 불필요합니다.
— David Conrad
1
로 변경하고 static void p(int s){System.out.print((char)s);}메인 int s=35;에서 s=32;, 및 p(10);(대신 p("\n");)을 만들고 문자를 몇 개 더 저장하십시오.
— David Conrad
당신은 변경하여 7 자 저장할 수 Integer.valueOf에new Byte
— Ypnypn
4

라켓 230 229 225 220

라켓 최고의 골프 ​​시간이 아닙니다.

골프 :

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

언 골프 드 :

(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)) " ")))))
— 매튜 버 트릭
소스
4

C : 123118111104 자

내 펄 솔루션과 비슷한 아이디어를 기반으로합니다. 공백을 추가 한 후 :

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

각 자리를 2 비트로 코딩하는 3 진 시스템을 사용합니다. 잘못된 값 (홀수-짝수 위치에 두 값이 있음)은로 필터링됩니다 x & (x>>1) & 0b01010101. 두 좌표는 모두 하나의 값으로 저장되므로 픽셀 색상을 확인하는 단계는 x & (x >> 2 * n) & 0b01010101입니다. n편의상 2의 거듭 제곱으로 저장됩니다.

편집하다

define간단한 상수 로 대체 되었습니다 m.

편집 2

0x5555555마스크는로 표현 될 수 (1LL<<32)/3있지만 n그 비트 만 필요 하므로 n/3충분합니다.

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

편집 3

약간의 조정. n의 실행 값에 대한 로드 값 이전에 실행되는 scanf에 따라 2 개의 문자 이득 이 발생 --n합니다. eol은 #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");
}
— nutki
소스
3

HTML / 자바 스크립트, 205 자

난독 화 , 205 자

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

HTML / JS, 298 자

공백과 함께 HTML이 재생되는 방식으로 인해 몇 개의 문자가 nbsp 문자 전용이어야합니다. 또한 대부분의 브라우저의 기본 글꼴은 Courier가 아니므로 해당 글꼴도 설정해야했습니다. 약 20 자 정도의 스타일링. 직접 입력 방법이 필요한 경우 추가 할 수 있지만 현재 입력을 변경하면 n이 다른 값으로 설정됩니다.

데모

<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

<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"
— 나침반
소스
3

CJam, 38 35 32 31 자

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

온라인으로 사용해보십시오.

예제 실행

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

작동 원리

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

기본 60,000 ( 6e4b)에서 기본 128 ( 128b) 로 유니 코드 문자열을 변환하고 문자 ( :c)로 캐스트 하고 결과 문자열 ( ~)을 평가합니다 .

결과적으로 다음 코드가 실행됩니다.

"■ "                                " 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))                              ";
— 데니스
소스
3

파이썬 3 – 116 113 자

편집 : 글쎄, 내가 너무 좋아하지 않는 트릭을 사용하고 코드를 3 바이트 압축했습니다. 그것이 최선의 방법이라면 Dunno이지만, 나는 함께 갈 것입니다.

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

인쇄 할 수없는 문자가 포함되어있을 수 있으므로 인쇄 가능한 버전의 문자열이 있습니다.

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

너무 크지는 않지만 적어도 일부 언어를 능가합니다.

그것이 확장되는 것 :

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)

누군가가 그것이 어떻게 작동하는지 볼 수없는 경우를 대비하여 언 골프 :

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)
— 뿌까
소스
와우 파이썬, 그것은 인상적입니다
— Paul Clavier
2

Bash + coreutils, 유니 코드 문자 105 개

우리는 바이트가 아닌 문자를 세고 있기 때문에 :

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

디코딩 된 형태로 :

순수 배쉬, 143 바이트

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
}

입력은 명령 행 인수에서 가져옵니다.

산출:

$ ./sierpinskicarpet.sh 3
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■       ■ ■ ■ 
■   ■       ■   ■ 
■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
$
— 디지털 외상
소스
2

기음#

전체 프로그램-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();}
— 윌리엄 바르보사
소스
나는 거의 3 년이 지났 것을 알고,하지만 당신은 골프 할 수있는이 같은 몇 가지 : 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 바이트 / 227 자 ) ( ■= 3 바이트, 당신이 그것을 대체 할 수 있도록 #아니라 2 바이트를 저장). 나는 주로 for 루프 안에 모든 것을 넣었으므로 더 이상 괄호가 필요하지 않습니다.
— Kevin Cruijssen
2

C-154

stdin에서 입력 추가 기능을 피할 수있는 좋은 방법을 찾으려고했지만 아무것도 찾지 못했습니다.

문자 수에는 필요한 공백 만 포함됩니다.

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);
}
— Allbeert
소스
1

PHP, 194 자

는 n명령 행에서 첫 번째 인수로 받았다.

<?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),"
";

읽을 수있는

<?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";
}
— 게드 록스
소스
1
당신이 문자를 사용하는 경우 ■대신 #, 당신은 따옴표를 제거하여이 개 문자를 저장할 수 있습니다.
— Ismael Miguel
1

스칼라 230 자

골프 코드 :

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

Ungolfed 코드 :

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

필요한 공간 만 포함되어 있습니다.

— 매튜
소스
1

V , 21 바이트 (비경쟁)

é*Àñ}yPgvr PGï3pyGHP

온라인으로 사용해보십시오!

16 진 덤프 :

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

V는 챌린지보다 최신이므로 경쟁이 아닌 것으로 표시되어야합니다. 그러나 여전히 문자가 아닌 바이트 수로 계산 할 때도이 답변이 다른 모든 것보다 짧다는 것을 보는 것이 좋습니다.

— DJMcMayhem
소스
단지 알림입니다. 더 이상 경쟁이
— 아닙니다
1

oK, 40 바이트

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

온라인으로 사용해보십시오.

로 시작 1하여 그리드 (1 1 1;1 0 1;1 1 1)에 그린 다음 같은 방식으로 그리드에 그린 다음 필요한 횟수만큼 반복합니다.

— zgrep
소스
1

C # (. NET 코어) 162 바이트

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

온라인으로 사용해보십시오!

탈고

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;
}
— 에이브
소스
0

R , 92 자

특수 문자가있는 94 바이트

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

온라인으로 사용해보십시오!

— 주세페
소스
나는 사람들이이 4 년 후에도 여전히하고있는 것에 놀랐습니다
— Paul Clavier
1
@PaulClavier 그것은 큰 도전입니다; 당신은 자랑스러워해야합니다 :)
— Giuseppe
0

캔버스 , 17 16 17 자

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

여기 사용해보십시오!

-1 : 루프 내부의 첫 번째를 삭제하는 대신 사용 ［됩니다 . ｛；
+1 : 고정 된 잘못된 동작 : ■이제 원래 게시물에 지정된 수준 1에 해당합니다.

— hakr14
소스
그것은 되는 새로운 합의에 따라, 경쟁.
— Outgolfer Erik
@EriktheOutgolfer 아, 알려 주셔서 감사합니다!
— hakr14
그리고 예,이 경우 점수 는 17이지만 문자가 아닌 바이트 단위로 솔루션을 계산합니다 (Canvas에는 코드 페이지가 있음).
— Outgolfer Erik
@EriktheOutgolfer 일반적으로 네,하지만 이 로 인해 문제가 사용하는 문자, ■멀티 바이트 인. 원래 게시물의 맨 아래로 말합니다.
— hakr14
모든 입력에 하나를 추가해야합니다. 1은 정사각형을 반환해야합니다 (예 : 0은 여기서 반환)
— Paul Clavier
0

핍 -S , 30 자

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

온라인으로 사용해보십시오!

기본 아이디어 :베이스 3의 좌표 그리드를 고려하십시오. 카페트의 구멍은 1) x 좌표 1의 트릿 이 있고, 2) y 좌표의 동일한 위치에있는 트립도 있습니다 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)

비슷한 해결책, 문자 수는 같지만 -2 바이트 : {2N({aTB3R2i}MSg)?s'■}MC3**a/3

— DLosc
소스
0

K (ngn / k) , 50 바이트

열 사이에 공백을 출력해야한다는 것을 상기시켜 준 @DLosc에게 감사드립니다.

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

온라인으로 사용해보십시오!

— ngn
소스
@DLosc 덕분에 다른 이상한 요구 사항도 수정되었습니다. arg / result 대신 stdin / stdout; 한 단계 씩 "레벨"
— ngn
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.