Karpet Sierpinski

23

Siapa yang tidak suka fraktal yang baik? The Sierpinski Karpet adalah contoh klasik dari fraktal.

Untuk menyelesaikan tugas ini, Anda akan diminta untuk membuat karpet jenis ndan mencetak gambar yang dihasilkan ke stdout(lihat contoh di bawah ini untuk memformat) n, mewakili karpet tingkat. Langkah-langkahnya dapat ditemukan di artikel Wikipedia ini.

Nilai ini akan diambil dari stdinatau setara.

Misalnya, input 4 akan menghasilkan karpet level 4:

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■
■   ■       ■   ■ ■   ■       ■   ■ ■   ■       ■   ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■                   ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■                   ■ ■ ■       ■ ■ ■
■   ■       ■   ■                   ■   ■       ■   ■
■ ■ ■       ■ ■ ■                   ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■                   ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■
■   ■       ■   ■ ■   ■       ■   ■ ■   ■       ■   ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

Input 3 akan menghasilkan karpet level 3:

■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■
■   ■       ■   ■
■ ■ ■       ■ ■ ■
■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■

Input 2 akan menghasilkan karpet level 2:

■ ■ ■
■   ■ 
■ ■ ■

Dan input 1 akan menghasilkan karpet level 1 (hanya persegi):

Perhatikan spasi di antara kolom.

Idenya adalah untuk menggunakan karakter ■ untuk blok dan ruang untuk celah

Baris dimulai dengan karakter ■.

Seperti biasa, solusi terkecil menang dengan jumlah karakter (karena karakter non-standar).

Atau, # dapat digunakan sebagai ganti karakter ■ dalam bahasa yang tidak mendukung Unicode.

Paul Clavier
sumber
1
Bukankah contoh pertama tingkat ketiga, bukan yang kedua?
Pengoptimal
6
Pertanyaan yang bagus, tetapi apakah mereka harus menjadi karakter itu? itu bukan ASCII, yang mengesampingkan banyak bahasa. Bisakah mereka hanya ruang dan X atau O? Saya benar-benar berpikir gambar Anda akan terlihat lebih baik dengan spasi daripada kotak kosong.
Level River St
Mengubah spons menjadi karpet, terima kasih.
Paul Clavier
Bagaimana jika bahasa Anda tidak mendukung keluaran unicode, apakah ada alternatif ASCII?
flawr
1
Bisakah garis memiliki spasi tambahan?
Dennis

Jawaban:

15

CJam, 38 37 31 30 28 karakter

Oh well, kami menghitung berdasarkan karakter, jadi mari kita lakukan beberapa Unicode membongkar:

"B胷맋풽巓뱖ᮨ㣙¬䙧੥墱륋청"2G#b129b:c~

Uji di sini. Masukkan saja level yang diinginkan ke dalam kolom input.

Penjelasan

Setelah konversi basis, ini

