ASCII 체스 판을 그립니다!


42

간단한 도전은 다음과 같습니다. 체스 판의 ASCII 표현을 생성해야합니다. 흰색은 대문자로 표시되고 검은 색은 소문자로 표시됩니다. 빈 타일은로 표시됩니다 .. 전체 보드는 다음과 같습니다.

rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR

이것은 질문이므로 입력 할 수 없으며 파일 저장, STDOUT으로 인쇄 또는 함수에서 복귀와 같은 기본 방법으로이 보드를 출력해야합니다. 선택적으로 하나의 후행 줄 바꾸기를 생성 있습니다 . 표준 허점이 적용되며 가장 짧은 프로그램은 바이트 단위입니다!

그러나 이것은 같은 언어로 제출 한 작품들 사이의 경쟁과 동일하다는 것을 기억하십시오. Java와 같은 언어가 perl과 같은 언어 또는 pyth 또는 cjam과 같은 골프 언어를 능가 할 가능성은 없지만 Java 답변이 가장 짧은 것이 여전히 인상적입니다! 각 언어에서 가장 짧은 답변을 추적 할 수 있도록이 리더 보드를 사용하면 언어 및 전체적으로 가장 짧은 제출을 표시 할 수 있습니다.

리더 보드

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

# Language Name, N bytes

N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :

# Ruby, <s>104</s> <s>101</s> 96 bytes

헤더에 여러 숫자를 포함하려는 경우 (예 : 점수가 두 파일의 합계이거나 인터프리터 플래그 페널티를 별도로 나열하려는 경우) 실제 점수가 헤더 의 마지막 숫자 인지 확인하십시오 .

# Perl, 43 + 2 (-p flag) = 45 bytes

언어 이름을 링크로 만들어 리더 보드 스 니펫에 표시 될 수도 있습니다.

# [><>](http://esolangs.org/wiki/Fish), 121 bytes


1
분명히 ASCII art체스 판은 다른 모든 광장에서 완전히 멈출 것입니까?
Shaun Bebbers

답변:


16

젤리 , 25 24 바이트

“.“.“p“rnbqkbn”ṁ€8µṚ;ŒuY

온라인으로 사용해보십시오!

1 바이트를 골라 낸 @Lynn에게 감사드립니다!

작동 원리

“.“.“p“rnbqkbn”ṁ€8µṚ;ŒuY  Main link. No arguments.

“.“.“p“rnbqkbn”           Yield [".", ".", "p", "rnbqkbnr"].
               ṁ€8        Mold-each 8; reshape each string like the array
                          [1, 2, 3, 4, 5, 6, 7, 8], i.e., cyclically repeat its
                          contents to create strings of length 8.
                          This yields the upper half of the board in reversed
                          order, i.e., the string array
                          A := "........", "........", "pppppppp", "rnbqkbnr"].
                  µ       Begin a new, monadic chain. Argument: A
                   Ṛ      Reverse A.
                     Œu   Convert all characters in A to uppercase.
                    ;     Concatenate the results to both sides.
                       Y  Join the strings, separating by linefeeds.

15

Vim, 26 바이트

irnbqkbnr<Esc>Y6p5Vr.VrpYGPgUj

신선한 Vim에 의존하거나 그렇지 않으면 5V잘못된 영역을 선택할 수 있습니다.

  • irnbqkbnr<Esc>: 맨 위 줄을 씁니다. 충분히 쉽다.
  • Y6p: 하나를 제외한 나머지 행을 만듭니다 . 물론 맨 위와 맨 아래 행을 제외한 모든 문자에 잘못된 문자가 포함되어 있습니다.
  • 5Vr.: 아직 세션에서 비주얼 모드를 사용하지 않은 경우 5 줄을 선택하기 위해 이와 같은 작업을 수행 할 수 있습니다. 같은 것을 다시 입력하면 25 줄을 선택하려고 시도합니다. Vim은 그렇게 이상합니다.
  • Vrp: 우리는 이미 2 번 라인에 있습니다. 폰을 만들어 봅시다.
  • YGP그 폰 라인을 맨 아래에 복사합니다. 이것이 바로 내가 6p대신 사용했던 이유 7p입니다.
  • gUj: 흰색 조각을 대문자로 표시하십시오.

