Ecco una semplice sfida per te: devi produrre questa rappresentazione ASCII di una scacchiera. Il bianco è rappresentato da caratteri maiuscoli e il nero da caratteri minuscoli. Le tessere vuote sono rappresentate da a .. Ecco la pensione completa:

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

Poiché si tratta di una domanda di complessità kolmogorov , non è possibile accettare alcun input ed è necessario generare questa scheda con qualsiasi metodo predefinito, ad esempio salvando un file, stampando su STDOUT o ritornando da una funzione. Si può opzionalmente produrre un fine riga. Si applicano scappatoie standard e il programma più breve in byte!

Tuttavia, ricorda che si tratta ugualmente di una competizione tra invii nella stessa lingua. Mentre è improbabile che una lingua come Java possa battere una lingua come il perl o una lingua da golf come pyth o cjam, avere la risposta Java più breve è ancora davvero impressionante! Per aiutarti a tracciare la risposta più breve in ogni lingua, puoi utilizzare questa classifica, che mostrerà la presentazione più breve per lingua e in generale.

Classifiche

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

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

Gelatina , 25 24 byte

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

Provalo online!

Grazie a @Lynn per il golf off 1 byte!

Come funziona

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

Si affida a un nuovo Vim, altrimenti 5Vpuò selezionare l'area sbagliata.

• irnbqkbnr<Esc>: Scrivi la riga superiore. Abbastanza facile.
• Y6p: Crea il resto delle righe, tranne una . Ovviamente tutti tranne le righe superiore e inferiore contengono i caratteri sbagliati.
• 5Vr.: Quando non hai ancora utilizzato la modalità visiva nella sessione, puoi fare cose come questa per selezionare 5 righe. Se hai digitato di nuovo la stessa cosa subito, proverebbe a selezionare 25 righe. Vim è strano così.
• Vrp: Siamo già sulla linea 2, quindi facciamo una linea di pedone.
• YGP: Copia quella linea di pedone nella sua posizione in basso. Questo è il motivo per cui ho usato 6pinvece di 7pprima.
• gUj: Capitalizza i pezzi bianchi.

Brainfuck , 224 byte

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

Ci sono voluti quasi un'ora per ottenerlo.

Python 2, 63 byte

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

Sfortunatamente, l'approccio abbastanza semplice era molto più breve delle cose "intelligenti" che ho provato all'inizio ...

Risposta bonus, anche 63 byte:

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

05AB1E , 24 byte

Utilizza la codifica CP-1252 .

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

Provalo online!

Spiegazione

"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

In realtà , 26 byte

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

Provalo online!

Spiegazione:

'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

Utilizza la nuova =>funzionalità.

Spiegazione

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

Provalo qui!

Oggi ho imparato qualcosa di nuovo sulla mia lingua: 1cpuò essere usato come un modo a 2 caratteri per dividere una stringa in un elenco di caratteri.

"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

Provalo online!

Spiegazione

'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 salvato grazie al tuxcrafting.

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

Questo è 45

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

Cercare qualcosa di più intelligente sembra solo allungarlo.

JavaScript (ES6), 69 65 byte

Salvato 4 byte grazie a edc65

let f =

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

console.log(f());

C #, 94 92 byte

Modifica: grazie a milk per aver salvato 1 byte modificando l'ordine delle stringhe per rimuovere lo spazio bianco di ritorno.

Modifica: salvato un altro byte aggiungendo un parametro fittizio ( x anziché () ) per la funzione anonima e chiamandolo con qualsiasi oggetto.

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

Programma completo utilizzando la funzione sopra:

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 # è un linguaggio molto dettagliato ...

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

Ungolfed:

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

Pubblicare comunque anche se la precedente versione di Python 2 è più breve. Non dovrebbe essere un solo liner per la quantità di byte, ma solo per giocarci.

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

aviene usato come prima riga e per determinare la lunghezza delle stringhe costituite da p, .e P(-> <$a). .

JavaScript (ES6), 73

.toUpperCase è semplicemente troppo lungo

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

Le stringhe rimaste sulla pipeline vengono stampate implicitamente con l' Write-Outputesecuzione del programma. Lo abbiniamo al comportamento newline predefinito per un array per produrre le quattro righe di punti con l'operatore virgola.

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

V , 27 , 26 byte

i¸P
RNBQKBNRäkgujddppÒ.4Ä

Provalo online!

Questo contiene alcuni caratteri non stampabili, quindi ecco la versione leggibile:

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

dove <esc>rappresenta 0x1B. Spiegazione:

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

Purtroppo Emotinomicon non ha niente come una funzione di stack duplicato. Sarebbe utile. Ma almeno più breve di Java. :)

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

Spiegazione:

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

Brain-Flak , 366 350 + 3 = 353 byte

Provalo online!

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

Questo ottiene un plus 3 perché richiede che il -Aflag funzioni correttamente.

Spiegazione

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

Questo utilizza un'idea di zawata per codificare ogni riga come (r*8)[:8], con una stringa ripetuta 8 volte e tagliata a misura 8. Le pedine e le righe vuote sono solo 'p'*8, '.'*8e 'P'*8, senza rifilatura. La prima riga utilizza 'rnbqkbn', con l' ('rnbqkbn'*8)[:8]inclusione di un'altra torre a destra quando moltiplicata e ritagliata. L'ultima riga è la stessa ma maiuscola.

Esprimiamo l'elenco delle parti di riga in modo compatto ['rnbqkbn','p','.','.','.','.','P','RNBQKBN']utilizzando il disimballaggio generalizzato di Python 3.5 . Scriviamo la prima e l'ultima voce e quelle rimanenti a carattere singolo vengono decompresse da una stringa.

In Python 2, invece, potremmo accontentarci splitdi 60 byte:

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

Python 3, 82 80 75 byte

Non è la risposta più breve in Python, ma è la mia prima e penso che sia abbastanza buono per la prima volta

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

Lotto, 105 byte

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

Il batch è seriamente dettagliato ...

R, 75 byte

Modifica: risolto un errore sciocco e ora scrivi semplicemente la parte maiuscola della lavagna.

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

Test e passaggi intermedi

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

Basato sulla risposta DLosc a Python 2 come il mio non potevo migliorare.

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

1 byte in meno rispetto all'utilizzo di "\ 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

Provalo online!

Spiegazione:

I pezzi neri vengono stampati per primi, salvando i due ranghi delle schede associate in ordine inverso nello spazio di attesa. I pezzi bianchi vengono stampati convertendo lo spazio di attesa in lettere maiuscole.

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 risparmiati rispetto all'output codificato grazie all'approccio di @SLC nella sua risposta C # .

Provalo qui.

Produzione:

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

C #, 85 84 83 74 byte

Modifica: accidentalmente c'erano troppe file di spazi vuoti!

Modifica: liberato un personaggio in più e risolto l'ordinamento (per errore è stato tutto invertito) grazie a @KevinCruijssen

Modifica: ripristinato all'83 perché avevo i gamberi sulla linea sbagliata

Modifica: Grazie a @adrianmp che mi ha aiutato a ridurlo ulteriormente omettendo il ritorno

Utilizzando lo stesso formato della risposta @adrianmp sopra:

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

Programma completo utilizzando la funzione sopra:

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