Tóm lược

Lấy cảm hứng từ sự phổ biến gần đây của các thử thách nghệ thuật ASCII, mục đích của thử thách này là vẽ một bàn cờ ASCII, giống như một ván cờ có thể chơi Cờ vua.

Viết chương trình lấy số nguyên dương nlàm đối số, trong stdinhoặc làm đầu vào của người dùng và xuất bảng kiểm tra với nx nbình phương, cùng với đường viền dày 1 ký tự.

Mỗi ô vuông nên có 2 ký tự. Các hình vuông phải theo mô hình trắng-đen xen kẽ bình thường (màu trắng trước, như ở góc trên bên trái) của bàn cờ. Các hình vuông màu trắng nên được tạo từ các ký tự khoảng trắng ( ) và các hình vuông màu đen nên được tạo từ các #ký tự pound ( ).

Đường viền phải được tạo từ dấu gạch ngang ( -) với dấu cộng ( +) trên đường viền hoặc điểm vuông góc của hình vuông.

Đầu vào

Số nguyên dương biểu thị số lượng hình vuông (kích thước trong hình vuông) để vẽ trong bảng kiểm tra, với mỗi hình vuông là 2x2 ký tự.

Kết quả ví dụ

n=2

+--+--+
|  |##|
|  |##|
+--+--+
|##|  |
|##|  |
+--+--+

n=3

+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+
|##|  |##|
|##|  |##|
+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+

n=4

+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+

... và cứ thế.

Ghi chú

• Không gian lưu trữ và dòng mới được chấp nhận.
• Bạn có thể viết toàn bộ chương trình hoặc chức năng.
• Không có không gian hàng đầu.
• Chương trình của bạn sẽ hiển thị kết quả chính xác cho n = 15.
• Đối với các ngôn ngữ bí truyền ít được biết đến và tương tự, cung cấp một liên kết đến ngôn ngữ.
• n=0nên sản xuất +. (tùy chọn, nhưng rất khuyến khích và khuyến khích.)
• Mã ngắn nhất trong byte thắng, vì đây là mã golf.

J, 24 byte

Một chức năng ẩn danh:

2 2&$&.>@(' #'{~2|+/~@i.)

Sử dụng:

   f =: 2 2&$&.>@(' #'{~2|+/~@i.)
   f 4
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+

Con trăn 2, 79

N=3*input()+1
for i in range(N):print('+||- #- #+||-# -# '*N)[3**i%7/2%3:3*N:3]

Đối với mỗi hàng, chọn một trong các mẫu

+--+--+--+--+--+
|  |##|  |##|  |
|##|  |##|  |##|

và in các 3*n+1ký tự từ nó. Mẫu được chọn bằng cách lặp lại 6 ký tự đầu tiên của nó, được chọn bằng thủ thuật xen kẽ chuỗi, cũng dùng để trích xuất một đoạn có độ dài chính xác.

Mẫu chính xác được chọn dựa trên giá trị của chỉ số hàng imodulo 6 bằng biểu thức số học 3**i%7/2%3đưa ra mẫu lặp lại [0,1,1,0,2,2]. Tôi tìm thấy nó bằng cách sử dụng thực tế x**i%7có thời gian 6, sau đó thử các giá trị xkhác nhau và xử lý hậu kỳ khác nhau để có được mẫu phù hợp.

Bình dương, 37

VJh*3Qsm@?+\|*2@" #"+/N3/d3%N3"+--"dJ

Thay vì hack cùng nhau, nhưng ngắn.

Trình diễn.

CJam, 43 42 byte

ri3*)_2m*{_3f%:!2b\3f/:+2%(e|"#|-+ "=}%/N*

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

Mỗi tọa độ được ánh xạ tới một char, ví dụ góc trên cùng bên trái là (0, 0) -> "+". Cụ thể, chúng tôi tính toán

[(y%3 == 0)*2 + (x%3 == 0)] or [(x//3 + y//3) % 2 - 1]

và lập chỉ mục vào chuỗi "#|-+ "tương ứng.

Võng mạc , 106 byte

1
$_0$_x
1(?=1*0)
+--
1(?=1*x)
s
(0s.*?0)s
$1o
(s\D*?)s
$1o
s
|  
o
|##
\D*?x
$0$0
0
+n
x
|n
(.*?n).*
$0$1

Đưa đầu vào là đơn nguyên (dựa trên thảo luận meta này ).

Mỗi dòng nên đi đến tập tin riêng của nó và nnên được thay đổi thành dòng mới trong các tập tin. Điều này là không thực tế nhưng bạn có thể chạy mã như là một tệp với -scờ, giữ các nđiểm đánh dấu. Bạn có thể thay đổi các ndòng mới thành đầu ra để dễ đọc nếu muốn. Ví dụ:

> echo -n 111|retina -s checkerboard|tr n '\n'
+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+
|##|  |##|
|##|  |##|
+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+

Chơi golf thêm và một số giải thích đến sau.

JavaScript (ES6), 117

n=>Array(n*3+1).fill("+--".repeat(n)+"+").map((v,i)=>v.replace(/./g,(k,x)=>i%3?"|  |##|  "[x%6+(i%6>2)*3]:k)).join`
`

Đoạn trích:

<input type="range" min=2 max=15 step=1 value=1 id="i" oninput="o.textContent=f(this.value)"><pre id="o"></pre><script>function f(n){ return Array.apply(0,Array(n*3+1)).map(function(){return "+--".repeat(n)+"+"}).map(function(v,i){ return v.replace(/./g,function(k,x) { return i%3?"|  |##|  "[x%6+(i%6>2)*3]:k}) }).join("\n") };o.textContent=f(2)</script>

Chức năng ẩn danh. Bắt đầu với một loạt các +--+--+--...dòng và trên các dòng thích hợp, thay thế +cho |và -cho hoặc #khi thích hợp.

Biểu thức quyết định ký tự thay thế "| |##| "[x%6+(i%6>2)*3], có thể được chơi thêm, nhưng tôi thấy rằng việc sử dụng chuỗi dự phòng dài hơn sẽ tiết kiệm được nhiều ký tự hơn so với phép tính phức tạp.

CJam, 59 byte

Đây là .. quá .. dài ..

ri:I," #"f=2f*_I({__sff^_}*]'|I)*f.\2/Nf*'+I)*"--"*aI)*.\N*

Dùng thử trực tuyến tại đây

CoffeeScript với ES6, 106 byte

f=(n,y=z='+--'[r='repeat'](n)+'+\n')->y+=('|##|  '[r](n).substr(i%2*3,n*3)+'|\n')[r](2)+z for i in[1..n];y

JavaScript (ES6), 111 byte

Các dòng mới có ý nghĩa và được tính là 1 byte mỗi.

Lợi nhuận rõ ràng làm cho nó dài hơn một chút:

f=n=>{for(i=0,y=z='+--'[r='repeat'](n)+`+
`;i<n;)y+=('|##|  '[r](n).substr(++i%2*3,n*3)+`|
`)[r](2)+z;return y}

Bản giới thiệu

Tại thời điểm viết bài, Firefox là trình duyệt chính duy nhất tương thích với ES6.

f=n=>{for(i=0,y=z='+--'[r='repeat'](n)+`+
`;i<n;)y+=('|##|  '[r](n).substr(++i%2*3,n*3)+`|
`)[r](2)+z;return y}

// Demonstration related things
document.getElementById('O').innerHTML = f(document.getElementById('n').value);

document.getElementById('n').addEventListener('change', function () {
  document.getElementById('O').innerHTML = f(this.value);
});

<p><input id=n type=number min=0 step=1 value=6></p>
<pre><output id=O></output></pre>

Trăn 3, 114 108 100

def f(n):
 for i in range(3*n+1):print(("|##|  "*n+"|")[::i//3%2*2-1][:3*n+1]if i%3 else"+--"*n+"+")

Giải pháp trước đây

108

def f(n):
 for i in range(3*n+1):
  a=("|##|  "*n+"|")[::i//3%2*2-1][:3*n+1];print(a if i%3 else"+--"*n+"+")

114

def f(n):a="+--"*n+"+\n";b="|  |##"*n+"|";print(a+a.join(([(b[:3*n+1]+"\n")*2,(b[::-1][:3*n+1]+"\n")*2]*n)[:n])+a)

118 (chưa nộp)

def f(n):
 for i in range(3*n+1):print((("|##|  "*n)[:3*n+1]if i//3%2 else("|  |##"*n)[:3*n+1])if i%3 else"+--"*n+"+")

CJam, 46 byte

li3*)_2m*[{_3f/2f%:=\3f%:g+2b"+-|#+-| "=}/]/N*

Dùng thử trực tuyến

Chà, tôi đã hy vọng rằng ít nhất tôi sẽ có một giải pháp ban đầu (tôi thường không nhìn vào các câu trả lời khác trước khi tự mình làm việc). Hóa ra @ Sp3000 đã làm một cái gì đó rất giống nhau, chỉ tốt hơn. Nhưng vì tôi đã hoàn thành công việc, tôi nghĩ dù sao tôi cũng sẽ đăng nó.

Giải trình:

li    Get input n.
3*)   Calculate 3*n+1, which is the total width/height.
_     Copy size. We'll need it at the end to insert the newlines.
2m*   Calculate cartesian power with 2. This enumerates all coordinate pairs.
[     Wrap characters in array for split operation at the end.
  {     Loop over all coordinate pairs.
    _     Copy coordinate pair.
    3f/   Divide coordinates by 3.
    2f%   Modulo 2. This characterizes even/odd squares.
    :=    Compare the two coordinates. This gives 0/1 for white/black squares.
    \3f%  Grab second copy of coordinates, and calculate modulo 3.
    :g    Sign. This gives 0 for grid lines, 1 for interior of squares.
    +     Concatenate the two results. We now have a 3 bit code.
    2b    Convert the 3 bits to a number in range 0..7.
    "+-|#+-| "
          Lookup table to convert 0..7 number to character.
    =     Lookup character.
  }/    End loop over coordinate pairs.
]     End wrapping characters.
/     Split character array into lines.
N*    And join them with newlines.

HackVM , 158 byte

Chắc chắn không phải là một người chiến thắng, nhưng điều này có vẻ như là một thử thách tốt để làm trong HVM.

Đặt kích thước vào ô nhớ đầu tiên và sử dụng mã sau:

77*1+c0<0^84*1+?1-11<-1>99*85++0^cc77*1+c066*5+-g!0<0^45*2+?1-95*0^0^2-PPP064*-6-gd95*2-P25*P$1<2>555**1-P0<0^76*6-?1-12<-2>2<3*48*+0^PP555**1-P076*2+-gd25*P$

Lưu ý: Mã cần phải chính xác trong một dòng để hoạt động.

Giải trình:

Call PLUSHDASHLINE
77*2+c

Read the cell and skip if done
0<0^84*1+?1-

  Flip row parity
  11<-1>

  Call NORMALLINE twice
  99*85++0^cc

  Call PLUSHDASHLINE
  77*1+c

Jump back to start of loop
066*5+-g!


DEFINE_PLUSDASHLINE
0<0^45*2+?1-95*0^0^2-PPP064*-6-gd95*2-P25*P$

DEFINE_NORMALLINE
1<2>555**1-P0<0^76*6-?1-12<-2>2<3*48*+0^PP555**1-P076*2+-gd25*P$

Mã này gọi 2 hàm PLUSHDASHLINEvà NORMALLINE, duy trì trạng thái toàn cục cho các chẵn lẻ (nghĩa là đặt một ' 'hoặc '#'một ô trong một ô).

Giải thích cho PLUSDASHLINE:

Repeat N times
0<0^45*2+?1-

  Print "+--"
  95*0^0^2-PPP

End Repeat
064*-6-g

Print "+"
d95*2-P

Print "\n"
25*P

Return
$

Giải thích cho NORMALLINE:

Copy Parity into Cell 2
1<2>

Print '|'
555**1-P

Repeat N times
0<0^76*6-?1-

  Flip Cell 2 (i.e. Flip Column Parity)
  12<-2>

  Calculate ' ' or '#' based upon parity
  2<3*48*+0^

  Print it twice
  PP

  Print '|'
  555**1-P

End Repeat
076*2+-g

Print "\n"
d25*P

Return
$

Sẽ đánh giá cao nếu ai đó đưa ra lời khuyên để cải thiện nó hơn nữa :)

Con trăn 2, 98

n=input()
f=lambda a,b,s:s+s.join(([a*2,b*2]*n)[:n])+s+'\n'
print f(f(*' #|'),f(*'# |'),f(*'--+'))

Không phải là con đường ngắn nhất, mà là một phương pháp thú vị. Hàm fnày có hai chuỗi a,bvà một dấu phân cách svà xen kẽ các đối số của nó như thế nào saasbbsaasbbsaas. Các hàng của bảng được tạo ở dạng này với các ký tự tương ứng, sau đó chính chúng được xen kẽ theo cách này để tạo ra kết quả.

Ruby: 83 ký tự

f=->n{puts d=?++'--+'*n,(0...n).map{|i|[?|+'%2s|'*n%(['','##',''][i%2,2]*n)]*2<<d}}

Chạy mẫu:

irb(main):001:0> f=->n{puts d=?++'--+'*n,(0...n).map{|i|[?|+'%2s|'*n%(['','##',''][i%2,2]*n)]*2<<d}}
=> #<Proc:0x000000007c51a0@(irb):1 (lambda)>

irb(main):002:0> f[0]
+
=> nil

irb(main):003:0> f[1]
+--+
|  |
|  |
+--+
=> nil

irb(main):004:0> f[2]
+--+--+
|  |##|
|  |##|
+--+--+
|##|  |
|##|  |
+--+--+
=> nil

irb(main):005:0> f[3]
+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+
|##|  |##|
|##|  |##|
+--+--+--+
|  |##|  |
|  |##|  |
+--+--+--+
=> nil

Ruby, 87

->n{a=[b="+--",c="|  |##",c,b,d="|##|  ",d]
0.upto(n*3){|i|puts"".ljust(n*3+1,a[i%6])}}

Đây là một chức năng ẩn danh. Gọi nó như thế này (tất cả các khả năng từ 0 đến 5)

f=->n{a=[b="+--",c="|  |##",c,b,d="|##|  ",d]
0.upto(n*3){|i|puts"".ljust(n*3+1,a[i%6])}}

6.times{|j|f.call(j)}

Nó sử dụng ljustphương thức trên một chuỗi rỗng. Ruby cho phép một chuỗi đệm được chỉ định để chứng minh, vì vậy chúng tôi sử dụng ljustvới một trong ba chuỗi đệm có thể có b,c,dtrên mỗi mảng a, được đặt hàng là bccbdd.

Julia, 124 byte

n->(t="+--"^n*"+";a="|  ";b="|##";m=n÷2;c=n%2>0;p=println;p(t);for i=1:n p(((i%2<1?(b*a)^m*b^c:(a*b)^m*a^c)*"|\n")^2*t)end)

Điều này tạo ra một hàm không tên chấp nhận một số nguyên và in ra thiết bị xuất chuẩn.

Ungolfed + giải thích:

function f(n)
    # Define the portions of the board
    t = "+--"^n * "+"
    a = "|  "
    b = "|##"

    # There will be n÷2 repeated a*b or b*a per line
    m = n ÷ 2

    # If n is odd, there will be an extra a or b
    c = n % 2 != 0

    # Print the top
    println(t)

    # Print each horizontal section of the board
    for i = 1:n
        # In even numbered sections, b precedes a
        j = (i % 2 == 0 ? (b*a)^m * b^c : (a*b)^m * a^c) * "|\n"
        println(j^2 * t)
    end
end

Javascript, ES6 149

n=>(r="+--".repeat(n)+"+",[...r].map((_,i)=>i%3?(x=i%6&&i%6<3?" ":"#",[...r].map((_,e)=>e%3?e%6&&e%6<3?x:"#"==x?" ":"#":"|").join('')):r).join('\n'))

Khá thú vị để viết mặc dù nó hơi dài

Hoạt động trên firefox

1 - Mở bàn điều khiển

2 - Gõ như sau

console.log((n=>(r="+--".repeat(n)+"+",[...r].map((_,i)=>i%3?(x=i%6&&i%6<3?" ":"#",[...r].map((_,e)=>e%3?e%6&&e%6<3?x:"#"==x?" ":"#":"|").join('')):r).join('\n')))(15));

Đầu ra (n = 15):

+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

Haskell, 99

Điều này được lấy cảm hứng một phần từ câu trả lời Haskell trước đây của catgocat ; Tôi đã viết phiên bản của riêng tôi, sau đó nhìn vào nó, sau đó viết một phiên bản khác. Tôi đang chơi theo cùng một quy tắc - đầu vào là một đối số, nhưng đầu ra là thiết bị xuất chuẩn. (Nếu đó có thể là một hàm thuần túy, hãy trừ 7 ký tự putStr$.)

f n=putStr$unlines$t$map t$y[a,b,b,a,c,c]where t=take(n*3+1)
a=y"+--"
b=y"|  |##"
c=drop 3b
y=cycle

Chúng tôi sử dụng tđể lấy một vùng gồm 3 n + 1 ký tự từ một bàn cờ vô hạn được xây dựng bằng cách sử dụng cyclevà đó là nó. Ý tưởng chính tôi lấy từ câu trả lời khác là đặt các mẫu của cả các ô viền và các ô kiểm tra lại với nhau thành các chuỗi.

Phiên bản đầu tiên của tôi (140 ký tự) đã sử dụng chiến lược tính toán ký tự tại mỗi điểm, có thể tốt hơn cho một vấn đề phức tạp hơn so với phiên bản này.

f n=putStr$unlines$map(\y->map(g y)r)r where r=[0..n*3]
g y x=s(s '+'y '|')x$s '-'y$cycle" #"!!(x`div`3+y`div`3)
s c i d|i`mod`3==0=c|True=d

Haskell, 118

Đây là câu trả lời golf haskell đầu tiên của tôi và đây là:

f n=mapM_(putStrLn.s)[0..3*n]where;d x=(++)$take(3*n)$cycle x;s x|x`mod`3<1=d"+--""+"|x`mod`6<3=d"|  |##""|"|1<2=d"|##|  ""|"

Phiên bản dễ đọc hơn:

func num = do
    let -- Range
        rag = 3 * num
        -- `+--+`
        a = d "+--" "+"
        -- `|  |##`
        b = d "|  |##" "|"
        -- `|##|  `
        c = d "|##|  " "|"
        -- generate line
        d x y = take rag (cycle x) ++ y
        -- step
        step x
            | x `mod` 6 `elem` [1, 2] = b
            | x `mod` 3 == 0          = a
            | otherwise               = c

    mapM_ (putStrLn . step) [0..rag]

Đầu ra

*Main> :load test
[1 of 1] Compiling Main             ( test.hs, interpreted )
Ok, modules loaded: Main.
*Main> f 1
+
*Main> f 4
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+
*Main> f 15
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
|##|  |##|  |##|  |##|  |##|  |##|  |##|  |##|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
|  |##|  |##|  |##|  |##|  |##|  |##|  |##|  |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

C - 119 101

Bây giờ sử dụng phép tính tương tự như câu trả lời @ Sp3000. Cũng tối ưu hóa cặp đôi.

i,j;f(n){for(i=j=0;j<=n*3;i++)putchar(i-n*3-1?" -|+#"[!(j%3)+2*!(i%3)?:(i/3+j/3)%2*4]:(j-=i=-1,10));}

Tôi nghĩ đó ?:là một phần mở rộng GCC ...

Câu trả lời cũ:

f(n){int i,j;char p[]=" -|+";for(i=j=0;j<=n*3;*p=" #"[(i++/3+j/3)%2])putchar(i-n*3-1?p[!(j%3)+2*!(i%3)]:(j-=i=-1,10));}

Nó duy trì 2 tọa độ và tính toán trung thực ký tự nào sẽ in cho mỗi cặp. Danh sách các ký tự để in được lưu trữ trong mảng và riêng điều này sẽ in một lưới "không màu". Phần tử đầu tiên của mảng được sửa đổi để vẽ hình vuông màu đen.

Tôi có thể thay đổi điều này để thay vì hai tọa độ độc lập, đó là một giá trị đếm lên hoặc (thậm chí tốt hơn), nhưng không thể quấn lấy đầu tôi ngay bây giờ.

Phần thưởng - thay thế 3 bằng bất kỳ số nào khác dẫn đến một chương trình vẽ bảng kiểm tra hợp lệ với kích thước ô khác nhau.

ôi - 91

{
    for(k=i=3*$0+1;i--;print"")
        for(j=k;j--;)printf i%3?j%3?234~(i+j)%6?FS:"#":j%3?"-":"|":"+"
}

Đã là một cuộc chiến để có được nó dưới 100. Đếm ngược và sử dụng toán tử khớp là những bước đột phá;) Phần còn lại là logic khá đơn giản.

Pyke, 47 byte, không cạnh tranh

"+--"Q*\+j+i
QQ]Uas 2%" #"@2*)F\|JjR+"+
"+2*pi
<Newline needed>

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