Aquí hay un desafío simple para usted: debe producir esta representación ASCII de un tablero de ajedrez. El blanco está representado por mayúsculas y el negro está representado por minúsculas. Los mosaicos vacíos están representados por a .. Aquí está la pensión completa:

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

Dado que esta es una pregunta de complejidad kolmogorov , no puede tomar ninguna entrada y debe sacar esta placa por cualquier método predeterminado, por ejemplo, guardar un archivo, imprimir en STDOUT o regresar de una función. Usted puede producir opcionalmente uno salto de línea final. Se aplican las lagunas estándar, ¡y el programa más corto en bytes!

Sin embargo, recuerde que esto es igualmente una competencia entre presentaciones en el mismo idioma. Si bien es poco probable que un lenguaje como Java pueda vencer a un lenguaje como Perl, o un lenguaje de golf como Pyth o Cjam, ¡tener la respuesta más corta de Java sigue siendo realmente impresionante! Para ayudarlo a rastrear la respuesta más corta en cada idioma, puede usar esta tabla de clasificación, que mostrará la presentación más corta por idioma y en general.

Tablas de clasificación

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

Jalea , 25 24 bytes

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

Pruébalo en línea!

¡Gracias a @Lynn por jugar golf en 1 byte!

Cómo funciona

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

irnbqkbnr<Esc>Y6p5Vr.VrpYGPgUj

Se basa en un Vim nuevo, o de lo contrario 5Vpuede seleccionar el área incorrecta.

• irnbqkbnr<Esc>: Escribe la fila superior. Suficientemente fácil.
• Y6p: Haga el resto de las filas, excepto una . Por supuesto, todas menos las filas superior e inferior contienen los caracteres incorrectos.
• 5Vr.: Cuando todavía no ha usado el modo visual en la sesión, puede hacer cosas como esta para seleccionar 5 líneas. Si volvía a escribir lo mismo de inmediato, intentaría seleccionar 25 líneas. Vim es raro así.
• Vrp: Ya estamos en la línea 2, así que hagamos una línea de peón.
• YGP: Copia esa línea de peón en su lugar en la parte inferior. Es por eso que usé en 6plugar de 7pantes.
• gUj: Capitaliza las piezas blancas.

Brainfuck , 224 bytes

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

Tomó casi una hora para conseguir esto.

Python 2, 63 bytes

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

Desafortunadamente, el enfoque bastante simple fue mucho más corto que las cosas "inteligentes" que probé al principio ...

Respuesta adicional, también 63 bytes:

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

05AB1E , 24 bytes

Utiliza la codificación CP-1252 .

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

Pruébalo en línea!

Explicación

"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

En realidad , 26 bytes

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

Pruébalo en línea!

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

Cheddar, 56 bytes

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

Utiliza la nueva =>función.

Explicación

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 bytes

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

Pruébalo aquí!

Hoy aprendí algo nuevo sobre mi idioma: 1cpuede usarse como una forma de 2 caracteres de dividir una cadena en una lista de caracteres.

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

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

Pruébalo en línea!

Explicación

'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 byte guardado gracias a la esmoquin.

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

Esto es 45

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

Intentar algo más inteligente parece hacerlo más largo.

JavaScript (ES6), 69 65 bytes

Guardado 4 bytes gracias a edc65

let f =

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

console.log(f());

C #, 94 92 bytes

Editar: Gracias a milk por guardar 1 byte cambiando el orden de las cadenas para eliminar el espacio en blanco de retorno.

Editar: se guardó 1 byte más al agregar un parámetro ficticio ( x en lugar de () ) para la función anónima y llamarlo con cualquier objeto.

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

Programa completo con la función anterior:

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 # es un lenguaje muy detallado ...

C # programa completo, 131 bytes

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

Sin golf:

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 bytes

Publicación de todos modos, aunque la versión anterior de Python 2 es más corta. No tendría que ser un trazador de líneas para la cantidad de bytes, solo jugar con él.

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

Haskell, 53 bytes

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

ase utiliza como la primera línea y para determinar la longitud de las cuerdas hechas de p, .y P(-> <$a). .

JavaScript (ES6), 73

.toUpperCase es simplemente demasiado largo

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

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

Las cadenas que quedan en la tubería se imprimen implícitamente con la Write-Outputejecución del programa. Combinamos eso con el comportamiento predeterminado de la nueva línea para que una matriz produzca las cuatro líneas de puntos con el operador de coma.

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

V , 27 , 26 bytes

i¸P
RNBQKBNRäkgujddppÒ.4Ä

Pruébalo en línea!

Contiene algunos caracteres no imprimibles, así que aquí está la versión legible:

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

donde <esc>representa 0x1B. Explicación:

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 bytes

Lamentablemente, Emotinomicon no tiene nada como una función de pila duplicada. Sería útil Pero al menos más corto que Java. :)

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

Explicación:

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

Brain-Flak , 366 350 + 3 = 353 bytes

Pruébalo en línea!

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

Esto obtiene un plus 3 porque requiere el -A bandera se ejecute correctamente.

Explicación

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 bytes

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

Esto usa una idea de zawata para codificar cada línea como (r*8)[:8], con una cadena repetida 8 veces y recortada a la longitud 8. Los peones y filas vacías son sólo 'p'*8, '.'*8y 'P'*8, sin recorte. La primera fila usa 'rnbqkbn', con('rnbqkbn'*8)[:8] inclusión de otra torre a la derecha cuando se multiplica y se recorta. La última fila es la misma pero en mayúscula.

Expresamos la lista de partes de fila de manera compacta ['rnbqkbn','p','.','.','.','.','P','RNBQKBN']usando el desempaquetado generalizado de Python 3.5 . Escribimos la primera y la última entrada, y las restantes de un solo carácter se desempaquetan de una cadena.

En Python 2, podríamos conformarnos splitcon 60 bytes:

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

Python 3, 82 80 75 Bytes

No es la respuesta más corta en Python, pero es mi primera y creo que es bastante buena por primera vez.

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

Lote, 105 bytes

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

Batch es muy detallado ...

R, 75 bytes

Editar: se corrigió un error tonto y simplemente escribe la parte mayúscula del tablero ahora.

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

Powershell, 82 73 bytes

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

J, 55 52 bytes

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

Prueba y pasos intermedios

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

Según la respuesta de DLosc a Python 2, como en la mía, no pude mejorar.

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

1 byte menos en comparación con el uso de "\ n" .join

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

q, 51 bytes

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

GNU sed, 54 bytes

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

Pruébalo en línea!

Explicación:

Las piezas negras se imprimen primero, guardando los dos rangos de tablero asociados en orden inverso en el espacio de espera. Las piezas blancas se imprimen al convertir el espacio de espera en letras mayúsculas.

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 bytes

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

10 bytes guardados en comparación con la salida codificada gracias al enfoque de @SLC en su respuesta C # .

Pruébalo aquí

Salida:

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

C #, 85 84 83 74 bytes

Editar: ¡Accidentalmente tenía demasiadas filas de espacios en blanco!

Editar: liberó un personaje adicional y arregló el pedido (accidentalmente lo invirtió todo) muchas gracias a @KevinCruijssen

Editar: volví a 83 porque tenía las gambas en la línea incorrecta

Editar: Gracias a @adrianmp que me ayudó a reducirlo aún más omitiendo return

Usando el mismo formato que @adrianmp responde arriba:

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

Programa completo con la función anterior:

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