Bạn có lưới 3x3. Mỗi ô có thể được tô màu đen hoặc trắng. Hiển thị tất cả 512 màu này. Ít byte nhất sẽ thắng.

Bạn có thể hiển thị các lưới trong bất kỳ đội hình nào miễn là chúng được phân tách trực quan và khoảng cách trông đều đặn. Bạn có thể sử dụng nghệ thuật hoặc hình ảnh ASCII. Bất kỳ hai biểu tượng hoặc màu sắc rõ ràng có thể được sử dụng cho màu đen và trắng. Bất kỳ khoảng trắng nào cũng được miễn là kết quả chính xác.

Ví dụ đầu ra:

...
...
...

...
...
..X

...
...
.X.

...
...
.XX

...
...
X..

...
...
X.X

...
...
XX.

...
...
XXX

...
..X
...

...
..X
..X

...
..X
.X.

...
..X
.XX

...
..X
X..

...
..X
X.X

...
..X
XX.

...
..X
XXX

...
.X.
...

...
.X.
..X

...
.X.
.X.

...
.X.
.XX

...
.X.
X..

...
.X.
X.X

...
.X.
XX.

...
.X.
XXX

...
.XX
...

...
.XX
..X

...
.XX
.X.

...
.XX
.XX

...
.XX
X..

...
.XX
X.X

...
.XX
XX.

...
.XX
XXX

...
X..
...

...
X..
..X

...
X..
.X.

...
X..
.XX

...
X..
X..

...
X..
X.X

...
X..
XX.

...
X..
XXX

...
X.X
...

...
X.X
..X

...
X.X
.X.

...
X.X
.XX

...
X.X
X..

...
X.X
X.X

...
X.X
XX.

...
X.X
XXX

...
XX.
...

...
XX.
..X

...
XX.
.X.

...
XX.
.XX

...
XX.
X..

...
XX.
X.X

...
XX.
XX.

...
XX.
XXX

...
XXX
...

...
XXX
..X

...
XXX
.X.

...
XXX
.XX

...
XXX
X..

...
XXX
X.X

...
XXX
XX.

...
XXX
XXX

..X
...
...

..X
...
..X

..X
...
.X.

..X
...
.XX

..X
...
X..

..X
...
X.X

..X
...
XX.

..X
...
XXX

..X
..X
...

..X
..X
..X

..X
..X
.X.

..X
..X
.XX

..X
..X
X..

..X
..X
X.X

..X
..X
XX.

..X
..X
XXX

..X
.X.
...

..X
.X.
..X

..X
.X.
.X.

..X
.X.
.XX

..X
.X.
X..

..X
.X.
X.X

..X
.X.
XX.

..X
.X.
XXX

..X
.XX
...

..X
.XX
..X

..X
.XX
.X.

..X
.XX
.XX

..X
.XX
X..

..X
.XX
X.X

..X
.XX
XX.

..X
.XX
XXX

..X
X..
...

..X
X..
..X

..X
X..
.X.

..X
X..
.XX

..X
X..
X..

..X
X..
X.X

..X
X..
XX.

..X
X..
XXX

..X
X.X
...

..X
X.X
..X

..X
X.X
.X.

..X
X.X
.XX

..X
X.X
X..

..X
X.X
X.X

..X
X.X
XX.

..X
X.X
XXX

..X
XX.
...

..X
XX.
..X

..X
XX.
.X.

..X
XX.
.XX

..X
XX.
X..

..X
XX.
X.X

..X
XX.
XX.

..X
XX.
XXX

..X
XXX
...

..X
XXX
..X

..X
XXX
.X.

..X
XXX
.XX

..X
XXX
X..

..X
XXX
X.X

..X
XXX
XX.

..X
XXX
XXX

.X.
...
...

.X.
...
..X

.X.
...
.X.

.X.
...
.XX

.X.
...
X..

.X.
...
X.X

