สรุป

แรงบันดาลใจจากความนิยมล่าสุดของความท้าทายงานศิลปะ ASCII จุดประสงค์ของความท้าทายนี้คือการวาดกระดานหมากรุก ASCII เช่นเดียวกับที่เล่นหมากรุกได้

เขียนโปรแกรมที่ใช้จำนวนเต็มบวกnเป็นอาร์กิวเมนต์ในstdinหรือเป็นอินพุตของผู้ใช้และส่งออกกระดานหมากรุกที่มีnx nกำลังสองพร้อมกับเส้นขอบที่มีความหนา 1 อักขระ

แต่ละสแควร์ควรเป็นอักขระ 2x2 สี่เหลี่ยมควรเป็นไปตามลวดลายสลับขาว - ดำ (สีขาวก่อนตามมุมบนซ้าย) ของกระดานหมากรุก สี่เหลี่ยมสีขาวควรทำจากอักขระเว้นวรรค ( ) และสี่เหลี่ยมสีดำควรทำจาก#อักขระปอนด์ ( )

เส้นขอบควรทำจากเครื่องหมายขีดกลาง ( -) พร้อมเครื่องหมายบวก ( +) ที่ขอบหรือจุดตั้งฉากของสี่เหลี่ยม

อินพุต

จำนวนเต็มบวกในการแสดงจำนวนของสแควร์ (มิติในสแควร์) เพื่อวาดในกระดานหมากรุกโดยแต่ละตารางจะมีตัวอักษร 2x2

ตัวอย่างผลลัพธ์

n=2

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

n=3

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

n=4

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

... และต่อไป

หมายเหตุ

• ช่องว่างต่อท้ายและบรรทัดใหม่เป็นที่ยอมรับ
• คุณสามารถเขียนได้ทั้งโปรแกรมหรือฟังก์ชั่น
• ไม่มีช่องว่างนำหน้า
• โปรแกรมของคุณควรแสดงผลลัพธ์ที่ถูกต้องสำหรับ n = 15
• สำหรับภาษาลึกลับที่ไม่เป็นที่รู้จักและคล้ายกันให้ระบุลิงก์ไปยังภาษา
• n=0+ควรผลิต (เป็นทางเลือก แต่แนะนำและสนับสนุนอย่างยิ่ง)
• รหัสที่สั้นที่สุดในหน่วยไบต์ชนะเช่นนี้เป็นรหัสกอล์ฟ

J, 24 ไบต์

ฟังก์ชั่นที่ไม่ระบุชื่อ:

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

การใช้งาน:

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

Python 2, 79

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

สำหรับแต่ละแถวให้เลือกหนึ่งในรูปแบบ

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

และพิมพ์3*n+1อักขระจากมัน รูปแบบถูกเลือกโดยการทำซ้ำอักขระ 6 ตัวแรกซึ่งถูกเลือกด้วยเคล็ดลับการสอดแทรกสตริงซึ่งทำหน้าที่แยกส่วนย่อยของความยาวที่ถูกต้อง

รูปแบบที่ถูกต้องถูกเลือกขึ้นอยู่กับค่าของดัชนีแถวiโมดูโล 6 โดยนิพจน์ทางคณิตศาสตร์3**i%7/2%3ที่ให้รูปแบบการทำซ้ำ [0,1,1,0,2,2] ฉันพบว่ามันใช้ความจริงที่x**i%7มี6จุดแล้วลองใช้ค่าที่xแตกต่างกันและ postprocessing ที่แตกต่างกันเพื่อให้ได้รูปแบบที่ถูกต้อง

Pyth, 37

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

ค่อนข้างแฮ็คด้วยกัน แต่สั้น

สาธิต.

CJam, 43 42 ไบต์

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

ลองมันออนไลน์

(0, 0) -> "+"แต่ละประสานงานถูกแมปไปถ่านเช่นมุมบนด้านซ้ายคือ โดยเฉพาะเราคำนวณ

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

และดัชนีลงในสตริง"#|-+ "ตาม

เรติน่า 106 ไบต์

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

ใช้อินพุตเป็น unary (อ้างอิงจากการสนทนาเมตานี้ )

