개요

최근 ASCII 아트 챌린지의 인기에서 영감을 얻은이 챌린지의 목적은 체스를 할 수있는 것과 같은 ASCII 바둑판을 그리는 것입니다.

양의 정수 n를 인수, stdin입력 또는 사용자 입력으로 사용 하는 프로그램을 작성하고 두께가 1자인 테두리와 함께 nx n사각형으로 바둑판을 출력하십시오 .

각 사각형은 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
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+
|  |##|  |##|
|  |##|  |##|
+--+--+--+--+
|##|  |##|  |
|##|  |##|  |
+--+--+--+--+

파이썬 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자를 반복하여 선택되며 올바른 길이의 스 니펫을 추출하는 역할도합니다.

반복 패턴 [0,1,1,0,2,2]를 제공 i하는 산술 식에 의해 행 인덱스 모듈러스 6 의 값에 기초하여 올바른 패턴이 선택 된다 3**i%7/2%3. x**i%7period가 있는 사실을 사용 하여 올바른 패턴을 얻기 위해 6다른 값 x과 사후 처리를 시도 했습니다.

피스, 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

이 메타 토론을 기반으로 단항으로 입력을 받습니다.

각 줄은 자체 파일로 이동 n해야하며 파일 에서 줄 바꿈으로 변경되어야합니다. 이것은 실용적이지 않지만 마커를 -s유지하면서 플래그를 사용하여 하나의 파일로 코드를 그대로 실행할 수 있습니다 n. n원하는 경우 가독성을 위해 출력에서를 개행으로 변경할 수 있습니다 . 예 :

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

추가 골프와 설명이 나중에 나옵니다.

자바 스크립트 (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*

여기에서 온라인으로 사용해보십시오

ES6가 포함 된 CoffeeScript, 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

자바 스크립트 (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>

파이썬 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$

코드는이 함수를 호출 PLUSHDASHLINE하고 NORMALLINE, (풋 여부, 즉 패리티을위한 글로벌 상태 유지 ' '또는를 '#'셀에 참조).

설명 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
$

누군가가 그것을 더 개선하기위한 팁을 주면 감사하겠습니다 :)

파이썬 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하여 다음과 같은 인수를 인터리브합니다 saasbbsaasbbsaas. 보드의 행은 각각의 문자와 함께이 형식으로 생성 된 다음 결과를 생성하기 위해 이러한 방식으로 인터리브됩니다.

루비 : 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빈 문자열 에서 메소드를 사용 합니다. 루비는 패딩 문자열을 정당화하기 위해 지정할 수있게하므로 , 배열 당 ljust3 개의 가능한 패딩 문자열 중 하나와 함께 순서대로 사용 합니다.b,c,dabccbdd

줄리아, 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에 인쇄하는 이름없는 함수를 만듭니다.

언 골프 + 설명 :

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

자바 스크립트, 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'))

조금 길지만 쓰기가 꽤 재미 있습니다.

파이어 폭스에서 작동

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

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

하스켈, 99

이것은 catgocat의 이전 Haskell 답변에서 부분적으로 영감을 얻었습니다 . 나는 내 자신의 버전을 썼고 그것을 본 다음 다른 것을 썼습니다. 나는 같은 규칙을 사용하고 있습니다. 입력은 인수이지만 출력은 표준입니다. (순수한 함수일 경우 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

우리 는를 사용하여 빌드 한 무한 체커 보드에서 3n + 1 문자 t의 영역을 가져 오는 데 사용 합니다. 내가 다른 대답에서 얻은 주요 아이디어는 테두리와 체커 셀의 패턴을 문자열로 묶는 것 입니다.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

하스켈, 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 이하로 맞추기 위해 꽤 싸웠습니다. 뒤로 계산하고 일치 연산자를 사용하는 것이 돌파구였습니다.

파이크, 47 바이트, 비경쟁

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

여기 사용해보십시오!