Oto proste wyzwanie: musisz stworzyć tę reprezentację szachownicy w ASCII. Biały jest reprezentowany wielkimi literami, a czarny małą. Puste kafelki są reprezentowane przez .. Oto pełne wyżywienie:

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

Ponieważ jest to pytanie o złożoność kolmogorowa , nie możesz przyjmować żadnych danych wejściowych i musisz wypisać tę tablicę dowolną domyślną metodą, na przykład zapisując plik, drukując do STDOUT lub powracając z funkcji. Państwo może ewentualnie produkować jeden kończący znak nowej linii. Obowiązują standardowe luki, a najkrótszy program w bajtach!

Pamiętaj jednak, że jest to tak samo konkurencja między zgłoszeniami w tym samym języku. Chociaż jest mało prawdopodobne, aby języki takie jak Java mogły pokonać język taki jak Perl lub język golfowy, taki jak Pyth lub Cjam, posiadanie najkrótszej odpowiedzi w języku Java jest nadal imponujące! Aby pomóc Ci śledzić najkrótszą odpowiedź w każdym języku, możesz użyć tej tabeli wyników, która pokaże najkrótsze przesłanie według języka i ogólnie.

Liderów

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik jest sumą dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie tabeli wyników:

# [><>](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>

Galaretka , 25 24 bajtów

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

Wypróbuj online!

Dzięki @Lynn za grę w golfa na 1 bajcie!

Jak to działa

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

irnbqkbnr<Esc>Y6p5Vr.VrpYGPgUj

Opiera się na świeżym Vimie, w przeciwnym razie 5Vmoże wybrać niewłaściwy obszar.

• irnbqkbnr<Esc>: Napisz górny wiersz. Wystarczająco łatwe.
• Y6p: Zrób resztę wierszy, z wyjątkiem jednego . Oczywiście wszystkie oprócz górnego i dolnego wiersza zawierają nieprawidłowe znaki.
• 5Vr.: Jeśli nie korzystałeś jeszcze z trybu wizualnego w sesji, możesz zrobić takie rzeczy, aby wybrać 5 linii. Jeśli od razu wpiszesz to samo, spróbuje wybrać 25 linii. Vim jest taki dziwny.
• Vrp: Jesteśmy już na linii 2, więc stwórzmy linię pionków.
• YGP: Skopiuj linię pionków na swoje miejsce na dole. Właśnie dlatego użyłem 6pzamiast 7pwcześniej.
• gUj: Kapitalizuj białe elementy.

Brainfuck , 224 bajty

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

Zajęło to prawie godzinę, aby to zdobyć.

Python 2, 63 bajty

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

Niestety, dość proste podejście było znacznie krótsze niż „sprytne” rzeczy, które próbowałem na początku ...

Dodatkowa odpowiedź, również 63 bajty:

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

05AB1E , 24 bajty

Wykorzystuje kodowanie CP-1252 .

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

Wypróbuj online!

Wyjaśnienie

"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

Właściwie 26 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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

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

Korzysta z nowej =>funkcji.

Wyjaśnienie

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

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

Wypróbuj tutaj!

Nauczyłem się dzisiaj czegoś nowego o moim języku: 1cmożna go wykorzystać jako 2-znakowy sposób dzielenia łańcucha znaków na listę znaków.

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

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

Wypróbuj online!

Wyjaśnienie

'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

Ruby, 45 44

1 bajt zapisany dzięki tuxcrafting.

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

To jest 45

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

Próbowanie czegoś mądrzejszego wydaje się po prostu wydłużyć.

JavaScript (ES6), 69 65 bajtów

Zaoszczędzono 4 bajty dzięki edc65

let f =

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

console.log(f());

C #, 94 92 bajty

Edycja: Dzięki mleku za zaoszczędzenie 1 bajtu poprzez zmianę kolejności ciągów w celu usunięcia białych znaków powrotu.

Edycja: Zapisano jeszcze 1 bajt, dodając parametr zastępczy ( x zamiast () ) dla funkcji anonimowej i wywołując go z dowolnym obiektem.

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

Pełny program korzystający z powyższej funkcji:

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 # jest bardzo pełnym językiem ...

C # pełny program, 131 bajtów

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

Nie golfowany:

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

