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

67 Answers 67

16
\$\begingroup\$

Jelly, 25 24 bytes

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

Try it online!

Thanks to @Lynn for golfing off 1 byte!

How it works

“.“.“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.
\$\endgroup\$
14
\$\begingroup\$

Vim, 26 bytes

irnbqkbnr<Esc>Y6p5Vr.VrpYGPgUj

Relies on a fresh Vim, or else 5V may select the wrong area.

  • irnbqkbnr<Esc>: Write the top row. Easy enough.
  • Y6p: Make the rest of the rows, except one. Of course all but the top and bottom rows contain the wrong characters.
  • 5Vr.: When you haven't used visual mode yet in the session, you can do things like this to select 5 lines. If you typed the same thing again right away, it would try to select 25 lines. Vim is weird like that.
  • Vrp: We're already on line 2, so let's make a pawn line.
  • YGP: Copy that pawn line into its place at the bottom. This is why I used 6p instead of 7p before.
  • gUj: Capitalize the white pieces.
\$\endgroup\$
10
\$\begingroup\$

Brainfuck, 224 bytes

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

Took almost an hour to get this.

\$\endgroup\$
8
\$\begingroup\$

Python 2, 63 bytes

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

Unfortunately, the fairly simple approach was much shorter than the "clever" stuff I tried at first...

Bonus answer, also 63 bytes:

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

05AB1E, 24 bytes

Uses CP-1252 encoding.

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

Try it online!

Explanation

"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
\$\endgroup\$
  • 1
    \$\begingroup\$ I think this is the FIRST time I've ever golfed an answer without looking and matched you on 100% of the characters used. Gotta agree this is as good as it gets haha. \$\endgroup\$ – Magic Octopus Urn Feb 10 '17 at 20:23
7
\$\begingroup\$

Actually, 26 bytes

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

Try it online!

Explanation:

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

Cheddar, 56 bytes

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

Uses the new => feature.

Explanation

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
\$\endgroup\$
  • 5
    \$\begingroup\$ So you answered a question about 'chess' in 'ches'? \$\endgroup\$ – DJMcMayhem Oct 10 '16 at 2:51
  • 4
    \$\begingroup\$ @DJMcMayhem .................. did you just..... \$\endgroup\$ – Downgoat Oct 10 '16 at 2:52
  • 1
    \$\begingroup\$ mm this is some beautiful cheese. nice abuse of default params \$\endgroup\$ – Conor O'Brien Oct 10 '16 at 3:03
6
\$\begingroup\$

Pyke, 28 27 26 bytes

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

Try it here!

I learned something new about my language today: 1c can be used as a 2 char way of splitting a string into a list of characters.

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

MATL, 26 bytes

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

Try it online!

Explanation

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

Ruby, 45 44

1 byte saved thanks to tuxcrafting.

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

This is 45

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

Trying anything cleverer just seems to make it longer.

\$\endgroup\$
  • \$\begingroup\$ Remove the space before the string after the puts \$\endgroup\$ – TuxCrafting Oct 10 '16 at 17:33
5
\$\begingroup\$

JavaScript (ES6), 69 65 bytes

Saved 4 bytes thanks to edc65

let f =

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

console.log(f());

\$\endgroup\$
  • 1
    \$\begingroup\$ Very clever! Maybe too clever, could save 4 bytes with 'rnbqkbnrnp....PRNBQKBNR'.replace(/p|\./ig,c=>c.repeat(8)+'\n') (change \n to a literal newline) \$\endgroup\$ – edc65 Oct 10 '16 at 19:35
5
\$\begingroup\$

C#, 94 92 bytes

Edit: Thanks to milk for saving 1 byte by changing string order to remove the return whitespace.

Edit: Saved 1 more byte by adding a dummy parameter (x instead of ()) for the anonymous function and calling it with any object.

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

Full program using the above function:

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# is a very verbose language...


