Sumário

Inspirado pela recente popularidade dos desafios de arte ASCII, o objetivo desse desafio é desenhar um tabuleiro de xadrez ASCII, como aquele no qual o xadrez pode ser jogado.

Escreva um programa que use um número inteiro positivo ncomo argumento, em stdinou como entrada do usuário e imprima um tabuleiro de xadrez com nx nquadrados, juntamente com uma borda com 1 caractere de espessura.

Cada quadrado deve ter caracteres de 2x2. Os quadrados devem seguir o padrão alternado branco-preto (branco primeiro, como no canto superior esquerdo) de um tabuleiro de xadrez. Os quadrados brancos devem ser feitos com caracteres space ( ) e os quadrados pretos com #caracteres libra ( ).

A borda deve ser feita de traços ( -) com um sinal de mais ( +) na borda ou no ponto perpendicular de um quadrado.

Entrada

Número inteiro positivo para representar o número de quadrados (dimensões em quadrados) a serem desenhados no tabuleiro de damas, com cada quadrado com caracteres de 2x2.

Resultados de exemplo

n=2

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

n=3

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

n=4

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

... e assim por diante.

Notas

• Espaços à direita e novas linhas são aceitáveis.
• Você pode escrever um programa inteiro ou uma função.
• Sem espaços à esquerda.
• Seu programa deve exibir resultados corretos para n = 15.
• Para idiomas esotéricos menos conhecidos e similares, forneça um link para o idioma.
• n=0deve produzir +. (opcional, mas altamente recomendado e incentivado.)
• O código mais curto em bytes vence, pois esse é o código golf.

J, 24 bytes

Uma função anônima:

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

Uso:

   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]

Para cada linha, seleciona um dos padrões

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

e imprime 3*n+1caracteres a partir dele. O padrão é escolhido repetindo seus 6 primeiros caracteres, selecionados com o truque de intercalação de cadeias, que também serve para extrair um trecho do comprimento correto.

O padrão correto é selecionado com base no valor do imódulo de índice de linha 6 por uma expressão aritmética 3**i%7/2%3que fornece o padrão de repetição [0,1,1,0,2,2]. Eu o encontrei usando o fato de que x**i%7tem período e 6, em seguida, tentando valores xdiferentes e pós-processamento diferentes para obter o padrão certo.

Pyth, 37

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

Em vez hackeado juntos, mas curto.

Demonstração.

CJam, 43 42 bytes

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

Experimente online .

Cada coordenada é mapeada para um caractere, por exemplo, o canto superior esquerdo (0, 0) -> "+". Especificamente, calculamos

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

e indexe na string de "#|-+ "acordo.

Retina , 106 bytes

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

Considera a entrada como unária (com base nesta metat Discussão ).

Cada linha deve ir para seu próprio arquivo e ndeve ser alterada para nova linha nos arquivos. Isso é impraticável, mas você pode executar o código como está, como um arquivo, com o -ssinalizador, mantendo os nmarcadores. Você pode alterar as nlinhas para novas linhas na saída para facilitar a leitura, se desejar. Por exemplo:

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

Mais golfe e algumas explicações vêm mais tarde.

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

Snippet:

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

Função anônima. Inicia com uma matriz completa de +--+--+--...linhas e, nas linhas apropriadas, substitui o +for |e -for ou #conforme apropriado.

A expressão que decide o caractere de substituição "| |##| "[x%6+(i%6>2)*3]provavelmente poderia ser mais alterada, mas descobri que o uso de uma string mais longa e redundante economiza mais caracteres do que um cálculo complexo.

CJam, 59 bytes

Este é muito longo ..

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

Experimente online aqui

CoffeeScript com ES6, 106 bytes

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 bytes

As novas linhas são significativas e contadas como 1 byte cada.

O retorno explícito aumentou um pouco:

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}

Demo

No momento da redação deste artigo, o Firefox é o único grande navegador compatível com o 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+"+")