Publikowanie mimo to, chociaż powyższa wersja Python 2 jest krótsza. Nie musiałby to być jeden linijka dla ilości bajtów, po prostu się nim bawił.

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

Haskell, 53 bajty

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

astosuje się w pierwszej linii, a do określenia długości łańcuchów wykonane z p, .i P(- » <$a). .

JavaScript (ES6), 73

.toUpperCase jest po prostu za długi

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

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

Ciągi pozostawione w potoku są domyślnie drukowane Write-Outputpodczas wykonywania programu. Łączymy to z domyślnym zachowaniem nowego wiersza dla tablicy, aby utworzyć cztery wiersze kropek z przecinkiem.

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

V , 27 , 26 bajtów

i¸P
RNBQKBNRäkgujddppÒ.4Ä

Wypróbuj online!

Zawiera niektóre niedrukowalne znaki, więc oto wersja do odczytu:

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

gdzie <esc>reprezentuje 0x1B. Wyjaśnienie:

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

Niestety Emotinomicon nie ma funkcji duplikowania stosu. Przydałby się. Ale przynajmniej krótszy niż Java. :)

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

Wyjaśnienie:

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

Brain-Flak , 366 350 + 3 = 353 bajtów

Wypróbuj online!

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

Otrzymuje plus 3, ponieważ wymaga -A poprawnego działania flagi.

Wyjaśnienie

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

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

Wykorzystuje to pomysł zawata, aby zakodować każdą linię jako (r*8)[:8], za pomocą łańcucha powtarzanego 8 razy i przycinanego na długość 8. Pionki i puste wiersze są po prostu 'p'*8, '.'*8i 'P'*8, bez przycinania. Pierwszy wiersz używa 'rnbqkbn', z('rnbqkbn'*8)[:8] tym kolejną wieżę po prawej stronie po pomnożeniu i przycięciu. Ostatni wiersz jest taki sam, ale pisany wielką literą.

Wyrażamy listę części wierszy w sposób kompaktowy ['rnbqkbn','p','.','.','.','.','P','RNBQKBN']za pomocą uogólnionego rozpakowywania w Pythonie 3.5 . Wypisujemy pierwsze i ostatnie wpisy, a pozostałe jednoznakowe są rozpakowywane z ciągu.

W Pythonie 2 splitzamiast tego moglibyśmy zadowolić się 60 bajtami:

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

Python 3, 82 80 75 bajtów

Nie jest to najkrótsza odpowiedź w pythonie, ale to moja pierwsza i myślę, że jest całkiem dobra po raz pierwszy

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

Partia, 105 bajtów

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

Partia jest poważnie pełna ...

R, 75 bajtów

Edycja: Naprawiono głupi błąd i po prostu wypisz teraz dużą część planszy.

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

PowerShell, 82 73 bajty

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

J, 55 52 bajtów

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

Kroki testowe i pośrednie

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

Oparty na odpowiedzi DLosc na Python 2, jak na mojej nie mogłem poprawić.

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

1 bajt mniej w porównaniu do używania „\ n” .join

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

q, 51 bajtów

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

GNU sed, 54 bajty

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

Wypróbuj online!

Wyjaśnienie:

Czarne elementy są drukowane jako pierwsze, co pozwala zaoszczędzić dwa powiązane szeregi planszy w odwrotnej kolejności w miejscu przechowywania. Białe elementy są drukowane przez konwersję miejsca wstrzymania na wielkie litery.

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

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

10 bajtów zapisanych w porównaniu do wyjścia zakodowanego na stałe dzięki podejściu @SLC w jego odpowiedzi w języku C # .

Wypróbuj tutaj.

Wynik:

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

C #, 85 84 83 74 bajty

Edycja: Przypadkowo miał za dużo rzędów pustych miejsc!

Edycja: Uwolniłem dodatkową postać i naprawiłem porządkowanie (przypadkowo cofnęło to wszystko) wiele dzięki @KevinCruijssen

Edycja: przywrócono do 83, ponieważ miałem krewetki w niewłaściwym wierszu

Edycja: Dzięki @adrianmp, który pomógł mi jeszcze bardziej go zmniejszyć, pomijając return

Używając tego samego formatu, co odpowiedź @adrianmp powyżej:

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

Pełny program korzystający z powyższej funkcji:

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