Створюйте фрактали з бітових моделей в ASCII


34

Огляд

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

Пояснення

Ось представлення ASCII килима Sierpinski :

Покоління 0:

# 

Покоління 1:

# # # 
#   # 
# # # 

Покоління 2:

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

Покоління n + 1 килима ASCII Sierpinski складається з сітки 3х3, що містить 8 примірників покоління n, центральний елемент сітки відсутній.

Отже, оскільки він визначається за допомогою сітки 3х3 і отримує в 3 рази більше ширини та висоти кожного покоління, можна сказати, що він має масштабний коефіцієнт 3.

Ми могли б визначити біт-шаблон для килима Sierpinski, пронумерувавши елементи в сітці 3x3 від 0 до 8, зверху вниз, зліва направо та встановивши відповідний біт цілого числа, якщо покоління n + 1 містить a копія покоління 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

Вихід (килимове покоління Sierpinski 3):

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

Вхід:

7,2,5

Вихід ( Сірпінський трикутник ):

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

Вхід:

325,3,3

Вихід ( канторний пил ):

#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 









#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 

Вхідні дані

186,3,3

Вихід ( фрактал Vicsek ):

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

Вхід:

279,3,3

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

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

тощо.

Примітки:

  • Це тому найкоротша відповідь у байтах виграє
  • Ваша програма може бути або окремою, або функцією, яка викликається з 3 вхідних параметрів і повертає (або друкує) рядок
  • Покоління 0 визначається як ##подальшим пробілом) навіть для бітового шаблону 0.
  • Останній рядок у останньому рядку необов’язковий, але дозволений, як і будь-яка кількість пробілів у кожному рядку.

3
+1, мені сподобалось це в пісочниці, і мені це більше подобається тут, із символом, зміненим з "##"на "# ". Я бачу, що один кінцевий пробіл в кінці рядка включений у ваші приклади, це потрібно? . За останнім правилом я вважаю, що це необов’язково, але той факт, що вам потрібен простір для генерації 0, здивує мене. Також я думаю, що вам слід вказати максимальний пробіл та нові рядки (у вас це множина). Як крайній приклад, я завжди міг почати з масиву 5 ^ 6 = 15625 рядків з 2 * 5 ^ 6 пробілами, а потім замінити #s. У більшості випадків це величезна кількість невикористаного пробілу
рівень річки Сент

@steveverrill Я не вимагаю проміжного простору при виведенні покоління 0, однак простір останнього є частиною його визначення, яке визначають наступні покоління в термінах. Множина нових рядків була друкарською помилкою.
samgak

Чи можете ви розмістити очікуваний вихід для чогось менш симетричного, наприклад 279,3,3,?
aditsu

@aditsu впевнений, дивіться відредаговане запитання
samgak

Відповіді:


4

APL (Dyalog Unicode) , 37 байт SBCS

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

Спробуйте в Інтернеті!


11

Лисп звичайний, 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) повинен бути намальований, роздруковується "# "чи іншим чином надрукується " ". Звичайно, ми також друкуємо нові рядки в кінці кожного рядка.

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

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

Приклад

(fractal 186 3 3)

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

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

Килим Серпінського, покоління 8

Vicsek (натисніть, щоб побачити оригінальний розмір):

Віцек фрактал


1
+1 за те, що схоже на стисну програму жахливо багатослівною мовою. 8 вкладених )підряд!
Рівень річки Св.

@steveverrill Я ніколи не виграю кодові гольфи ... але все ж, я думаю, що синтаксис окупається для великих програм. І якщо чесно, я майже не бачу дужок, просто гарне дерево.
coredump

Це gif-зображення насправді розбиває веб-браузер мого телефону ... Чудовий гольф з більш незвичною мовою
Гленн Сміт

@HiGuy Дякую Чи має CodeGolf значок для збою браузера інших людей? Слід :-)
coredump

5

Pyth, 38 байт

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

Спробуйте в Інтернеті: Регулярний пакет введення / тестування

Пояснення випливає пізніше.


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)

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

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*

Спробуйте в Інтернеті

Це генерує всі координати вихідної матриці у вигляді масивів <кількість поколінь> пар чисел, менших за масштабний коефіцієнт (усі такі комбінації), то для кожної пари чисел отримується відповідний біт із шаблону, і для кожного координатного масиву він помножує біти і помножує на 3. Кінцева обробка однакова.

Напевно, є місце для більше гольфу.


2

C, 316 байт

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

Без гольфу:

#include <stdio.h>

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

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

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

    char *out=malloc(width*width);

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


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

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

3
Відповідно до пунктів кулі в кінці специфікації, замість програми дозволена функція. Змініть його на функцію і просто передайте їй три вхідні параметри - це дозволить позбутися від усіх цих атоїв і заощадити близько 40 байт.
Рівень Рівер Сент,

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

Матлаб, 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.)
недолік

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

К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
(,"# "
 ("  #   "
  "# # # "
  "  #   ")
 ("        #         "
  "      # # #       "
  "        #         "
  "  #     #     #   "
  "# # # # # # # # # "
  "  #     #     #   "
  "        #         "
  "      # # #       "
  "        #         ")
 ("                          #                           "
  "                        # # #                         "
  "                          #                           "
  "                    #     #     #                     "
  "                  # # # # # # # # #                   "
  "                    #     #     #                     "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "
  "        #                 #                 #         "
  "      # # #             # # #             # # #       "
  "        #                 #                 #         "
  "  #     #     #     #     #     #     #     #     #   "
  "# # # # # # # # # # # # # # # # # # # # # # # # # # # "
  "  #     #     #     #     #     #     #     #     #   "
  "        #                 #                 #         "
  "      # # #             # # #             # # #       "
  "        #                 #                 #         "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "
  "                    #     #     #                     "
  "                  # # # # # # # # #                   "
  "                    #     #     #                     "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "))
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.