ASCIIのビットパターンからフラクタルを生成する


34

概要

フラクタルをコード化するビットパターンと、フラクタルの世代ごとのスケールファクターおよび世代数を指定して、単純なフラクタルパターンを印刷するプログラムを作成します。

説明

これは、シェルピンスキーカーペットの ASCII表現です。

ジェネレーション0:

# 

ジェネレーション1:

# # # 
#   # 
# # # 

ジェネレーション2:

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

ASCII Sierpinski Carpetのジェネレーションn + 1は、ジェネレーションnの8つのコピーを含む3x3グリッドで構成され、グリッドの中心要素が欠落しています。

したがって、3x3グリッドを使用して定義され、世代ごとに幅と高さが3倍大きくなるため、スケールファクターは3と言えます。

Sierpinskiカーペットのビットパターンを定義するには、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カーペットの場合は3など)および世代番号を受け入れ、ASCIIフラクタルを出力するプログラムを作成することです。

入力

プログラムは、ビットパターン、スケールファクタ(2〜5の範囲)、世代数(0〜5の範囲)の3つの整数を受け入れる必要があります。

これらの値に対して入力検証を実行する必要はありません。プログラムが指定された範囲よりも大きい値に対して機能する場合、まったく問題ありません。

入力は、任意の形式(タプル、コンマ/スペース区切りリストなど)で渡すことができます

出力

プログラムは、#文字と、フラクタルが定義されている位置のスペース、定義されていないダブルスペース、および各行の終わりの改行文字で構成されるフラクタルを出力する必要があります。関数から。

入力:

495,3,3

出力(Sierpinski Carpet generation 3):

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

入力:

7,2,5

出力(シェルピンスキートライアングル):

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

入力:

325,3,3

出力(Cantor Dust):

#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 









#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 

入力

186,3,3

出力(Vicsekフラクタル):

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

入力:

279,3,3

出力(非対称フラクタルの例):

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

ノート:

  • これはので、バイト単位の最短回答が勝ちます
  • プログラムは、スタンドアロンまたは3つの入力パラメーターで呼び出され、文字列を返す(または出力する)関数のいずれかです。
  • ジェネレーション0は#(a#、ビットパターン0であっても後にスペースが続く)ます。
  • 最後の行の末尾の改行はオプションですが、許可されます。各行の末尾の空白も同様です。

3
+1、私はサンドボックスでこれが好きで、シンボルがから"##"に変更されて、ここでより好きになりました"# "。行末の末尾にスペースが1つ含まれていますが、これは必須ですか?。最後のルールに従って、私はそれがオプションであると仮定しますが、世代0に末尾のスペースが必要であるという事実は不思議に思います。また、許可されている最大の空白と改行(複数ある)を示す必要があると思います。極端な例として、常に2 * 5 ^ 6スペースの5 ^ 6 = 15625行の配列から始めて、#sを置き換えることができます。未使用の空白の膨大な量の最も入力の場合には
レベル川聖

@steveverrill 世代0を出力するとき、末尾のスペースは必要ありませんが、末尾のスペースはその定義の一部であり、後続の世代は用語で定義されます。複数の改行はタイプミスであり、修正されました。
samgak

対称性の低いものなど、予想される出力を投稿できます279,3,3か?
-aditsu

@aditsu sure、編集された質問を参照してください
-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

Common 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(ネストdotimes)を反復処理し、各セルを描画するかどうかを計算します(レイキャスティングのようなアプローチ)。これは、f補助関数を使用してフラクタルの内部を再帰的に調べることによって行われます。
  • 位置(x、y)のフラクタルを描画、印刷"# "、または印刷する場合" "。もちろん、各行の最後に改行も印刷します。

例えば、Sierpinskyの三角形が表されS=7R=2。世代3では、正方形のサイズは2 3 = 8です。各セル(x、y)について、次のことが起こります。

  • fxygが3にバインドされ、sが4にバインドされて呼び出されます(8/2)
  • 我々切り捨てXによるsのかどうかを知るためには、xが暗黙の行列の左側または右側に属します。truncate商と剰余の両方を返します。これらはそれぞれpxxにバインドされています(同じシンボルxを再利用しますが、これは問題ではありません)。
  • pyと新しいyを与えるyについても同じことが言えます。
  • この例では、pxpyは0または1のいずれかです(パターンは長さ2の正方形であるため)。ここで彼らは、特定の(x、y)は位置のビット場合:フラクタルのパターンでpy.R +のPXNは、0であり、X及びYは何も描かれてはならない位置を表します。
  • それ以外の場合、フラクタルの対応する部分に「ズーム」する必要がありfxおよびyの新しいバインディングで再帰的に呼び出します。これらは現在、内側フラクタル内の相対位置です。世代にG-1を渡し、フラクタルの半分の長さを表すs / 2を渡します。
  • 再帰の基本ケースは、Gがゼロのときに発生します。この場合、現在の(x、y)位置を描画する必要があります。

