Tổng quan
Viết chương trình in ra các mẫu fractal đơn giản được cung cấp một mẫu bit mã hóa fractal, cộng với hệ số tỷ lệ trên mỗi thế hệ của fractal và số lượng thế hệ.
Giải trình
Dưới đây là một đại diện ASCII của Thảm Sierpinki :
Thế hệ 0:
#
Thế hệ 1:
# # #
# #
# # #
Thế hệ 2:
# # # # # # # # #
# # # # # #
# # # # # # # # #
# # # # # #
# # # #
# # # # # #
# # # # # # # # #
# # # # # #
# # # # # # # # #
Thế hệ n + 1 của Thảm Sierpinki ASCII được tạo thành từ lưới 3x3 chứa 8 bản sao của thế hệ n, với phần tử trung tâm của lưới bị thiếu.
Vì vậy, bởi vì nó được xác định bằng cách sử dụng lưới 3x3 và lớn hơn gấp 3 lần chiều rộng và chiều cao mỗi thế hệ, chúng ta có thể nói nó có hệ số tỷ lệ là 3.
Chúng ta có thể xác định một mẫu bit cho thảm Sierpinki bằng cách đánh số các phần tử trong lưới 3x3 từ 0 đến 8, từ trên xuống dưới, từ trái sang phải và đặt bit tương ứng của một số nguyên nếu thế hệ n + 1 chứa một bản sao của thế hệ n tại vị trí lưới đó:
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
Đối với hệ số tỷ lệ là 2, mẫu bit sẽ được sắp xếp như sau:
0 1
2 3
vân vân
Nhiệm vụ của bạn là viết một chương trình chấp nhận một mẫu bit ở dạng này, một hệ số tỷ lệ (ví dụ 3 cho Thảm Sierpinki) và một số thế hệ và tạo ra một fractal ASCII.
Đầu vào
Chương trình của bạn nên chấp nhận 3 số nguyên theo thứ tự sau: mẫu bit, hệ số tỷ lệ (từ 2 đến 5, bao gồm) và số lượng thế hệ (từ 0 đến 5, bao gồm).
Bạn không cần thực hiện bất kỳ xác thực đầu vào nào trên các giá trị này và nó hoàn toàn ổn nếu chương trình hoạt động với các giá trị lớn hơn phạm vi được chỉ định.
Các đầu vào có thể được chuyển qua dưới mọi hình thức (bộ dữ liệu, danh sách được phân tách bằng dấu phẩy / dấu cách, v.v.)
Đầu ra
Chương trình sẽ tạo ra một fractal tạo thành từ # ký tự theo sau là khoảng trắng ở các vị trí nơi fractal được xác định, khoảng trắng ở nơi không có và một ký tự dòng mới ở cuối mỗi dòng, in chúng ra hoặc trả về một chuỗi từ một chức năng.
Ví dụ
Đầu vào:
495,3,3
Đầu ra (Sierpinki Thảm thế hệ 3):
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
Đầu vào:
7,2,5
Đầu ra ( Tam giác Sierpinki ):
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # #
# # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # #
# # # #
# # # # # # # #
# # # #
# # # #
# #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # #
# # # #
# # # # # # # #
# # # #
# # # #
# #
# # # # # # # #
# # # #
# # # #
# #
# # # #
# #
# #
#
Đầu vào:
325,3,3
Đầu ra ( Bụi Cantor ):
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
Đầu vào
186,3,3
Đầu ra ( fractal Vicsek ):
#
# # #
#
# # #
# # # # # # # # #
# # #
#
# # #
#
# # #
# # # # # # # # #
# # #
# # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # #
# # #
# # # # # # # # #
# # #
#
# # #
#
# # #
# # # # # # # # #
# # #
#
# # #
#
Đầu vào:
279,3,3
Đầu ra (ví dụ về một fractal bất đối xứng):
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # #
# # #
# # # # # # # # #
# # #
# # #
# # # # # # # # #
# # #
# # #
# # #
#
#
# # #
#
#
# # # # # # # # #
# # #
# # #
# # #
#
#
# # #
#
#
v.v.
Ghi chú:
- Đây là môn đánh gôn, vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng
- Chương trình của bạn có thể là một độc lập hoặc một hàm được gọi với 3 tham số đầu vào và trả về (hoặc in) một chuỗi
- Thế hệ 0 được định nghĩa là
#(#theo sau là khoảng trắng) ngay cả đối với mẫu bit là 0. - Một dòng mới ở cuối dòng là tùy chọn nhưng được phép, cũng như bất kỳ số lượng khoảng trắng ở cuối trên mỗi dòng.
279,3,3?
"##"thành"# ". Tôi thấy một khoảng trống ở cuối dòng được bao gồm trong các ví dụ của bạn, có bắt buộc không? . Theo quy tắc cuối cùng tôi sẽ cho rằng đó là tùy chọn, nhưng thực tế là bạn yêu cầu một không gian kéo dài cho thế hệ 0 khiến tôi tự hỏi. Ngoài ra tôi nghĩ bạn nên chỉ ra khoảng trắng tối đa và dòng mới (bạn có số nhiều) được phép. Như một ví dụ cực đoan, tôi luôn có thể bắt đầu với một mảng 5 ^ 6 = 15625 dòng 2 * 5 ^ 6 khoảng trắng sau đó thay thế#s. Trong hầu hết các trường hợp đầu vào, đó là một lượng lớn khoảng trắng chưa sử dụng