1
최고의 골프 ​​언어가 있습니다!
시계 반대 방향으로 돌리지

10

Brainfuck , 224 바이트

+++++[>+++[>++++++<-]+<-]>>.[>>+>+<<<-]>>>[<<<+>>>-]<<<----.<+++[>---<-]>.>>-.------.<<.>>+++.++++.--<++++++++++>>++++++++++.<........>.[>+++++<-]>----<++++[>........<<<.>>-]<........<.>++.----.<<.>>+++.------.<<.>>+++.++++.

이것을 얻기 위해 거의 1 시간 걸렸다.


8

파이썬 2, 63 바이트

print"\n".join(["rnbqkbnr","p"*8]+["."*8]*4+["P"*8,"RNBQKBNR"])

불행히도, 매우 간단한 접근 방식은 처음에 시도한 "영리한"것보다 훨씬 짧았습니다 ...

보너스 답변, 63 바이트 :

print"\n".join(["rnbqkbnr"]+[c*8for c in"p....P"]+["RNBQKBNR"])

8

05AB1E , 24 바이트

CP-1252 인코딩을 사용합니다 .

"rnbqkbnr"'p8×'.8×D)Âu«»

온라인으로 사용해보십시오!

설명

"rnbqkbnr"                # push the string "rnbqkbnr"
                          # STACK: "rnbqkbnr"
          'p8×            # push the char "p" repeated 8 times
                          # STACK: "rnbqkbnr", "pppppppp"
              '.8×        # push the char "." repeated 8 times
                          # STACK: "rnbqkbnr", "pppppppp", "........"
                  D       # duplicate
                          # STACK: "rnbqkbnr", "pppppppp", "........", "........"
                   )      # wrap in list
                          # STACK: ["rnbqkbnr", "pppppppp", "........", "........"]
                    Â     # push a reversed copy of the list
                          # STACK: ["rnbqkbnr", "pppppppp", "........", "........"], 
                                   ["........", "........", "pppppppp", "rnbqkbnr"]
                     u«   # convert to upper-case and concatenate
                          # STACK: ['rnbqkbnr', 'pppppppp', '........', '........', 
                                    '........', '........', 'PPPPPPPP', 'RNBQKBNR']
                       »  # join list by newline

1
나는 이것이 내가 보지 않고 답을 골라 낸 첫 번째 시간이라고 생각하고 사용 된 캐릭터의 100 %를 일치시킵니다. 이것이 하하를 얻는 것만 큼 좋다는 데 동의합니다.
Magic Octopus Urn

7

실제로 26 바이트