.X.
...
XX.

.X.
...
XXX

.X.
..X
...

.X.
..X
..X

.X.
..X
.X.

.X.
..X
.XX

.X.
..X
X..

.X.
..X
X.X

.X.
..X
XX.

.X.
..X
XXX

.X.
.X.
...

.X.
.X.
..X

.X.
.X.
.X.

.X.
.X.
.XX

.X.
.X.
X..

.X.
.X.
X.X

.X.
.X.
XX.

.X.
.X.
XXX

.X.
.XX
...

.X.
.XX
..X

.X.
.XX
.X.

.X.
.XX
.XX

.X.
.XX
X..

.X.
.XX
X.X

.X.
.XX
XX.

.X.
.XX
XXX

.X.
X..
...

.X.
X..
..X

.X.
X..
.X.

.X.
X..
.XX

.X.
X..
X..

.X.
X..
X.X

.X.
X..
XX.

.X.
X..
XXX

.X.
X.X
...

.X.
X.X
..X

.X.
X.X
.X.

.X.
X.X
.XX

.X.
X.X
X..

.X.
X.X
X.X

.X.
X.X
XX.

.X.
X.X
XXX

.X.
XX.
...

.X.
XX.
..X

.X.
XX.
.X.

.X.
XX.
.XX

.X.
XX.
X..

.X.
XX.
X.X

.X.
XX.
XX.

.X.
XX.
XXX

.X.
XXX
...

.X.
XXX
..X

.X.
XXX
.X.

.X.
XXX
.XX

.X.
XXX
X..

.X.
XXX
X.X

.X.
XXX
XX.

.X.
XXX
XXX

.XX
...
...

.XX
...
..X

.XX
...
.X.

.XX
...
.XX

.XX
...
X..

.XX
...
X.X

.XX
...
XX.

.XX
...
XXX

.XX
..X
...

.XX
..X
..X

.XX
..X
.X.

.XX
..X
.XX

.XX
..X
X..

.XX
..X
X.X

.XX
..X
XX.

.XX
..X
XXX

.XX
.X.
...

.XX
.X.
..X

.XX
.X.
.X.

.XX
.X.
.XX

.XX
.X.
X..

.XX
.X.
X.X

.XX
.X.
XX.

.XX
.X.
XXX

.XX
.XX
...

.XX
.XX
..X

.XX
.XX
.X.

.XX
.XX
.XX

.XX
.XX
X..

.XX
.XX
X.X

.XX
.XX
XX.

.XX
.XX
XXX

.XX
X..
...

.XX
X..
..X

.XX
X..
.X.

.XX
X..
.XX

.XX
X..
X..

.XX
X..
X.X

.XX
X..
XX.

.XX
X..
XXX

.XX
X.X
...

.XX
X.X
..X

.XX
X.X
.X.

.XX
X.X
.XX

.XX
X.X
X..

.XX
X.X
X.X

.XX
X.X
XX.

.XX
X.X
XXX

.XX
XX.
...

.XX
XX.
..X

.XX
XX.
.X.

.XX
XX.
.XX

.XX
XX.
X..

.XX
XX.
X.X

.XX
XX.
XX.

.XX
XX.
XXX

.XX
XXX
...

.XX
XXX
..X

.XX
XXX
.X.

.XX
XXX
.XX

.XX
XXX
X..

.XX
XXX
X.X

.XX
XXX
XX.

.XX
XXX
XXX

X..
...
...

X..
...
..X

X..
...
.X.

X..
...
.XX

X..
...
X..

X..
...
X.X

X..
...
XX.

X..
...
XXX

X..
..X
...

X..
..X
..X

X..
..X
.X.

X..
..X
.XX

X..
..X
X..

X..
..X
X.X

X..
..X
XX.

X..
..X
XXX

X..
.X.
...

X..
.X.
..X

X..
.X.
.X.

X..
.X.
.XX