C# full program, 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());}}

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());
    }
}
\$\endgroup\$
  • 2
    \$\begingroup\$ "C# is a very verbose language...". You haven't tried VB.NET then... ;) \$\endgroup\$ – TyCobb Oct 10 '16 at 17:06
  • 2
    \$\begingroup\$ You can save a byte by defining a and b as uppercase then you can get rid of the space after return: return(a+b).ToLower()+... \$\endgroup\$ – milk Oct 10 '16 at 19:15
  • \$\begingroup\$ @TyCobb I tried VB.NET quite some time ago. I didn't know about code golfing back then :P \$\endgroup\$ – adrianmp Oct 10 '16 at 19:42
  • \$\begingroup\$ can you use var instead of string ? \$\endgroup\$ – NibblyPig Oct 11 '16 at 11:27
  • \$\begingroup\$ @SLC I haven't programmed in C# for a while, so correct me if I'm wrong, but I don't think you can use var with multiple declarations on a single line. So string a="rnbqkbnr\n",b="pppppppp\n",c="........\n"; would become var a="rnbqkbnr\n";var b="pppppppp\n";var c="........\n";, which increases the byte-count. EDIT: It would give an "An implicitly typed local variable declaration cannot include multiple declarators" error. \$\endgroup\$ – Kevin Cruijssen Oct 11 '16 at 12:07
4
\$\begingroup\$

Python 2, 68 bytes

Posting anyway although the above Python 2 version is shorter. It would not have to be a one liner for the amount of bytes, just played with it.

x,y,z="rnbqkbnr\n","p"*8+"\n","."*8+"\n";print x,y,4*z,(y+x).upper()
\$\endgroup\$
  • \$\begingroup\$ Since z is only used once you can get rid of it and produce the dots in the print statement. \$\endgroup\$ – Karl Napf Oct 14 '16 at 1:59
3
\$\begingroup\$

Haskell, 53 bytes

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

a is used as the first line and to determine the length of strings made of p, . and P (-> <$a). .

\$\endgroup\$
3
\$\begingroup\$

JavaScript (ES6), 73

.toUpperCase is simply too long

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

\$\endgroup\$
  • \$\begingroup\$ I think (r=c=>c[0].repeat(8)+\n,b=r.)=> saves you a byte. \$\endgroup\$ – Neil Oct 10 '16 at 8:43
  • \$\begingroup\$ @Neil I don't see the saving. I tried to rewrite the code increasing readibility (a little), but the byte count stay the same \$\endgroup\$ – edc65 Oct 10 '16 at 9:23
  • \$\begingroup\$ Ah, I see what I did wrong there, somehow I lost a newline along the way. Sorry about that. \$\endgroup\$ – Neil Oct 10 '16 at 9:45
3
\$\begingroup\$

PowerShell v2+, 44 bytes

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

Strings left on the pipeline are implicitly printed with Write-Output at program execution. We couple that with the default newline behavior for an array to produce the four lines of periods with the comma-operator.

PS C:\Tools\Scripts\golfing> .\draw-ascii-chess-board.ps1
rnbqknbr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKNBR
\$\endgroup\$
  • \$\begingroup\$ Where are the new lines in the lines of points? " ,('.'*8)*4" it is the ',' I suppose... \$\endgroup\$ – RosLuP Oct 11 '16 at 15:48
  • \$\begingroup\$ @RosLuP The comma-operator ,, creates an array (in this case, an array of strings). The default Write-Output at program completion inserts a newline between elements left on the pipeline, including individual array elements. So, we're abusing the default output behavior to not need to write explicit newlines in the code. \$\endgroup\$ – AdmBorkBork Oct 11 '16 at 15:52
3
\$\begingroup\$

V, 27, 26 bytes

i¸P
RNBQKBNRäkgujddppÒ.4Ä

Try it online!

This contains some unprintable characters, so here is the readable version:

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

where <esc> represents 0x1B. Explanation:

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

Brain-Flak, 366 350 + 3 = 353 bytes

Try it online!

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

This gets a plus 3 because it requires the -A flag to run properly.

Explanation

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.