'p8*"rnbqkbnr"│û@û4'.8*n((

온라인으로 사용해보십시오!

설명:

'p8*"rnbqkbnr"│û@û4'.8*n((
'p8*                        "p"*8 ["pppppppp"]
    "rnbqkbnr"              that string ["rnbqkbnr", "pppppppp"]
              │             duplicate stack ["rnbqkbnr", "pppppppp", "rnbqkbnr", "pppppppp"]
                û@û         uppercase the dupes ["RNBQKBNR", "PPPPPPPP", "rnbqkbnr", "pppppppp"]
               4   '.8*n    "."*8, 4 times ["RNBQKBNR", "PPPPPPPP", "........", "........", "........", "........", "rnbqkbnr", "pppppppp"]
                        ((  move the uppercase strings to the bottom of the stack, implicitly print

6

체다, 56 바이트

a=['rnbqkbnr','p'*8]+['.'*8]*2->(a+a.rev=>@.upper).vfuse

새로운 =>기능을 사용합니다 .

설명

a=                      // set a to the first half
  ['rnbqkbnr','p'*8] +  // First two rows
  ['.'*8]*2             // Next two dots
->(
   a +
   a.rev=>@.upper       // Reverse and map all items to uppercase
).vfuse                 // Join on newlines

5
그래서 'ches'에서 'chess'에 대한 질문에 대답 했습니까?
DJMcMayhem

4
@DJMcMayhem .................. 방금 했어요 .....
Downgoat

1
흠, 이것은 아름다운 치즈입니다. 기본 매개 변수의 좋은 남용
Conor O'Brien

6

파이크, 28 27 26 바이트

"rnbqkbnr"i"P..p"1c8m*Xil3

여기 사용해보십시오!

나는 오늘 나의 언어에 대해 새로운 것을 배웠다 : 1c문자열을 문자리스트로 나누는 2 개의 문자로 사용될 수있다.

"rnbqkbnr"i                - i = "rnbqkbnr"
                             stack = ["rnbqkbnr"])
           "P..p"1c        -  chunk("P..p", 1)
                             stack = ["rnbqkbnr", ["P", ".", ".", "p"]]
                   8m*     - map(8*>, ^)
                             stack = ["rnbqkbnr", ["PPPPPPPP", "........", "........", "pppppppp"]]
                      X    - splat(^)
                             stack = ["rnbqkbnr", "pppppppp", "........", "........", "PPPPPPPP"]
                       il3 - i.changecase()
                             stack = ["rnbqkbnr", "pppppppp", "........", "........", "PPPPPPPP", "RNBQKBNR"]
                           - implicit join with newlines

rnbqkbnr
pppppppp
........
........
PPPPPPPP
RNBQKBNR

5

MATL , 26 바이트

'rnbqkbnr' 'p..'!l8X"vtPXk

온라인으로 사용해보십시오!

설명

'rnbqkbnr'   % Push this string (1×8 char array)
'p..'!       % Push this string transposed (3×1 char array)
l8X"         % Repeat 1×8 times: gives 3×8 char array
v            % Concatenate the two arrays vertically into a 4×8 char array
tP           % Duplicate and flip vertically
Xk           % Convert to uppercase. Implicitly display the two 4×8 arrays

5

루비, 45 44

tuxcrafting 덕분에 1 바이트가 절약되었습니다.

puts"rnbqkbnr",?p*8,[?.*8]*4,?P*8,"RNBQKBNR"

이것은 45입니다

puts s="rnbqkbnr",?p*8,[?.*8]*4,?P*8,s.upcase

더 똑똑한 것을 시도하면 더 길어질 것 같습니다.


puts
TuxCrafting

5

자바 스크립트 (ES6), 69 65 바이트

edc65 덕분에 4 바이트 절약

let f =

_=>`rnbqkbnr
p....PRNBQKBNR`.replace(/p|\./ig,c=>c.repeat(8)+`
`)

console.log(f());


1
매우 영리한! 어쩌면 너무 영리와 4 바이트를 절약 할 수있다 'rnbqkbnrnp....PRNBQKBNR'.replace(/p|\./ig,c=>c.repeat(8)+'\n')(변경 \n리터럴 개행)
edc65

5

C #, 94 92 바이트

편집 : 반환 공백을 제거하기 위해 문자열 순서를 변경하여 1 바이트를 절약 한 우유 덕분 입니다.

편집 : 더미 변수를 추가하여 저장된 하나 이상의 바이트 ( X 대신에 () 익명 함수) 및 객체를 호출.

x=>{string a="RNBQKBNR\n",b="PPPPPPPP\n",c="........\n";return(a+b).ToLower()+c+c+c+c+b+a;};

위 기능을 사용한 전체 프로그램 :

using System;

namespace DrawAnASCIIChessBoard
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<object,string>f= x=>{string a="RNBQKBNR\n",b="PPPPPPPP\n",c="........\n";return(a+b).ToLower()+c+c+c+c+b+a;};
            Console.WriteLine(f(1));
        }
    }
}

C #은 매우 장황한 언어입니다 ...


C # 전체 프로그램, 131 바이트

class P{static void Main(){string a="rnbqkbnr\n",b="pppppppp\n",c="........\n";System.Console.Write(a+b+c+c+c+c+(b+a).ToUpper());}}

언 골프 드 :

class P
{
    static void Main()
    {
        string a="rnbqkbnr\n",
            b="pppppppp\n",
            c="........\n";
        System.Console.Write(a+b+c+c+c+c+(b+a).ToUpper());
    }
}

2
"C #은 매우 장황한 언어입니다 ...". VB.NET을 시도하지 않았지만 ...;)
TyCobb

2
바이트를 정의 a하고 b대문자로 저장하면 다음 공간을 제거 할 수 있습니다 return.return(a+b).ToLower()+...
milk

@ TyCobb 나는 얼마 전에 VB.NET을 시도했습니다. 나는 당시 코드 골프에 대해 몰랐다 : P
adrianmp

var대신에 사용할 수 string있습니까?
NibblyPig

@ SLC 나는 C #에서 한동안 프로그래밍하지 않았으므로 틀렸다면 수정하십시오.하지만 var한 줄에 여러 선언을 사용할 수 있다고 생각하지 않습니다 . 따라서 string a="rnbqkbnr\n",b="pppppppp\n",c="........\n";가되어 var a="rnbqkbnr\n";var b="pppppppp\n";var c="........\n";바이트 수를 증가시킵니다. 편집 : " 암시 적으로 형식이 지정된 지역 변수 선언은 여러 선언자를 포함 할 수 없습니다 "오류가 발생 합니다.
Kevin Cruijssen

4

파이썬 2, 68 바이트

어쨌든 위의 Python 2 버전이 더 짧아도 게시합니다. 바이트 양에 대해 하나의 라이너 일 필요는 없으며 방금 재생했습니다.

x,y,z="rnbqkbnr\n","p"*8+"\n","."*8+"\n";print x,y,4*z,(y+x).upper()

z한 번만 사용 되므로 이를 제거하고 print 문에 점을 생성 할 수 있습니다.
Karl Napf

3

하스켈, 53 바이트

a="rnbkqbnr" 
unlines$a:map(<$a)"p....P"++["RNBKQBNR"]

a첫번째 라인으로 사용되어 이루어지는 문자열의 길이를 결정하기 위해 p, .그리고 P(-> <$a). .


3

자바 스크립트 (ES6), 73

.toUpperCase 단순히 너무 길다

_=>`rnbqkbnr
${r=c=>c[0].repeat(8)+`
`,r`p`+(b=r`.`)+b+b+b+r`P`}RNBQKBNR`

O.textContent=(
  
_=>`rnbqkbnr
${r=c=>c[0].repeat(8)+`
`,r`p`+(b=r`.`)+b+b+b+r`P`}RNBQKBNR`

)()
<pre id=O></pre>


나는 (r=c=>c[0].repeat(8)+\ n 생각 ,b=r합니다. )=>바이트를 절약합니다.
Neil

@ 닐 저축은 보이지 않습니다. 나는 코드 증가 일기 좋게 (조금) 재 작성하려고했으나 바이트 수는 동일하게 유지
edc65

아, 나는 내가 잘못한 것을 보았습니다. 어쨌든 나는 줄 바꿈을 잃었습니다. 미안합니다.
Neil

3

PowerShell v2 +, 44 바이트

'rnbqknbr'
'p'*8
,('.'*8)*4
'P'*8
'RNBQKNBR'

파이프 라인에 남아있는 문자열 Write-Output은 프로그램 실행시 암시 적으로 인쇄됩니다 . 배열에 대한 기본 개행 동작과 결합하여 쉼표 연산자로 4 줄의 기간을 생성합니다.

PS C:\Tools\Scripts\golfing> .\draw-ascii-chess-board.ps1
rnbqknbr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKNBR

포인트 라인에서 새 라인은 어디에 있습니까? ", ( '.'* 8) * 4" ','라고 가정합니다.
RosLuP

@RosLuP 쉼표 연산자 ,는 배열 (이 경우 문자열 배열)을 만듭니다. Write-Output프로그램 완료 시 기본값 은 개별 배열 요소를 포함하여 파이프 라인에 남아있는 요소 사이에 줄 바꿈을 삽입합니다. 따라서 코드에 명시적인 줄 바꿈을 작성할 필요가 없도록 기본 출력 동작을 남용합니다.
AdmBorkBork

3

V , 27 , 26 바이트

i¸P
RNBQKBNRäkgujddppÒ.4Ä

온라인으로 사용해보십시오!

여기에는 인쇄 할 수없는 문자가 포함되어 있으므로 읽을 수있는 버전은 다음과 같습니다.

i¸P
RNBQKBNR<esc>äkgujddppÒ.4Ä

여기서는을 <esc>나타냅니다 0x1B. 설명:

i                               " Enter insert mode
 ¸P                             " Enter 8 'P' characters
                                " and a newline
RNBQKBNR<esc>                   " Enter the first row and escape to normal mode.
             äk                 " Duplicate this line and the line above
               guj              " Convert this line, and the line below to lowercase
                  dd            " Delete this line
                    pp          " And paste it twice below us
                      Ò.        " Replace this whole line with '.' chars
                        4Ä      " And create four copies of this line

3

이모 노미 콘, 89 바이트

슬프게도 Emotinomicon에는 중복 스택 기능이 없습니다. 유용 할 것입니다. 그러나 적어도 Java보다 짧습니다. :)

