ASCII에서 비트 패턴으로 프랙탈 생성


34

개요

프랙탈을 인코딩하는 비트 패턴과 프랙탈의 세대 별 스케일 팩터 및 세대 수를 고려하여 간단한 프랙탈 패턴을 인쇄하는 프로그램을 작성하십시오.

설명

다음은 Sierpinski Carpet 의 ASCII 표현입니다 .

0 세대 :

# 

1 세대

# # # 
#   # 
# # # 

2 세대

# # # # # # # # # 
#   # #   # #   # 
# # # # # # # # # 
# # #       # # # 
#   #       #   # 
# # #       # # # 
# # # # # # # # # 
#   # #   # #   # 
# # # # # # # # # 

ASCII Sierpinski Carpet의 n + 1 세대는 그리드의 중심 요소가 누락 된 8 세대 n 개의 사본을 포함하는 3x3 그리드로 구성됩니다.

따라서 3x3 그리드를 사용하여 정의되고 각 세대의 너비와 높이가 3 배 더 커지므로 스케일 팩터가 3이라고 말할 수 있습니다.

3x3 그리드의 요소에 0에서 8까지, 위에서 아래로, 왼쪽에서 오른쪽으로 번호를 매기고 n + 1 세대에 해당 그리드 위치에서 n 세대 사본 :

bit:       place value:   bit pattern:   bit value:

0 1 2      1    2    4    1 1 1          1    2    4
3 4 5      8   16   32    1 0 1          8    0   32 
6 7 8      64 128  256    1 1 1          64 128  256 

integer value = 1 + 2 + 4 + 8 + 32 + 64 + 128 + 256 = 495

스케일 팩터가 2 인 경우 비트 패턴은 다음과 같이 배열됩니다.

0 1
2 3

등등.

이 형식의 비트 패턴, 스케일 팩터 (예 : Sierpinski Carpet의 경우 3) 및 생성 번호를 받아들이고 ASCII 프랙탈을 출력하는 프로그램을 작성해야합니다.

입력

프로그램은 비트 패턴, 스케일 팩터 (2-5 포함) 및 생성 횟수 (0-5 포함)의 순서로 3 개의 정수를 수용해야합니다.

이 값에 대해 입력 유효성 검사를 수행 할 필요가 없으며 프로그램이 지정된 범위보다 큰 값에 대해 작동하는 경우에는 문제가 없습니다.

입력은 모든 형식 (튜플, 쉼표 / ​​공백으로 구분 된 목록 등)으로 전달 될 수 있습니다.

산출

프로그램은 #문자 로 구성된 프랙탈 다음에 프랙탈이 정의 된 위치에 공백, 그에 해당하지 않는 이중 공백 및 각 줄 끝에 줄 바꿈 문자를 출력하여 문자열을 출력하거나 반환해야합니다. 함수에서.

입력:

495,3,3

출력 (Sierpinski Carpet generation 3) :

# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 

입력:

7,2,5

출력 ( Sierpinski Triangle ) :

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   #   #   #   #   #   #   #   #   #   #   #   #   #   #   #   
# #     # #     # #     # #     # #     # #     # #     # #     
#       #       #       #       #       #       #       #       
# # # #         # # # #         # # # #         # # # #         
#   #           #   #           #   #           #   #           
# #             # #             # #             # #             
#               #               #               #               
# # # # # # # #                 # # # # # # # #                 
#   #   #   #                   #   #   #   #                   
# #     # #                     # #     # #                     
#       #                       #       #                       
# # # #                         # # # #                         
#   #                           #   #                           
# #                             # #                             
#                               #                               
# # # # # # # # # # # # # # # #                                 
#   #   #   #   #   #   #   #                                   
# #     # #     # #     # #                                     
#       #       #       #                                       
# # # #         # # # #                                         
#   #           #   #                                           
# #             # #                                             
#               #                                               
# # # # # # # #                                                 
#   #   #   #                                                   
# #     # #                                                     
#       #                                                       
# # # #                                                         
#   #                                                           
# #                                                             
#                                                               