(fractal 186 3 3)

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

を使用して第8世代のシェルピンスキーカーペットを計算すると、(fractal 495 3 8)24.7秒かかり、83 MBの出力テキストファイルが生成されます。画像を出力するわずかに変更されたバージョンを書きました。同じパラメーターの場合、GIFファイルの重みは1.5MB(同じ計算時間)です。

シェルピンスキーのカーペット、ジェネレーション8

Vicsek(クリックして元のサイズを表示):

ヴィセクフラクタル


1
恐ろしく冗長な言語の簡潔なプログラムのように見えるものに対して+1。入れ子)になった8
レベルリバーセント

@steveverrill私はコードゴルフに勝つことは決してありません...しかし、それでも、構文は大規模なプログラムに対して報われると思います。正直なところ、もうかっこはもうほとんどありません。素敵なツリーです。
コアダンプ

そのgif画像は実際に私の携帯電話のWebブラウザーをクラッシュさせます...より異常な言語での素晴らしいゴルフ
グレンスミス

@HiGuyありがとう。CodeGolfには、他の人のブラウザーをクラッシュさせるためのバッジがありますか?:-)
coredump

5

Pyth、38バイト

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

オンラインで試す:通常の入力/テストスイート

後で説明します。


1+ 186 3 5(オンラインインタープリター)の出力を待っていますが、それを除けば、これがどれほど短いかに本当に感銘を受けました。
コアダンプ

1
@coredumpオンラインインタープリターを使用してこのような大きな出力を得るとは思わない。テストする場合は、Pythコンパイラーをダウンロードする必要があります。私のラップトップでは約10秒かかります。
ジャクベ

4

ルビー、154

スコアは機能のみです。テストプログラムで以下に説明します。私が現時点で主張している唯一のゴルフは、コメントとインデントの削除です。後でゴルフします。現時点では、このプログラムを楽しんでいます。

この関数は6つの引数を取りますが、最初の呼び出しでは、仕様ごとに最初の3つだけが提供されます。これにより、残りの3つの引数がデフォルト値に設定され、特にa出力が格納される文字列が作成され、改行で終了するスペースの行に初期化されます。副作用として、$w1行あたりのシンボル数を示すグローバル変数も作成されます。

関数が自分自身を再帰的に呼び出す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)

出力

これは、「ゴルフ」という単語の文字の形式に大まかに基づいたフラクタルのセットです。より大きなビットマップを使用すると、より現実的な文字を実現できます。最後の例が示すように、最も興味深いフラクタルは偶然発見されました。

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マトリックス)を繰り返し乗算し、結果のマトリックスを1つに結合します。より大きなマトリックス。最後に、各番号にスペースを追加し、スペースと改行で結合します。

2番目のアイデア、49

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

オンラインで試す

これにより、出力行列のすべての座標が、スケールファクター(このようなすべての組み合わせ)よりも小さい数値の<generation count>ペアの配列として生成され、数値の各ペアに対してパターンから対応するビットが取得され、各座標配列に対してビットを乗算し、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
仕様の最後の箇条書きによると、プログラムの代わりに関数が許可されています。それを関数に変更し、3つの入力パラメーターを渡すだけです。これにより、すべてのatoiを取り除き、約40バイト節約できます。
レベルリバーセント

2

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

最初のカットは、おそらくもう少しゴルフすることができます...


各の間にスペースがありません#。仕様で要求されていることに加えて、出力の外観を本当に向上させます。
レベルリバーセント

@steveverrillあなたの権利。最初は気づかなかった。簡単な修正を加えて編集しました。ありがとう:)
gilad hoch

2

Matlab、115バイト

Kronecker 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
トムカーペンター

このツールボックスは私の標準の学生版に含まれているようですので、これは受け入れられると思います。(。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.