44
\$\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\$ Sep 9 '19 at 9:55

92 Answers 92

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\$

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.

\$\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
    Oct 11 '16 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
    Oct 11 '16 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\$ Oct 11 '16 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\$ Oct 11 '16 at 15:37
  • \$\begingroup\$ "p".repeat(8) would be 13 chats... It is better "pppppppp" 10 chars \$\endgroup\$
    – user58988
    Oct 11 '16 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
    Oct 11 '16 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
    Oct 11 '16 at 16:18
  • \$\begingroup\$ Count the figure: 64+7 nl + 11 I count something as 81 or 82 \$\endgroup\$
    – user58988
    Oct 11 '16 at 18:35
  • \$\begingroup\$ Its 82. I forgot to correct the byte count after correcting the code. \$\endgroup\$
    – rnso
    Oct 12 '16 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
    Oct 14 '16 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
    Nov 22 '16 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
    Dec 1 '19 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
    Feb 25 '20 at 10:53
  • \$\begingroup\$ :O, oops thanks manatwork! Edited... \$\endgroup\$
    – Sarreph
    Feb 25 '20 at 13:27
  • \$\begingroup\$ Why not use template strings? That way you can use actual line feeds instead of \n. \$\endgroup\$ Jun 18 '20 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\$

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
    Sep 8 at 15:03
  • \$\begingroup\$ @Razetime thanks a lot! I completely forgot about monadic . \$\endgroup\$
    – ovs
    Sep 8 at 15:14
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\$
0
\$\begingroup\$

PHP, 67 64 63 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
\$\endgroup\$
1
  • \$\begingroup\$ 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 \$\endgroup\$
    – user59178
    Oct 10 '16 at 10:34
0
\$\begingroup\$

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

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.

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

SQL, 146 Bytes

declare @ char(8)='rnbqkbnr'
print 'pppppppp'
print '........'
print '........'
print '........'
print '........'
print 'PPPPPPPP'
print upper(@)
\$\endgroup\$
2
  • \$\begingroup\$ This doesn't appear to print the first (lowercase) row. \$\endgroup\$
    – BradC
    Sep 9 '19 at 16:35
  • \$\begingroup\$ I'd rather reuse ........ and then you can do the whole upper/lower thing if that saves any (probably not). \$\endgroup\$
    – S.S. Anne
    Feb 5 '20 at 0:30
0
\$\begingroup\$

Microscript II, 56 bytes

"rnbqkbnr\npppppppp"P"........"PPPP"PPPPPPPP\nRNBQKBNR"
\$\endgroup\$
0
\$\begingroup\$

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

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

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

brainfuck, 248 bytes

There is probably a better way to do this.

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

Try it online!

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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