(((()()()()()){})<((((((((([][]()()()()))))))))<>)<>>)(((()()()){})(({}()()())(([{}(()()())](([{}()](<>({}()())<>)<>)<>)<>)<>))){<>({}<>)}{}
\$\endgroup\$
  • \$\begingroup\$ You can push the first two lines with ((((((((((((((((((((()()()()()){}){}){}()){})[()()()()])[([][][]){}])[][][])[]()())[[][][]])[][])()()()())<([]()())>[()()])))))))) which I think would save you 16 bytes. This doesn't use the alternate stack at all, so it could probably be even shorter. \$\endgroup\$ – DJMcMayhem Oct 19 '17 at 17:40
3
\$\begingroup\$

Python 3.5, 56 bytes

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

This uses an idea by zawata to encode each line as (r*8)[:8], with a string repeated 8 times and trimmed to length 8. The pawns and empty rows are just 'p'*8, '.'*8, and 'P'*8, with no trimming. The first row uses 'rnbqkbn', with ('rnbqkbn'*8)[:8] including another rook on the right when multiplied and trimmed. The last row is the same but capitalized.

We express the list of row-parts compactly ['rnbqkbn','p','.','.','.','.','P','RNBQKBN'] using Python 3.5's generalized unpacking. We write out the first and last-entries, and the remaining single-character ones are unpacked from a string.

In Python 2, we could settle for split instead for 60 bytes:

for i in'rnbqkbn p . . . . P RNBQKBN'.split():print(i*8)[:8]
\$\endgroup\$
3
\$\begingroup\$

Python 3, 82 80 75 Bytes

Not the shortest answer in python but it's my first and i think its pretty good for a first time

print('\n'.join((i*8)[:8]for i in'rnbqkbn p . . . . P RNBQKBN'.split()))
\$\endgroup\$
  • 1
    \$\begingroup\$ Welcome to the site! You could take two bytes off if you remove some extra spaces. E.g. [:8]for i in['rnbqkbn'.... \$\endgroup\$ – DJMcMayhem Oct 12 '16 at 2:14
  • 1
    \$\begingroup\$ Nice idea with unifying all the lines and reusing the rooks. You can write the list shorter as 'rnbqkbn p . . . . P RNBQKBN'.split(). \$\endgroup\$ – xnor Oct 12 '16 at 2:23
  • \$\begingroup\$ @DJMcMayhem didn't know those weren't necessary. thanks! \$\endgroup\$ – zawata Oct 12 '16 at 6:02
  • \$\begingroup\$ @xnor that is a great idea! ill have to add that trick to my "arsenal" haha \$\endgroup\$ – zawata Oct 12 '16 at 6:02
2
\$\begingroup\$

Batch, 105 bytes

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

Batch is seriously verbose...

\$\endgroup\$
2
\$\begingroup\$

J, 55 52 bytes

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

Test and intermediate steps

   '.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
\$\endgroup\$
2
\$\begingroup\$

Emotinomicon, 89 bytes

Sadly Emotinomicon has nothing like an duplicate stack function. Would be usefull. But at least shorter than Java. :)

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

Explanation:

😭(...)😲⏪⏬⏩
😭(...)😲            String literal
         ⏪  ⏩      Loop
           ⏬        Pop one char and output
\$\endgroup\$
  • \$\begingroup\$ Hmm... that would be a useful function, now wouldn't it... \$\endgroup\$ – Conor O'Brien Oct 14 '16 at 1:00
2
\$\begingroup\$

Python 3, 64 bytes

Based off DLosc answer to Python 2 as on mine I could not improve.

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

1 byte less compared to using "\n".join

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

q, 51 bytes

"\n"sv flip{x,"p...P","c"$("i"$x)-32}each"rnbqkbnr"
\$\endgroup\$
  • \$\begingroup\$ You can shave off a few bytes with upper, and each-right. Also the following prints to stdout rather than returning a string with newlines: -1 flip"p...P"{y,x,upper y}/:"rnbqkbnr";. 40 bytes. Nice solution though! \$\endgroup\$ – streetster Jul 19 '17 at 16:18
2
\$\begingroup\$

