画一个ASCII棋盘！

42

这对您来说是一个简单的挑战：您必须产生棋盘的ASCII表示形式。白色用大写字母表示，黑色用小写字母表示。空图块用表示.。这是全膳：

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

由于这是一个kolmogorov复杂性问题，因此您可能不接受任何输入，并且必须通过任何默认方法输出此评估板，例如，保存文件，打印到STDOUT或从函数返回。您可以选择产生一个尾随换行符。存在标准漏洞，并且以字节为单位的最短程序！

但是，请记住，这同样是同一种语言的提交之间的竞争。尽管Java之类的语言不可能击败perl之类的语言，或者pyth或cjam之类的高尔夫语言，但Java的最短答案仍然令人印象深刻！为了帮助您跟踪每种语言的最短答案，您可以使用此排行榜，它将按语言和总体显示最短的提交。

排行榜

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以通过打败旧分数来保持标题。例如：

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

如果要在标头中包含多个数字（例如，因为您的分数是两个文件的总和，或者您想单独列出解释器标志罚分），请确保实际分数是标头中的最后一个数字：

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

您还可以将语言名称设置为链接，然后该链接将显示在页首横幅代码段中：

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

显示代码段

code-golf  ascii-art  kolmogorov-complexity 
— DJMcMayhem
source
1
显然一个ASCII art棋盘必须完全停止所有其他方？
— Shaun Bebbers

Answers:

16

果冻，25 24 字节

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

在线尝试！

感谢@Lynn打高尔夫球1个字节！

这个怎么运作

“.“.“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.
— 丹尼斯
source
15

Vim，26个字节

irnbqkbnr<Esc>Y6p5Vr.VrpYGPgUj

依靠新的Vim，否则5V可能会选择错误的区域。

  • irnbqkbnr<Esc>：写第一行。很简单。
  • Y6p：进行其余的行，除了一个。当然，除了顶行和底行之外，所有其他行都包含错误的字符。
  • 5Vr.：在会话中尚未使用可视模式时，可以执行以下操作选择5行。如果您立即再次输入相同的内容，它将尝试选择25行。Vim很奇怪。
  • Vrp：我们已经在第2行上了，所以让我们做一个典当行。
  • YGP：将该典当行复制到其底部。这就是为什么我使用6p而不是7p以前。
  • gUj：将白色部分大写。
— 乌迪欧卡
source
1
有最好的高尔夫语言！
— 于
10

Brainfuck，224字节

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

花了将近一个小时才能得到这个。

— 猎人VL
source
8

Python 2，63个字节

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

不幸的是，这种相当简单的方法比我最初尝试的“聪明”方法要短得多。

奖励答案，也为63个字节：

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

05AB1E，24字节

使用CP-1252编码。

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

在线尝试！

说明

"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
— 艾米尼亚
source
1
我认为这是我第一次没有找到答案并与您匹配100％使用的角色，这是我第一次。一定同意这是一样好的，哈哈。
— 魔术八达通Ur
7

其实是26个位元组

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

在线尝试！

说明：

'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
— 麦高
source
6

Cheddar，56个字节

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

使用新=>功能。

说明

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
— 下山羊
source
5
因此，您回答了有关“棋”中“棋”的问题？
— DJMcMayhem
4
@DJMcMayhem ..................您是否刚刚.....
— Downgoat
1
这是一些漂亮的奶酪。默认参数的很好滥用
— Conor O'Brien
6

Pyke，28 27 26字节

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

在这里尝试！

我今天学到了一些有关我的语言的新知识：1c可以用作将字符串分成字符列表的2种字符的方式。

"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
— 蓝色
source
5

MATL，26字节

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

在线尝试！

说明

'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
— 路易斯·门多
source
5

红宝石，45 44

多亏了tuxcrafting，节省了1个字节。

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

这是45

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

尝试任何更聪明的方法似乎只会使它更长。

— 水准河圣
source
在puts
— TuxCrafting 16-10-10
5

JavaScript（ES6），69 65字节

由于edc65，节省了4个字节

let f =

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

console.log(f());
展开摘要

— Arnauld
source
1
非常聪明！也'rnbqkbnrnp....PRNBQKBNR'.replace(/p|\./ig,c=>c.repeat(8)+'\n')\n
— 许太聪明了
5

C＃，94 92字节

编辑：感谢milk通过更改字符串顺序以删除返回空格来节省1个字节。

编辑：通过为匿名函数添加一个虚拟参数（x代替（））并使用任何对象调用它，又节省了1个字节。

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