입력:

325,3,3

출력 ( Cantor Dust ) :

#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 









#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 

입력

186,3,3

출력 ( Vicsek fractal ) :

                          #                           
                        # # #                         
                          #                           
                    #     #     #                     
                  # # # # # # # # #                   
                    #     #     #                     
                          #                           
                        # # #                         
                          #                           
        #                 #                 #         
      # # #             # # #             # # #       
        #                 #                 #         
  #     #     #     #     #     #     #     #     #   
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
  #     #     #     #     #     #     #     #     #   
        #                 #                 #         
      # # #             # # #             # # #       
        #                 #                 #         
                          #                           
                        # # #                         
                          #                           
                    #     #     #                     
                  # # # # # # # # #                   
                    #     #     #                     
                          #                           
                        # # #                         
                          #                           

입력:

279,3,3

출력 (비대칭 프랙탈의 예) :

# # # # # # # # # # # # # # # # # # # # # # # # # # # 
  #     #     #     #     #     #     #     #     #   
    #     #     #     #     #     #     #     #     # 
      # # #             # # #             # # #       
        #                 #                 #         
          #                 #                 #       
            # # #             # # #             # # # 
              #                 #                 #   
                #                 #                 # 
                  # # # # # # # # #                   
                    #     #     #                     
                      #     #     #                   
                        # # #                         
                          #                           
                            #                         
                              # # #                   
                                #                     
                                  #                   
                                    # # # # # # # # # 
                                      #     #     #   
                                        #     #     # 
                                          # # #       
                                            #         
                                              #       
                                                # # # 
                                                  #   
                                                    # 

기타

노트:

  • 이것은 이므로 바이트 단위의 최단 답변이 이깁니다.
  • 프로그램은 독립형이거나 3 개의 입력 매개 변수로 호출되고 문자열을 리턴 (또는 인쇄)하는 함수일 수 있습니다.
  • 0 발생은 0 의 비트 패턴에 대해서도 #(a #다음에 공백) 으로 정의됩니다 .
  • 마지막 줄의 후행 줄 바꿈은 선택 사항이지만 각 줄의 후행 공백과 마찬가지로 허용됩니다.

3
+1, 샌드 박스에서이 기호가 마음에 들었고 기호가에서 "##"로 변경되어 더 좋아했습니다 "# ". 줄 끝에 하나의 후행 공간이 예제에 포함되어 있습니다. 필요합니까? . 마지막 규칙에 따라 선택 사항이라고 가정하지만 0 세대에 후행 공간이 필요하다는 사실은 궁금합니다. 또한 최대 공백과 줄 바꿈 (여러 개가 있음)을 표시해야한다고 생각합니다. 극단적 인 예로서 항상 2 ^ 5 ^ 6 공백의 5 ^ 6 = 15625 줄의 배열로 시작한 다음 #s 를 대체 할 수 있습니다. 대부분의 입력 사례에서 사용되지 않는 공백의 양이 엄청나 다
Level River St

@steveverrill 0 세대를 출력 할 때 후행 공간이 필요하지 않지만 후행 공간은 그 정의의 일부이며, 후속 세대는 용어로 정의됩니다. 복수 줄 바꿈은 오타로 수정되었습니다.
samgak

279,3,3? 와 같이 덜 대칭적인 것으로 예상되는 결과를 게시 할 수 있습니까?
aditsu

@aditsu 확실히, 편집 된 질문보기
samgak

답변:


4

APL (Dyalog Unicode) , 37 바이트 SBCS