Soluções anteriores

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 (não enviado)

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 bytes

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

Experimente online

Bem, eu esperava ter pelo menos uma solução original (normalmente não vejo outras respostas antes de trabalhar por conta própria). Acontece que o @ Sp3000 já havia feito algo muito semelhante, só que melhor. Mas como já fiz o trabalho, pensei em publicá-lo de qualquer maneira.

Explicação:

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 bytes

Definitivamente não é um vencedor, mas isso parecia um bom desafio para se fazer na HVM.

Coloque o tamanho na primeira célula da memória e use o seguinte código:

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$

Nota: O código precisa estar exatamente em uma linha para funcionar.

Explicação:

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$

O código chama 2 funções PLUSHDASHLINEe NORMALLINE, mantém um estado global para paridades (ou seja, se deve colocar um ' 'ou a '#'em uma célula).

Explicação para 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
$

Explicação para 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
$

Gostaria que alguém desse dicas para melhorá-lo ainda mais :)

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

Não é o caminho mais curto, mas um método divertido. A função fpega duas strings a,be um separador se intercala seus argumentos como saasbbsaasbbsaas. As linhas do quadro são criadas neste formulário com seus respectivos caracteres, depois são intercaladas dessa maneira para produzir o resultado.

Ruby: 83 caracteres

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

Exemplo de execução:

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

Esta é uma função anônima. Chame assim (todas as possibilidades de 0 a 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)}

Ele faz uso do ljustmétodo em uma string vazia. O Ruby permite que uma string de preenchimento seja especificada para justificativa; portanto, usamos ljustuma das três possíveis sequências de preenchimento b,c,dpor matriz a, ordenadas como bccbdd.

Julia, 124 bytes

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)

Isso cria uma função sem nome que aceita um número inteiro e imprime no stdout.

Ungolfed + explicação:

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

Muito divertido de escrever, embora seja um pouco longo

Funciona no firefox

1 - Console aberto

2 - Digite o seguinte

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

Saída (n = 15):

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

Haskell, 99

Isso é parcialmente inspirado na resposta anterior de Haskell por catgocat ; Escrevi minha própria versão, depois olhei para ela e depois escrevi outra. Estou jogando com as mesmas regras - a entrada é um argumento, mas a saída é stdout. (Se puder ser uma função pura, subtraia 7 caracteres 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

Costumamos tpegar uma região de 3 n + 1 caracteres de um tabuleiro de xadrez infinito criado usando cycle, e é isso. A ideia principal que tirei a outra resposta é a de colocar os padrões de células tanto a fronteira e verificador juntos em cordas.

Minha primeira versão (140 caracteres) usou a estratégia de calcular o caractere em cada ponto, o que poderia ser melhor para um problema mais complexo que este.

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

Esta é a minha primeira resposta de código haskell de golfe e aqui está:

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

Versão mais legível:

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]

Saída

*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

Usa agora o cálculo semelhante à resposta do @ Sp3000. Também otimizações de casal.

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

Eu acho que ?:é uma extensão do GCC ...

Resposta antiga:

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

Ele mantém 2 coordenadas e calcula honestamente qual caractere imprimir para cada par. A lista de caracteres a serem impressos é armazenada em matriz e, por si só, imprime uma grade "sem cor". O primeiro elemento da matriz é modificado para desenhar quadrados pretos.

Eu posso mudar isso para que, em vez de duas coordenadas independentes, seja um valor em contagem decrescente ou (talvez até melhor), mas não consigo entender isso agora.

Bônus - substituir 3 por qualquer outro número resulta em um programa que desenha um tabuleiro de damas válido com tamanho de célula diferente.

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

Foi uma luta e tanto ficar abaixo de 100. Contar para trás e usar o operador de partida foram os avanços;) O resto é uma lógica bastante direta.

Pyke, 47 bytes, não concorrente

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

Experimente aqui!