3li(#,{3b1f&2b}%_f{f{&S9632c?S}N}

yang sama dengan yang berikut, hanya dengan karakter Unicode ditulis sebagai 9632c:

3li(#,{3b1f&2b}%_f{f{&S'■?S}N}

Kode ini didasarkan pada pengamatan berikut: jika kita melihat koordinat (x, y) dari masing-masing sel, maka kita mendapatkan sel kosong, setiap kali kedua x dan y memiliki 1pada posisi yang sama dalam representasi basis-3 mereka. Jika Anda memikirkannya, pola pengulangan skala kecil adalah digit basis-3 yang signifikan, maka digit berikutnya yang lebih signifikan mengatur pengulangan skala besar berikutnya dan seterusnya.

3                                      "Push a 3 on the stack.";
 li(                                   "Read input, convert to integer, decrement.";
    #                                  "Raise to that power. This yields the dimensions.";
     ,                                 "Turn into a range array.";
      {       }%                       "Map the block onto the array.";
       3b                              "Convert to base 3.";
         1f&                           "Bit-wise AND each digit with 1.";
            2b                         "Convert to base 2.";
                _                      "Duplicate this list.";
                 f{          }         "Map this block onto one list, with the second list
                                        as an additional parameter.";
                   f{      }           "Map this block onto the second list, with the first
                                        list's current element as an additional parameter.";
                                       "I.e. this iterates over all coordinate pairs.";
                     &                 "Bitwise AND to check that the base-3 representations
                                        had a 1 in the same position.";
                      S'■?             "Select the right character.";
                          S            "Push a space.";
                            N          "Push a newline";

Isi dari array yang dihasilkan dicetak secara otomatis.

Terima kasih kepada Dennis karena telah memangkas tiga byte.

Martin Ender
sumber
2
#0<'■S-> #~S'■menyimpan 1 karakter.
Pengoptimal
Anda bisa menggantinya [1_]a#~dengan 3Yba&.
Dennis
@Dennis rapi. Terima kasih!
Martin Ender
@ Dennis Saya selalu lupa bahwa &menghasilkan nilai kebenaran / kepalsuan (atau bahkan itu ada). Mungkin layak posting di tips CJam untuk cara kanonik untuk menguji apakah array mengandung beberapa elemen.
Martin Ender
1
@Ypnypn Tidak. Itu terlihat lebih lama tapi itu karena karakter Unicode bukan monospace. Kode yang dibongkar memiliki 30 karakter.
Martin Ender
7

Matlab (113) (110) (99) (85)

Anda dapat mencobanya di sini (Anda harus mengganti input('')dengan input yang Anda inginkan.)

Sekarang 99 berkat feersum! Dan sekarang turun ke 85 berkat RTL!

Golf:

a=ones(3);a(5)=0;c=1;for i=2:input('');c=kron(c,a);end;disp(char(kron(c,[1,0])*3+32))

Tidak Disatukan:

a=ones(3);a(5)=0;c=1;  %creating the template / anchor
for i=2:input('');
    c=kron(c,a);       %recursive iterations
end;
disp(char(kron(c,[1,0])*3+32))

d=[c,c]*0;  %this is all just for adding the additional spaces
d(:,1:2:end)=c;
disp(char(d*3+32));    %converting to spaces (32) and # (35)

Penjelasan:

Saya menyalahgunakan produk Kroner untuk tugas ini. (Ini adalah produk khusus yang ditentukan untuk dua matriks ukuran masing-masing sewenang-wenang. Contoh:

A = [1,2] is a 3x2 matrix, B is a nxm matrix.
    [3,4]
    [5,6]

Kemudian

kron(A,B) = [1*B , 2*B] is a 2n x 2m matrix.
            [3*B , 4*B]
            [5*B , 6*B]

Jadi inilah contoh untuk n = 5 (Dalam metode penghitungan yang lama, itu adalah 4);

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   #                                                       #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   #                                                       #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # #                                                       # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   #                                                       #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # #                                                       # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   #                                                       #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   #                                                       #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
cacat
sumber
Terima kasih, saya tidak melihat bahwa persyaratannya berubah. Saya juga memperbarui kode (saya hanya harus mengubah nilai awal dari for loop.)
flawr
Alih-alih d=zeros(size([c,c]))Anda harus menggunakan d=[c c]*0.
feersum
bagus, saran: variabel ddapat dihindari dengan menyalahgunakan kronsekali lagi: disp(char(kron(c,[1,0])*3+32));,
RTL
6

Haskell, 114 108

s 1=["# "]
s n=k j++k(map(>>" ")j)++k j where j=s$n-1;k i=j%i%j
(%)=zipWith(++)
main=interact$unlines.s.read
haskeller bangga
sumber
5

Python - 100

r=range(3**~-input())
for i in r:print" ".join("# "[any(i/3**k%3==j/3**k%3==1for k in r)]for j in r)
Wrzlprmft
sumber
5

Perl 5: 68 karakter

n di stdin.

#!/usr/bin/perl -l
//,print map/2/?"  ":"■ ",map$_+$',@,for@,=grep!/[24-9]/,0..3x<>/10

Representasi ternary berkode desimal dari daftar koordinat pertama kali dihasilkan di @,(nama dipilih sehingga tidak perlu ruang antara @,dan for) menggunakan digit 0, 1, dan 3. Sekarang menambahkan koordinat x dan y dalam domain desimal akan memiliki 2 dalam hasil jika dan hanya jika ada dua yang ada di posisi yang cocok. //digunakan untuk menyebarkan variabel default $_dari loop luar ( for) ke variabel postmatch $'ketika itu dibayangi oleh mapvariabel default di loop dalam.

nutki
sumber
4

Java, 330 283 Karakter

class T{public static void main(String[]a){int n=Integer.valueOf(a[0]);int m=(int)Math.pow(3,n-1);for(n=0;n<m;n++){for(int j=0;j<m;){String s="#";int x=n;int y=j++;while(x>0||y>0){if(x%3==1&&y%3==1){s=" ";}x/=3;y/=3;}p(s);}p("\n");}}static void p(String s){System.out.print(""+s);}}

Param adalah ukuran yang Anda inginkan. Kecuali ada optimasi untuk algoritme, saya mencoba menekan semuanya.

Terima kasih kepada @StretchManiac menghapus imetode dan membersihkan deklarasi sedikit diperas .

Kode yang Dapat Dibaca

class T {
    public static void main(String[] a) {
        int n = Integer.valueOf(a[0]);
        int m = (int) Math.pow(3, n - 1);
        for (n = 0; n < m; n++) {
            for (int j = 0; j < m;) {
                String s = "#";
                int x = n;
                int y = j++;
                while (x > 0 || y > 0) {
                    if (x % 3 == 1 && y % 3 == 1) {
                        s = " ";
                    }
                    x /= 3;
                    y /= 3;
                }
                p(s);
            }
            p("\n");
        }
    }

    static void p(String s) {
        System.out.print("" + s);
    }
}
Kompas
sumber
Anda dapat menyingkirkan "publik" sebelum kelas, sebagai argumen utama yang dapat Anda lakukan String[]a, dan jika Anda hanya menggunakan isekali, maka Anda akan lebih baik menyingkirkan metode ini.
Stretch Maniac
@ StretchManiac terima kasih atas tipsnya. Saya akan menerapkannya sedikit.
Kompas
3
Mengapa Anda melakukannya ""+sdalam pmetode Anda ? Itu tiga karakter tambahan tanpa tujuan. Bahkan jika jenis sselain apa pun String, itu masih sama sekali tidak perlu.
David Conrad
1
Mengubahnya ke static void p(int s){System.out.print((char)s);}dan di make utama itu int s=35;, s=32;dan p(10);(bukan p("\n");) dan menyimpan beberapa karakter lebih.
David Conrad
Anda dapat menyimpan tujuh karakter dengan mengubah Integer.valueOfkenew Byte
Ypnypn
4

Raket 230 229 225 220

Bukan jam terbaik Racket untuk bermain golf.

Golf:

(define(s n)(letrec([t(λ(x y)(if(or(= x 0)(= y 0))"■"(if(=(modulo x 3)(modulo y 3)1)" "(t(floor(/ x 3))(floor(/ y 3))))))][i(expt 3(- n 1))])(for-each displayln(for/list([r i])(string-join(for/list([c i])(t r c))" ")))))

Tidak Disatukan:

(define (s n)
  (letrec ([t (λ (x y)
                (if (or (= x 0) (= y 0)) 
                    "■"
                    (if (= (modulo x 3) (modulo y 3) 1)
                        " "
                        (t (floor (/ x 3)) (floor (/ y 3))))))]
           [i (expt 3 (- n 1))])
    (for-each displayln 
              (for/list ([r i])
                (string-join 
                 (for/list ([c i]) 
                   (t r c)) " ")))))
Matthew Butterick
sumber
4

C: 123 118 111 104 karakter

Berdasarkan ide yang sama dengan solusi perl saya. Setelah menambahkan beberapa spasi:

m=0x55555555;
x;
main(n){
  scanf("%d",&n);
  n=1<<2*--n;
  for(x=n*n;x--;)
    printf(x&x/2&m?"":"%c%c",x&x/n&m?32:35,x&n-1?32:10);
}

Menggunakan sistem ternary yang mengkodekan setiap digit dengan 2 bit. Nilai ilegal (memiliki dua yang dalam posisi ganjil) difilter dengan x & (x>>1) & 0b01010101. Kedua koordinat disimpan dalam satu nilai, jadi memeriksa warna piksel turun ke x & (x >> 2 * n) & 0b01010101. ndisimpan sebagai kekuatan 2 untuk kenyamanan.

Edit

Diganti definedengan konstanta sederhana m.

Edit 2

0x5555555mask dapat diwakili dengan (1LL<<32)/3, tetapi kita hanya membutuhkan nbit-bit itu sehingga n/3cukup.

x;
main(n){
  scanf("%d",&n);
  n=1<<2*--n;
  for(x=n*n;x--;)
    printf(x&x/2&n*n/3?"":"%c%c",x&x/n&n/3?32:35,x&n-1?32:10);
}

Edit 3

Tweak kecil. Satu 2 char gain mengandalkan scanf dieksekusi sebelum nilai pemuatan nuntuk eksekusi --n. Eol hanya bisa mengikuti #, ya.

x;
main(n){
  n=scanf("%d",&n)<<2*--n;
  for(x=n*n;x--;)
    x&x/2&n*n/3||printf(x&x/n&n/3?"  ":x&n-1?"# ":"#\n");
}
nutki
sumber
3

HTML / JavaScript, 205 Karakter

Obfuscatweet , 205 Chars

document.write(unescape(escape('🁳𨱲𪑰𭀾𬰽𙰦𫡢𬱰𞰧𞱮🐴𞱭👍𨑴𪀮𬁯𭰨𜰬𫠭𜐩𞱦𫱲𚁩🐰𞱩🁭𞱩𚰫𛁤𚀧🁢𬠾𙰩𚑻𩡯𬠨𪠽𜀻𪠼𫐻𚑩𩠨𨰨𪐬𪠫𚰩𚑤𚀧𘰧𚐻𩑬𬱥𘁤𚁳𚑽𩡵𫡣𭁩𫱮𘁣𚁸𛁹𚑻𭱨𪑬𩐨𮁼𯁹𚑻𪑦𚁸𙐳🐽𜐦𙡹𙐳🐽𜐩𬡥𭁵𬡮𘀰𞱸👦𚁸𚐻𮐽𩠨𮐩𯑲𩑴𭑲𫠠𜑽𩡵𫡣𭁩𫱮𘁦𚁡𚑻𬡥𭁵𬡮𘁍𨑴𪀮𩡬𫱯𬠨𨐯𜰩𯑦𭑮𨱴𪑯𫠠𩀨𨐩𮱤𫱣𭑭𩑮𭀮𭱲𪑴𩐨𬰫𨐩𯐼𛱳𨱲𪑰𭀾🁳𭁹𫁥🠪𮱦𫱮𭀭𩡡𫑩𫁹𞠢𠱯𭑲𪑥𬠢').replace(/uD./g,'')))

HTML / JS, 298 Karakter

Karena cara HTML bermain dengan spasi, beberapa karakter harus didedikasikan untuk nbsp char. Selain itu, font default sebagian besar browser bukanlah Courier, jadi saya harus mengaturnya juga. Tentang gaya penataan 20 karakter. Jika ini membutuhkan metode input langsung, saya bisa menambahkannya, tetapi mengubah input saat ini adalah pengaturan n ke nilai yang berbeda.

Demo

<script>s='&nbsp;';n=4;m=Math.pow(3,n-1);for(i=0;i<m;i++,d('<br>')){for(j=0;j<m;)if(c(i,j++))d('#');else d(s)}function c(x,y){while(x||y){if(x%3==1&&y%3==1)return 0;x=f(x);y=f(y)}return 1}function f(a){return Math.floor(a/3)}function d(a){document.write(s+a)}</script><style>*{font-family:"Courier"

HTML / JS yang bisa dibaca

<script>
    s='&nbsp;';
    n=4;
    m=Math.pow(3,n-1);
    for(i=0;i<m;i++,d('<br>')){
        for(j=0;j<m;)
            if(c(i,j++))
                d('#');
            else d(s)
    }
    function c(x,y){
        while(x||y){
            if(x%3==1&&y%3==1)
                return 0;
            x=f(x);
            y=f(y)
        }
        return 1
    }
    function f(a){
        return Math.floor(a/3)
    }
    function d(a){
        document.write(s+a)
        }
</script>
<style>
*{font-family:"Courier"
Kompas
sumber
3

CJam, 38 35 32 31 karakter

"■ ""՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~

Cobalah online.

Contoh dijalankan

$ cjam <(echo '"■ ""՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~') <<< 3; echo
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■       ■ ■ ■ 
■   ■       ■   ■ 
■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 

Bagaimana itu bekerja

"՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~

mengkonversi string Unicode dari basis 60.000 ( 6e4b) ke basis 128 ( 128b), dilemparkan ke Karakter (:c ) dan mengevaluasi string yang dihasilkan ( ~).

Akibatnya, kode berikut ini dijalankan:

"■ "                                " C := '■ '                                           ";
    li(                             " J := int(input()) - 1                               ";
       {                      }*    " for I in range(J):                                  ";
        z]A*                        "   T := [zip(C)] * 10                                ";
            ):,                     "   U := pop(T)                                       ";
               Sf*                  "   V := [ ' ' * len(u) : u ∊ U ]                     ";
                  4\t               "   U[4] := V                                         ";
                     3/{:+z~}%      "   C := { c : c ∊ zip(concat(u)), u ∊ U.split(3) }   ";
                              zN*  " print '\n'.join(zip(C))                              ";
Dennis
sumber
3

Python 3 - 116 113 karakter

EDIT: Yah, gunakan trik yang saya tidak suka terlalu banyak dan kompres kode oleh 3 byte. Entah itu cara terbaik yang mungkin, tetapi saya akan pergi dengan itu.

exec(bytes('ⱴ㵬❛離₠崧氬浡摢⁡㩺癥污稨✫潦⁲湩琠❝਩潦⁲⁩湩爠湡敧椨瑮椨灮瑵⤨⴩⤱爺瀬氽✨㍛✪Ⱙ⡬嬢⭫‧✠⠪⨳椪⬩⤢琻爽瀫爫昊牯椠椠㩴牰湩⡴⥩','utf-16')[2:].decode('utf-8'))

Mungkin berisi beberapa karakter yang tidak patut dicetak, jadi inilah versi string yang dapat dicetak.

'ⱴ㵬❛離₠崧氬浡摢\u2061㩺癥污稨✫\u206b潦\u2072\u206b湩琠❝\u0a29潦\u2072\u2069湩爠湡敧椨瑮椨灮瑵⤨\u2d29⤱爺瀬氽✨㍛✪Ⱙ⡬嬢\u2b6b‧✠⠪⨳椪⬩⤢琻爽瀫爫昊牯椠椠\u206e㩴牰湩⡴⥩'

Tidak terlalu hebat, tapi setidaknya mengalahkan beberapa bahasa.

Apa yang diperluas ke:

t=['■ ']
for i in range(int(input())-1):r,p=[k*3for k in t],[k+'  '*(3**i)+k for k in t];t=r+p+r
for i in t:print(i)

Agak tidak terserang jika seseorang tidak dapat melihat cara kerjanya:

t=['■ ']                                     # iteration 1
for i in range(int(input()) - 1):            # do n-1 more iterations
    r = [k * 3 for k in t]                   # first & last rows are the last carpet x3
    p = [k + '  ' * (3 ** i) + k for k in t] # middle row: last carpet, space, last carpet
    t = r + p + r                            # and put them to the new carpet
for i in t:                                  # print final iteration
    print(i)
PurkkaKoodari
sumber
Wow python, itu mengesankan
Paul Clavier
3

Mathematica, 71 byte

Grid@Nest[ArrayFlatten@ArrayPad[{{0}},1,{{#}}]&,1,#]/.{0->"",1->"■"}&

memasukkan

3

keluaran

masukkan deskripsi gambar di sini

J42161217
sumber
Saya mengikuti Anda seperti menjalar total. +1;).
Magic Gurita Guci
Apakah Anda pikir Anda dapat mempersingkat ini dengan SubstitusiSistem ?
Vitaliy Kaurov
2

CJam, 76 karakter

3ri(#:M_*,{_M/:I\M%:J;;{I3%1=J3%1=&0X?:X;I3/:I0>J3/:J0>|}gX'■S?1:X;}%M/Sf*N*

Ini adalah terjemahan langsung dari rumus yang diberikan di sini

Coba di sini

Pengoptimal
sumber
2

Bash + coreutils, 105 karakter unicode

Karena kami menghitung karakter dan bukan byte:

eval `iconv -tunicode<<<潦⡲眨㌽⨪␨ⴱ⤱琬〽琻眼眪琻⬫⤩笻戠ꂖ昻牯⠨㵸╴ⱷ㵹⽴㭷㹸簰祼〾砻㴯ⰳ⽹㌽⤩笻⠠砨㌥ㄭ籼╹ⴳ⤱簩扼尽簠硼〽紻瀻楲瑮⁦␢⁢㬢⠨╴⵷⭷⤱簩敼档㭯੽|cut -b3-`

Dalam bentuk yang diterjemahkan:

Pure Bash, 143 byte

for((w=3**($1-1),t=0;t<w*w;t++));{
b=■
for((x=t%w,y=t/w;x>0||y>0;x/=3,y/=3));{
((x%3-1||y%3-1))||b=\ ||x=0
}
printf "$b "
((t%w-w+1))||echo
}

Input diambil dari baris perintah args:

Keluaran:

$ ./sierpinskicarpet.sh 3
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■       ■ ■ ■ 
■   ■       ■   ■ 
■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
$ 
Trauma Digital
sumber
2

C #

Program lengkap - 237:

using System;class P{static void Main(string[] a){int b=(int)Math.Pow(3,int.Parse(a[0])-1),c,d,e,f;for(c=0;c<b;c++){var g="";for(d=0;d<b;){var h="■";e=c;f=d++;while(e>0|f>0){h=e%3==1&f%3==1?" ":h;e/=3;f/=3;}g+=h;}Console.WriteLine(g);}}}

LINQPad - 166 + Math.Ceiling(Math.Log(a + 1) / Math.Log(10))

int a=3;int b=(int)Math.Pow(3,a-1),c,d,e,f;for(c=0;c<b;c++){var g="";for(d=0;d<b;){var h="■";e=c;f=d++;while(e>0|f>0){h=e%3==1&f%3==1?" ":h;e/=3;f/=3;}g+=h;}g.Dump();}
William Barbosa
sumber
Saya tahu ini sudah hampir tiga tahun, tetapi Anda dapat bermain golf beberapa hal seperti ini: using System;class P{static void Main(string[]a){string g,h;for(int b=(int)Math.Pow(3,int.Parse(a[0])-1),c=-1,d,e,f;++c<b;Console.WriteLine(g))for(g="",d=0;d<b;g+=h)for(h="■",e=c,f=d++;e>0|f>0;e/=3,f/=3)h=e%3==1&f%3==1?" ":h;}}( 229 byte / 227 karakter ) ( = 3 byte, sehingga Anda dapat menggantinya dengan #untuk menyimpan 2 byte juga). Saya terutama meletakkan segala sesuatu di dalam for-loop sehingga tidak perlu lagi tanda kurung.
Kevin Cruijssen
2

C - 154

Masukan dari stdin. Saya mencoba menemukan cara yang baik untuk menghindari fungsi tambahan, tetapi tidak dapat menemukan apa pun.

Hitungan karakter hanya mencakup ruang yang diperlukan.

p(l,x,y){
    return l?x/l&y/l&1||p(l/3,x%l,y%l):0;
}
x,y;
main(v){
    scanf("%d",&v);
    v=pow(3,--v);
    for(;y<v;y++,puts(""))
        for(x=0;x<v;)
            printf("%c ",p(v,x++,y)?32:35);
}
Allbeert
sumber
1

PHP, 194 karakter

The nditerima sebagai argumen pertama di baris perintah.

<?php
function d(&$a,$n,$e,$x,$y){if(--$n)for(;$i<9;)$p=pow(3,$n)|d($a,$n,$e|$i==4,$x+$p*$j,$y+$p*($i-$j)/3)|$j=++$i%3;else$a[$x][$y]=$e?" ":■;}@d($a,$argv[1]);foreach($a as$s)echo join($s),"
";

Dapat dibaca

<?php

function draw(&$array, $n, $empty, $x, $y) {
    $n--;
    if ($n != 0) {
        for ($i = 0; $i < 9; $i++) {
            $j = $i % 3;
            $p = pow(3, $n);
            draw($array, $n, $empty || $i == 4, $x + $p * $j, $y + $p * ($i - $j) / 3);
        }
    } else {
        $array[$x][$y] = $empty ? " " : "#";
    }
}

$array = array();
draw($array, $argv[1], false, 0, 0);
foreach ($array as $line) {
    echo join($line), "\n";
}
Gedrox
sumber
1
Jika Anda menggunakan char sebagai gantinya #, Anda dapat menyimpan 2 karakter dengan menghapus tanda kutip.
Ismael Miguel
1

Scala 230 karakter

Kode golf:

object T extends App {def m=math.pow(3,args(0).toInt-1).toInt-1;def p=print _;val x=0 to m;x.map{n=>x.map{j=>if(q(n,j)==1)p(" #");else p("  ")};p("\n");};def q(n:Int,j:Int):Int={if(n>0|j>0)if((n%3&j%3)==1)0 else q(n/3,j/3)else 1}}

Kode tidak dikunci:

object T extends App {
  def m = math.pow(3, args(0).toInt - 1).toInt - 1;

  def p = print _;
  val x = 0 to m;
  x.map { n => x.map { j => if (q(n, j) == 1) p(" #"); else p("  ")}; p("\n");};

  def q(n: Int, j: Int): Int = {
    if (n > 0 | j > 0) if ((n % 3 & j % 3) == 1) 0 else q(n / 3, j / 3) else 1
  }
}

Hanya ruang yang diperlukan yang disertakan.

Mathill
sumber
1

V , 21 byte (tidak bersaing)

é*Àñ}yPgvr PGï3pyGHP

Cobalah online!

Hexdump:

00000000: e92a c0f1 167d 7950 6776 7220 5047 ef33  .*...}yPgvr PG.3
00000010: 7079 4748 50                             pyGHP

V lebih baru daripada tantangan, sehingga harus ditandai sebagai tidak bersaing. Tapi tetap, itu bagus untuk melihat jawaban ini menjadi waaaaay lebih pendek dari semua yang lain, bahkan ketika menghitung dalam byte daripada karakter.

DJMcMayhem
sumber
Hanya pengingat; tidak lagi non-bersaing
RedClover
1

OK, 40 byte

`0:" #"{(x-1)(,'//3 3#111101111b*9#,)/1}

Cobalah online.

Dimulai dengan 1, dan kemudian menariknya dalam kotak (1 1 1;1 0 1;1 1 1), yang kemudian menarik dalam kotak dengan cara yang sama, dll. Mengulangi jumlah yang diperlukan kali.

zgrep
sumber
1

C # (.NET Core) , 162 byte

n=>{var f="";int s=(int)Math.Pow(3,n),z=0;while(z<s*s){int x=z%s,y=z/s,h=1;for(;x>0|y>0;y/=3,x/=3)if(y%3==1&x%3==1)h=0;f+=" #"[h]+(z++%s<s-1?" ":"\n");}return f;}

Cobalah online!

Merosot

n=>{
    var f="";
    int s=(int)Math.Pow(3,n),z=0;

    while(z<s*s)
    {
        int x=z%s, y=z/s, h=1;
        for(; x>0 | y>0; y/=3, x/=3)
            if(y%3==1 & x%3==1)
                h=0;

        f += " #"[h] + (z++%s<s-1? " " : "\n");
    }

    return f;
}
Ayb4btu
sumber
0

R , 92 karakter

94 byte dengan karakter khusus.

write(c(" ","■")[1+Reduce("%x%",rep(list(matrix(c(1,1,1,1,0,1),3,3)),n<-scan()-1),1)],1,3^n)

Cobalah online!

Giuseppe
sumber
Saya hanya kagum orang masih melakukan ini 4 tahun kemudian
Paul Clavier
1
@ PaulClavier itu tantangan besar; Anda harus bangga :)
Giuseppe
0

Kanvas , 17 16 17 karakter

■;╷[⌐ +2×;┌∔∔;3*+

Coba di sini!

-1: Digunakan alih-alih menghapus yang pertama di dalam loop.
+1: Memperbaiki perilaku errenous: sekarang terkait dengan level 1, sebagaimana ditentukan dalam pos asli.

hakr14
sumber
Hal ini bersaing, per konsensus baru.
Erik the Outgolfer
@EriktheOutgolfer oh, terima kasih telah memberi tahu saya!
hakr14
Dan ya, dalam hal ini skornya adalah 17, tetapi kami menghitung solusi dalam byte, bukan karakter (Kanvas memiliki halaman kode).
Erik the Outgolfer
@EriktheOutgolfer biasanya ya, tetapi tantangan ini menggunakan karakter, karena bersifat multibyte. Mengatakan demikian ke bagian bawah di pos asli.
hakr14
Anda perlu menambahkan satu ke semua input Anda. 1 harus mengembalikan kotak (yaitu apa yang dikembalikan 0 di sini)
Paul Clavier
0

Pip -S , 30 karakter

"■■ "@MX{{aTB3R2i}MSg}MC3**a/3

Cobalah online!

Ide dasarnya: pertimbangkan kisi koordinat di pangkalan 3. Lubang-lubang di karpet terjadi di mana 1) trit di koordinat x adalah 1, dan 2) trit di posisi yang sama di koordinat y juga 1.

"■■ "@MX{{aTB3R2i}MSg}MC3**a/3
                                i is 0; a is 1st cmdline arg (implicit)
                        3**a/3  Width/height of the carpet
                      MC        Make a coordinate grid that size and map this function
                                to the coordinate pairs:
                    g            Take each [x y] pair
                  MS             Map this function to each coord and add the results:
         {aTB3   }                Convert to base 3
              R2i                 Replace 2's with 0's
                                  E.g. 15 -> 120 -> 100 and 16 -> 121 -> 101
                                 When we add the results, we get [15 16] -> 201
      MX{            }           Take the max of that list (0, 1, or 2)
"■■ "@                           Use that to index into this string (resulting in a space
                                 iff two 1's coincided to make a 2, or ■ otherwise)
                                Print the resulting nested list with each sublist on its
                                own line and space-delimited (implicit, -S flag)

Solusi serupa, jumlah karakter yang sama tetapi -2 byte: {2N({aTB3R2i}MSg)?s'■}MC3**a/3

DLosc
sumber
0

K (ngn / k) , 50 byte

terima kasih @Dosc untuk mengingatkan saya, saya harus menampilkan spasi antara kolom

1@"\n"/"# "1_',/'1,''+/''a*/:\:a:+2!!1_(. 0:"")#3;

Cobalah online!

ngn
sumber
@Dosc, terima kasih, perbaiki juga persyaratan aneh lainnya: stdin / stdout alih-alih arg / hasil; off-by-one "level"
ngn