'# '{⊃⍪/,/⍺\⍤1⊂⍉⍪⍉⍵}⍣⎕⍨(2⍴⎕)⍴⌽⎕⊤⍨992
                                      input the bit pattern
                               ⊤⍨992  decode 99 binary digits from it
                                        (53 is the limit for floating point)
                                      reverse, least significant bit goes first
                                      input the scale factor
                       (2 )           twice, to use as dimensions of a matrix
                                      reshape bit pattern into such a matrix
                                      input the number of generations
'# '{              }⍣                 apply that many times, starting from '# '
               ⍉⍪⍉⍵                    make sure the argument is a matrix
                                      enclose
          \⍤1                         expand using rows of bit-pattern matrix
                                        (1 for identical copy, 0 for zeroed out)
     ⊃⍪/,/                             concat all horizontally and vertically

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


11

일반적인 Lisp, 248 242 바이트

(lambda(n r g &aux(s(expt r g)))(labels((f(g x y s)(or(= g 0)(#2=multiple-value-bind(q x)(floor x s)(#2#(p y)(floor y s)(if(logbitp(+ q(* p r))n)(f(1- g)x y(/ s r))))))))(#3=dotimes(y s)(#3#(x s)(princ(if(f g x y(/ s r))"# ""  ")))(terpri))))

언 골프

(defun fractal (n r g &aux (s (expt r g)))
  (labels((f(g x y s)
            (or(= g 0)
               (multiple-value-bind (px x) (truncate x s)
                 (multiple-value-bind (py y) (truncate y s)
                   (and
                    (logbitp (+ px (* py r)) n)
                    (f (1- g) x y (/ s r))))))))
    (fresh-line)
    (dotimes(y s)
      (dotimes(x s)
        (princ
         (if (f g x y(/ s r))
             "# "
             "  ")))
      (terpri))))

설명

  • 입력:
    • N 은 인코딩 된 패턴입니다
    • R 은 패턴의 크기입니다
    • G 는 세대입니다
  • 출력은 길이의 내재적 정방 행렬 인 S = R G
  • 각 행 y , 열 x (nested dotimes)를 반복하고 각 셀을 그릴 지 여부를 계산합니다 (레이 캐스팅 방식). f보조 기능으로 프랙탈 내부를 재귀 적으로 살펴보면 됩니다.
  • 위치 (x, y) 의 프랙탈을 그리 "# "거나 인쇄하거나 인쇄해야하는 경우 " ". 물론 각 행 끝에 줄 바꿈을 인쇄합니다.

예를 들어, Sierpinsky의 삼각형은 S=7및 로 표시됩니다 R=2. 3 세대에서 제곱 크기는 2 3 = 8입니다. 각 셀 (x, y) 에 대해 다음이 발생합니다.

  • f불려 X , Y , g는 3 행 및 s는 (8/2)를 4 행
  • 우리 잘라야 X , 알고하기 위해 x는 암시 행렬의 왼쪽이나 오른쪽에 속한다. truncate몫과 나머지를 각각 반환합니다. 이는 각각 pxx에 바인딩됩니다 (우리는 동일한 기호 x를 재사용 하지만 문제는 아닙니다).
  • py 와 new y 를 제공 하는 y도 마찬가지 입니다.
  • 이 예에서 pxpy 는 0 또는 1 일 수 있습니다 (패턴이 길이가 2의 제곱이므로). 이들은 프랙탈 패턴에서 (x, y) 가 어디에 있는지를 식별합니다. 위치 py.R + px 에서 N 의 비트 가 0 일 때, xy 는 아무것도 그려야 할 위치를 나타냅니다.
  • 그렇지 않으면 프랙탈의 해당 부분으로 "확대"해야 f하며 xy에 대한 새로운 바인딩을 재귀 적으로 호출 해야합니다 . 그것들은 이제 내부 프랙탈 내부의 상대적 위치입니다. 우리 는 생성을 위해 G-1 을 , 프랙탈의 절반 길이를 나타 내기 위해 s / 2 를 전달합니다.
  • 재귀의 기본 경우는 G 가 0 일 때 발생 하며,이 경우 현재 (x, y) 위치를 그려야합니다.

(fractal 186 3 3)

                          #                           
                        # # #                         
                          #                           
                    #     #     #                     
                  # # # # # # # # #                   
                    #     #     #                     
                          #                           
                        # # #                         
                          #                           
        #                 #                 #         
      # # #             # # #             # # #       
        #                 #                 #         
  #     #     #     #     #     #     #     #     #   
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
  #     #     #     #     #     #     #     #     #   
        #                 #                 #         
      # # #             # # #             # # #       
        #                 #                 #         
                          #                           
                        # # #                         
                          #                           
                    #     #     #                     
                  # # # # # # # # #                   
                    #     #     #                     
                          #                           
                        # # #                         
                          #                           

8 세대 Sierpinski Carpet을 사용하여 컴퓨팅하는 (fractal 495 3 8)데 24.7 초가 걸리고 83MB의 출력 텍스트 파일이 생성됩니다. 이미지를 출력하는 약간 수정 된 버전을 작성했습니다. 동일한 매개 변수의 경우 GIF 파일의 무게는 1.5MB (동일한 계산 시간)입니다.

시 에르 핀 스키 카펫, 8 세대

Vicsek (원본 크기를 보려면 클릭) :

비섹 프랙탈


1
끔찍한 장황한 언어로 간결한 프로그램처럼 보이는 것이 +1입니다. 8 )연속으로 중첩 !
Level River St

@ steveverrill 나는 코드 골프에서 결코 이길 수 없지만 ...하지만 여전히 큰 프로그램의 경우 문법이 좋습니다. 그리고 솔직히, 나는 거의 더 이상 괄호를 보지 않고 단지 좋은 나무입니다.
coredump 2013 년

즉, GIF 이미지는 실제로 내 휴대 전화의 웹 브라우저 ... 더 이상한 언어 그레이트 골프 충돌
글렌 스미스

@HiGuy 감사합니다. CodeGolf에 다른 사람의 브라우저 충돌을 일으키는 배지가 있습니까? 그것은 :-)
코어 덤프

5

Pyth, 38 바이트

VJ^UQvwjdm@" #".A@L_.[0^Q2jvz2+V*RQNdJ

온라인 사용해보기 : 일반 입력 / 테스트 스위트

나중에 설명합니다.


1+ 나는 여전히 186 3 5(온라인 통역사) 의 결과물을 기다리고 있지만 그 외에는 이것이 얼마나 짧은 지에 대해 깊은 감명을받습니다.
coredump 2015 년

1
@coredump 온라인 인터프리터를 사용하면 큰 결과를 얻지 못할 것이라고 생각합니다. 테스트하려면 Pyth 컴파일러 를 다운로드해야합니다 . 랩톱에서 약 10 초가 걸립니다.
Jakube

4

루비, 154

점수는 기능에만 해당됩니다. 아래의 테스트 프로그램에서 ungolfed로 표시되었습니다. 내가 주장하는 유일한 골프는 의견과 들여 쓰기를 제거하는 것입니다. 나는 나중에 골프를 할 것이다. 현재 나는 프로그램을 가지고 노는 것이 즐겁습니다.

이 함수는 6 개의 인수를 취하지 만 최초 호출시 스펙마다 처음 3 개만 제공됩니다. 이로 인해 나머지 세 개의 인수가 기본값으로 설정되고 특히 a출력이 저장 되는 문자열 이 작성되어 줄 바꿈으로 끝나는 공백 행으로 초기화됩니다. 부작용으로 전역 변수 $w도 만들어져 라인 당 기호 수를 나타냅니다.

함수가 재귀 적으로 호출되면 a다음 재귀의 왼쪽 상단 모서리의 문자열 과 x 및 y 좌표를 포함하여 6 개의 인수를 모두 제공합니다.

의견에 표시된 것처럼 프로그램의 나머지 부분은 매우 간단합니다.

#function
f=->b,s,g,x=0,y=0,a=(' '*(-1+2*$w=s**g)+'
')*$w{                                         #accept arguments, if x,y,a are not provided create them. $w = number of symbols per row 
  v=s**g/s                                     #v=width of blocks for this recursion depth
  if g==0
    a[2*y*$w+2*x]=?#                           #if g==0 plot a #
  else                                         #else iterate s*s times through the bits of b, and recurse as necessary
    (s*s).times{|i|b>>i&1>0&&f.call(b,s,g-1,x+i%s*v,y+i/s*v,a)} 
  end
  a
}

#test program (requires 3 input numbers separated by newlines)
b=gets.to_i
s=gets.to_i
g=gets.to_i
#get return value and output to stdout
puts f.call(b,s,g)

산출

다음은 GOLF라는 단어의 글자 형태를 기반으로 한 일련의 프랙탈입니다. 더 큰 비트 맵으로보다 사실적인 글자를 얻을 수 있습니다. 마지막 예에서 알 수 있듯이 가장 흥미로운 프랙탈이 우연히 발견되었습니다.

63775,4,2 (G)

# # # # # # # # # # # # # # # #
#       #       #       #      
#     # #     # #     # #     #
# # # # # # # # # # # # # # # #
# # # #                        
#                              
#     #                        
# # # #                        
# # # #                 # # # #
#                       #      
#     #                 #     #
# # # #                 # # # #
# # # # # # # # # # # # # # # #
#       #       #       #      
#     # #     # #     # #     #
# # # # # # # # # # # # # # # #

495,3,3 (O, sierpinski carpet)

# # # # # # # # # # # # # # # # # # # # # # # # # # #
#   # #   # #   # #   # #   # #   # #   # #   # #   #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # #       # # # # # #       # # # # # #       # # #
#   #       #   # #   #       #   # #   #       #   #
# # #       # # # # # #       # # # # # #       # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
#   # #   # #   # #   # #   # #   # #   # #   # #   #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # #                   # # # # # # # # #
#   # #   # #   #                   #   # #   # #   #
# # # # # # # # #                   # # # # # # # # #
# # #       # # #                   # # #       # # #
#   #       #   #                   #   #       #   #
# # #       # # #                   # # #       # # #
# # # # # # # # #                   # # # # # # # # #
#   # #   # #   #                   #   # #   # #   #
# # # # # # # # #                   # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
#   # #   # #   # #   # #   # #   # #   # #   # #   #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # #       # # # # # #       # # # # # #       # # #
#   #       #   # #   #       #   # #   #       #   #
# # #       # # # # # #       # # # # # #       # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
#   # #   # #   # #   # #   # #   # #   # #   # #   #
# # # # # # # # # # # # # # # # # # # # # # # # # # #

457,3,3 (L)

#                                                    
#                                                    
# # #                                                
#                                                    
#                                                    
# # #                                                
#     #     #                                        
#     #     #                                        
# # # # # # # # #                                    
#                                                    
#                                                    
# # #                                                
#                                                    
#                                                    
# # #                                                
#     #     #                                        
#     #     #                                        
# # # # # # # # #                                    
#                 #                 #                
#                 #                 #                
# # #             # # #             # # #            
#                 #                 #                
#                 #                 #                
# # #             # # #             # # #            
#     #     #     #     #     #     #     #     #    
#     #     #     #     #     #     #     #     #    
# # # # # # # # # # # # # # # # # # # # # # # # # # #

7967,4,2 (F)

# # # # # # # # # # # # # # # #
#       #       #       #      
# # # # # # # # # # # # # # # #
#       #       #       #      
# # # #                        
#                              
# # # #                        
#                              
# # # # # # # # # # # # # # # #
#       #       #       #      
# # # # # # # # # # # # # # # #
#       #       #       #      
# # # #                        
#                              
# # # #                        
#      

1879,3,3 (skull and crossbones discovered by accident)

# # # # # # # # # # # # # # # # # # # # # # # # # # #
  #     #     #     #     #     #     #     #     #  
#   # #   # #   # #   # #   # #   # #   # #   # #   #
      # # #             # # #             # # #      
        #                 #                 #        
      #   #             #   #             #   #      
# # #       # # # # # #       # # # # # #       # # #
  #           #     #           #     #           #  
#   #       #   # #   #       #   # #   #       #   #
                  # # # # # # # # #                  
                    #     #     #                    
                  #   # #   # #   #                  
                        # # #                        
                          #                          
                        #   #                        
                  # # #       # # #                  
                    #           #                    
                  #   #       #   #                  
# # # # # # # # #                   # # # # # # # # #
  #     #     #                       #     #     #  
#   # #   # #   #                   #   # #   # #   #
      # # #                               # # #      
        #                                   #        
      #   #                               #   #      
# # #       # # #                   # # #       # # #
  #           #                       #           #  
#   #       #   #                   #   #       #   #

3

CJam, 45

3aaq~@2b2$_*0e[W%@/a*{ffff*:.+:.+}/' ff+Sf*N*

내 첫 번째 아이디어의 구현. 온라인으로 사용해보십시오

기본적으로 3을 포함하는 1 * 1 행렬 ( '#'과 ''의 차이)로 시작한 다음 행렬의 각 숫자에 비트 패턴 (0/1 행렬)을 반복적으로 곱한 다음 결과 행렬을 하나로 결합합니다. 더 큰 매트릭스. 마지막으로 각 숫자에 공백을 추가하고 공백 및 줄 바꿈과 결합합니다.

두번째 아이디어, 49

q~@2bW%2$/z@@m*_,\_m*:z@f{3@@f{\~@==*}~' +}/Sf*N*

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

이렇게하면 출력 행렬의 모든 좌표가 스케일 팩터 (이러한 모든 조합)보다 작은 <생성 수> 쌍의 배열로 생성 된 다음 각 숫자 쌍에 대해 패턴에서 해당 비트를 가져오고 각 좌표 배열에 대해 비트를 곱하고 3을 곱합니다. 최종 처리는 동일합니다.

더 많은 골프를 즐길 여지가있을 것입니다.


2

C, 316 바이트

main(a,_,b,s,g,i,w,o,z,x,y)char**_,*o;{b=atoi(_[1]);s=atoi(_[2]);g=atoi(_[3]);w=1;for(i=0;i<g;++i){w*=s;}o=malloc(w*w);for(i=0;i<w*w;++i)o[i]=35;z=w/s;while(z){for(y=0;y<w;++y)for(x=0;x<w;++x)if(!((b>>((y/z)%s*s+(x/z)%s))&1))o[y*w+x]=32;z/=s;}for(y=0;y<w;++y){for(x=0;x<w;++x)printf("%c ",o[y*w+x]);printf("\n");}}

언 골프 :

#include <stdio.h>

int main(int argc, char *argv[]) 
{
    int bitpattern;
    int scale;
    int generation;

    bitpattern = atoi(argv[1]);
    scale = atoi(argv[2]);
    generation = atoi(argv[3]);

    int i;
    int width = 1;
    for (i=0; i<generation; ++i) {width*=scale;}

    char *out=malloc(width*width);

    for (i=0; i<width*width; ++i) out[i]='#';


    int blocksize = width/scale;
    for (i=0; i<generation; ++i) {
        int x,y;
        for (y=0; y<width; ++y) {
            for (x=0; x<width; ++x) {
                int localX = x/blocksize;
                localX %= scale;
                int localY = y/blocksize;
                localY %= scale;
                int localPos = localY*scale+localX;
                if (!((bitpattern>>localPos)&1))out[y*width+x]=' ';
            }
        }
        blocksize/=scale;
    }

    int x,y;
    for (y=0; y<width; ++y) {
        for (x=0; x<width; ++x)
            printf("%c ",out[y*width+x]);
        printf("\n");
    }
    return 0;
}

3
스펙 끝의 글 머리 기호에 따르면 프로그램 대신 기능이 허용됩니다. 함수로 변경하고 세 개의 입력 매개 변수를 전달하면 모든 아토이를 제거하고 약 40 바이트를 절약 할 수 있습니다.
Level River St

2

스칼라 293 299

(e:Int,s:Int,g:Int)=>{def b(x:Int,y:Int)=(1<<x*s+y&e)>0;def f(n:Int):Seq[Seq[Char]]=if(n<1)Seq(Seq('#'))else if(n<2)Seq.tabulate(s,s)((i,j)=>if(b(i,j))'#'else' ')else{val k=f(n-1);val t=k.size;Seq.tabulate(t*s,t*s)((i,j)=>if(b(i/t,j/t))k(i%t)(j%t)else' ')};f(g).map(_.mkString(" ")).mkString(" \n")}

언 골프 :

//create an anonymous function
(encoded: Int, size: Int, generation: Int) => {

  // method will return true if coords (x,y) should be drawn as '#'
  def isBlackInPattern(x: Int, y: Int): Boolean = (1 << x * size + y & encoded) > 0

  // recurse until generation is 1
  def fillRecursively(gen: Int): Seq[Seq[Char]] = {

    // this is just to satisfy OP requirements.
    // if the stopping condition were generation = 1,
    // I could have spared this line...
    if(gen < 1) Seq(Seq('#'))

    //actual stopping condition (generation 1). 
    // fill a matrix of characters with spaces
    // and hashes acording to the pattern.
    else if(gen < 2) Seq.tabulate(size, size)((i, j) => 
      if (isBlackInPattern(i,j)) '#' 
      else ' '
    )

    // recurse, and use previously created fractals to fill
    // the current generation according to the `isBlackInPattern` condition
    else {
      val previousGeneration = fillRecursively(gen-1)
      val previousSize = previousGeneration.size
      // create the current matrix and fill it
      Seq.tabulate(previousSize*size,previousSize*size)((i,j)=>
        if(isBlackInPattern(i/previousSize,j/previousSize))
          previousGeneration(i%t)(j%t)
        else ' '
      )
    }
  }
  // call to recursive function and format matrix of characters to string
  fillRecursively(generation).map(_.mkString(" ")).mkString(" \n")
}

예 :

val f = (e:Int,s:Int,g:Int)=>{def b(x:Int,y:Int)=(1<<x*s+y&e)>0;def f(n:Int):Seq[Seq[Char]]=if(n<1)Seq(Seq('#'))else if(n<2)Seq.tabulate(s,s)((i,j)=>if(b(i,j))'#'else' ')else{val k=f(n-1);val t=k.size;Seq.tabulate(t*s,t*s)((i,j)=>if(b(i/t,j/t))k(i%t)(j%t)else' ')};f(g).map(_.mkString(" ")).mkString(" \n")}
f: (Int, Int, Int) => String = <function3>

scala> println(f(495,3,3))
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #

scala> println(f(7,2,5))
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   #   #   #   #   #   #   #   #   #   #   #   #   #   #   #   
# #     # #     # #     # #     # #     # #     # #     # #     
#       #       #       #       #       #       #       #       
# # # #         # # # #         # # # #         # # # #         
#   #           #   #           #   #           #   #           
# #             # #             # #             # #             
#               #               #               #               
# # # # # # # #                 # # # # # # # #                 
#   #   #   #                   #   #   #   #                   
# #     # #                     # #     # #                     
#       #                       #       #                       
# # # #                         # # # #                         
#   #                           #   #                           
# #                             # #                             
#                               #                               
# # # # # # # # # # # # # # # #                                 
#   #   #   #   #   #   #   #                                   
# #     # #     # #     # #                                     
#       #       #       #                                       
# # # #         # # # #                                         
#   #           #   #                                           
# #             # #                                             
#               #                                               
# # # # # # # #                                                 
#   #   #   #                                                   
# #     # #                                                     
#       #                                                       
# # # #                                                         
#   #                                                           
# #                                                             
# 

scala> println(f(18157905,5,2))
#       #                               #       # 
  #   #                                   #   #   
    #                                       #     
  #   #                                   #   #   
#       #                               #       # 
          #       #           #       #           
            #   #               #   #             
              #                   #               
            #   #               #   #             
          #       #           #       #           
                    #       #                     
                      #   #                       
                        #                         
                      #   #                       
                    #       #                     
          #       #           #       #           
            #   #               #   #             
              #                   #               
            #   #               #   #             
          #       #           #       #           
#       #                               #       # 
  #   #                                   #   #   
    #                                       #     
  #   #                                   #   #   
#       #                               #       # 

첫 번째 컷, 아마도 조금 더 골프를 칠 수 있습니다 ...


의 사이에 공백이 없습니다 #. 스펙에서 요구하는 것 외에도 실제로 출력 모양을 향상시킵니다.
Level River St

@steveverrill 당신의 권리. 나는 처음에 그것을 알아 차리지 못했습니다. 빠른 수정으로 편집했습니다. thanks :)
gilad hoch

2

Matlab, 115 바이트

크로네 커 kron제품은 모든 것을 훨씬 쉽게 만듭니다 :

function f(p,f,g);z=nan(f);z(:)=de2bi(p,f*f);x=3;for k=1:g;x=kron(x,z);end;disp([reshape([x;0*x],f^g,2*f^g)+32,''])

# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 

비록 de2bi당신이 통신 시스템 도구 상자가있는 경우에만 작동합니다. 그것 없이는 작동하지 않습니다. 필요합니다 dec2bin.
Tom Carpenter

이 도구 상자가 표준 학생 버전에 포함되어있는 것 같습니다. ( de2bi와 동일하지 않습니다 dec2bin.)
flawr

2

C, 158 바이트

f(p,s,g,h,i,j,c){for(j=1;g--;j*=s);for(h=j;h;){h--;for(i=j;i;){i--;for(c=35,g=j/s;g;g/=s)c=!((p>>((h/g)%s*s+(i/g)%s))&1)?32:c;printf("%c ",c);}printf("\n");}}

1

K5, 70 바이트

시작입니다.

{,/'("  ";"# ")$[z;(z-1){,/'+,/'+x@y}[(0*t;t)]/t:(2#y)#|(25#2)\x;,,1]}

실제로 :

{,/'("  ";"# ")$[z;(z-1){,/'+,/'+x@y}[(0*t;t)]/t:(2#y)#|(25#2)\x;,,1]}[186;3]'!4
(,"# "
 ("  #   "
  "# # # "
  "  #   ")
 ("        #         "
  "      # # #       "
  "        #         "
  "  #     #     #   "
  "# # # # # # # # # "
  "  #     #     #   "
  "        #         "
  "      # # #       "
  "        #         ")
 ("                          #                           "
  "                        # # #                         "
  "                          #                           "
  "                    #     #     #                     "
  "                  # # # # # # # # #                   "
  "                    #     #     #                     "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "
  "        #                 #                 #         "
  "      # # #             # # #             # # #       "
  "        #                 #                 #         "
  "  #     #     #     #     #     #     #     #     #   "
  "# # # # # # # # # # # # # # # # # # # # # # # # # # # "
  "  #     #     #     #     #     #     #     #     #   "
  "        #                 #                 #         "
  "      # # #             # # #             # # #       "
  "        #                 #                 #         "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "
  "                    #     #     #                     "
  "                  # # # # # # # # #                   "
  "                    #     #     #                     "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "))
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.