😭RNBKQBNR
PPPPPPPP
........
........
........
........
pppppppp
rnbkqbnr😲⏪⏬⏩

설명:

😭(...)😲⏪⏬⏩
😭(...)😲            String literal
         ⏪  ⏩      Loop
           ⏬        Pop one char and output

흠 ... 그것은 유용한 기능이 될 것이지만 지금은 그렇지 않을 것입니다 ...
Conor O'Brien

프로그램조차도 슬프다. 😭 = 슬프게도
A _

3

Brain-Flak , 366350 + 3 = 353 바이트

온라인으로 사용해보십시오!

(((((((((((()()())){}(((({}))){}{}(([((({})){}){}](([({}())](((((({}()){}){}){}()){})<>))<>)<>)<>)))<<>({}<>)<>({}<>)<>({}<>)([]()())>[()]))))))))(()()()()){({}[()]<((((((((((((()()()()()){})()){}()){}))))))))>)}{}(((()()()()()){})<((((((((([][]()()()()))))))))<>)<>>)(((((()()()))){})(({}{})(([{}({})](([{}()](<>({}()())<>)<>)<>)<>)<>))){<>({}<>)}{}

-A플래그가 제대로 실행 되어야하므로 플러스 3이 됩니다.

설명

First we push the last 5 letters to the active stack.
We also push copies of last 3 numbers to the inactive stack.
This is done with fairly simple methods I won't go into for the sake of brevity.

 (((()()())){}(((({}))){}{}(([((({})){}){}](([({}())](((((({}()){}){}){}()){})<>)<><>)<>)<>)<>)))

