47
\$\begingroup\$

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.

Leaderboards

To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:

# 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>

\$\endgroup\$
1
  • 2
    \$\begingroup\$ Surely an ASCII art chess board would have the full stop every other square? \$\endgroup\$ Commented Sep 9, 2019 at 9:55

101 Answers 101

1
\$\begingroup\$

Vim, 50 strokes

qairnbqkbnr<enter><esc>8ip<esc><enter><esc>[email protected]@aj@aj@ajgU$jgU$

Golfed out 8 bits thanks to @DJMcMayhem

\$\endgroup\$
1
  • \$\begingroup\$ A couple tips: 1) you could do <esc>8ip<esc> instead of pppppppp. 2) You could do Vr. or 8r. instead of :s/./\./ \$\endgroup\$
    – DJMcMayhem
    Commented Oct 10, 2016 at 13:26
1
\$\begingroup\$

Python 2, 61 bytes

print'rnbqkbnr\npppppppp\n'+('.'*8+'\n')*4+'P'*8+'\nRNBQKBNR'

Very brute-force. The 'P'*8 is worth it on the right, but the left pppppppp is flanked by newlines that make it not worth doing as 'p'*8.

\$\endgroup\$
1
  • \$\begingroup\$ Really cool that you were able to shave off more bytes, the *6 should be *4 but that won't change anything. \$\endgroup\$
    – DomPar
    Commented Oct 10, 2016 at 23:28
1
\$\begingroup\$

Xasm, 944 Bytes

00000001 114
00000001 110
00000001 98
00000001 113
00000001 107
00000001 98
00000001 110
00000001 114
00000001 10
00000001 112
00000001 112
00000001 112
00000001 112
00000001 112
00000001 112
00000001 112
00000001 112
00000001 10
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 10
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 10
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 10
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 46
00000001 10
00000001 80
00000001 80
00000001 80
00000001 80
00000001 80
00000001 80
00000001 80
00000001 80
00000001 10
00000001 82
00000001 78
00000001 66
00000001 81
00000001 75
00000001 66
00000001 78
00000001 82
00000011

I just did this for novelty. I won't win shortest code but maybe longest! ^_^

\$\endgroup\$
1
\$\begingroup\$

Charcoal, 32 bytes

rnbkqbnr¶P×p⁸M⁵↓⁺×P⁸¶RNBKQBNRUB.

Explanation

rnbkqbnr¶                            Print "rnbkqbnr\n"
         P×p⁸                       Print "p" * 8 without moving cursor
              M⁵↓                   Move cursor 5 characters down
                  ⁺×P⁸¶RNBKQBNR      Print "p" * 8 + "\nRNBKQBNR"
                               UB. Set background to '.'
\$\endgroup\$
3
  • \$\begingroup\$ Does this have a custom code page? \$\endgroup\$ Commented Oct 14, 2016 at 0:10
  • \$\begingroup\$ @ConorO'Brien Yes, but it's undocumented and requires a flag right now, so I have no idea if it counts \$\endgroup\$
    – ASCII-only
    Commented Oct 14, 2016 at 0:21
  • \$\begingroup\$ I mean, that should be fine. That's how the file is read. \$\endgroup\$ Commented Oct 14, 2016 at 0:48
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

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'
\$\endgroup\$
1
  • \$\begingroup\$ You have to include the console.log(a) in your byte count, so this is 78 bytes. Welcome to PPCG! \$\endgroup\$
    – user45941
    Commented Oct 11, 2016 at 1:22
1
\$\begingroup\$

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(); })();
\$\endgroup\$
4
  • \$\begingroup\$ Wish i was better at ES6 D: \$\endgroup\$
    – Esteru
    Commented Oct 11, 2016 at 14:03
  • 1
    \$\begingroup\$ 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"). \$\endgroup\$ Commented Oct 11, 2016 at 15:26
  • \$\begingroup\$ 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. \$\endgroup\$ Commented Oct 11, 2016 at 15:37
  • \$\begingroup\$ "p".repeat(8) would be 13 chats... It is better "pppppppp" 10 chars \$\endgroup\$
    – user58988
    Commented Oct 11, 2016 at 18:28
