Generieren Sie Fraktale aus Bitmustern in ASCII

34

Überblick

Schreiben Sie ein Programm, das einfache fraktale Muster mit einem Bitmuster, das das Fraktal codiert, plus dem Skalierungsfaktor pro Generation für das Fraktal und die Anzahl der Generationen druckt.

Erläuterung

Hier ist eine ASCII-Darstellung des Sierpinski-Teppichs :

Generation 0:

# 

Generation 1:

# # # 
#   # 
# # # 

Generation 2:

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

Die Generation n + 1 des ASCII-Sierpinski-Teppichs besteht aus einem 3x3-Raster mit 8 Kopien der Generation n, wobei das zentrale Element des Rasters fehlt.

Wir können also sagen, dass es einen Skalierungsfaktor von 3 hat, da es mit einem 3x3-Raster definiert wird und in Breite und Höhe bei jeder Generation dreimal größer wird.

Wir könnten ein Bitmuster für den Sierpinski-Teppich definieren, indem wir die Elemente im 3x3-Raster von 0 bis 8, von oben nach unten und von links nach rechts nummerieren und das entsprechende Bit einer Ganzzahl setzen, wenn die Generation n + 1 a enthält Kopie der Generation n an dieser Gitterposition:

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

Für einen Skalierungsfaktor von 2 würde das Bitmuster folgendermaßen angeordnet sein:

0 1
2 3

und so weiter.

Ihre Aufgabe ist es, ein Programm zu schreiben, das ein Bitmuster in dieser Form, einen Skalierungsfaktor (z. B. 3 für den Sierpinski-Teppich) und eine Generationsnummer akzeptiert und ein ASCII-Fraktal ausgibt.

Eingang

Ihr Programm sollte 3 Ganzzahlen in der folgenden Reihenfolge akzeptieren: ein Bitmuster, einen Skalierungsfaktor (von 2 bis einschließlich 5) und eine Generierungszahl (von 0 bis einschließlich 5).

Sie müssen für diese Werte keine Eingabevalidierung durchführen, und es ist vollkommen in Ordnung, wenn das Programm für Werte arbeitet, die über den angegebenen Bereichen liegen.

Die Eingaben können in beliebiger Form (Tupel, durch Kommas / Leerzeichen getrennte Liste usw.) übergeben werden.

Ausgabe

Das Programm sollte ein Fraktal ausgeben, das aus dem #Zeichen besteht, gefolgt von einem Leerzeichen an den Stellen, an denen das Fraktal definiert ist, doppelten Leerzeichen, an denen es nicht definiert ist, und einem Zeilenumbruchzeichen am Ende jeder Zeile, das entweder ausgedruckt oder eine Zeichenfolge zurückgegeben wird von einer Funktion.

Beispiele

Eingang:

495,3,3

Leistung (Sierpinski Carpet Generation 3):

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

Eingang:

7,2,5

Ausgabe ( Sierpinski-Dreieck ):

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

Eingang:

325,3,3

Leistung ( Cantor Dust ):

#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 









#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 

Eingang

186,3,3

Ausgabe ( Vicsek-Fraktal ):

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

Eingang:

279,3,3

Ausgabe (Beispiel eines asymmetrischen Fraktals):

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

etc.

Anmerkungen:

  • Das ist also gewinnt die kürzeste Antwort in Bytes
  • Ihr Programm kann entweder ein eigenständiges Programm oder eine Funktion sein, die mit den drei Eingabeparametern aufgerufen wird und eine Zeichenfolge zurückgibt (oder ausgibt)
  • Generation 0 ist definiert als #( #gefolgt von einem Leerzeichen), auch für ein Bitmuster von 0.
  • Ein abschließender Zeilenumbruch in der letzten Zeile ist optional, aber zulässig, ebenso wie ein beliebiger Leerraum in jeder Zeile.
Samgak
quelle
3
+1, ich mochte dies in Sandbox und ich mag es hier mehr, mit dem Symbol geändert von "##"zu "# ". Ich sehe, dass das letzte Leerzeichen am Ende der Zeile in Ihren Beispielen enthalten ist. Ist es erforderlich? . Nach der letzten Regel würde ich annehmen, dass dies optional ist, aber die Tatsache, dass Sie für die Generation 0 einen nachgestellten Speicherplatz benötigen, wundert mich. Außerdem denke ich, dass Sie das maximale Leerzeichen und die erlaubten Zeilenumbrüche (Sie haben es im Plural) angeben sollten. Als extremes Beispiel könnte ich immer mit einem Array von 5 ^ 6 = 15625 Zeilen mit 2 * 5 ^ 6 Leerzeichen beginnen und dann das #s ersetzen . In den meisten Eingabefällen ist das eine enorme Menge an nicht verwendetem Leerzeichen
Level River St
@steveverrill Für die Ausgabe von Generation 0 benötige ich kein Leerzeichen. Das Leerzeichen ist jedoch Teil der Definition, für die nachfolgende Generationen definiert sind. Der Plural der Zeilenumbrüche war ein Tippfehler, der behoben wurde.
Samgak
Könnten Sie die erwartete Ausgabe für etwas weniger Symmetrisches veröffentlichen, z 279,3,3.
Aditsu
@Aditsu sicher, siehe bearbeitete Frage
Samgak

