Podsumowanie

Zainspirowany niedawną popularnością wyzwań artystycznych ASCII, celem tego wyzwania jest narysowanie szachownicy ASCII, takiej jak ta, na której można grać w szachy.

Napisz program, który przyjmuje dodatnią liczbę całkowitą njako argument, w stdinlub jako dane wejściowe użytkownika, i wypisz szachownicę z kwadratami nx n, wraz z ramką o grubości 1 znaku.

Każdy kwadrat powinien mieć 2x2 znaki. Kwadraty powinny być zgodne z normalnym naprzemiennie biało-czarnym (najpierw białym, jak w lewym górnym rogu) wzorem szachownicy. Białe kwadraty powinny być wykonane ze znaków spacji ( ), a czarne kwadraty powinny być wykonane ze #znaków funta ( ).

Obramowanie powinno być wykonane z myślników ( -) z plusem ( +) na obramowaniu lub prostopadłym punkcie kwadratu.

Wkład

Dodatnia liczba całkowita reprezentująca liczbę kwadratów (wymiary w kwadratach) do narysowania w szachownicy, przy czym każdy kwadrat ma 2x2 znaki.

Przykładowe wyniki

n=2

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

n=3

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

n=4

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

... i tak dalej.

Notatki

• Dopuszczalne są spacje końcowe i nowe linie.
• Możesz napisać cały program lub funkcję.
• Brak spacji wiodących.
• Twój program powinien wyświetlać prawidłowe wyniki dla n = 15.
• W przypadku mniej znanych języków ezoterycznych i podobnych podaj link do tego języka.
• n=0powinien produkować +. (opcjonalnie, ale zdecydowanie zalecane i zalecane).
• Najkrótszy kod w bajtach wygrywa, ponieważ jest to kod golfowy.

J, 24 bajty

Anonimowa funkcja:

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

Stosowanie:

   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]

Dla każdego wiersza wybiera jeden ze wzorów

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

i drukuje 3*n+1z niego postacie. Wzór jest wybierany przez powtarzanie pierwszych 6 znaków, wybranych za pomocą sztuczki przeplatania łańcucha, która służy również do wyodrębnienia fragmentu o odpowiedniej długości.

Prawidłowy wzorzec jest wybierany na podstawie wartości indeksu wiersza imodulo 6 przez wyrażenie arytmetyczne, 3**i%7/2%3które daje powtarzający się wzorzec [0,1,1,0,2,2]. Znalazłem to, korzystając z faktu, że x**i%7ma kropkę 6, a następnie próbowałem różnych wartości xi różnych postprocessingu, aby uzyskać odpowiedni wzór.

Pyth, 37 lat

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

Raczej zhakowane razem, ale krótkie.

Demonstracja.

CJam, 43 42 bajty

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

Wypróbuj online .

Każda współrzędna jest odwzorowana na znak, np. Lewy górny róg to (0, 0) -> "+". W szczególności obliczamy

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

i odpowiednio indeksować w ciągu "#|-+ ".

Siatkówka , 106 bajtów

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

Traktuje dane wejściowe jako jednoargumentowe (na podstawie tej meta dyskusji ).

Każda linia powinna przejść do własnego pliku i npowinna zostać zmieniona na nową linię w plikach. Jest to niepraktyczne, ale możesz uruchomić kod w postaci pliku z -sflagą, zachowując nznaczniki. Jeśli chcesz, możesz zmienić te nznaki wyjściowe na nowe wiersze w celu zwiększenia czytelności. Na przykład:

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

Dalsza gra w golfa i wyjaśnienia pojawiają się później.

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

Skrawek:

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

Funkcja anonimowa. Zaczyna się od pełnej tablicy +--+--+--...linii i na odpowiednich liniach zastępuje +for |i -for lub #odpowiednio.

Wyrażenie, które decyduje o zamiennym znaku, "| |##| "[x%6+(i%6>2)*3]prawdopodobnie mogłoby być jeszcze bardziej golfa, ale odkryłem, że użycie dłuższego, zbędnego łańcucha oszczędza więcej znaków niż skomplikowane obliczenia.

CJam, 59 bajtów

To .. jest… zbyt… długie…

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

Wypróbuj online tutaj

CoffeeScript z ES6, 106 bajtów

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 bajtów

Nowe linie są znaczące i są liczone jako 1 bajt.

Wyraźny zwrot sprawił, że stał się on nieco dłuższy:

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}

Próbny

W chwili pisania tego tekstu Firefox jest jedyną dużą przeglądarką zgodną z 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+"+")