使用以上功能的完整程序：

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＃是一种非常冗长的语言...

C＃完整程序，131个字节

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

取消高尔夫：

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());
    }
}
— 阿德里安普
source
2
“ C＃是一种非常冗长的语言...”。您还没有尝试过VB.NET ...;）
— TyCobb
2
您可以通过定义保存一个字节a，并b为大写，那么你可以摆脱空间后return：return(a+b).ToLower()+...
— 牛奶
@TyCobb我很早以前尝试过VB.NET。那时我不知道打高尔夫球的代码：P
— adrianmp '16
可以var代替使用string吗？
— NibblyPig
@SLC我已经有一段时间没有用C＃编程了，所以如果我写错了，请更正我，但是我认为您不能var在一行上使用多个声明。因此string a="rnbqkbnr\n",b="pppppppp\n",c="........\n";将变为var a="rnbqkbnr\n";var b="pppppppp\n";var c="........\n";，这将增加字节数。编辑：它将给出一个“ 隐式类型的局部变量声明不能包含多个声明符 ”错误。
— 凯文·克鲁伊森
4

Python 2，68个字节

无论如何，尽管上面的Python 2版本较短。它不必是字节数的唯一衬线，只需使用它即可。

x,y,z="rnbqkbnr\n","p"*8+"\n","."*8+"\n";print x,y,4*z,(y+x).upper()
— DomPar
source
因为z仅使用一次，您就可以摆脱它并在print语句中产生点。
— Karl Napf
3

Haskell，53个字节

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

a被用作第一线，并确定由字符串的长度p，.和P（ - > <$a）。。

— 妮米
source
3

JavaScript（ES6），73

.toUpperCase 太长了

