Draw an ASCII chess board!

Here is a simple challenge for you: You must produce this ASCII representation of a chess board. White is represented by uppercase characters, and black is represented by lowercase. Empty tiles are represented by a .. Here is the full board:

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


Since this is a question, you may not take any input and you must output this board by any default method, for example, saving a file, printing to STDOUT or returning from a function. You may optionally produce one trailing newline. Standard loopholes apply, and the shortest program in bytes!

However, remember this is equally as much a competition between submissions in the same language. While it's unlikely that a languages like Java could beat a language like perl, or a golfing language like pyth or cjam, having the shortest Java answer is still really impressive! To help you track the shortest answer in each language, you may use this leaderboard, which will show the shortest submission by language and overall.

# Language Name, N bytes


where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:

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


If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:

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


You can also make the language name a link which will then show up in the leaderboard snippet:

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

• Surely an ASCII art chess board would have the full stop every other square? Sep 9 '19 at 9:55

SX, 65 bytes

我("""rnbqkbnr
pppppppp
"""+('.'*8+"\n")*4+"PPPPPPPP\nRNBQKBNR")


By the way, I am planning on making some radical changes to SX to make it better for code golfing.

Vim, 35 bytes

4irnbqkbnr<cr><esc>ddVkr.kVrpkyG:g//m0<cr>gUGP


4irnbqkbnr<cr><esc> # enter 4 lines, each containing the lowercase figures
dd                  # delete the empty line at the bottom
Vkr.                # replace the bottom two lines with '.'s
kVrp                # replace the next line up with 'p's
kyG                 # go up and copy all lines
:g//m0<cr>          # move the lines with periods to the top
# now instead of the black half of the board, we have the white half
gUG                 # change all characters upper case
P                   # paste what we had copied before (the black half) above the current line


The :g//m0 trick is copied from this answer by Lynn.

JavaScript (ES6), 63 75 bytes

original

a=rnbqkbnr
;for(j of'p....P')a+=j.repeat(8)+
;a+='RNBQKBNR'


edited, with output integrated:

a=rnbqkbnr
;for(j of'p....P')a+=j.repeat(8)+
;console.log(a+'RNBQKBNR')


alternative version using throw but I think this is not valid because write extra output. Total 69 bytes:

a=
rnbqkbnr
;for(j of'p....P')a+=j.repeat(8)+
;throw a+'RNBQKBNR'

• You have to include the console.log(a) in your byte count, so this is 78 bytes. Welcome to PPCG!
– user45941
Oct 11 '16 at 1:22

Jvascript 152 Bytes - 146 Bytes - 99 Bytes

Golfed code:

(n="rnbqkbnr",l=
,s=l+"........",t=n+l+"pppppppp"+s+s)=>t+l+[...t].reverse().join.toUpperCase()


Ungolfed:

t = (n = "rnbqkbnr", l = "\n", s = l + ".".repeat(8), t = n + l + "p".repeat(8) + s + s) => {
console.log(t + l + t.split("").reverse().join("").toUpperCase());
}
(() => { t(); })();

• Wish i was better at ES6 D: Oct 11 '16 at 14:03
• Here are a few tips to get you started: 1) You don't need to call the function, just define it; you also don't need the braces around it, nor the semicolon: (n="rnbqkbnr",l="\n",s=l+".".repeat(8),t=n+l+"p".repeat(8)+s+s)=>console.log(t+l+t.split("").reverse().join("").toUpperCase()) 2) You can replace "\n" with a literal newline between backticks, as shown here. 3) "........" is shorter than ".".repeat(8) (same with "pppppppp"). Oct 11 '16 at 15:26
• More tips: 4) In an arrow function without braces, a value is automatically returned, so you don't even need console.log. 5) t.split("") can be shortened to [...t], and .join("") to .join . View the golfed version here. You can look through the Tips for golfing in ES6 thread for even more tips. Oct 11 '16 at 15:37
• "p".repeat(8) would be 13 chats... It is better "pppppppp" 10 chars
– user58988
Oct 11 '16 at 18:28

Racket 82 bytes

(display"rnbqknbr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKNBR")


Another version: 162 bytes