Antworten:

4

APL (Dyalog Unicode) , 37 Byte 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

Probieren Sie es online!

ngn
quelle
11

Gemeines Lisp, 248 242 Bytes

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

Ungolfed

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

Erläuterung

  • Eingang:
    • N ist das codierte Muster
    • R ist die Größe des Musters
    • G ist die Generation
  • Die Ausgabe ist eine implizite Quadratmatrix der Länge S = R G
  • Wir iterieren über jede Zeile y , Spalte x (verschachtelt dotimes) und berechnen, ob jede Zelle gezeichnet werden soll (Raycast-ähnlicher Ansatz). Dies geschieht durch rekursives Betrachten des Fraktals mit der fHilfsfunktion.
  • Soll das Fraktal an Position (x, y) gezeichnet, gedruckt "# "oder sonst gedruckt werden " ". Natürlich drucken wir auch Zeilenumbrüche am Ende jeder Zeile.

Zum Beispiel wird Sierpinskys Dreieck durch S=7und dargestellt R=2. Bei Generation 3 ist die Quadratgröße 2 3 = 8. Für jede Zelle (x, y) geschieht Folgendes:

  • fheißt mit x , y , g an 3 und s an 4 gebunden (8/2)
  • Wir kürzen x um s , um zu wissen, ob x zur linken oder rechten Seite der impliziten Matrix gehört. truncategibt sowohl den Quotienten als auch den Rest zurück, die jeweils an px und x gebunden sind (wir verwenden dasselbe Symbol x , aber dies ist kein Problem).
  • Gleiches gilt für y , was py und new y ergibt .
  • In diesem Beispiel können px und py entweder 0 oder 1 sein (da das Muster ein Quadrat der Länge 2 ist). Sie identifizieren, wo (x, y) im fraktalen Muster ist: Wenn das Bit an der Position py.R + px von N 0 ist, repräsentieren x und y eine Position, an der nichts gezeichnet werden sollte.
  • Andernfalls müssen wir in den entsprechenden Teil des Fraktals "zoomen" und rufen frekursiv die neuen Bindungen für x und y auf . Dies ist nun die relative Position innerhalb des inneren Fraktals. Wir übergeben G-1 für die Generation und s / 2 , um die halbe Länge des Fraktals darzustellen.
  • Der Grundfall der Rekursion tritt auf, wenn G Null ist. In diesem Fall sollte die aktuelle (x, y) Position gezogen werden.

Beispiel

(fractal 186 3 3)

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

Die Berechnung der achten Generation des Sierpinski-Teppichs (fractal 495 3 8)dauert 24,7 Sekunden und erzeugt eine Ausgabetextdatei von 83 MB. Ich habe eine leicht modifizierte Version geschrieben, die ein Bild ausgibt. Für die gleichen Parameter wiegt die GIF-Datei 1,5 MB (gleiche Rechenzeit):

Sierpinskys Teppich, Generation 8

Vicsek (Klicken um Originalgröße zu sehen):

Vicsek-Fraktal

Core-Dump
quelle
1
+1 für etwas, das wie ein kurzes Programm in einer schrecklich wortreichen Sprache aussieht. 8 )in einer Reihe verschachtelt !
Level River St
@steveverrill Ich gewinne nie Code-Golf ... aber dennoch denke ich, dass sich die Syntax für größere Programme auszahlt. Und ehrlich gesagt sehe ich fast keine Klammern mehr, nur noch einen schönen Baum.
Coredump
Dieses GIF-Bild bringt den Webbrowser meines Telefons zum Absturz ... Großartiges Golfen mit einer ungewöhnlicheren Sprache
Glenn Smith,
@ HiGuy Danke. Hat CodeGolf ein Abzeichen dafür, dass der Browser anderer Leute abstürzt? Es sollte :-)
coredump
5

Pyth, 38 Bytes

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

Probieren Sie es online aus: Regular Input / Test Suite

Erklärung folgt später.

Jakube
quelle
1+ Ich warte immer noch auf die Ausgabe von 186 3 5(Online-Dolmetscher), aber ansonsten bin ich wirklich beeindruckt, wie kurz das ist.
Coredump
1
@coredump Ich glaube nicht, dass Sie mit dem Online-Interpreter eine so große Ausgabe bekommen. Wenn Sie es testen möchten, müssen Sie den Pyth-Compiler herunterladen . Auf meinem Laptop dauert es ungefähr 10 Sekunden.
Jakube,
4

Rubin, 154

Die Punktzahl gilt nur für die Funktion. Unten im Testprogramm ungolfed dargestellt. Das einzige, was ich im Moment behaupte, ist das Entfernen von Kommentaren und Einrückungen. Ich werde später Golf spielen. Im Moment macht es mir Spaß, mit dem Programm zu spielen.

