16

Mengkuadratkan Alun-Alun adalah proses ubin persegi hanya menggunakan kotak lainnya. Jika ubin ini hanya menggunakan kotak dengan ukuran berbeda, maka itu dianggap sempurna . Kotak kuadrat sempurna terkecil yang mungkin adalah ubin 112x112 persegi menggunakan 21 kotak yang berbeda.

Saya telah membuat versi seni ascii dari kotak ini di bawah:

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

Kiriman Anda harus mencetak kotak di atas. Anda dapat mencetak refleksi dan / atau rotasi kotak di atas jika Anda mau. Baris baru yang tertinggal di baris terakhir diizinkan. Ini adalah kode-golf , jadi pengiriman terkecil menang!

code-golf kolmogorov-complexity

— Nathan Merrill
sumber

@Optimizer Menurut pertanyaan dan Wikipedia, semua kotak kecil harus berukuran sama sekali berbeda.

— Level River St

Nathan, Apakah pengajuan saya sesuai dengan aturan? Saya menggunakan ketebalan yang seragam untuk semua lini.

— DavidC

@ Davidvidarrarr Saya memiliki setiap sisi dari persegi yang diuraikan (sehingga sisi dalam memiliki beberapa tanda pon). Selain itu, Anda perlu menggunakan #sebagai gantinyaX

— Nathan Merrill

1

Nathan, Di pesawat, ujung-ujungnya bukan batas. Mereka adalah segmen garis satu dimensi. Di mana dua ubin berbatasan, kita harus melihat satu baris, bukan dua. Kalau tidak, kami menyampaikan gagasan bahwa ada celah di antara ubin.

— DavidC

@DavidCarraher sementara itu benar, saya pikir lebih masuk akal untuk mewakilinya di ascii dengan cara ini.

— Nathan Merrill

4

CJam, 88 84 83 byte

'p:Ci_C*a*"2#   *%!"{i_S*a*{3af.|W%z}4*1$0=C#C*f{\+}..e<{_C&{oNo}|}%}/

Uji di sini.

Penjelasan

Inilah ide dasarnya: mulailah dengan kotak "kosong" 112x112. Sekarang pergi melalui kotak dalam urutan membaca (kiri ke kanan, atas ke bawah). Tambahkan setiap kotak ke posisi pertama yang tersedia. Setelah itu, cetak semua baris yang sudah selesai - ini memastikan bahwa kita hanya perlu memeriksa baris pertama (yang tersisa) untuk mencari tahu ke mana persegi selanjutnya berjalan.

Kotak kosong diinisialisasi ke ps, karena saya membutuhkan karakter dengan kode karakter lebih besar dari ruang dan #, dan karena saya bisa menggunakan kembali kode karakternya sendiri 112untuk ukuran kotak awal. Saya memanfaatkan beberapa trik seni ASCII Dennis di sini untuk mengisi kotak-kotak kecil ke dalam kotak.

'p:C        e# Store the character 'p' in C.
i           e# Convert to its character code 112.
_C*a*       e# Generate a 112x112 array of p's.
"2#   *%!"  e# The 21 characters in this string correspond to the side lengths of
            e# the squares in the solution in reading order.
{           e# For each character in that string...
  i         e#   Convert to its character code (the current square's side length N).
  _S*a*     e#   Generate an NxN array of spaces.
  {         e#   Run this block 4 times. Each iteration turns the leading column into #'s
            e#   and then rotates the square by 90 degrees.
    3af.|   e#     For the first character in each row, take the bitwise OR with 3. 
            e#     This turns spaces into #'s and leaves #'s unchanged.
    W%z     e#     Reverse and transpose, which rotates by 90 degrees.
  }4*
  1$0=      e#   Copy the remaining grid and fetch the top row.
  C#        e#   Find the index of the first 'p'.
  C*        e#   Get a string of that many p's.
  f{\+}     e#   Prepend this string to each row of the small square, which gives the
            e#   square the correct horizontal position.
  ..e<      e#   Take the pairwise minimum of the square and the remaining grid. The p's
            e#   prepended to the square will leave the grid unchanged, but the spaces
            e#   and #'s in the square will overwrite the p's in the grid.
  {         e#   Map this block onto each row of the grid.
    _C&     e#     Copy the row and check if any p's are left.
    {oNo}|  e#     If NOT, the row is complete and we print it together with a newline.
            e#     This also removes the row from the grid, such that the top row for
            e#     the next iteration will have space for the next square left.
  }%
}/

— Martin Ender
sumber

9

Mathematica 360 426

Kode ini bekerja dengan terlebih dahulu menggambar kuadrat kotak yang sempurna, rasterising dan binarizing gambar, dan kemudian mengonversi 0 menjadi "#" dan 1 menjadi "".

