Đây là một thử thách đơn giản dành cho bạn: Bạn phải tạo ra đại diện ASCII này của một bàn cờ. Màu trắng được thể hiện bằng các ký tự viết hoa và màu đen được thể hiện bằng chữ thường. Gạch rỗng được đại diện bởi a .. Đây là bảng đầy đủ:

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

Vì đây là một câu hỏi phức tạp kolmogorov , bạn không thể lấy bất kỳ đầu vào nào và bạn phải xuất bảng này bằng bất kỳ phương thức mặc định nào, ví dụ: lưu tệp, in vào STDOUT hoặc trả về từ một hàm. Bạn có thể tùy ý sản xuất một dòng mới. Các lỗ hổng tiêu chuẩn được áp dụng và chương trình ngắn nhất tính bằng byte!

Tuy nhiên, hãy nhớ rằng đây cũng là một cuộc cạnh tranh giữa các bài nộp trong cùng một ngôn ngữ. Mặc dù không chắc rằng các ngôn ngữ như Java có thể đánh bại một ngôn ngữ như perl hoặc ngôn ngữ chơi gôn như pyth hoặc cjam, nhưng câu trả lời Java ngắn nhất vẫn thực sự ấn tượng! Để giúp bạn theo dõi câu trả lời ngắn nhất trong mỗi ngôn ngữ, bạn có thể sử dụng bảng xếp hạng này, bảng này sẽ hiển thị bài gửi ngắn nhất theo ngôn ngữ và tổng thể.

Bảng xếp hạng

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

# Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

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

Nếu bạn muốn bao gồm nhiều số trong tiêu đề của mình (ví dụ: vì điểm của bạn là tổng của hai tệp hoặc bạn muốn liệt kê riêng các hình phạt cờ của thông dịch viên), hãy đảm bảo rằng điểm thực tế là số cuối cùng trong tiêu đề:

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

Bạn cũng có thể đặt tên ngôn ngữ thành một liên kết mà sau đó sẽ hiển thị trong đoạn trích bảng xếp hạng:

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

var QUESTION_ID=95745,OVERRIDE_USER=31716;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Thạch , 25 24 byte

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

Hãy thử trực tuyến!

Cảm ơn @Lynn vì đã chơi golf 1 byte!

Làm thế nào nó hoạt động

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

Vim, 26 byte

irnbqkbnr<Esc>Y6p5Vr.VrpYGPgUj

Dựa vào Vim mới, nếu không, 5Vcó thể chọn sai khu vực.

• irnbqkbnr<Esc>: Viết hàng trên cùng. Vừa đủ dễ.
• Y6p: Thực hiện phần còn lại của các hàng, ngoại trừ một . Tất nhiên tất cả trừ các hàng trên cùng và dưới cùng chứa các ký tự sai.
• 5Vr.: Khi bạn chưa sử dụng chế độ trực quan trong phiên, bạn có thể thực hiện những việc như thế này để chọn 5 dòng. Nếu bạn gõ lại cùng một thứ ngay lập tức, nó sẽ cố gắng chọn 25 dòng. Vim thật kỳ lạ như thế.
• Vrp: Chúng tôi đã ở dòng 2, vì vậy hãy tạo một dòng cầm đồ.
• YGP: Sao chép dòng cầm đồ đó vào vị trí của nó ở phía dưới. Đây là lý do tại sao tôi sử dụng 6pthay vì 7ptrước đây.
• gUj: Viết hoa các mảnh màu trắng.

Brainfuck , 224 byte

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

Mất gần một giờ để có được điều này.

Python 2, 63 byte

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

Thật không may, cách tiếp cận khá đơn giản lại ngắn hơn nhiều so với những thứ "thông minh" mà tôi đã thử lúc đầu ...

Phần thưởng trả lời, cũng 63 byte:

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

05AB1E , 24 byte

Sử dụng mã hóa CP-1252 .

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

Hãy thử trực tuyến!

Giải trình

"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

Trên thực tế , 26 byte

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

Hãy thử trực tuyến!

Giải trình:

'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

Cheddar, 56 byte

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

Sử dụng =>tính năng mới .

Giải trình

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

Pyke, 28 27 26 byte

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

Hãy thử nó ở đây!

Tôi đã học được một điều mới về ngôn ngữ của tôi ngày hôm nay: 1ccó thể được sử dụng như một cách chia 2 chuỗi thành một danh sách các ký tự.

"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

MATL , 26 byte

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

Hãy thử trực tuyến!

Giải trình

'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

Hồng ngọc, 45 44

Lưu 1 byte nhờ tuxcrafting.

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

Đây là 45

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

Thử bất cứ điều gì thông minh hơn dường như làm cho nó dài hơn.

JavaScript (ES6), 69 65 byte

Đã lưu 4 byte nhờ edc65

let f =

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

console.log(f());

C #, 94 92 byte

Chỉnh sửa: Nhờ sữa để tiết kiệm 1 byte bằng cách thay đổi thứ tự chuỗi để xóa khoảng trắng trả về.

