Генерация фракталов из битовых паттернов в ASCII

34

обзор

Напишите программу, которая распечатывает простые фрактальные шаблоны с заданным битовым шаблоном, кодирующим фрактал, плюс масштабный коэффициент для каждого поколения фрактала и количество поколений.

объяснение

Вот ASCII-представление ковра Серпинского :

Поколение 0:

# 

Поколение 1:

# # # 
#   # 
# # # 

Поколение 2:

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

Поколение n + 1 ковра Серпинского ASCII состоит из сетки 3х3, содержащей 8 копий поколения n, при этом отсутствует центральный элемент сетки.

Итак, поскольку он определяется с использованием сетки 3х3 и увеличивается в 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

и так далее.

Ваша задача - написать программу, которая принимает битовый шаблон в этой форме, масштабный коэффициент (например, 3 для ковра Серпинского) и номер поколения и выводит фрактал ASCII.

вход

Ваша программа должна принимать 3 целых числа в следующем порядке: битовая комбинация, масштабный коэффициент (от 2 до 5 включительно) и число генераций (от 0 до 5 включительно).

Вам не нужно выполнять какую-либо проверку входных данных для этих значений, и это прекрасно, если программа работает для значений, превышающих указанные диапазоны.

Входные данные могут быть переданы в любой форме (кортежи, список через запятую / через пробел и т. Д.)

Выход

Программа должна выводить фрактал, состоящий из #символа, за которым следуют пробел в позициях, где фрактал определен, двойные пробелы, где его нет, и символ новой строки в конце каждой строки, либо распечатывая их, либо возвращая строку из функции.

Примеры

Входные данные:

495,3,3

Выход (ковер Серпинского 3 поколения):

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

Входные данные:

7,2,5

Выход ( треугольник Серпинского ):

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

Входные данные:

325,3,3

Выход ( Кантор Пыль ):

#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 









#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 

вход

186,3,3

Выход ( Vicsek фрактал ):

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

Входные данные:

279,3,3

Вывод (пример асимметричного фрактала):

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

и т.п.

Заметки:

  • Это поэтому выигрывает самый короткий ответ в байтах
  • Ваша программа может быть либо автономной, либо функцией, которая вызывается с 3 входными параметрами и возвращает (или печатает) строку
  • Поколение 0 определяется как #( #сопровождаемое пробелом) даже для битовой комбинации 0.
  • Конечный символ новой строки в последней строке является необязательным, но разрешенным, как и любое количество пробелов в каждой строке.
samgak
источник
3
+1, мне понравилось в песочнице, и мне больше нравится здесь, с символом, измененным с "##"на "# ". Я вижу, что один пробел в конце строки включен в ваши примеры, это требуется? , В соответствии с последним правилом я бы предположил, что это необязательно, но тот факт, что для поколения 0 вам нужен завершающий пробел, заставляет задуматься. Также я думаю, что вы должны указать максимально допустимые пробелы и символы новой строки (у вас это множественное число). В качестве крайнего примера я всегда могу начать с массива из 5 ^ 6 = 15625 строк по 2 * 5 ^ 6 пробелов, а затем заменить #s. В большинстве случаев это огромное количество неиспользуемого пробела
Level River St.
@steveverrill Я не требую конечного пробела при выводе поколения 0, однако конечный пробел является частью его определения, для которого последующие поколения определены в терминах. Множественное число новых строк было опечаткой, исправлено.
Самгак
Не могли бы вы опубликовать ожидаемый результат для чего-то менее симметричного, например 279,3,3?
aditsu 10.10.15
@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

Обыкновенный Лисп, 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))))

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

объяснение

  • Входные данные:
    • N - кодированный шаблон
    • R - размер рисунка
    • G это поколение
  • На выходе получается неявная квадратная матрица длиной S = R G
  • Итерируем по каждой строке y , столбцу x (вложенный dotimes) и вычисляем, должна ли быть нарисована каждая ячейка (подход, подобный raycasting). Это делается путем рекурсивного просмотра фрактала со fвспомогательной функцией.
  • Если фрактал в позиции (x, y) должен быть нарисован, выведите "# "или напечатайте" " . Конечно, мы также печатаем переводы строк в конце каждой строки.