Die Funktion akzeptiert sechs Argumente, aber beim ersten Aufruf werden nur die ersten 3 gemäß der Spezifikation bereitgestellt. Dadurch werden die drei verbleibenden Argumente auf Standardwerte gesetzt, und insbesondere die Zeichenfolge, ain der die Ausgabe gespeichert ist, wird erstellt und in Zeilen mit Leerzeichen initialisiert, die durch Zeilenumbrüche abgeschlossen werden. Als Nebeneffekt wird auch die globale Variable $werstellt, die die Anzahl der Symbole pro Zeile angibt.

Wenn die Funktion sich selbst rekursiv aufruft, werden alle sechs Argumente bereitgestellt, einschließlich der Zeichenfolge aund der x- und y-Koordinaten der oberen linken Ecke der nächsten Rekursion

Der Rest des Programms ist ziemlich unkompliziert, wie in den Kommentaren angegeben.

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

Ausgabe

Hier ist eine Reihe von Fraktalen, die lose auf der Form der Buchstaben des Wortes GOLF basieren. Realistischere Buchstaben könnten mit größeren Bitmaps erzielt werden. Wie das letzte Beispiel zeigt, werden die interessantesten Fraktale zufällig entdeckt.

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)

# # # # # # # # # # # # # # # # # # # # # # # # # # #
  #     #     #     #     #     #     #     #     #  
#   # #   # #   # #   # #   # #   # #   # #   # #   #
      # # #             # # #             # # #      
        #                 #                 #        
      #   #             #   #             #   #      
# # #       # # # # # #       # # # # # #       # # #
  #           #     #           #     #           #  
#   #       #   # #   #       #   # #   #       #   #
                  # # # # # # # # #                  
                    #     #     #                    
                  #   # #   # #   #                  
                        # # #                        
                          #                          
                        #   #                        
                  # # #       # # #                  
                    #           #                    
                  #   #       #   #                  
# # # # # # # # #                   # # # # # # # # #
  #     #     #                       #     #     #  
#   # #   # #   #                   #   # #   # #   #
      # # #                               # # #      
        #                                   #        
      #   #                               #   #      
# # #       # # #                   # # #       # # #
  #           #                       #           #  
#   #       #   #                   #   #       #   #
Level River St
quelle
3

CJam, 45

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

Umsetzung meiner ersten Idee. Probieren Sie es online aus

Grundsätzlich beginnt es mit einer 1 * 1-Matrix, die 3 enthält (die Differenz zwischen '#' und ''), multipliziert dann wiederholt jede Zahl in der Matrix mit dem Bitmuster (0/1-Matrix) und kombiniert die resultierenden Matrizen zu einer größere Matrix. Am Ende wird jeder Zahl ein Leerzeichen hinzugefügt und mit Leerzeichen und Zeilenumbrüchen verbunden.

2. Idee, 49

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

Probieren Sie es online aus

Dies erzeugt alle Koordinaten der Ausgabematrix als Arrays von <Generierungszahl> -Zahlenpaaren, die kleiner als der Skalierungsfaktor sind (alle diese Kombinationen). Für jedes Zahlenpaar wird dann das entsprechende Bit aus dem Muster und für jedes Koordinatenarray abgerufen es multipliziert die Bits und multipliziert mit 3. Die endgültige Verarbeitung ist dieselbe.

Es gibt wahrscheinlich Platz für mehr Golf.

aditsu
quelle
2

C 316 Bytes

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

Nicht golfen:

#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;
}
LambdaBeta
quelle
3
Gemäß den Aufzählungspunkten am Ende der Spezifikation ist eine Funktion anstelle eines Programms zulässig. Wandle es in eine Funktion um und übergebe ihm einfach die drei Eingabeparameter - das würde all das Atoi-Zeug loswerden und dir ungefähr 40 Bytes sparen.
Level River St
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")}

ungolfed:

//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")
}

Beispiele:

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

erster schnitt, kann wohl noch etwas weiter golfen werden ...

Gilad hoch
quelle
Ihnen fehlt ein Leerzeichen zwischen jedem von Ihnen #. Abgesehen davon, dass es von der Spezifikation verlangt wird, verbessert es das Erscheinungsbild Ihrer Ausgabe.
Level River St
@ Steveverrill du hast recht. Das habe ich anfangs nicht bemerkt. Ich habe mit einer Schnellkorrektur bearbeitet. Danke :)
Gilad Hoch
2

Matlab, 115 Bytes

Das Kronecker- kronProdukt macht alles viel einfacher:

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,''])

# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
fehlerhaft
quelle
Dies de2bifunktioniert jedoch nur, wenn Sie über die Communications Systems Toolbox verfügen. Geht nicht ohne Es würde brauchen dec2bin.
Tom Carpenter
Es scheint, dass diese Toolbox in meiner Standard-Studentenversion enthalten ist, daher halte ich dies für akzeptabel. (Beachten Sie, dass de2bidies nicht dasselbe ist wie dec2bin.)
Fehler
2

C 158 Bytes

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");}}
Neoheurist
quelle
1

K5, 70 Bytes

Es ist ein Anfang:

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

In Aktion:

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