pengantar
Dalam tantangan ini, matriks 2 × 2 diindeks seperti ini:
0 1
2 3
Kami mendefinisikan keluarga fraktal seperti pola F(L)
, di mana L
merupakan panjang- n
daftar indeks ini dan F(L)
memiliki ukuran .2n-1 × 2n-1
- Jika
L == []
, makaF(L)
adalah pola 1 × 1#
. Jika
L != []
, makaF(L)
dibangun sebagai berikut. MembiarkanP
menjadi pola yang diperoleh dariL
dengan elemen pertama dihapus. Ambil empat kisi ukuran diisi dengan titik , dan ganti kisi diindeks dengan pola . Kemudian, rekatkan kisi-kisi menggunakan satu lapisan hash di antara mereka. Berikut adalah diagram untuk empat kasus:2n-1-1 × 2n-1-1
.
L[0]
P
#
L[0]==0 L[0]==1 L[0]==2 L[0]==3 #... ...# ...#... ...#... [P]#... ...#[P] ...#... ...#... #... ...# ...#... ...#... ####### ####### ####### ####### ...#... ...#... #... ...# ...#... ...#... [P]#... ...#[P] ...#... ...#... #... ...#
Contoh
Pertimbangkan inputnya L = [2,0]
. Kita mulai dengan kisi 1 × 1 #
, dan melintasi L
dari kanan. Elemen paling kanan adalah 0
, jadi kami mengambil empat salinan dari grid 1 × 1 .
, ganti yang pertama dengan #
, dan rekatkan bersama-sama dengan hash. Ini menghasilkan kisi 3 × 3
##.
###
.#.
Elemen berikutnya adalah 2
, jadi kami mengambil empat salinan dari kisi 3 × 3 .
, dan mengganti yang ketiga dengan kisi di atas. Keempat kisi tersebut adalah
... ... ##. ...
... ... ### ...
... ... .#. ...
dan menempelkannya bersama dengan #
hasil di kisi 7 × 7
...#...
...#...
...#...
#######
##.#...
####...
.#.#...
Ini adalah hasil akhir kami.
Memasukkan
Input Anda adalah daftar L
indeks 0, 1, 2, 3
. Anda dapat menganggapnya sebagai daftar bilangan bulat, atau serangkaian angka. Perhatikan bahwa mungkin kosong, dan mungkin berisi duplikat. Panjangnya L
paling banyak 5.
Keluaran
Output Anda adalah pola F(L)
sebagai string yang dibatasi-baris baru.
Aturan dan penilaian
Anda dapat menulis program atau fungsi lengkap. jumlah byte terendah menang, dan celah standar tidak diizinkan.
Uji kasus
[]
#
[0]
##.
###
.#.
[3]
.#.
###
.##
[2,0]
...#...
...#...
...#...
#######
##.#...
####...
.#.#...
[1,1]
...#.##
...####
...#.#.
#######
...#...
...#...
...#...
[1,2,0]
.......#...#...
.......#...#...
.......#...#...
.......########
.......###.#...
.......#####...
.......#.#.#...
###############
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
[3,3,1]
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
.......#.......
###############
.......#...#...
.......#...#...
.......#...#...
.......########
.......#...#.##
.......#...####
.......#...#.#.
[0,1,2,3]
.......#...#...#...............
.......#...#...#...............
.......#...#...#...............
.......#########...............
.......#.#.#...#...............
.......#####...#...............
.......#.###...#...............
################...............
.......#.......#...............
.......#.......#...............
.......#.......#...............
.......#.......#...............
.......#.......#...............
.......#.......#...............
.......#.......#...............
###############################
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
...............#...............
[0,0,1,2,3]
.......#...#...#...............#...............................
.......#...#...#...............#...............................
.......#...#...#...............#...............................
.......#########...............#...............................
.......#.#.#...#...............#...............................
.......#####...#...............#...............................
.......#.###...#...............#...............................
################...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
.......#.......#...............#...............................
################################...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
...............#...............#...............................
###############################################################
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
...............................#...............................
#
?L !=[]
dalam contoh itu, karena memiliki 1 atau lebih elemen. Apakah ini berarti bahwa F (L) selalu a#
pada awalnya?L = [2,0]
, Anda memenggal kepala dan melihat polaF([0])
, lalu memenggal kepala[0]
dan melihat polaF([])
, yaitu kisi 1x1#
. Kemudian Anda menggunakan indeks yang dipotong0
untuk membangun pola 3x3, dan menggunakan indeks yang dipotong2
untuk yang membangun pola 7x7. Untuk menjawab pertanyaan Anda: ya, Anda selalu mulai dengan kisi 1x1 karena itulah dasar dari rekursi.Jawaban:
CJam,
5947434140 byteTerima kasih kepada Sp3000 untuk menghemat 1 byte.
Uji di sini.
Penjelasan
Agak ketinggalan jaman. Akan diperbaiki nanti.
Semua pemesanan dimensi dari daftar 4D membuat saya pusing ...
Kode ini mengimplementasikan spesifikasi dengan sangat harfiah, menggunakan algoritma iteratif dari bagian contoh alih-alih definisi rekursifnya .. Salah satu trik golf utama adalah bahwa saya menggunakan spasi alih-alih
#
selama perhitungan dan hanya menggantinya dengan#
di akhir, yang menyederhanakan kode di satu tempat dan memungkinkan saya untuk menggunakannyaS
daripada'#
atau"#"
di beberapa tempat.sumber
MATL ,
4241 byteCobalah online!
Penjelasan
Ini berfungsi berulang menggunakan produk Kronecker untuk memperluas array di setiap iterasi. Array dibangun dengan
0
dan1
bukannya.
dan#
, dan pada akhirnya mereka digantikan oleh karakter yang sesuai.Akan ada iterasi sebanyak ukuran input. Input diproses dari kanan ke kiri. Indeks iterasi dimulai pada
1
.Menggunakan contoh dalam tantangan, dengan input
[2,0]
, array diinisialisasi sebagaiIni sesuai dengan inisial
1
(#
) diperpanjang oleh satu baris dan satu kolom, yang tujuannya akan jelas nanti. Nilai dalam kolom itu tidak penting, karena akan ditimpa; mereka bisa juga sama:Pada setiap iterasi, array yang ada adalah Kronecker-dikalikan dengan array 2 × 2 nol-satu yang berisi
1
posisi yang ditunjukkan oleh entri input saat ini, dan0
pada entri lainnya. Dalam contoh di iterasi i = 1, karena entri input paling kanan adalah0
, array nol-satu adalahdan produk Kronecker dari dua array ini adalah
Selanjutnya, baris dan kolom dengan indeks
2^i
diisi dengan yang:Tiga baris dan kolom pertama merupakan hasil dari iterasi pertama. Seperti sebelumnya, ada baris dan kolom tambahan, yang berguna untuk memperluas array di iterasi berikutnya.
Pada iterasi i = 2, karena nilai input saat ini berisi
2
array di atas adalah Kronecker-dikalikan denganpemberian yang mana
Mengisi
2^i
baris dan kolom -th dengan yang memberiKarena ini adalah iterasi terakhir, baris dan kolom tambahan dihapus:
dan penggantian karakter dilakukan untuk menghasilkan hasil akhir:
Penjelasan terperinci dari kode berikut:
sumber
Haskell,
123122 byteContoh penggunaan:
Bagaimana itu bekerja:
sumber
JavaScript (ES6),
171152 byteMengambil hasil dari panggilan rekursif, lalu mengganti setiap baris dengan dirinya sendiri ditambah hash plus serangkaian titik dengan panjang yang sama, dalam urutan terbalik jika perlu, kemudian dari hasil parsial itu menciptakan serangkaian titik kecuali untuk baris baru dan kolom tengah hash, dan juga serangkaian hash dengan baris baru yang mengelilinginya, kemudian menggabungkan ketiga string tersebut bersama-sama dalam urutan yang sesuai.
sumber
Ruby,
143134 byteFungsi anonim.
1 byte disimpan oleh penataan ulang baris pertama. 6 byte disimpan dengan mengubah cara z bertambah dari rumus ke tabel. 2 byte disimpan dengan menghilangkan varable
w
.Tidak digabungkan dalam program uji
sumber
Ruby, 150 byte
Fungsi anonim. Menggunakan panggilan rekursif untuk membuat daftar string, satu string per baris, kemudian bergabung bersama-sama di akhir.
sumber
Python 3.5, 1151 byte:
Tidak banyak kode golf, tapi oh well. Akan mencoba memangkasnya lebih dari waktu di mana saya bisa.
Cara yang cukup naif untuk melakukan ini, tetapi, bagaimanapun, saat ini berfungsi dengan baik dan, seperti yang Anda lihat, tidak menggunakan modul / perpustakaan eksternal. Selain itu, dapat mengambil cara yang lebih dari 5 item dalam daftar yang disediakan
s
tanpa kehilangan akurasi apapun (yaitu, jika perangkat keras Anda bisa mengatasinya). Itu memenuhi semua persyaratan, dan saya tidak bisa lebih bahagia dengan apa yang saya dapatkan. :)Sekarang juga tidak hanya dapat menerima angka dalam kisaran
0=>3
sebagai nilai apa pun , tetapi nomor , periode apa pun , berkat&
operator bitwise! Anda dapat membaca lebih lanjut tentang mereka di sini . Sekarang, misalnya,[4,4,1,2,3]
karena daftar input sama dengan[0,0,1,2,3]
.Catatan: Input harus disediakan sebagai daftar
Tidak digabungkan dengan penjelasan:
Penjelasan yang lebih luas & jauh lebih menarik secara visual:
Untuk penjelasan yang lebih luas dan jauh lebih menarik secara visual, pertimbangkan untuk kedua kalinya melalui "main" -Loop dalam kode di atas, di mana daftar inputnya
[0,2]
. Dalam hal ini, elemen dalam daftar "utama"l
adalah:dan
dan daftar
y
hanya akan berisi0
. Mengambil keuntungan dari cara Python untuk mengindeks elemen terakhir gridl[-1]
, kita dapat memberi label elemen paling kiri dari grid seperti:Pola apa yang Anda lihat? Setiap indeks di paling kiri dari grid adalah kelipatan dari 8, dan karena, dengan menggunakan persamaan
2^(n-1)-1
menghasilkan panjang setiap segmen dari titik-titik dalam grid, kita dapat melakukan((2^(n-1)-1)*2)+2
untuk menemukan panjang tepi atas grid secara keseluruhan (+2 untuk memasukkan tengah#
dan\n
akhir). Kita dapat menggunakan persamaan itu, yang akan kita panggili
untuk menemukan nilai indeks setiap elemen di sisi kiri kisi ukuran apa pun dengan membuat daftar, dan menambahkan ke daftar setiap bilangan bulat, yang akan kita panggil_
, dalam rentang0=>length of grid l[-1]
, sedemikian sehingga item tersebut adalah kelipatani
, DAN juga sedemikian sehingga_
TIDAK samai*(2^(n-1)-1)
, sehingga kita dapat mengecualikan segmen tengah#
s memisahkan bagian atas dari bagian bawah. Tapi kami ingin SEMUA elemen titik dari kiri, dan bukan hanya elemen di sisi paling kiri. Nah, ada perbaikan untuk itu, dan itu hanya akan menambahkan ke daftar daftar yang berisi dii+h
mana h adalah setiap bilangan bulat dalam rentang0=>2^(n-1)
setiap kali nilai dari rentang0=>length of grid l[-1]
ditambahkan ke daftar, sehingga setiap kali, akan ada sebanyak jumlah nilai yang ditambahkan ke daftar sebagai panjang satu kuadran titik. Dan itu adalah daftara
.Tapi sekarang, bagaimana dengan titik-titik di sebelah kanan? Baiklah, mari kita lihat pengindeksannya dengan cara yang berbeda:
Seperti yang Anda lihat, nilai sekarang di tengah adalah yang kita butuhkan, karena mereka adalah awal dari indeks setiap segmen titik di sisi kanan grid. Sekarang, apa polanya di sini? Nah, jika itu belum cukup jelas, sekarang nilai tengah semua kelipatan
i/2
! Dengan informasi itu, kita sekarang dapat membuat daftar lain,b
dimana kelipatani/2
ditambahkan dari jangkauan0=>length of grid l[-1]
sehingga setiap bilangan bulat dari rentang itu, yang akan kita panggil lagi_
, TIDAK sama dengan(i/2)*(p*2)
untuk mengecualikan garis#
s yang memisahkan bagian atas dan bagian bawah, DAN sedemikian rupa sehingga _ TIDAK sudah ada dalam daftar a, karena kita tidak benar-benar membutuhkan 8,16,32, dll. dalam daftarb
. Dan sekarang, sekali lagi, kami tidak hanya menginginkan indeks spesifik itu. Kami ingin SEMUA karakter titik di sisi kanan kotak. Yah, sama seperti yang kami lakukan dalam daftara
, di sini kami juga dapat menambahkan ke daftarb
daftar_+h
manah
setiap bilangan bulat dalam kisaran0=>2^(n-1)
.Sekarang, kami memiliki daftar
a
danb
dikemas dan siap untuk pergi. Bagaimana kita menyatukan ini sekarang? Di sinilah daftarW
,T
,G
, danC
masuk. Mereka akan memegang indeks untuk masing-masing kuadran tertentu dari titik-titik dalam gridl[-1]
. Sebagai contoh, mari kita daftar cadanganW
sebagai daftar untuk semua indeks yang sama dengan kuadran 1 (indeks 0) dari kisi. Dalam daftar ini, kami kemudian akan menambahkan2^(n-1)
daftar pertama dari daftara
, karena daftara
berisi semua indeks untuk titik-titik di bagian kiri kotak, dan kemudian membaginya semua sehinggaW
sekarang berisi(2^(n-1))*(2^(n-1))
elemen. Kami akan melakukan hal yang sama untuk daftarT
, tetapi dengan perbedaan yangT
akan mengandung elemen dari daftarb
, sejak ituT
dicadangkan untuk kuadran 2 (indeks 1). DaftarG
akan sama dengan daftarW
, kecuali itu akan berisi sisa elemen dari daftara
, dan daftarC
sama dengan daftarT
, kecuali sekarang berisi sisa elemen dari daftarb
. Dan itu dia! Kami sekarang memiliki nilai indeks untuk setiap kuadran yang berisi titik-titik dalam kisi, semua dibagi menjadi empat daftar yang sesuai dengan setiap kuadran. Kita sekarang dapat menggunakan 4 daftar ini (W, T, G, C) untuk memberi tahu program karakter mana yang harus diganti dalam kotakl[-1]
dengan masing-masing karakter dari kotakl[0]
, yang merupakan elemen paling pertama dari daftarl
. Karena nilainya ada di0
sini, itu akan mengganti semua titik di kuadran pertama (indeks 0) denganl[0]
daftar pemanfaatan kisiW
.Karena itu, kami akhirnya memiliki yang berikut:
Wah! Proses yang panjang, bukan? Namun, itu bekerja dengan sempurna, dan, sekali lagi, saya tidak bisa lebih bahagia. :)
sumber