Например, треугольник Серпинского представлен S=7и R=2. В поколении 3 размер квадрата составляет 2 3 = 8. Для каждой ячейки (x, y) происходит следующее:

  • fвызывается с x , y , g, связанным с 3 и s, связанным с 4 (8/2)
  • Мы усекаем х на s , чтобы узнать, принадлежит ли x левой или правой части неявной матрицы. truncateвозвращает как частное, так и остаток, которые связаны соответственно с px и x (мы повторно используем один и тот же символ x , но это не проблема).
  • То же самое относится и к у , которая дает ру и новый y .
  • В этом примере px и py могут быть 0 или 1 (потому что шаблон является квадратом длины 2). Они идентифицируют, где находится (х, у) в паттерне фрактала: когда бит в позиции py.R + px из N равен 0, x и y представляют позицию, где ничто не должно быть нарисовано.
  • В противном случае мы должны «увеличить» соответствующую часть фрактала, и мы будем вызывать fрекурсивно с новыми привязками для x и y . Теперь это относительная позиция внутри внутреннего фрактала. Проходим G-1 за поколение и с / 2 чтобы представить половину длины фрактала.
  • Базовый случай рекурсии встречается, когда G равен нулю, и в этом случае текущая (x, y) позиция должна быть нарисована.

пример

(fractal 186 3 3)

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

Вычисление 8-го поколения ковра Серпинского с использованием (fractal 495 3 8) занимает 24,7 секунды и создает выходной текстовый файл размером 83 МБ. Я написал слегка модифицированную версию, которая выводит изображение. Для тех же параметров файл GIF весит 1,5 МБ (то же время вычислений):

Ковер Серпинского, 8 поколение

Vicsek (нажмите, чтобы увидеть оригинальный размер):

Vicsek фрактал

CoreDump
источник
1
+1 за то, что выглядит как лаконичная программа на ужасно многословном языке. 8 вложенных )подряд!
Уровень Река St
@steveverrill Я никогда не выигрываю в гольф-кодах ... но все же я думаю, что синтаксис окупается для больших программ. И, честно говоря, я почти не вижу скобок, просто красивое дерево.
coredump
Это изображение GIF на самом деле ломает веб-браузер моего телефона ... Великолепная игра в гольф с более необычным языком
Гленн Смит
@HiGuy Спасибо. Есть ли у CodeGolf значок для сбоя браузера других людей? Стоит :-)
coredump
5

Pyth, 38 байт

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

Попробуйте онлайн: Regular Input / Test Suite

Объяснение следует позже.

Jakube
источник
1+ Я все еще жду выхода 186 3 5(онлайн-переводчика), но кроме этого я действительно впечатлен тем, насколько это коротко.
coredump
1
@coredump Я не думаю, что вы получите такой большой результат, используя онлайн-переводчик. Если вы хотите проверить это, вам придется скачать компилятор Pyth . Это займет около 10 секунд на моем ноутбуке.
Якуб
4

Рубин, 154

Оценка только для функции. Представлено без присмотра ниже в тестовой программе. Единственная игра в гольф, на которую я сейчас претендую, это удаление комментариев и отступов. Я буду в гольф позже. На данный момент мне весело играть с программой.

Функция принимает шесть аргументов, но при первоначальном вызове в спецификации указываются только первые 3 аргумента. Это приводит к тому, что для трех оставшихся аргументов устанавливаются значения по умолчанию, и, в частности, aсоздается строка, в которой хранится вывод, и инициализируется строками пробелов, оканчивающимися символами новой строки. Как побочный эффект глобальной переменной$w также создается , указывающая количество символов в строке.