We Move Everything from the offstack to the onstack.
The first 3 letters are the same as the last 3 letters in the first line

{<>({}<>)}{}

We push 10 for a new line

((()()()()()){})

Using the value of Q we create a P and push it 8 times

((((((((<...>[()]))))))))

We loop 4 times each time pushing 8 dots and a newline

(()()()())
{({}[()]<
    ((((((((((((()()()()()){})()){}()){}))))))))
>)}{}

We push the last two lines in a very similar way to the first two.

(((()()()()()){})<((((((((([][]()()()()))))))))<>)<>>)(((()()()){})(({}()()())(([{}(()()())](([{}()](<>({}()())<>)<>)<>)<>)<>))){<>({}<>)}{}

((((((((((((((((((((()()()()()){}){}){}()){})[()()()()])[([][][]){}])[][][])[]()())[[][][]])[][])()()()())<([]()())>[()()]))))))))16 바이트를 절약 할 수 있다고 생각 하는 처음 두 줄을 밀어 넣을 수 있습니다 . 대체 스택을 전혀 사용하지 않으므로 더 짧을 수 있습니다.
DJMcMayhem

3

파이썬 3.5, 56 바이트

for r in['rnbqkbn',*'p....P','RNBQKBN']:print((r*8)[:8])

이것은 zawata의 아이디어를 사용 하여(r*8)[:8] 문자열을 8 번 반복하고 길이로 트리밍하여 각 라인을 인코딩합니다 8. 졸 및 빈 행은있다 'p'*8, '.'*8그리고 'P'*8어떤 트리밍과 함께. 첫 번째 행의 사용 'rnbqkbn'으로, ('rnbqkbn'*8)[:8]승산 및 트리밍 때 오른쪽 다른 루크 등. 마지막 행은 동일하지만 대문자입니다.

파이썬 3.5의 일반화 된 언 패킹 (unpacking)을['rnbqkbn','p','.','.','.','.','P','RNBQKBN'] 사용하여 행 부분 목록을 간결하게 표현합니다 . 첫 번째 항목과 마지막 항목을 작성하고 나머지 한 문자 문자는 문자열에서 압축을 풉니 다.