Poprzednie rozwiązania

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 (nie przesłano)

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 bajtów

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

Wypróbuj online

Cóż, miałem nadzieję, że przynajmniej będę miał oryginalne rozwiązanie (zwykle nie patrzę na inne odpowiedzi przed samodzielną pracą). Okazuje się, że @ Sp3000 zrobił już coś bardzo podobnego, tylko lepiej. Ale ponieważ już wykonałem tę pracę, pomyślałem, że i tak ją opublikuję.

Wyjaśnienie:

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 bajtów

Zdecydowanie nie jest zwycięzcą, ale wyglądało to na niezłe wyzwanie w HVM.

Umieść rozmiar w pierwszej komórce pamięci i użyj następującego kodu:

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$

Uwaga: Kod musi działać dokładnie w jednym wierszu, aby działać.

Wyjaśnienie:

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$

Kod wywołuje 2 funkcje PLUSHDASHLINEi NORMALLINEutrzymuje stan globalny dla parzystości (tj. Czy wstawić a ' 'czy a'#' do komórki).

Wyjaśnienie dla 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
$

Wyjaśnienie dla 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
$

Byłbym wdzięczny, gdyby ktoś dał wskazówki, jak go ulepszyć :)

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

Nie najkrótsza droga, ale zabawna metoda. Funkcja fprzyjmuje dwa ciągi znaków a,bi separator si przeplata swoje argumenty jak saasbbsaasbbsaas. Rzędy planszy są tworzone w tej formie z odpowiednimi postaciami, a następnie same są przeplatane w ten sposób, aby uzyskać wynik.

Ruby: 83 znaki

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

Przykładowy przebieg:

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

To anonimowa funkcja. Nazwij to tak (wszystkie możliwości od 0 do 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)}

Wykorzystuje ljustmetodę na pustym ciągu. Ruby pozwala na określenie łańcucha dopełniającego w celu uzasadnienia, dlatego używamy ljustjednego z trzech możliwych łańcuchów dopełniających b,c,dna tablicę a, uporządkowanych jako bccbdd.

Julia, 124 bajty

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)

To tworzy nienazwaną funkcję, która akceptuje liczbę całkowitą i wypisuje na standardowe wyjście.

Niegolfowane + wyjaśnienie:

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

Fajnie jest pisać, choć jest trochę długa

Działa na Firefox

1 - Otwórz konsolę

2 - Wpisz następujące polecenie

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

Wyjście (n = 15):

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

Haskell, 99

Jest to częściowo inspirowane poprzednią odpowiedzią Haskell autorstwa catgocat ; Napisałem własną wersję, potem na nią spojrzałem, a potem napisałem inną. Gram na tych samych zasadach - wejście jest argumentem, ale wyjście jest standardowe. (Jeśli może to być czysta funkcja, odejmij 7 znaków 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

Używamy tregionu 3 n + 1 znaków z nieskończonej szachownicy zbudowanej za pomocą cyclei to wszystko. Główną ideą, którą wziąłem z drugiej odpowiedzi, jest zebranie wzorów komórek granicy i kontrolera w ciągi.

Moja pierwsza wersja (140 znaków) wykorzystywała strategię obliczania postaci w każdym punkcie, co może być lepsze w przypadku bardziej złożonego problemu niż ten.

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

To jest moja pierwsza odpowiedź na golfa haskell code i oto:

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

Bardziej czytelna wersja:

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]

Wydajność

*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

Używa teraz obliczeń podobnych do odpowiedzi @ Sp3000. Również kilka optymalizacji.

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

Myślę, że ?:to rozszerzenie GCC ...

Stara odpowiedź:

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

Utrzymuje 2 współrzędne i szczerze oblicza, który znak należy wydrukować dla każdej pary. Lista znaków do wydrukowania jest przechowywana w tablicy, a to samo drukuje „bezbarwną” siatkę. Pierwszy element tablicy jest modyfikowany, aby rysować czarne kwadraty.

Mógłbym to zmienić, tak aby zamiast dwóch niezależnych współrzędnych jedna wartość zliczała w górę lub (a może nawet lepiej) w dół, ale nie mogę teraz tego zawinąć.

Bonus - zastąpienie 3 dowolną inną liczbą powoduje, że program rysuje prawidłową szachownicę o innym rozmiarze komórki.

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

Walka o osiągnięcie poziomu poniżej 100 była przełomem. Przełomem było przełożenie;) Reszta jest dość logiczna.

Pyke, 47 bajtów, niekonkurujący

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

Wypróbuj tutaj!