X..
.X.
X..

X..
.X.
X.X

X..
.X.
XX.

X..
.X.
XXX

X..
.XX
...

X..
.XX
..X

X..
.XX
.X.

X..
.XX
.XX

X..
.XX
X..

X..
.XX
X.X

X..
.XX
XX.

X..
.XX
XXX

X..
X..
...

X..
X..
..X

X..
X..
.X.

X..
X..
.XX

X..
X..
X..

X..
X..
X.X

X..
X..
XX.

X..
X..
XXX

X..
X.X
...

X..
X.X
..X

X..
X.X
.X.

X..
X.X
.XX

X..
X.X
X..

X..
X.X
X.X

X..
X.X
XX.

X..
X.X
XXX

X..
XX.
...

X..
XX.
..X

X..
XX.
.X.

X..
XX.
.XX

X..
XX.
X..

X..
XX.
X.X

X..
XX.
XX.

X..
XX.
XXX

X..
XXX
...

X..
XXX
..X

X..
XXX
.X.

X..
XXX
.XX

X..
XXX
X..

X..
XXX
X.X

X..
XXX
XX.

X..
XXX
XXX

X.X
...
...

X.X
...
..X

X.X
...
.X.

X.X
...
.XX

X.X
...
X..

X.X
...
X.X

X.X
...
XX.

X.X
...
XXX

X.X
..X
...

X.X
..X
..X

X.X
..X
.X.

X.X
..X
.XX

X.X
..X
X..

X.X
..X
X.X

X.X
..X
XX.

X.X
..X
XXX

X.X
.X.
...

X.X
.X.
..X

X.X
.X.
.X.

X.X
.X.
.XX

X.X
.X.
X..

X.X
.X.
X.X

X.X
.X.
XX.

X.X
.X.
XXX

X.X
.XX
...

X.X
.XX
..X

X.X
.XX
.X.

X.X
.XX
.XX

X.X
.XX
X..

X.X
.XX
X.X

X.X
.XX
XX.

X.X
.XX
XXX

X.X
X..
...

X.X
X..
..X

X.X
X..
.X.

X.X
X..
.XX

X.X
X..
X..

X.X
X..
X.X

X.X
X..
XX.

X.X
X..
XXX

X.X
X.X
...

X.X
X.X
..X

X.X
X.X
.X.

X.X
X.X
.XX

X.X
X.X
X..

X.X
X.X
X.X

X.X
X.X
XX.

X.X
X.X
XXX

X.X
XX.
...

X.X
XX.
..X

X.X
XX.
.X.

X.X
XX.
.XX

X.X
XX.
X..

X.X
XX.
X.X

X.X
XX.
XX.

X.X
XX.
XXX

X.X
XXX
...

X.X
XXX
..X

X.X
XXX
.X.

X.X
XXX
.XX

X.X
XXX
X..

X.X
XXX
X.X

X.X
XXX
XX.

X.X
XXX
XXX

XX.
...
...

XX.
...
..X

XX.
...
.X.

XX.
...
.XX

XX.
...
X..

XX.
...
X.X

XX.
...
XX.

XX.
...
XXX

XX.
..X
...

XX.
..X
..X

XX.
..X
.X.

XX.
..X
.XX

XX.
..X
X..

XX.
..X
X.X

XX.
..X
XX.

XX.
..X
XXX

XX.
.X.
...

XX.
.X.
..X

XX.
.X.
.X.

XX.
.X.
.XX

XX.
.X.
X..

XX.
.X.
X.X

XX.
.X.
XX.

XX.
.X.
XXX

XX.
.XX
...

XX.
.XX
..X

XX.
.XX
.X.

XX.
.XX
.XX

XX.
.XX
X..

XX.
.XX
X.X

XX.
.XX
XX.

XX.
.XX
XXX

XX.
X..
...

XX.
X..
..X

XX.
X..
.X.

XX.
X..
.XX