(display(string-append"rnbqknbr\n"(make-string 8 #\p)(list->string(for/list((i
(range 0 37)))(if(= 0(modulo i 9))#\newline #\.)))(make-string 8 #\P)"\nRNBQKNBR"))


Ungolfed:

(define (f)
(display (string-append
"rnbqknbr\n"
(make-string 8 #\p)
(list->string
(for/list ((i (range 0 37)))
(if(= 0 (modulo i 9)) #\newline #\.)))
(make-string 8 #\P)
"\nRNBQKNBR"))
)


Testing:

(f)


Output:

rnbqknbr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKNBR

• I count 7 '.' Not 8 '.'
– user58988
Oct 11 '16 at 15:05
• Thanks for pointing out the error. I have corrected the code. I had missed the fact that each line has 9 characters (8 dots and 1 newline) and not 8.
– rnso
Oct 11 '16 at 16:18
• Count the figure: 64+7 nl + 11 I count something as 81 or 82
– user58988
Oct 11 '16 at 18:35
• Its 82. I forgot to correct the byte count after correcting the code.
– rnso
Oct 12 '16 at 2:49

CJam, 29 28 bytes

"rnbqkbnr"{"p.."+_W%eu+}%zN*


Try it online!

Explanation:

This new version saves a byte by doing the work on columns inside a map { }% instead of 8*-ing rows. An interesting feature is that the string (array of chars) becomes an array of strings which can then be transposed without splitting.

"rnbqkbnr"  e# hard-coded pieces
{           e# do to each piece
"p.."+    e# append "p.."
_W%       e# copy and reverse
eu+       e# capitalize and append
}%z         e# transpose to rows
N*          e# insert newlines


Scala, 65 bytes

Seq("rnbqkbnr","p",".",".",".",".","P","RNBQKBNR")map(_*8 take 8)


Really straightforward; makes use of the repeat 8 times and take the first 8 chars

Pyth, 41 35 34 33 Bytes

K*z\p8J"rnbqkbnr"JKp*+*\.8b4rK1rJ1


Golfed a byte thanks to @daHugLenny

Try It Online

Explanation

K*\p8          K="pppppppp"
J"rnbqkbnr"    J="rnbqkbnr"
J              print The Variable J
K              print The Variable K
p+*+*\.8b4     print"........\n" 4 times
rK1            print K but in uppercase
rJ1            print J but in uppercase

• You can replace "p" with \p. Oct 14 '16 at 19:26

Python 3, 83 Bytes

t="rnbqkbnr"
n="\n"
print((t)+n+("p"*8)+n+(("."*8+"\n")*4)+n+("P"*8)+n+(t.upper()))

• Welcome to the site! Some improvements I see: a lot of your parenthesis are redundant. Also, you used "\n" somewhere you could have used n Nov 22 '16 at 17:23

8th, 74 bytes

Code

"RNBQKBNR\n" dup lc . "PPPPPPPP\n" dup lc . ( "........\n" . ) 4 times . .


Output

ok> "RNBQKBNR\n" dup lc . "PPPPPPPP\n" dup lc . ( "........\n" . ) 4 times . .
rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR


SmileBASIC, 52 bytes

?"rnbqkbnr
?"p"*8?("."*8+CHR$(10))*4;"P"*8?"RNBQKBNR  T-SQL, 70 bytes PRINT REPLACE('rnbqkbnr pppppppp 1111PPPPPPPP RNBQKBNR',1,'........ ')  SQL allows line breaks inside quotes, I used that in both the main and the replaced strings. Using a numeral instead of a symbol as my replacement character lets me save 2 additional bytes. Tried to replace the other two strings, but couldn't find anything shorter than 80 bytes: SELECT r+p+e+e+e+e+UPPER(p+r)FROM(SELECT'rnbqkbnr 'r,'pppppppp 'p,'........ 'e)a  Japt-R, 28 bytes rnbqkbnr p . .¸m!î8 cUmu w  Test it Wren, 61 bytes I suppose this is not a good way of programming, but this is worth it when it comes to code golf. Fn.new{"rnbqkbnr "+"p"*8+" "+("."*8+" ")*4+"P"*8+" RNBQKBNR"}  Try it online! Explanation Fn.new{ // New function "rnbqkbnr " // rnbqkbnr\n +"p"*8 // pppppppp +" " // \n +("."*8 // ........ +" " // \n )*4 // above strings 4 times +"P"*8 // PPPPPPPP +" RNBQKBNR" // \nRNBQKBNR }  Python 3, 66 64 bytes 64 bytes: print('rnbqkbnr','p'*8,('.'*8+'\n')*4,'P'*8,'RNBQKBNR',sep='\n')  Logic: 1. Pieces remain the same as previously 2. pawns and dots get repeated 8 times 3. "." is appended a new line and the whole thing is repeated 4 times. 4. entire print is separated with sep='\n' 66 bytes: print('\n'.join(['rnbqkbnr']+[i*8for i in 'p....P']+['RNBQKBNR']))  Logic: 1. create the piece arrays as is at first and last positions. 2. create the middle 6 rows by list comprehension - using repetition i*8. 3. Sum the lists to get 8 elements 4. Join elements with a line break in between (\n) 5. print() Output: rnbqkbnr pppppppp ........ ........ ........ ........ PPPPPPPP RNBQKBNR  • I based my answer on original python 2 from years ago, but I see yours is quite similar except you didn't unpack the middle dots with Python 3.5+ syntax: codegolf.stackexchange.com/a/196543/2212 Dec 1 '19 at 2:43 Keg, 43+14039 37 bytes rnbqkbnr ∑p) (4|.8* )(8|P) RNBQKBNR  Try it online! Answer History 39 bytes rnbqkbnr (8|p) (4|.8* )(8|P) RNBQKBNR  Try it online! 40 bytes rnbqkbnr (8|p) (4|(8|\.) )(8|P) RNBQKBNR  Try it online! -4 bytes due to fixing a bug. That's new. 44 bytes rnbqkbnr\ (8|p)\ (4|(8|\.)\ )(8|P)\ RNBQKBNR  Try it online! Run length encoding where possible. Implicitly print the result. In depth: rnbqkbnr #push rnbqkbnr (8|p) #8 times, push the letter "p" \ #escaped newline (4| #4 times, do (8|\. #8 times, push "." )\ #then push a newline ) (8|P) #8 times, push P \ #escaped newline RNBQKBNR #push RNBQKBNR  JavaScript (Babel Node), 89 81 bytes console.log("rnbqkbnr\npppppppp\n"+"........\n".repeat(4)+"PPPPPPPP\nRNBQKBNR\n")  Try it online! • You know that ........ is shorter than ${'.'.repeat(8)}, right? Feb 25 '20 at 10:53
• :O, oops thanks manatwork! Edited... Feb 25 '20 at 13:27
• Why not use template strings? That way you can use actual line feeds instead of \n. Jun 18 '20 at 20:19

Stax, 22 21 bytes

î}-øΓ╤Ö¼└°≤╠ç]♀WσGpÑ


Run and debug it

Pyth, 27 bytes

js.erbk_B+"rnbqkbnr"*L8"p..


Try it online!

js.erbk_B+"rnbqkbnr"*L8"p..
"p..   The string "p.."
*L8       Repeat each character 8 times, yields ["pppppppp", "........", "........"]
+"rnbqkbnr"          Prepend "rnbqkbnr" to the list
_B                     Pair the list with itself, reversed
.e                          Map as b, with index k:
rbk                         Change case of elements of b
The r token converts to lower case if one of the arguments is 0, and
converts to uppercase if one of the arguments is 1.
s                            Concatenate the two halves of the output
j                             Join on newlines, implicit print


JavaScript (V8), 65 bytes

_=>rnbqkbnr
pppppppp
+........
.repeat(4)+PPPPPPPP
RNBQKBNR


Try it online!

Explanation :

_ =>            // beginning of function param is not needed so we do _ instead of ()
rnbqkbnr
pppppppp
             // first two lines are written better than doing line1+\n+line2+\n
........
repeat(4)   // repeat this line of ........ 4 times
+PPPPPPPP
RNBQKBNR    // last two lines


APL(Dyalog Unicode), 26 25 bytes SBCS

Taking some inspiration from coltim's K answer.

-1 byte thanks to Razetime!

(⎕C⍪⊖)'RNBQKBNR'⍪8/⍪'P..'


APL(Dyalog Unicode), 30 28 bytes SBCS

(⎕C∘⊖⍪⊢)⍉'..P'⍪⍤1⍪'RNBQKBNR'


Try it on APLgolf!

⍪'RNBQKBNR' Make a 8x1 matrix of characters
'..P'⍪⍤1 Prepend three columns made from the characters from '..P'
⍉ Transpose to get the bottom half of the result
⎕C∘⊖ Mirror vertically and convert to lower case
⍪⊢ Stack this on top of the bottom half

Try it with step by step output

• 25: (⎕C⍪⊖)'RNBQKBNR'⍪8/⍪'P..' Sep 8 at 15:03
• @Razetime thanks a lot! I completely forgot about monadic ⍪.
– ovs
Sep 8 at 15:14

Dart, 62 bytes

f()=>"rnbqkbnr\n${"p"*8}\n${"........\n"*4+"P"*8}\nRNBQKBNR";


I am annoyed that I can't reduce the "........\n"*4 part further, but due to the newline being included in the multiplication, all rewrites come out at the same length as the original:

"${"."*8}\n"*4 ("."*8+"\n")*4 "........\n"*4  Dart's string functions, like toUpperCase(), have too long names to use them in golfing. PHP, 676463 62 bytes Note: uses IBM-850 encoding. <?=~str_pad(ìæØÄöØæì§ÅÅÅÅÅÅÅÅ,54,§ÐÐÐÐÐÐÐÐ)?>PPPPPPPP RNBQKBNR  Run like this: echo '<?=~str_pad(ìæØÄöØæì§ÅÅÅÅÅÅÅÅ,54,§ÐÐÐÐÐÐÐÐ)?>PPPPPPPP RNBQKBNR' | php 2>/dev/null;echo  And in "unencoded" form: echo '<?=str_pad("rnbqkbnr\npppppppp",54,"\n........"),"PPPPPPPP\nRNBQKBNR";' | php 2>/dev/null;echo  Explanation Unfortunately I couldn't find a more interesting approach (that actually saves bytes) than to just print the string, except for the 4 middle lines which are repeated using str_repeat str_pad. Tweaks • Saved 3 bytes by replacing str_repeat with str_pad. • Saved a byte by using closing tag, thx to user59178. • Saved a byte by changing the pad string to start with a newline, so last newline can be dropped from the first argument of str_pad • It looks to me like you can save a byte by changing ,~»»»»»»»»§¡▒¢«┤¢▒¡; to ?>PPPPPPPP\nRNBQKBNR (use an actual newline character) and making use of the fact that php just prints anything outside of the tags Oct 10 '16 at 10:34 Mathematica, 76 72 bytes {"rnbqkbnr ","p"~(t=Table)~8," ",t["."~t~8<>" ",4],"P"~t~8}<>" RNBQKBNR"  Table is used to generate lists of strings. When lists of strings meet the concatenation operator <>, they get flattened into strings automatically, so the construction { ... , ... , ... }<>... is preferred over using <> throughout when there are sufficiently many strings to be concatenated. Also 72 bytes: {"rnbqkbnr ","p"~(t=Table)~8," ",{"."~t~8," "}~t~4,"P"~t~8}<>" RNBQKBNR"  In comparison, the direct string itself is 73 bytes: "rnbqkbnr pppppppp ........ ........ ........ ........ PPPPPPPP RNBQKBNR"  Perl 5, 49 bytes print join$/,$_=rnbqkbnr,"p"x8,("."x8)x4,"P"x8,uc  If only we had something like p instead of print, the remaining legible words could be removed. print join$/, ...    - print the items joined by the input
record separator, $/, which is "\n" by default$_ = rnbqkbnr         - set (and return) the default variable.
A bare string is taken as a string constant,
but gives a warning...  but only if they're enabled
"p" x 8               - string multiplier
("."x8)x4             - string and list multiplier.
"P" x 8               - same
uc                    - uppercase, if no expression given, uses $_  Of course this depends on the order of evaluation of the parameters to join, as $_ needs to be set before uc is called. Also, this doesn't print a trailing newline, which makes it look ugly if executed from the command line.

SQL, 146 Bytes

declare @ char(8)='rnbqkbnr'
print 'pppppppp'
print '........'
print '........'
print '........'
print '........'
print 'PPPPPPPP'
print upper(@)

• This doesn't appear to print the first (lowercase) row. Sep 9 '19 at 16:35
• I'd rather reuse ........ and then you can do the whole upper/lower thing if that saves any (probably not). Feb 5 '20 at 0:30

Microscript II, 56 bytes

"rnbqkbnr\npppppppp"P"........"PPPP"PPPPPPPP\nRNBQKBNR"


tcl, 86

proc R {s n\ 8} {string repe $s$n}
puts rnbqkbnr\n[R p]\n[R [R .]\n 4][R P]\nRNBQKBNR


demo

Japt-R, 25 bytes

"rnbqkbnr"¬m+'.²ip)®+ÔuÃÕ


Test it

"rnbqkbnr"¬m+'.²ip)®+ÔuÃÕ
"rnbqkbnr"                    :String literal
¬                   :Split
m+                 :Map & append
'.²              :  "." repeated twice
ip            :  Prepend "p"
)           :End map
®+         :Map & append
Ô        :  Reversed string
u       :  Uppercased
Ã      :End map
Õ     :Transpose
:Implicit output, joined by newlines


brainfuck, 248 bytes

There is probably a better way to do this.

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

Try it online!