1
\$\begingroup\$

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
\$\endgroup\$
4
  • \$\begingroup\$ I count 7 '.' Not 8 '.' \$\endgroup\$
    – user58988
    Commented Oct 11, 2016 at 15:05
  • \$\begingroup\$ 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. \$\endgroup\$
    – rnso
    Commented Oct 11, 2016 at 16:18
  • \$\begingroup\$ Count the figure: 64+7 nl + 11 I count something as 81 or 82 \$\endgroup\$
    – user58988
    Commented Oct 11, 2016 at 18:35
  • \$\begingroup\$ Its 82. I forgot to correct the byte count after correcting the code. \$\endgroup\$
    – rnso
    Commented Oct 12, 2016 at 2:49
1
\$\begingroup\$

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
\$\endgroup\$
1
\$\begingroup\$

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

\$\endgroup\$
1
\$\begingroup\$

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
\$\endgroup\$
1
  • \$\begingroup\$ You can replace "p" with \p. \$\endgroup\$
    – acrolith
    Commented Oct 14, 2016 at 19:26
1
\$\begingroup\$

Python 3, 83 Bytes

t="rnbqkbnr"
n="\n"
print((t)+n+("p"*8)+n+(("."*8+"\n")*4)+n+("P"*8)+n+(t.upper()))
\$\endgroup\$
1
  • 2
    \$\begingroup\$ 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 \$\endgroup\$
    – DJMcMayhem
    Commented Nov 22, 2016 at 17:23
1
\$\begingroup\$

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
\$\endgroup\$
1
\$\begingroup\$

SmileBASIC, 52 bytes

?"rnbqkbnr
?"p"*8?("."*8+CHR$(10))*4;"P"*8?"RNBQKBNR
\$\endgroup\$
1
\$\begingroup\$

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
\$\endgroup\$
1
\$\begingroup\$

Japt -R, 28 bytes

`rnbqkbnr p . .`¸m!î8
cUmu w

Test it

\$\endgroup\$
1
\$\begingroup\$

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
}
\$\endgroup\$
1
\$\begingroup\$

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
\$\endgroup\$
1
  • 1
    \$\begingroup\$ 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 \$\endgroup\$
    – JBernardo
    Commented Dec 1, 2019 at 2:43
1
\$\begingroup\$

Keg, 43+1 40 39 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
\$\endgroup\$
1
\$\begingroup\$

JavaScript (Babel Node), 89 81 bytes

console.log("rnbqkbnr\npppppppp\n"+"........\n".repeat(4)+"PPPPPPPP\nRNBQKBNR\n")

Try it online!

\$\endgroup\$
3
  • 1
    \$\begingroup\$ You know that ........ is shorter than ${'.'.repeat(8)}, right? \$\endgroup\$
    – manatwork
    Commented Feb 25, 2020 at 10:53
  • \$\begingroup\$ :O, oops thanks manatwork! Edited... \$\endgroup\$
    – Sarreph
    Commented Feb 25, 2020 at 13:27
  • \$\begingroup\$ Why not use template strings? That way you can use actual line feeds instead of \n. \$\endgroup\$ Commented Jun 18, 2020 at 20:19
1
\$\begingroup\$

Stax, 22 21 bytes

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

Run and debug it

\$\endgroup\$
1
\$\begingroup\$

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
\$\endgroup\$
1
\$\begingroup\$

Zsh, 69 65 bytes

69bytes   try it online!!

build array, print it forwards, print it backwards+lowercase

D=........ X=(RNBQKBNR PPPPPPPP $D $D);printf %s\\n $X ${(Oa)X:l}
\$\endgroup\$
1
\$\begingroup\$

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
+             // add to it
`........
`repeat(4)   // repeat this line of ........ 4 times
+`PPPPPPPP
RNBQKBNR`    // last two lines 
\$\endgroup\$
1
\$\begingroup\$

APL(Dyalog Unicode), 26 25 bytes SBCS

Taking some inspiration from coltim's K answer.

-1 byte thanks to Razetime!

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

Try it on APLgolf! or Get some intermediate values


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