_=>`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>
展开摘要

— edc65
source
我认为(r=c=>c[0].repeat(8)+\ n ,b=r。)=>节省您一个字节。
— 尼尔
@Neil我看不到节省。我试图重写代码（增加了一点可读性），但是字节数保持不变
— edc65
啊，我知道我在哪里做错了，在某种程度上我丢失了换行符。对于那个很抱歉。
— 尼尔，
3

PowerShell v2 +，44字节

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

留在管道上的字符串Write-Output在程序执行时隐式打印。我们将其与数组的默认换行行为相结合，以使用逗号运算符产生四行句号。

PS C:\Tools\Scripts\golfing> .\draw-ascii-chess-board.ps1
rnbqknbr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKNBR
— AdmBorkBork
source
点线中的新线在哪里？“，（'。'* 8）* 4”是'，'我想...
— RosLuP
@RosLuP逗号运算符,创建一个数组（在这种情况下，是字符串数组）。Write-Output程序完成时的默认值在管道上剩余的元素（包括单个数组元素）之间插入换行符。因此，我们正在滥用默认输出行为，无需在代码中编写显式换行符。
— AdmBorkBork，2016年
3

V，27，26字节

i¸P
RNBQKBNRäkgujddppÒ.4Ä

在线尝试！

其中包含一些不可打印的字符，因此为可读版本：

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

在哪里<esc>代表0x1B。说明：

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
— DJMcMayhem
source
3

Emotinomicon，89个字节

可悲的是，Emotinomicon没有什么比复制堆栈函数更重要的了。会有用的。但是至少比Java短。:)

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

说明：

😭(...)😲⏪⏬⏩
😭(...)😲            String literal
         ⏪  ⏩      Loop
           ⏬        Pop one char and output
— 罗曼·格拉夫
source
嗯...那将是一个有用的功能，现在不是吧……
— Conor O'Brien
甚至程序也很难过。😭=可悲
— A _
3

Brain-Flak，366350 + 3 = 353字节

在线尝试！

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

这将获得加号3，因为它要求该-A标志正常运行。

说明

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.

(((()()()()()){})<((((((((([][]()()()()))))))))<>)<>>)(((()()()){})(({}()()())(([{}(()()())](([{}()](<>({}()())<>)<>)<>)<>)<>))){<>({}<>)}{}
— 小麦巫师
source
您可以按一下前两行((((((((((((((((((((()()()()()){}){}){}()){})[()()()()])[([][][]){}])[][][])[]()())[[][][]])[][])()()()())<([]()())>[()()]))))))))，我认为这样可以为您节省16个字节。这根本不使用备用堆栈，因此它可能更短。
— DJMcMayhem
3

Python 3.5，56个字节

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

它使用zawata的想法将每行编码为(r*8)[:8]，字符串重复8次并修剪成一定长度8。小兵和空行只是'p'*8，'.'*8和'P'*8，没有修剪。第一行使用'rnbqkbn'，('rnbqkbn'*8)[:8]在相乘和修剪后在右侧包括另一个rook。最后一行是相同的，但大写。

我们['rnbqkbn','p','.','.','.','.','P','RNBQKBN']使用Python 3.5的广义拆包来紧凑地表示行部分的列表。我们写出第一个和最后一个条目，其余的单个字符从字符串中解包。

在Python 2中，我们可以split代替60个字节：

for i in'rnbqkbn p . . . . P RNBQKBN'.split():print(i*8)[:8]
— 异或
source
3

Python 3，82 80 75字节

这不是python中最短的答案，但这是我的第一个答案，我认为这是第一次

print('\n'.join((i*8)[:8]for i in'rnbqkbn p . . . . P RNBQKBN'.split()))
— 扎瓦塔
source
1
欢迎光临本站！如果删除一些多余的空格，则可以减少两个字节。EG[:8]for i in['rnbqkbn'....
— DJMcMayhem
1
统一所有行并重新使用新手的好主意。您可以将列表缩写为'rnbqkbn p . . . . P RNBQKBN'.split()。
— xnor
@DJMcMayhem不知道那些不必要。谢谢！
— zawata
@xnor是个好主意！生病，必须将这种技巧添加到我的“武器库”中哈哈
— zawata
2

批次，105个字节

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

批处理非常冗长...

— 尼尔
source
2

R，75个字节

编辑：修复了一个愚蠢的错误，现在只需写出板的大写部分即可。 

cat("rnbqkbnr\npppppppp\n",rep("........\n",4),"PPPPPPPP\nRNBQKBNR",sep="")
— 比利沃伯
source
1
黑色零件在这种情况下会出错：棋子应该在其他零件的前面。
— JDL
@JDL您当然是正确的，谢谢。最后一秒更改时的愚蠢错误。
— Billywob '16
— Giuseppe
2

J，55 52字节

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

测试和中间步骤

   '.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
— 科纳·奥布莱恩
source
2

Python 3，64个字节

根据我对Python 2的DLosc回答，我无法改进。

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

与使用“ \ n”相比，少1个字节

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

q，51个字节

"\n"sv flip{x,"p...P","c"$("i"$x)-32}each"rnbqkbnr"
— 波士顿沃克
source
您可以使用upper和each-right删除几个字节。同样，以下内容将打印到stdout而不是返回带有换行符的字符串：-1 flip"p...P"{y,x,upper y}/:"rnbqkbnr";。40个字节 不错的解决方案！
— streetster '17
2

GNU sed，54个字节

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

在线尝试！

说明：

首先打印黑色部分，以相反的顺序将两个相关的板级保存在保留空间中。通过将保留空间转换为大写字母来打印白色部分。

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)
— Seshoumara
source
2

Java 7，103 99 89字节

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

与@SLC的C＃回答方法相比，与硬编码输出相比，节省了10个字节。

在这里尝试。

输出：

rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR
— 凯文·克鲁伊森
source
那怎么办呢String f(){return"rnbqkbnr\npppppppp\n........\n........\n........\n........\nPPPPPPPP\nRNBQKBNR";}。这是100个字节。
— Numberknot
@Numberknot多么无聊..但是你说的对，它更短。顺便说一句，这是99个字节，而不是100。
— 凯文Cruijssen
2

C＃，85 84 83 74字节

编辑：偶然有太多行的空格！

编辑：由于@KevinCruijssen，多了一个额外的字符并修复了顺序（偶然将其全部颠倒了）

编辑：恢复到83 cos我的虾在错误的行上

编辑：感谢@adrianmp，他通过省略返回帮助我进一步缩小了它

使用与上述@adrianmp答案相同的格式：

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

使用以上功能的完整程序：

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));
        }
    }
}
— NibblyPig
source
嗨，欢迎来到PPCG！嗯，您的作品顺序似乎与OP之一不符。顺便说一句，您可以通过删除之间的空格来节省1个字节return "，因此变为：x=>{return"rnbqkbnr\npppppppp\nxxxxPPPPPPPP\nRNBQKBNR".Replace("x","........\n");};。好的答案，所以我+1。在这里过得愉快。:)
— Kevin Cruijssen '16
并感谢您的回答。我已经移植了相同的方法来我的Java 7的答案（当然你计入），由10降低字节数:)
— 凯文Cruijssen
我进一步改进了它
— NibblyPig '16
我刚刚意识到那是不对的
— NibblyPig
1
不错的方法！您实际上可以将其减少到74个字节：x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n");
— adrianmp
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.