GNU sed, 54 bytes

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

Try it online!

Explanation:

The black pieces are printed first, saving the two associated board ranks in reverse order in the hold space. The white pieces are printed by converting the hold space to uppercase letters.

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

Java 7, 103 99 89 bytes

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

10 bytes saved compared to hardcoded output thanks to @SLC's approach in his C# answer.

Try it here.

Output:

rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR
\$\endgroup\$
  • \$\begingroup\$ What about this String f(){return"rnbqkbnr\npppppppp\n........\n........\n........\n........\nPPPPPPPP\nRNBQKBNR";}.This is 100 bytes. \$\endgroup\$ – Numberknot Oct 11 '16 at 8:40
  • \$\begingroup\$ @Numberknot How boring.. but you're right, it is shorter. Btw, it's 99 bytes, not 100. \$\endgroup\$ – Kevin Cruijssen Oct 11 '16 at 8:53
2
\$\begingroup\$

C#, 85 84 83 74 bytes

Edit: Accidentally had too many rows of blank spaces!

Edit: Freed an extra character and fixed the ordering (accidentally had it all reversed) many thanks to @KevinCruijssen

Edit: Reverted back to 83 cos I had the prawns on the wrong line

Edit: Thanks to @adrianmp who helped me shrink it further by omitting return

Using the same format as @adrianmp answer above:

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

Full program using the above function:

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));
        }
    }
}
\$\endgroup\$
  • \$\begingroup\$ Hi, welcome to PPCG! Hmm, the order of your pieces seems incorrect with the one of OP. Btw, you can save 1 byte by removing the space between return ", so it becomes: x=>{return"rnbqkbnr\npppppppp\nxxxxPPPPPPPP\nRNBQKBNR".Replace("x","........\n");};. Nice answer, so +1 from me. And enjoy your stay here. :) \$\endgroup\$ – Kevin Cruijssen Oct 11 '16 at 11:53
  • \$\begingroup\$ And thanks for your answer. I've ported the same approach to my Java 7 answer (of course crediting you), lowering the byte-count by 10. :) \$\endgroup\$ – Kevin Cruijssen Oct 11 '16 at 12:01
  • \$\begingroup\$ I have improved it further \$\endgroup\$ – NibblyPig Oct 11 '16 at 12:10
  • \$\begingroup\$ Gah I just realised that's not right \$\endgroup\$ – NibblyPig Oct 11 '16 at 12:13
  • 1
    \$\begingroup\$ Nice approach! You can actually reduce it to 74 bytes: x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n"); \$\endgroup\$ – adrianmp Oct 11 '16 at 12:23
2
\$\begingroup\$

Gloo, 46 Bytes

Gloo is a very, erm, young language with very little stack manipulation implemented. I think this is probably the best I can do since there's also no uppercase function. The raw bytes are below, and can be run from the interpreter using gloo.py -f <file>.

Offset   00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
000000   22 72 6E 62 71 6B 62 6E 72 0A 22 22 70 22 38 2A   "rnbqkbnr.""p"8*
000010   22 0A 22 22 2E 22 38 2A 22 0A 22 2B 34 2A 22 50   ".""."8*"."+4*"P
000020   22 38 2A 22 0A 52 4E 42 51 4B 42 4E 52 22         "8*".RNBQKBNR"

This doesn't count because it was updated after the challenge started, but now there's an easy 32 byte solution:

"rnbqkbnr"'p8*[_?¶Ä'.4*‘8*’;[¶jj

Offset(h) 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F

00000000  22 72 6E 62 71 6B 62 6E 72 22 27 70 38 2A 5B 5F  "rnbqkbnr"'p8*[_
00000010  3F B6 C4 27 2E 34 2A 91 38 2A 92 3B 5B B6 6A 6A  ?¶Ä'.4*‘8*’;[¶jj
\$\endgroup\$
2
\$\begingroup\$

Python 3, 60 bytes

print('rnbqkbnr','p'*8,*['.'*8]*4,'P'*8,'RNBQKBNR',sep='\n')
\$\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.