\$\endgroup\$
2
  • 1
    \$\begingroup\$ 25: (⎕C⍪⊖)'RNBQKBNR'⍪8/⍪'P..' \$\endgroup\$
    – Razetime
    Commented Sep 8, 2021 at 15:03
  • \$\begingroup\$ @Razetime thanks a lot! I completely forgot about monadic . \$\endgroup\$
    – ovs
    Commented Sep 8, 2021 at 15:14
1
\$\begingroup\$

Thunno N, \$28 \log_{256}(96) \approx\$ 23 bytes

(The leaderboard needs an integer, so I rounded it. It's actually 23.05 bytes)

"rnbqkbnr"'p8*'.8*DZMDrusA+r

Attempt This Online!

Port of Emigna's 05AB1E answer.

"rnbqkbnr"  # Push "rnbqkbnr"           STACK: "rnbqkbnr"
'p8*        # Push "pppppppp"           STACK: "rnbqkbnr", "pppppppp"
'.8*D       # Push "........" twice     STACK: "rnbqkbnr", "pppppppp", "........", "........"
ZMD         # Push the stack twice      STACK: ["rnbqkbnr", "pppppppp", "........", "........"],
                                               ["rnbqkbnr", "pppppppp", "........", "........"]
ru          # Reverse, uppercase        STACK: ["rnbqkbnr", "pppppppp", "........", "........"],
                                               ["........", "........", "PPPPPPPP", "RNBQKBNR"]
sA+         # Concatenate               STACK: ['RNBQKBNR', 'PPPPPPPP', '........', '........',
                                                '........', '........', 'pppppppp', 'rnbqkbnr']
r           # Reverse                   STACK: ['rnbqkbnr', 'pppppppp', '........', '........',
                                                '........', '........', 'PPPPPPPP', 'RNBQKBNR']
            # N flag joins by newlines
\$\endgroup\$
1
\$\begingroup\$

Python 3, 80 bytes

print(*(l:=["rnbqkbnr",'p'*8,b:='.'*8,b]),*[m.upper()for m in l][::-1],sep='\n')

Try it online!

When you first look at this code, you might ask: why so many asterisks? 2 asterisks are splat operators, and the other 2 are string multiplication.

I'll first work from the inner-most layer of code and I'll work the way up, explaining everything.

We make a variable b, which is one of the blank lines. Which is the string '.' repeated 8 times. We put that and another copy of b.

That is inside a list, which has some more items before that. There's the top row and the pawn row ('p' repeated 8 times). That is saved into a variable l and splatted into print.

Then we have a comprehension, which makes every line in l have uppercase letters (white's side). We need to reverse that array and then splat it into print.

Finally, we use the new line as an argument separator and we are done!

\$\endgroup\$
1
\$\begingroup\$

Vis editor, 36 bytes

irnbqkbnr<Escape>5o<Escape>4<Ctrl-k>:i8/.<Enter><Escape>08rpykGpddpVkU
irnbqkbnrX5oX4K:i8/.NX08rpykGpddpVkU

Sequences and are counted as 1 byte each.

  1. i - Insert the first row.
  2. <E>5o<E> - Add 5 newlines under the first line, cursor is now at end of file.
  3. 4<C-k> - Add 4 additional cursors above current cursor
  4. :i8/. - Use a Sam command to insert 8 periods at all 5 cursor locations. Still in NORMAL mode.
  5. <Esc> - Get rid of all but the primary cursor, which is conveniently located at the 2nd line. Still in NORMAL mode.
  6. 08rp - Go to begining and replace the following 8 dots with p.
  7. yk - Yank current line and line above (j is down, k is up).
  8. G - Jump to end of file.
  9. pddp - Paste 1st and 2nd line, then swap them.
  10. VkU - Select entire last line and line above (as before, k is up), uppercase both.

I had a slightly shorter codegolf in vis, but this is more instructure because it uses a Sam expression :i8/ and multi cursors (including the location of the primary cursor).

rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR
\$\endgroup\$
1
\$\begingroup\$

Python 3, 75 bytes

lambda a="rnbqkbnr",b="p"*8:"\n".join([a,b,*["."*8]*4,b.upper(),a.upper()])

Try it online!

\$\endgroup\$
0
\$\begingroup\$

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.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.