Chỉnh sửa: Đã lưu thêm 1 byte bằng cách thêm tham số giả ( x thay vì () ) cho hàm ẩn danh và gọi nó với bất kỳ đối tượng nào.

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

Chương trình đầy đủ sử dụng chức năng trên:

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 # là một ngôn ngữ rất dài ...

Chương trình đầy đủ C #, 131 byte

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

Ung dung:

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

Python 2, 68 byte

Dù sao thì việc đăng bài mặc dù phiên bản Python 2 ở trên ngắn hơn. Nó sẽ không phải là một lớp lót cho số lượng byte, chỉ cần chơi với nó.

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

Haskell, 53 byte

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

ađược sử dụng như dòng đầu tiên và để xác định độ dài của dây làm bằng p, .và P(-> <$a). .

JavaScript (ES6), 73

.toUpperCase đơn giản là quá dài

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

PowerShell v2 +, 44 byte

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

Các chuỗi còn lại trên đường ống được in ngầm Write-Outputkhi thực hiện chương trình. Chúng tôi kết hợp với hành vi dòng mới mặc định cho một mảng để tạo ra bốn dòng thời gian với toán tử dấu phẩy.

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

V , 27 , 26 byte

i¸P
RNBQKBNRäkgujddppÒ.4Ä

Hãy thử trực tuyến!

Điều này có chứa một số ký tự không thể in được, vì vậy đây là phiên bản có thể đọc được:

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

nơi <esc>đại diện 0x1B. Giải trình:

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

Emotinomicon, 89 byte

Đáng buồn là Emotinomicon không có gì giống như một chức năng ngăn xếp trùng lặp. Sẽ hữu ích. Nhưng ít nhất là ngắn hơn Java. :)

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

Giải trình:

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

Brain-Flak , 366 350 + 3 = 353 byte

Hãy thử trực tuyến!

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

Điều này được cộng 3 vì nó yêu cầu -A cờ chạy đúng.

Giải trình

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.

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

Python 3.5, 56 byte

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

Điều này sử dụng một ý tưởng của zawata để mã hóa từng dòng như (r*8)[:8], với một chuỗi được lặp lại 8 lần và được cắt theo chiều dài 8. Các con cờ và các hàng trống chỉ là 'p'*8, '.'*8và 'P'*8, không cắt tỉa. Hàng đầu tiên sử dụng 'rnbqkbn', với('rnbqkbn'*8)[:8] bao gồm một rook khác ở bên phải khi nhân và cắt. Hàng cuối cùng là giống nhau nhưng viết hoa.

Chúng tôi thể hiện danh sách các phần hàng một cách gọn gàng ['rnbqkbn','p','.','.','.','.','P','RNBQKBN']bằng cách sử dụng giải nén tổng quát của Python 3.5 . Chúng tôi viết ra các mục đầu tiên và cuối cùng, và các ký tự đơn còn lại được giải nén từ một chuỗi.

Trong Python 2, chúng ta có thể giải quyết splitthay vì 60 byte:

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

Python 3, 82 80 75 byte

Không phải là câu trả lời ngắn nhất trong python nhưng đây là lần đầu tiên của tôi và tôi nghĩ nó khá tốt cho lần đầu tiên

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

Mẻ, 105 byte

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

Batch rất nghiêm túc ...

R, 75 byte

Chỉnh sửa: Đã sửa một lỗi ngớ ngẩn và chỉ cần viết ra phần chữ hoa của bảng.

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

Powershell, 82 73 byte

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

J, 55 52 byte

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

Các bước kiểm tra và trung gian

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

Python 3, 64 byte

Dựa trên câu trả lời DLosc cho Python 2 như tôi không thể cải thiện.

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

Ít hơn 1 byte so với sử dụng "\ n" .join

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

q, 51 byte

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

GNU sed, 54 byte

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

Hãy thử trực tuyến!

Giải trình:

Các mảnh màu đen được in trước, lưu hai bảng xếp hạng liên kết theo thứ tự ngược lại trong không gian giữ. Các mảnh màu trắng được in bằng cách chuyển đổi không gian giữ thành chữ in hoa.

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)

Java 7, 103 99 89 byte

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

10 byte được lưu so với đầu ra được mã hóa cứng nhờ cách tiếp cận của @SLC trong câu trả lời C # của anh ấy .

Hãy thử nó ở đây.

Đầu ra:

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

C #, 85 84 83 74 byte

Chỉnh sửa: Vô tình có quá nhiều hàng trống!

Chỉnh sửa: Đã giải phóng một ký tự phụ và sửa lỗi thứ tự (vô tình bị đảo ngược tất cả) rất nhiều nhờ @KevinCruijssen

Chỉnh sửa: Hoàn nguyên về 83 cos Tôi đã có tôm trên dòng sai

Chỉnh sửa: Cảm ơn @adrianmp, người đã giúp tôi thu nhỏ nó hơn nữa bằng cách bỏ qua trả lại

Sử dụng định dạng tương tự như @adrianmp trả lời ở trên:

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

Chương trình đầy đủ sử dụng chức năng trê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));
        }
    }
}