XX.
X..
X..

XX.
X..
X.X

XX.
X..
XX.

XX.
X..
XXX

XX.
X.X
...

XX.
X.X
..X

XX.
X.X
.X.

XX.
X.X
.XX

XX.
X.X
X..

XX.
X.X
X.X

XX.
X.X
XX.

XX.
X.X
XXX

XX.
XX.
...

XX.
XX.
..X

XX.
XX.
.X.

XX.
XX.
.XX

XX.
XX.
X..

XX.
XX.
X.X

XX.
XX.
XX.

XX.
XX.
XXX

XX.
XXX
...

XX.
XXX
..X

XX.
XXX
.X.

XX.
XXX
.XX

XX.
XXX
X..

XX.
XXX
X.X

XX.
XXX
XX.

XX.
XXX
XXX

XXX
...
...

XXX
...
..X

XXX
...
.X.

XXX
...
.XX

XXX
...
X..

XXX
...
X.X

XXX
...
XX.

XXX
...
XXX

XXX
..X
...

XXX
..X
..X

XXX
..X
.X.

XXX
..X
.XX

XXX
..X
X..

XXX
..X
X.X

XXX
..X
XX.

XXX
..X
XXX

XXX
.X.
...

XXX
.X.
..X

XXX
.X.
.X.

XXX
.X.
.XX

XXX
.X.
X..

XXX
.X.
X.X

XXX
.X.
XX.

XXX
.X.
XXX

XXX
.XX
...

XXX
.XX
..X

XXX
.XX
.X.

XXX
.XX
.XX

XXX
.XX
X..

XXX
.XX
X.X

XXX
.XX
XX.

XXX
.XX
XXX

XXX
X..
...

XXX
X..
..X

XXX
X..
.X.

XXX
X..
.XX

XXX
X..
X..

XXX
X..
X.X

XXX
X..
XX.

XXX
X..
XXX

XXX
X.X
...

XXX
X.X
..X

XXX
X.X
.X.

XXX
X.X
.XX

XXX
X.X
X..

XXX
X.X
X.X

XXX
X.X
XX.

XXX
X.X
XXX

XXX
XX.
...

XXX
XX.
..X

XXX
XX.
.X.

XXX
XX.
.XX

XXX
XX.
X..

XXX
XX.
X.X

XXX
XX.
XX.

XXX
XX.
XXX

XXX
XXX
...

XXX
XXX
..X

XXX
XXX
.X.

XXX
XXX
.XX

XXX
XXX
X..

XXX
XXX
X.X

XXX
XXX
XX.

XXX
XXX
XXX

K, 11 byte