Output dikembalikan sebagai karakter ASCII biasa dalam sebuah tabel.

f@{n_,x_,y_}:=Rectangle[{x,y},{x+n,y+n}];t=Transpose;
Flatten[i=Rasterize[Graphics[{EdgeForm[{(*Thickness[.015],*)Black}],White,
f/@ Partition[{33,0,0,29,0,33,50,0,62,37,33,0,25,29,37,42,70,0,18,70,42,24,88,42,9,54,53,7,63,53,15,50,62,17,65,60,
11,82,66,19,93,66,35,50,77,27,85,85},3]
},ImageSize->70
],RasterSize->70]//Binarize//ImageData,1]/.{0:> "#",1:> " "};
GraphicsGrid@t@Most@Most@Rest@t[Most@Most[Rest[ArrayReshape[%,Dimensions[i]]]]]

Saya lebih suka rendering ini, diperoleh dengan menghapus Thickness[.015]

— DavidC
sumber

Ketebalan garis tidak bervariasi, 50x50 persegi adalah 48 karakter spasi dan 48 karakter spasi, dengan batas #'s. Itu bertabrakan dengan kotak lain di kanan dan bawah, yang ditarik dengan cara yang sama. Di mana dua kotak yang memiliki #semua bulat di luar bertemu, karena itu Anda mendapatkan ganda #untuk garis dalam, Dan kotak memang persegi, mereka memiliki jumlah karakter yang sama secara vertikal dan horizontal, Masalahnya adalah font. Jawaban ini tidak sesuai dengan spesifikasi, Jika diterima, pertanyaannya akan tertutup untuk kemenangan yang tidak objektif.

— Level River St

Garis-garis dipahami sebagai satu dimensi, bukan dua dimensi. Mereka tidak dapat diartikan sebagai batas yang memiliki ketebalan. Bagaimanapun, kita mempartisi wilayah kuadrat menjadi subkawasan kuadrat. Perbatasan tidak boleh mengambil area apa pun.

— DavidC

Itulah intinya. Garis pergi di antara kotak , dan OP memilih untuk mewakili kotak dengan batas internal. Mungkin lebih jelas jika dia memilih untuk menggunakan simbol yang berbeda untuk setiap kotak (dan mungkin juga mengisinya). Dalam kasus apa pun, seperti yang Anda lihat dari pertanyaan bendera baru, pemahaman yang biasa (dan seluruh poin dari kompleksitas komolgorov tag) adalah dengan setia mereproduksi representasi seni Ascii yang disediakan oleh OP, bukan membuat interpretasi Anda sendiri. Meski menarik, ini bukan jawaban yang valid. Banyak kotak masih memiliki jumlah karakter dan tinggi yang berbeda.

— Level River St

Mengingatkan saya pada Von Karman Streets

— Beta Decay

3

Ruby, 180 byte

Versi golf berdasarkan pada versi ungolfed di bawah ini. Kami mengambil keuntungan dari kenyataan bahwa biasanya ada 2 atau 3 kotak dengan yang samay koordinat yang untuk sudut kiri atas.

String sulap pertama berisi kode ASCII untuk square sidelength+70dan y increment +40. Ketika menemukan sidelength kuadrat (kode Ascii> 67) kita mengasumsikan kuadrat berikutnya berada pada koordinat y yang sama, dan koordinat x dapat diperoleh dengan menambah koordinat x saat ini dengan sidelength+2. Ketika menjumpai kenaikan bertahap (kode Ascii <67) kami menambah koordinat y sesuai dan mengatur ulang koordinat x ke angka yang dikodekan dalam string sihir kedua.

a=Array.new(112){?#*112}
x=y=1
j=9
'vg_CLW0SUO3J\,a]M*KV/T3n-Hi,e'.each_byte{|i|i>67?(s=i-70;(y..y+s-1).map{|i|a[i][x,s]=" "*s};x+=s+2):(x=')Fo_h){[~'[j-=1].ord-40;y+=i-40)}
puts a

Versi asli

Solusi ini (sepenuhnya ungolfed) mengandung 315 byte, tidak termasuk baris dan indentasi kosong. Ini hanya menciptakan sebuah array 112 string 112 #'s lalu menggantikan bagian dalam kotak dengan spasi.

$a=Array.new(112){"#"*112}
def f(x,y,s)
  (y..y+s-1).map{|i|$a[i][x,s]=" "*s}
end

f(1,1,48)
f(51,1,33)
f(86,1,25)

f(86,28,6)
f(94,28,17)

f(51,36,13)
f(66,36,15)
f(83,36,9)

f(83,47,4)
f(89,47,22)

f(1,51,27)
f(30,51,23)
f(55,51,7)

f(64,53,5)
f(71,53,16)

f(55,60,14)

f(71,71,40)

f(30,76,2)
f(34,76,35)

f(1,80,31)

puts $a

— Level River St
sumber

3

C, 198 byte

char*i="bSK8C?A;6HMI927B@Z4UQ",o[112][113],x,y,p,q,n;main(){for(;y<112;puts(o[y]),y++)for(x=-1;++x<112;)if(!o[y][x]){n=*i++-48;for(p=-1;++p<n;)for(q=-1;++q<n;)o[q+y][p+x]=p&&n-1-p&&q&&n-1-q?32:35;}}

(Tidak disatukan)

char *i="bSK8C?A;6HMI927B@Z4UQ", o[112][113], x, y, p, q, n;
main() {
  for ( ; y<112; puts(o[y]),y++) {
    for (x=-1; ++x<112; ) {
      if (!o[y][x]) {
        n = *i++ - 48;
        for (p=-1; ++p<n; ) {
          for(q=-1; ++q<n; ) {
            o[q+y][p+x] = (p && n-1-p && q && n-1-q) ? ' ' : '#';
          }
        }
      }
    }
  }
}

Semua ini dilakukan dengan memindai melalui array 112 × 112 byte (diinisialisasi ke nol). Setiap kali bertemu dengan byte nol, ia mengambil nilai dari array idan menambahkan kotak ukuran yang sesuai. Byte tambahan di setiap baris bertindak sebagai terminator string sehingga kita dapat menggunakan puts()untuk menghasilkan seluruh baris alih-alih menggunakanputchar() untuk menghasilkan karakter secara individual.

Ini mungkin bisa bermain golf sedikit lagi, tapi saya rasa tidak banyak peluang mengalahkan jawaban steveverrill .

(tautan ideone)

— osifrque melengking
sumber

+1 Ini adalah konsep yang sangat baik, jauh lebih baik dari saya, dalam bahasa yang tidak terlalu golf. Saya percaya itu mungkin bisa mengalahkan jawaban saya. Catatan Anda perlu mencetak #ketika !(p%(n-1)&&q%(n-1))saya juga akan mengurangi jumlah forloop dari empat menjadi dua, menggunakan x=i%113dan y = i/113 etc.

— Level River St

3

R, 293 291 287 282 byte

a=array('#',112:113)
a[,113]='
'
for(g in list(c(0,0,49,34,26),c(27,85,7,18),c(35,50,14,16,10),c(46,82,5,23),c(50,0,28,24,8,1),c(52,63,6,17),c(59,54,15),c(70,70,41),c(75,29,3,36),c(79,0,32))){y=g[1];x=g[2]
for(b in g[0:1-2]){a[(y+2):(y+b),(x+2):(x+b)]=' '
x=x+b+1}}
cat(t(a),sep='')

Setelah saya melakukan ini, saya menyadari bahwa saya telah melakukan proses yang hampir sama dengan @steveverrill. Array '#' dan kosongkan interior kuadrat. Mungkin bisa memeras lebih banyak dari ini. Pengembalian carriage untuk saluran ke-3 signifikan. Terima kasih kepada AlexA untuk beberapa.

— MickyT
sumber

Anda hanya referensi ssekali, jadi tidak bisakah Anda melakukan for(g in list(...))daripada menentukan ssecara terpisah sebelumnya? Saya pikir itu akan menghemat 2-3 byte.

— Alex A.

@AlexA. Terima kasih, yang sudah saya lewatkan

— MickyT

2

MS-DOS Binary, 137

Kode berikut akan berjalan dalam MS-DOS jika Anda menulisnya ke dalam file bernama square.com, tidak diperlukan kompilasi lebih lanjut (tetapi karena diberikan dalam hex, Anda harus "unhex" terlebih dahulu):

fcba8f01b82370e83000bd1400bb4d018b1743438a27b02043e81e004d75
f1b97000ba8f3289d7b00daab00aaab82409aa83ea70cd214975ecc331c9
88e189ce89d788e1f3aa83c2704e75f4c3201d30e223218527190524063d
1f11521d0d811c0f321f09921c04b8141670101b4d12176619076f1905a6
141066120e4602288d100221022300021f

Output akan tidak dapat dikenali di sebagian besar terminal, tetapi Anda dapat mengarahkannya ke file ( square.com > output.txt) dan melihatnya di editor teks. Jika Anda menginginkan sesuatu yang lebih mudah dibaca, kode berikut ini akan menghasilkan square.com yang berfungsi jika dimasukkan ke debug.exe ( debug.exe < square.asm):

a
cld
mov dx,18f
mov ax,7023
call 13a
mov bp,14
mov bx,14d
mov dx,[bx]
inc bx
inc bx
mov ah,[bx]
mov al,20
inc bx
call 13a
dec bp
jnz 110
mov cx,70
mov dx,328f
mov di,dx
mov al,d
stosb
mov al,a
stosb
mov ax,924
stosb
sub dx,70
int 21
dec cx
jnz 125
ret
xor cx,cx
mov cl,ah
mov si,cx
mov di,dx
mov cl,ah
rep stosb
add dx,70
dec si
jnz 140
ret
db 20,1d,30,e2,23,21
db 85,27,19,05,24,6
db 3d,1f,11,52,1d,d
db 81,1c,f,32,1f,9
db 92,1c,4,b8,14,16
db 70,10,1b,4d,12,17
db 66,19,7,6f,19,5
db a6,14,10,66,12,e
db 46,02,28,8d,10,2
db 21,02,23,00,02,1f

n square.com
rcx
89
w
q

— pengguna2845840
sumber

1

Matlab / Oktaf, 258

Seperti biasa, Matriks. Saya mencatat kode baris dan indeks kolom masing-masing persegi serta ukurannya. Saya bisa menggunakan ini untuk mengisi kotak 'kosong' besar #.

r=[2,2,2,29,29,37,37,37,48,48,52,52,52,54,54,61,72,77,77,81];
c=[2,52,87,87,95,52,67,84,84,90,2,31,56,65,72,56,72,31,35,2];
s=[47,32,24,5,16,12,14,8,3,21,26,22,6,4,15,13,39,1,34,30];
z=ones(112)*35;
for i=1:20;
    z(r(i)+(0:s(i)),c(i)+(0:s(i)))=32;
end;disp([z,''])

— cacat
sumber

0

Bash, 252

Setiap codegolfer harus dapat mengalahkan algoritma kompresi tujuan umum:

base64 -d<<<H4sIADyFv1UCA+3ZOw6EMAwFwH5PgeT735EOUSyfQAgOmVeCxUgusAkRbfOLqTARd0qAQCAQCAQCgcAvg80375dW/T+lQGAbsCCdgvsdXl0AAoHjgM8e7mUA92bKG+DtpAevDPflRsko7BXcKAQCD9+X3wOPCoFA4ABgnZ/OmcHTS+bw4PXzkV7Ak93KDdboVm6wxrOAQCAQCAQCgUAgENj++7BuZsq8xQ1vMQAA|gunzip

Terima kasih kepada Toby Speight untuk petunjuk untuk menggunakan input yang lebih pendek (konyol saya digunakan gzipalih-alih gzip -9untuk kompresi) dan string di sini.

— pengguna2845840
sumber

2 lebih pendek dengan di sini-string:

base64 -d<<<H4sIAP9YuVUAA+3XQQrDIBAF0H1PUfD+d+yq0FA7GirGie/vdEZfkCy0lLl5lOfJlPaKoAUIBAKBQCAQCLwzOP3mfdFVv9IKBM4BTyQpGA0PE0AgcB8wzC3A6vS7egH4d5YH64WPtVGh/zvygj8agcCvQuufzA+2GoFA4AZgd9KCwS7Hzu3B7qQFO09rbXDEaa0NjtgLCAQCgUAgEAgEAoHz34dj8wLKvMUNbzEAAA==|gunzip

— Toby Speight

Dan input yang lebih pendek membuat kita turun ke 251 :

base64 -d<<<H4sIADyFv1UCA+3ZOw6EMAwFwH5PgeT735EOUSyfQAgOmVeCxUgusAkRbfOLqTARd0qAQCAQCAQCgcAvg80375dW/T+lQGAbsCCdgvsdXl0AAoHjgM8e7mUA92bKG+DtpAevDPflRsko7BXcKAQCD9+X3wOPCoFA4ABgnZ/OmcHTS+bw4PXzkV7Ak93KDdboVm6wxrOAQCAQCAQCgUAgENj++7BuZsq8xQ1vMQAA|gunzip

— Toby Speight

Apakah Anda yakin itu berhasil? Saya hanya mendapatkan gunzip: command not found. Saya bisa membuatnya bekerja menggunakan subshell:, (base64 -d|gunzip)<<<...tapi itu masih menggunakan 258 byte.

— user2845840

Aneh, @ user284584 - sesuatu yang aneh dengan jalur Anda? Saya menguji apa yang saya tulis (dalam shell interaktif, jika itu membuat perbedaan)

— Toby Speight

oh Tuhan ... coba salin komentar Anda dan tempel kembali ke shell. Stackexchange "sangat membantu" memasukkan 6 karakter yang tidak terlihat, 3 masing-masing dari u + 200c & u + 200b. Setelah menghapusnya, itu berhasil.

— user2845840

Cetak Square Terkecil Sempurna

CJam, 88 84 83 byte

Penjelasan

Mathematica 360 426

Ruby, 180 byte

C, 198 byte

(Tidak disatukan)

R, 293 291 287 282 byte

MS-DOS Binary, 137

Matlab / Oktaf, 258

Bash, 252