파이썬 2에서는 split60 바이트 를 대신 사용할 수 있습니다 .

for i in'rnbqkbn p . . . . P RNBQKBN'.split():print(i*8)[:8]

3

파이썬 3, 82 80 75 바이트

파이썬에서 가장 짧은 대답은 아니지만 내 첫 번째이며 처음으로 꽤 좋다고 생각합니다.

print('\n'.join((i*8)[:8]for i in'rnbqkbn p . . . . P RNBQKBN'.split()))

1
사이트에 오신 것을 환영합니다! 여분의 공백을 제거하면 2 바이트를 줄일 수 있습니다. 예[:8]for i in['rnbqkbn'....
DJMcMayhem

1
모든 라인을 통합하고 루크를 재사용하는 것이 좋습니다. 목록을보다 짧게 작성할 수 있습니다 'rnbqkbn p . . . . P RNBQKBN'.split().
xnor

@DJMcMayhem은 이것이 필요하지 않은 것을 몰랐습니다. 감사!
zawata

@ xnor 그것은 좋은 생각입니다! 아픈 내 "무기"하하에 그 트릭을 추가 할 필요가
zawata

2

배치, 105 바이트

@set e=@echo ........
@echo rnbqkbnr
@echo pppppppp
%e%
%e%
%e%
%e%
@echo PPPPPPPP
@echo RNBQKBNR

배치는 매우 장황하다 ...


2

R, 75 바이트

편집 : 바보 오류를 수정하고 단순히 보드의 대문자 부분을 작성하십시오.

cat("rnbqkbnr\npppppppp\n",rep("........\n",4),"PPPPPPPP\nRNBQKBNR",sep="")

1
검은 색 조각은 이것이 의미하는 것처럼 잘못 나옵니다. 폰은 다른 조각 앞에 있어야합니다.
JDL

@JDL 물론 정확합니다. 감사합니다. 마지막 두 번째 변경을 할 때 바보 같은 실수.
Billywob


2

파워 쉘, 82 73 바이트

$x=("rnbqkbnr",$("p"*8),$("."*8),$("."*8));$x+$x[3..0].ToUpper()-join"`n"


@Veskah-어떻게 작동합니까? 나는 *per전에 일을 보지 못했고 구글은 나에게 어떤 포인터도주지 않는다. 설명이 있습니까?
크리스 J

전체 쓰기에 대해서는 여기를 확인하십시오. 그러나 %는 주어진 이름에 대해 특성 / 방법 (이름에 와일드 카드 포함)을 호출 할 수 있습니다.
Veskah

2

J, 55 52 바이트

'.rnbkqpPQKBNR'{~(+-@|.)8 8$1 2 3 4 5 3 2 1,8 48#6 0

테스트 및 중간 단계

   '.rnbkqpPQKBNR'{~(+-@|.)8 8$1 2 3 4 5 3 2 1,8 48#6 0
rnbkqbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBKQBNR
   8 48#6 0
6 6 6 6 6 6 6 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   1 2 3 4 5 3 2 1,8 48#6 0
1 2 3 4 5 3 2 1 6 6 6 6 6 6 6 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   8 8$1 2 3 4 5 3 2 1,8 48#6 0
1 2 3 4 5 3 2 1
6 6 6 6 6 6 6 6
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
   (+-@|.)8 8$1 2 3 4 5 3 2 1,8 48#6 0
 1  2  3  4  5  3  2  1
 6  6  6  6  6  6  6  6
 0  0  0  0  0  0  0  0
 0  0  0  0  0  0  0  0
 0  0  0  0  0  0  0  0
 0  0  0  0  0  0  0  0
_6 _6 _6 _6 _6 _6 _6 _6
_1 _2 _3 _4 _5 _3 _2 _1
   '.rnbkqpPQKBNR'{~(+-@|.)8 8$1 2 3 4 5 3 2 1,8 48#6 0
rnbkqbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBKQBNR

2

파이썬 3, 64 바이트

필자가 개선 할 수없는 Python 2에 대한 DLosc 답변을 기반으로합니다.

print(*["rnbqkbnr","p"*8]+["."*8]*4+["P"*8,"RNBQKBNR"],sep="\n")

"\ n"을 사용할 때보 다 1 바이트가 적습니다.

print("\n".join(["rnbqkbnr","p"*8]+["."*8]*4+["P"*8,"RNBQKBNR"]))

2

q, 51 바이트

"\n"sv flip{x,"p...P","c"$("i"$x)-32}each"rnbqkbnr"

위와 오른쪽을 사용하여 몇 바이트를 줄일 수 있습니다. 또한 다음은 줄 바꿈이있는 문자열을 반환하지 않고 표준 출력으로 인쇄합니다 -1 flip"p...P"{y,x,upper y}/:"rnbqkbnr";. 40 바이트 그래도 좋은 해결책!
streetster

2

GNU sed, 54 바이트

s:^:rnbqkbnr:p;h
s:.:p:gp;G
h;s:[^\n]:.:gp;G
s:.:\U&:g

온라인으로 사용해보십시오!

설명:

검은 색 조각이 먼저 인쇄되어 두 개의 관련 보드 순위가 보류 공간에 역순으로 저장됩니다. 흰색 부분은 보류 공간을 대문자로 변환하여 인쇄됩니다.

s:^:rnbqkbnr:p;h   # change pattern and hold spaces to 'rnbqkbnr' and print string
s:.:p:gp           # replace each pattern space letter with a 'p', then print
G;h                # append hold space, then copy pattern space to hold space
s:[^\n]:.:gp       # replace each pattern space letter with a '.', then print
G;s:.:\U&:g        # append hold space and convert pattern space to uppercase
                   # (automatic printing of pattern space at the end)

2

자바 7, 103 99 89 바이트

String f(){return"rnbqkbnr\npppppppp\nxxxxPPPPPPPP\nRNBQKBNR".replace("x","........\n");}

C # 응답에서 @SLC 의 접근 방식 덕분에 하드 코딩 된 출력에 비해 10 바이트가 절약 되었습니다 .

여기에서 시도하십시오.

산출:

rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR

String f(){return"rnbqkbnr\npppppppp\n........\n........\n........\n........\nPPPPPPPP\nRNBQKBNR";}이것은 어떻습니까 . 이것은 100 바이트 입니다.
Numberknot

@Numberknot 얼마나 지루한 지 .. 맞아요. Btw, 100이 아닌 99 바이트입니다.
Kevin Cruijssen

2

C #, 85 84 83 74 바이트

편집 : 실수로 빈 행이 너무 많습니다!

편집 : @KevinCruijssen 덕분에 여분의 캐릭터를 확보하고 순서를 고쳤습니다.

편집 : 나는 잘못된 줄에 새우를 가지고 83 cos로 되 돌렸다

편집 : @adrianmp 덕분에 반환을 생략하여 더 축소 할 수있었습니다.

위의 @adrianmp 답변과 동일한 형식을 사용하십시오.

x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n");

위 기능을 사용한 전체 프로그램 :

using System;

namespace DrawAnASCIIChessBoard
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<object, string> f = 
                x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n");
                    Console.WriteLine(f(1));
        }
    }
}

안녕하세요, PPCG에 오신 것을 환영합니다! 흠, 당신의 작품의 순서는 OP의 하나의 순서가 올바르지 않은 것 같습니다. Btw에서 사이의 공백을 제거하여 1 바이트를 절약 할 수 return "있으므로 다음과 같이됩니다 x=>{return"rnbqkbnr\npppppppp\nxxxxPPPPPPPP\nRNBQKBNR".Replace("x","........\n");};. 좋은 답변이므로 +1 그리고 당신의 체류를 즐기십시오. :)
Kevin Cruijssen

답장을 보내 주셔서 감사합니다. Java 7 답변에 동일한 접근 방식을 포팅했습니다 (물론 크레딧) , 바이트 수를 10으로
줄였습니다

더 개선했습니다
NibblyPig

가, 나는 그것이 옳지 않다는 것을 깨달았습니다
NibblyPig

1
좋은 접근 방식! 실제로이를 74 바이트로 줄일 수 있습니다.x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n");
adrianmp
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.