แต่ละบรรทัดควรไปที่ไฟล์ของตนเองและnควรเปลี่ยนเป็นบรรทัดใหม่ในไฟล์ สิ่งนี้ไม่สามารถใช้งานได้ แต่คุณสามารถเรียกใช้รหัสตามที่เป็นอยู่ซึ่งเป็นไฟล์เดียวที่มีการ-sตั้งค่าสถานะเพื่อรักษาnเครื่องหมาย คุณสามารถเปลี่ยนnเป็นบรรทัดใหม่ในผลลัพธ์เพื่อให้สามารถอ่านได้หากคุณต้องการ เช่น:

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

กอล์ฟเพิ่มเติมและคำอธิบายบางอย่างมาในภายหลัง

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`
`

ตัวอย่างข้อมูล:

<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>

ฟังก์ชั่นไม่ระบุชื่อ เริ่มต้นด้วยอาร์เรย์เต็ม+--+--+--...บรรทัดและบนบรรทัดที่เหมาะสมแทนที่+for |และ-for หรือ#ตามความเหมาะสม

นิพจน์ที่ตัดสินใจว่าจะใช้อักขระทดแทน"| |##| "[x%6+(i%6>2)*3]อาจจะเพิ่มขึ้นได้ แต่ฉันพบว่าการใช้สตริงที่ยาวและซ้ำซ้อนช่วยประหยัดอักขระได้มากกว่าการคำนวณที่ซับซ้อน

CJam, 59 ไบต์

.. นี้ .. ก็เช่นกัน ..

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

ลองออนไลน์ได้ที่นี่

CoffeeScript ที่มี ES6, 106 ไบต์

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 ไบต์

การขึ้นบรรทัดใหม่มีความสำคัญและนับเป็น 1 ไบต์ในแต่ละบรรทัด

ผลตอบแทนที่ชัดเจนทำให้มันอีกต่อไปอีกเล็กน้อย:

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}

การสาธิต

ในขณะที่เขียน Firefox เป็นเบราว์เซอร์หลักที่เข้ากันได้กับ 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>

Python 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+"+")

โซลูชั่นก่อนหน้า

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 (ไม่ได้ส่ง)

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 ไบต์

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

ลองออนไลน์

ฉันหวังว่าอย่างน้อยฉันก็จะมีวิธีแก้ปัญหาดั้งเดิม (โดยปกติฉันไม่ได้ดูคำตอบอื่น ๆ ก่อนทำงานด้วยตัวเอง) ปรากฎว่า @ Sp3000 ได้ทำสิ่งที่คล้ายกันแล้วดีกว่าเท่านั้น แต่เนื่องจากฉันทำงานไปแล้วฉันคิดว่าฉันจะโพสต์ต่อไป

คำอธิบาย:

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 ไบต์

ไม่ใช่ผู้ชนะแน่นอน แต่นี่เป็นความท้าทายที่ต้องทำใน HVM

วางขนาดลงในเซลล์หน่วยความจำแรกและใช้รหัสต่อไปนี้:

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$

หมายเหตุ:รหัสจะต้องอยู่ในบรรทัดเดียวในการทำงาน

คำอธิบาย:

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$

รหัสนี้เรียกฟังก์ชัน 2 ฟังก์ชันPLUSHDASHLINEและNORMALLINEรักษาสถานะโกลบอลสำหรับ parities (เช่นว่าจะใส่ a ' 'หรือ a '#'ในเซลล์)

คำอธิบายสำหรับ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
$

คำอธิบายสำหรับ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
$

จะขอบคุณมันถ้ามีคนให้คำแนะนำในการปรับปรุงเพิ่มเติม :)

Python 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(*'--+'))

ไม่ใช่วิธีที่สั้นที่สุด แต่เป็นวิธีที่สนุก ฟังก์ชั่นfใช้เวลาในสองสายa,bและตัวคั่นsและ interleaves saasbbsaasbbsaasข้อโต้แย้งของมันเช่น แถวของกระดานถูกสร้างขึ้นในรูปแบบนี้ด้วยตัวละครที่เกี่ยวข้องจากนั้นจะแทรกตัวด้วยวิธีนี้เพื่อสร้างผลลัพธ์

Ruby: 83 ตัวอักษร

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

วิ่งตัวอย่าง:

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

ทับทิม, 87

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