Когда функция вызывает себя рекурсивно, она предоставляет все шесть аргументов, включая строку a и координаты x и y верхнего левого угла следующей рекурсии

Остальная часть программы довольно проста, как указано в комментариях.

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

# # # # # # # # # # # # # # # # # # # # # # # # # # #
  #     #     #     #     #     #     #     #     #  
#   # #   # #   # #   # #   # #   # #   # #   # #   #
      # # #             # # #             # # #      
        #                 #                 #        
      #   #             #   #             #   #      
# # #       # # # # # #       # # # # # #       # # #
  #           #     #           #     #           #  
#   #       #   # #   #       #   # #   #       #   #
                  # # # # # # # # #                  
                    #     #     #                    
                  #   # #   # #   #                  
                        # # #                        
                          #                          
                        #   #                        
                  # # #       # # #                  
                    #           #                    
                  #   #       #   #                  
# # # # # # # # #                   # # # # # # # # #
  #     #     #                       #     #     #  
#   # #   # #   #                   #   # #   # #   #
      # # #                               # # #      
        #                                   #        
      #   #                               #   #      
# # #       # # #                   # # #       # # #
  #           #                       #           #  
#   #       #   #                   #   #       #   #
Уровень реки St
источник
3

CJam, 45

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

Реализация моей первой идеи. Попробуйте онлайн

По сути, он начинается с матрицы 1 * 1, содержащей 3 (разница между '#' и ''), затем многократно умножает каждое число в матрице на битовую комбинацию (матрица 0/1) и объединяет полученные матрицы в одну большая матрица. В конце он добавляет пробел к каждому числу и соединяет пробелами и символами новой строки.

2-я идея, 49

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

Попробуйте онлайн

При этом все координаты выходной матрицы генерируются как массивы пар чисел <count count>, меньших, чем масштабный коэффициент (все такие комбинации), затем для каждой пары чисел он получает соответствующий бит из шаблона и для каждого массива координат он умножает биты и умножает на 3. Окончательная обработка такая же.

Там, вероятно, есть место для большего количества игры в гольф.

aditsu
источник
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");}}

Un-golfed:

#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
источник
3
Согласно пунктам в конце спецификации, вместо программы разрешена функция. Измените его на функцию и просто передайте три входных параметра - это избавит вас от всего этого и сэкономит вам около 40 байтов.
Уровень Река Сент-
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")}

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

Примеры:

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

первый срез, вероятно, можно играть в гольф немного дальше ...

Гилад Хох
источник
Вам не хватает пробела между каждым из вас #. Помимо того, что этого требует спецификация, он действительно улучшает внешний вид вашей продукции.
Уровень Река St
@steveverrill ваше право. Сначала я этого не заметил. Я отредактировал с быстрым исправлением. спасибо :)
Гилад хох
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,''])

# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
flawr
источник
Хотя 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");}}
Neoheurist
источник
1

К5, 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
(,"# "
 ("  #   "
  "# # # "
  "  #   ")
 ("        #         "
  "      # # #       "
  "        #         "
  "  #     #     #   "
  "# # # # # # # # # "
  "  #     #     #   "
  "        #         "
  "      # # #       "
  "        #         ")
 ("                          #                           "
  "                        # # #                         "
  "                          #                           "
  "                    #     #     #                     "
  "                  # # # # # # # # #                   "
  "                    #     #     #                     "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "
  "        #                 #                 #         "
  "      # # #             # # #             # # #       "
  "        #                 #                 #         "
  "  #     #     #     #     #     #     #     #     #   "
  "# # # # # # # # # # # # # # # # # # # # # # # # # # # "
  "  #     #     #     #     #     #     #     #     #   "
  "        #                 #                 #         "
  "      # # #             # # #             # # #       "
  "        #                 #                 #         "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "
  "                    #     #     #                     "
  "                  # # # # # # # # #                   "
  "                    #     #     #                     "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "))
Johne
источник