(3 3#)'!9#2

Ví dụ đầu ra:

((0 0 0
  0 0 0
  0 0 0)
 (0 0 0
  0 0 0
  0 0 1)
 (0 0 0
  0 0 0
  0 1 0)
 (0 0 0
  0 0 0
  0 1 1)
…

Đây là đại diện khá đẹp của K trong danh sách các ma trận, mà tôi nghĩ là đủ cho thông số kỹ thuật. Mỗi ma trận được giới hạn bởi một bộ dấu ngoặc đơn kèm theo.

Và kiểm tra độ tỉnh táo nhanh chóng để chứng minh rằng 512 ma trận được xây dựng:

  #(3 3#)'!9#2
512

Rất đơn giản. Hầu hết các công việc là trong !. Đầu tiên chúng ta tạo ra một vectơ dài 9 giây bằng cách sử dụng "Take" ( 9#2). Sau đó, chúng tôi sử dụng hình thức đơn điệu "đo đường" !- một vài ví dụ minh họa hành vi của nó:

  !2 2
(0 0
 0 1
 1 0
 1 1)
  !2 3
(0 0
 0 1
 0 2
 1 0
 1 1
 1 2)
  !2 2 2
(0 0 0
 0 0 1
 0 1 0
 0 1 1
 1 0 0
 1 0 1
 1 1 0
 1 1 1)

Sau đó, chỉ cần thực hiện định hình lại 3x3 ( (3 3#)) của mỗi ( ') các vectơ 0/1 có độ dài 9/1.

Toán học, 25 byte

Image/@{0,1}~Tuples~{3,3}

Cung cấp một mảng với tất cả các lưới như hình ảnh, cũng được hiển thị trực tiếp trên màn hình:

(Cắt xén để không làm nổ bài không cần thiết.)

JavaScript, 77 80

Sửa đổi sau khi sửa đổi OP. Bây giờ chúng tôi có một câu hỏi, vì vậy đây là một câu trả lời.

Chạy đoạn mã trong bất kỳ trình duyệt nào để kiểm tra.

// Test: redefine console to have output inside the snippet

console = { log: function(x) { O.textContent+=x+'\n\n';} }

// Solution: 77 chars (note, distinct outputs to console are automatically separed)
  
for(i=511;++i<1024;)console.log(i.toString(2).slice(1).match(/.../g).join`
`)

<pre id=O></pre>

Bài cũ: hiển thị đồ họa trong trình duyệt, với javascript và canvas. ~ 300 byte mã (có thể được thực hiện ngắn hơn).

Chạy đoạn trích dưới đây.

d=8, // Min block size
C.width=d*64,C.height=d*128,
T=C.getContext('2d')

for(i=0;i<512;i++)
{
  bx=4*(i/32|0)
  by=4*(i%32)
  for(b=1,j=0;j<9;j++,b+=b)    
  {
    if(b&i) 
      x=j/3|0, y=j%3, T.fillRect((bx+x)*d,(by+y)*d,d,d);
  }
  T.strokeRect(bx*d,by*d,d*3,d*3);
}

<canvas id=C></canvas>

Matlab, 33

reshape(dec2bin(0:511,9)',3,3,[])

Là loại khó khăn để có được kích thước chính xác, nhưng tôi rất hài lòng với kết quả này!

POWERSHELL - 65

0..511|%{[convert]::ToString($_,2).padleft(9,'0')-split"(.{3})"}

kết quả

000

000

000


000

000

001


000

000

010


000

000

011

xác nhận

(0..511|%{[convert]::ToString($_,2).padleft(9,'0')-split"(.{3})"} | measure -Line).lines/3

512

chỉnh sửa lấy cảm hứng từ màn hình hiển thị kết quả của câu trả lời toán học-617

Add-Type -AssemblyName System.Drawing
$a=new-object System.Drawing.Bitmap 992,496
$g=[Drawing.Graphics]::FromImage($a)
$b=@{};$y=@{};$i=$c=$d=$z=$k=$l=$m=0;
0..511|%{$y[$d++]=[convert]::ToString($_,2).padleft(9,'0')}
while($m-lt480){while($l-lt496){for($z=($m+0);$z-lt($m+32);$z++){
      $y[$z].tochararray()|%{if($_-eq"0"){$b[$i++]=[Drawing.Brushes]::Black}
        else{$b[$i++]=[Drawing.Brushes]::White}
      }
      for($j=($l+0);$j-lt($l+30);$j+=10){
        ($k+0),($k+10),($k+20)|%{$g.FillRectangle($b[$c++],$_,$j,10,10)}
      }$k+=31
    }$k=0;$l+=31;$m+=32
  }
}$a.save("$HOME/3X3_Grid.png")

Python 2, 49 byte

i=2048;exec"print bin(i/4)[i%4*3+3:][:3];i+=1;"*i

Chia mở rộng nhị phân của i. Các giá trị nhị phân có độ dài 10 đến 512 được sử dụng, cắt bỏ 1 (và tiền tố 0b) ban đầu . Đây là những chia thành các khối của 3 như cửa sổ [3:6], [6:9], [9:12], và [12:15], với một trống cuối cùng để thực hiện một dòng trống. Lặp lại qua bốn lát được thu gọn với vòng lặp bên ngoài đếm qua 512 số với thủ thuật divmod.

CJam, 12 byte

2,9m*3f/N*N*

Kiểm tra nó ở đây.

Công dụng 0 và1 như các nhân vật riêng biệt.

Giải trình

2,  e# Push [0 1].
9m* e# Generate all 9-tuples of 0s and 1s.
3f/ e# Split each 9-tuple into 3 subarrays of length 3.
N*  e# Join all those grids with newlines.
N*  e# Put newlines between all the length-3 arrays.

Một giải pháp thay thế (vẫn là 12 byte) là

2,3m*3m*N*N*

Ruby, 86 byte

0.upto(511).map{|i|i.to_s(2).rjust(9,'0')}.each{|j|p j[0..2];p j[3..5];p j[6..8];puts}

Mine in với dấu ngoặc kép vì pngắn hơn puts, nhưng nó vẫn phù hợp với các quy tắc.

Haskell, 57 54 byte

r x=sequence[x,x,x]
u=unlines
f=putStr$u$map u$r$r".X"

f đưa ra đầu ra giống như trong mô tả thử thách, tức là bắt đầu bằng

...
...
...

...
...
..X

...
...
.X.

Chỉnh sửa: @Mauris tìm thấy 3 byte để lưu. Cảm ơn!

C # - 111

for(int i=0;i<512;i++)Console.WriteLine(Regex.Replace(Convert.ToString(i,2).PadLeft(9,'0'),"(.{3})","$1\r\n"));

Chuyển đổi mọi int thành biểu diễn nhị phân của nó và chia mỗi 3 ký tự.

Python 2, 95 byte

Các ký tự riêng biệt là 0và 1, mỗi khối được phân tách bằng \n\n.

n='\n';print(n+n).join(y[:3]+n+y[3:6]+n+y[-3:]for y in[bin(x)[2:].zfill(9)for x in range(512)])

Con trăn 2, 81

import re
for i in range(512):print re.sub('(.{3})','\\1\n',bin(i)[2:].zfill(9))

Ruby, 92 byte

0.upto(511){|i|("%09d"%i.to_s(2)).scan(/.{3}/).map{|j|j.scan(/./)}.map{|j|puts j.join};puts}

Đếm bằng 0s và 1s, và mỗi khối được phân tách bằng một dòng trống ( \n\n)

Ruby, 68 byte

In chính xác đầu ra giống như ví dụ được đưa ra trong câu hỏi

puts (0..511).map{|i|("%09b"%i).tr("01",".X").gsub(/.../){$&+$/}}*$/

Python 3, 80 byte

for i in range(512):print("\n".join(format(i,'09b')[j:j+3]for j in(0,3,6)),"\n")

Tôi đã xoay sở để vượt qua ai đó :)

PHP, 55 byte

for(;$c<512;)echo chunk_split(sprintf("%09b ",$c++),3);

sử dụng 0và 1. Chạy với -r.

Bình thường, 11 byte

V^`T9jbc3Nk

Hãy thử nó ở đây!

Cảm ơn @Jakube :)

Python 2 , 56 byte

from itertools import*
print set(combinations('X.'*9,9))

Hãy thử trực tuyến!

Trả về các cấu hình 512 dưới dạng một đối tượng được đặt trong python. Tham khảo phiên bản không ghi chú để làm cho đầu ra dễ đọc hơn.

Phiên bản Ungolfed để làm cho đầu ra dễ đọc hơn:

Python 2 , 121 byte

from itertools import*
for i in set(combinations('X.'*9,9)):
	for j in range(3):print''.join(list(i))[j*3:(j*3)+3]
	print

Hãy thử trực tuyến!

C - 97 byte

i;main(j){for(;i++<512;)for(j=0;j++<13;)putchar(j%4&&j<13?i%(1<<j-j/4)>(1<<j-j/4-1)-1?88:46:10);}

Về cơ bản in kết quả đầu ra từ câu hỏi ban đầu.

Swift 2, 92 byte

Chuỗi int đến nhị phân trong Swift chiếm quá nhiều ký tự nên tôi chỉ sử dụng hai vòng lặp lồng nhau ...

var s="";for x in 0..<512{(0..<9).map{s+=($0%3==0 ?"\n":"")+"\(x>>$0&1)"};s+="\n-"};print(s)

Prolog (SWI), 98 byte

Đầu ra là danh sách các ma trận 3x3 chứa các phần tử 0 và 1.

r([]).
r([H|T]):-between(0,1,H),r(T).
p(Y):-Z=[[_,_,_],[_,_,_],[_,_,_]],findall(Z,maplist(r,Z),Y).

Phiên dịch trực tuyến

Tôi cảm thấy như thế hệ ma trận có thể ngắn hơn.
Nó có thể phù hợp giữa một trong một forall hoặc một cái gì đó tương tự, nhưng tôi không thể tìm ra làm thế nào.

Lời khuyên chơi golf đánh giá cao.

Perl, 56 55 byte

print$_/9&1<<$_%9?1:0,$/x(!(++$_%3)+!($_%9))for+0..4607

Đầu ra:

000
000
000

100
000
000
...

Python 3, 123 121 109 103 byte

Đây là cái cũ của tôi:

import itertools
[print(a+b+c,d+e+f,g+h+i,'\n',sep='\n') for a,b,c,d,e,f,g,h,i in itertools.product(['X','.'],repeat=9)]

Và đây là cái mới của tôi:

import itertools as i
[print(a[:3],a[3:6],a[6:],'\n',sep='\n') for a in i.product(['X','.'],repeat=9)]

Điều này in thêm các ký tự nhưng OP cho biết nghệ thuật ASCII được cho phép ngụ ý nhiều ký tự đều ổn.

Python 3, 74 byte

i=512;b="\n"
while i:i-=1;a=format(i,'09b');print(a[:3]+b+a[3:6]+b+a[6:],b)

Chỉ ngắn hơn một chút so với câu trả lời của Dest Destible Lemon

Perl, 52 byte

printf+("%03b
"x3).$/,$_&7,$_/8&7,$_>>6&7 for 0..511

hoặc 54 byte:

print map$_.$/,sprintf('%09b',$_)=~/.../g,''for 0..511

hoặc Perl 5.14+, 48 byte:

say sprintf('%09b',$_)=~s/.../$&\n/gr for 0..511

Jelly , 17 byte (không cạnh tranh)

512+ḶBḊ€s€3Y€j“¶¶

Hãy thử trực tuyến!

Công dụng 01. Vì một lỗi trong ⁾, tôi đã phải sử dụng “¶¶thay vì ⁾¶¶, vì nếu không, thay vì hai dòng mới, hai chuyến hành hương sẽ xuất hiện trong đầu ra. Tuy nhiên, như bạn có thể thấy, điều đó không làm tôi mất bất kỳ byte nào cả.

K đánh bại điều này, vì vậy điều này phải được tiếp tục đánh xuống.

05AB1E , 15 byte (không cạnh tranh)

žAFNžA+b¦3ô»,¶?

Hãy thử trực tuyến!

J , 27 byte

echo@<"2'.X'{~_3]\"1#:i.512

Hãy thử trực tuyến!

Tcl , 72 byte

time {puts [regsub -all (...) [format %09b [expr [incr i]-1]] \&\n]} 512

Hãy thử trực tuyến!

Python 2 , 114 byte

from itertools import *
for i in product(".X",repeat=9):
    i="".join(i);print i[0:3]+"\n"+i[3:6]+"\n"+i[6:]+"\n"

Hãy thử trực tuyến!