นี่คือฟังก์ชั่นที่ไม่ระบุชื่อ เรียกมันว่าแบบนี้ (ความเป็นไปได้ทั้งหมดตั้งแต่ 0 ถึง 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)}

มันทำให้การใช้ljustวิธีการในสตริงที่ว่างเปล่า ทับทิมช่วยให้สตริง padding จะถูกระบุไว้สำหรับเหตุผลเพื่อให้เราใช้ljustกับหนึ่งในสามของสตริง padding เป็นไปได้b,c,dต่ออาร์เรย์สั่งเป็นabccbdd

Julia, 124 ไบต์

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)

สิ่งนี้จะสร้างฟังก์ชั่นที่ไม่มีชื่อที่รับจำนวนเต็มและพิมพ์ไปยัง stdout

คำอธิบาย Ungolfed +:

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'))

ค่อนข้างสนุกที่จะเขียนแม้ว่ามันจะค่อนข้างยาว

ทำงานบน Firefox

1 - เปิดคอนโซล

2 - พิมพ์ต่อไปนี้

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));

เอาท์พุท (n = 15):

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

Haskell, 99

สิ่งนี้ได้รับแรงบันดาลใจบางส่วนจากคำตอบ Haskell ก่อนหน้าโดย catgocat ; ฉันเขียนเวอร์ชันของฉันเองแล้วดูจากนั้นเขียนอีกฉบับ ฉันกำลังเล่นตามกฎเดียวกัน - อินพุตเป็นอาร์กิวเมนต์ แต่ผลลัพธ์คือ stdout (ถ้าเป็นฟังก์ชั่นแท้ให้ลบตัวอักษร 7 ตัว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

เราใช้tในการใช้พื้นที่ 3 n + 1 ตัวละครจากกระดานหมากรุกที่ไม่มีที่สิ้นสุดที่สร้างขึ้นโดยใช้cycleและนั่นคือมัน แนวคิดหลักที่ฉันนำมาจากคำตอบอื่นคือการวางรูปแบบของทั้งเส้นขอบและเซลล์ตัวตรวจสอบเข้าด้วยกันเป็นสตริง

รุ่นแรกของฉัน (140 ตัวอักษร) ใช้กลยุทธ์ในการคำนวณตัวละครในแต่ละจุดซึ่งอาจจะดีกว่าสำหรับปัญหาที่ซับซ้อนกว่านี้

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

นี่คือคำตอบกอล์ฟรหัส haskell แรกของฉันและนี่คือ:

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"|##|  ""|"

รุ่นที่อ่านเพิ่มเติมได้:

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]

เอาท์พุต

*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

ใช้ตอนนี้การคำนวณคล้ายกับคำตอบ @ Sp3000 ยังเพิ่มประสิทธิภาพคู่

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));}

ฉันคิดว่านั่น?:เป็นส่วนขยาย GCC ...

คำตอบเก่า:

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));}

มันคง 2 พิกัดและคำนวณอย่างสุจริตว่าตัวละครที่จะพิมพ์สำหรับแต่ละคู่ รายชื่อตัวละครที่จะพิมพ์จะถูกจัดเก็บไว้ในอาร์เรย์ องค์ประกอบแรกของอาร์เรย์ได้รับการแก้ไขเพื่อวาดสี่เหลี่ยมสีดำ

ฉันอาจจะเปลี่ยนสิ่งนี้เพื่อให้แทนที่จะเป็นสองค่าพิกัดอิสระมันมีค่าหนึ่งค่านับหรือ (อาจจะดีกว่า) ลง แต่ไม่สามารถคาดศีรษะได้ในตอนนี้

โบนัส - การแทนที่ 3 ด้วยผลลัพธ์ตัวเลขอื่น ๆ ในโปรแกรมที่วาดตารางหมากรุกที่ถูกต้องด้วยขนาดเซลล์ที่แตกต่างกัน

awk - 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?"-":"|":"+"
}

เป็นการต่อสู้เพื่อให้ได้ต่ำกว่า 100 การนับถอยหลังและการใช้โอเปอเรเตอร์เป็นการแข่งขัน;) ส่วนที่เหลือเป็นตรรกะที่ตรงไปตรงมามากทีเดียว

Pyke, 47 ไบต์, ไม่ใช่การแข่งขัน

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

ลองที่นี่!