วาดกระดานหมากรุก ASCII!


42

นี่คือความท้าทายที่ง่ายสำหรับคุณ: คุณต้องสร้าง ASCII ที่เป็นตัวแทนของกระดานหมากรุก สีขาวแสดงด้วยอักขระตัวพิมพ์ใหญ่และสีดำแสดงด้วยตัวพิมพ์เล็ก .กระเบื้องที่ว่างเปล่าจะถูกแทนด้วย นี่คือคณะกรรมการเต็มรูปแบบ:

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

เนื่องจากนี่เป็นคำถามที่คุณอาจไม่ต้องป้อนข้อมูลใด ๆ และคุณต้องแสดงผลบอร์ดนี้ด้วยวิธีการเริ่มต้นเช่นบันทึกไฟล์พิมพ์ไปยัง 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


1
แน่นอนว่าASCII artกระดานหมากรุกจะมีการหยุดเต็มทุกตารางอื่น ๆ ?
Shaun Bebbers

คำตอบ:


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.

15

เป็นกลุ่ม 26 ไบต์

irnbqkbnr<Esc>Y6p5Vr.VrpYGPgUj

อาศัยกลุ่มสดหรืออื่น ๆ5Vอาจเลือกพื้นที่ที่ไม่ถูกต้อง

  • irnbqkbnr<Esc>: เขียนแถวบนสุด ง่ายพอสมควร
  • Y6p: ให้ส่วนที่เหลือของแถวที่ยกเว้นหนึ่ง แน่นอนว่าทั้งหมดยกเว้นแถวบนและแถวล่างมีอักขระที่ไม่ถูกต้อง
  • 5Vr.: เมื่อคุณยังไม่ได้ใช้โหมดภาพในเซสชันคุณสามารถทำสิ่งนี้เพื่อเลือก 5 บรรทัด หากคุณพิมพ์สิ่งเดียวกันอีกครั้งในทันทีมันจะพยายามเลือก 25 บรรทัด เป็นกลุ่มที่แปลกเช่นนั้น
  • Vrp: เราอยู่ในบรรทัดที่ 2 แล้วดังนั้นลองสร้างสายจำนำ
  • YGP: คัดลอกบรรทัดที่จำนำไว้ที่ด้านล่าง นี่คือเหตุผลที่ฉันใช้6pแทน7pก่อน
  • gUj: ใช้ชิ้นส่วนสีขาวให้เป็นประโยชน์

1
ภาษากอล์ฟที่ดีที่สุดมี!
หยุดที่จะเปิด

10

Brainfuck , 224 ไบต์

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

ใช้เวลาเกือบชั่วโมงเพื่อรับสิ่งนี้


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"])

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

1
ฉันคิดว่านี่เป็นครั้งแรกที่ฉันเคยเล่นกอล์ฟโดยไม่ได้ดูและจับคู่คุณกับตัวละครที่ใช้ 100% ต้องยอมรับว่ามันดีพอ ๆ กับที่จะได้รับฮ่าฮ่า
Magic Octopus Urn

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

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

5
คุณตอบคำถามเกี่ยวกับ 'หมากรุก' ใน 'ches' หรือไม่
DJMcMayhem

4
@DJMcMayhem .................. คุณเพิ่ง .....
Downgoat

1
นี่เป็นชีสที่สวยงาม การละเมิดที่ดีของ params เริ่มต้น
Conor O'Brien

6

Pyke, 28 27 26 bytes

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

ลองที่นี่!

ฉันได้เรียนรู้สิ่งใหม่เกี่ยวกับภาษาของฉันในวันนี้: 1cสามารถใช้เป็นวิธีการแยกอักขระสองตัวในรายการอักขระได้

"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


5

ทับทิม, 45 44

บันทึก 1 ไบต์ต้องขอบคุณการใช้งาน tuxcrafting

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

นี่คือ 45

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

ลองทำอะไรที่ฉลาดกว่านี้ดูจะทำให้มันนานขึ้น


ลบช่องว่างข้างหน้าสตริงหลังจากputs
TuxCrafting

5

JavaScript (ES6), 69 65 ไบต์

บันทึกแล้ว 4 ไบต์ด้วย edc65

let f =

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

console.log(f());


1
ฉลาดมาก! อาจจะฉลาดเกินไปที่จะบันทึก 4 ไบต์ด้วย'rnbqkbnrnp....PRNBQKBNR'.replace(/p|\./ig,c=>c.repeat(8)+'\n')(เปลี่ยน\nเป็นตัวอักษรขึ้นบรรทัดใหม่)
edc65

5

C #, 94 92 ไบต์

แก้ไข: ขอบคุณนมสำหรับการบันทึก 1 ไบต์โดยเปลี่ยนคำสั่งสตริงเพื่อลบช่องว่างส่งคืน

แก้ไข: บันทึกอีก 1 ไบต์โดยการเพิ่มพารามิเตอร์ดัมมี่ ( xแทน() ) สำหรับฟังก์ชั่นที่ไม่ระบุชื่อและเรียกมันด้วยวัตถุใด ๆ

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 # เป็นภาษา verbose มาก ...


โปรแกรม 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());}}

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

2
"C # เป็นภาษา verbose มาก ... " คุณไม่ได้ลอง VB.NET แล้ว ... ;)
TyCobb

2
คุณสามารถบันทึก byte โดยการกำหนดaและbเป็นตัวพิมพ์ใหญ่แล้วคุณสามารถกำจัดพื้นที่หลังจากreturn:return(a+b).ToLower()+...
นม

@TyCobb ฉันลอง VB.NET ค่อนข้างนานมาแล้ว ตอนนั้นฉันไม่รู้เกี่ยวกับการเล่นกอล์ฟรหัส: P
adrianmp

คุณสามารถใช้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";ซึ่งจะเพิ่มจำนวนไบต์ แก้ไข: มันจะให้เป็น " พิมพ์โดยปริยายประกาศตัวแปรท้องถิ่นไม่สามารถรวม declarators หลายข้อผิดพลาด"
Kevin Cruijssen

4

Python 2, 68 ไบต์

การโพสต์ต่อไปแม้ว่ารุ่น Python 2 ด้านบนจะสั้นกว่า มันจะไม่ต้องเป็นซับเดียวสำหรับจำนวนไบต์เพียงแค่เล่นกับมัน

x,y,z="rnbqkbnr\n","p"*8+"\n","."*8+"\n";print x,y,4*z,(y+x).upper()

เนื่องจากzมีการใช้งานเพียงครั้งเดียวคุณสามารถกำจัดมันและสร้างจุดในคำสั่งการพิมพ์
Karl Napf

3

Haskell, 53 ไบต์

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

aถูกนำมาใช้เป็นบรรทัดแรกและเพื่อกำหนดความยาวของสายทำจากp, .และP(-> <$a) .


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>


ผมคิดว่า(r=c=>c[0].repeat(8)+\ ,b=rn )=>ช่วยให้คุณประหยัดไบต์
Neil

@ ไม่มีฉันไม่เห็นการประหยัด ฉันพยายามเขียนโค้ดที่เพิ่มความสามารถในการอ่าน (เล็กน้อย) แต่จำนวนไบต์ยังคงเหมือนเดิม
edc65

อ่าฉันเห็นสิ่งที่ฉันทำผิดตรงนั้นฉันหายไปกับการขึ้นบรรทัดใหม่ ขอโทษสำหรับเรื่องนั้น.
Neil

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

บรรทัดใหม่ในบรรทัดของคะแนนอยู่ที่ไหน ", ('.' * 8) * 4" มันคือ ',' ฉันว่า ...
RosLuP

@RosLuP ตัวดำเนินการเครื่องหมายจุลภาค,สร้างอาร์เรย์ (ในกรณีนี้คืออาร์เรย์ของสตริง) ค่าเริ่มต้นWrite-Outputเมื่อโปรแกรมเสร็จสิ้นจะแทรกบรรทัดใหม่ระหว่างองค์ประกอบที่เหลืออยู่ในไปป์ไลน์รวมถึงองค์ประกอบอาร์เรย์แต่ละรายการ ดังนั้นเราจึงละเมิดพฤติกรรมการส่งออกเริ่มต้นที่ไม่จำเป็นต้องเขียนขึ้นบรรทัดใหม่ที่ชัดเจนในรหัส
AdmBorkBork

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

3

อิโมติโนมิก, 89 ไบต์

Sadly Emotinomicon ไม่มีอะไรที่เหมือนกับฟังก์ชันสแต็กที่ซ้ำกัน น่าจะมีประโยชน์ แต่อย่างน้อยก็สั้นกว่า Java :)

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

คำอธิบาย:

😭(...)😲⏪⏬⏩
😭(...)😲            String literal
         ⏪  ⏩      Loop
           ⏬        Pop one char and output

อืม ... ที่จะเป็นฟังก์ชันที่มีประโยชน์ตอนนี้จะไม่ได้ ...
Conor โอไบรอัน

แม้แต่โปรแกรมก็เศร้า 😭 = Sadly
A _

3

Brain-Flak , 366 350 + 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.

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

คุณสามารถกดสองบรรทัดแรก((((((((((((((((((((()()()()()){}){}){}()){})[()()()()])[([][][]){}])[][][])[]()())[[][][]])[][])()()()())<([]()())>[()()]))))))))ที่ฉันคิดว่าจะช่วยให้คุณประหยัดได้ 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]โกงอื่นทางด้านขวาเมื่อคูณและตัดแต่ง แถวสุดท้ายนั้นเหมือนกัน แต่พิมพ์ใหญ่

เราแสดงรายการแถวส่วนดาน['rnbqkbn','p','.','.','.','.','P','RNBQKBN']โดยใช้การเปิดออกหลาม 3.5 ของทั่วไป เราเขียนรายการแรกและรายการสุดท้ายและรายการอักขระเดี่ยวที่เหลือจะถูกคลายออกจากสตริง

ใน Python 2 เราสามารถชำระsplitแทน 60 ไบต์ได้:

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

3

Python 3, 82 80 75 ไบต์

ไม่ใช่คำตอบที่สั้นที่สุดในหลาม แต่มันเป็นครั้งแรกของฉันและฉันคิดว่ามันค่อนข้างดีเป็นครั้งแรก

print('\n'.join((i*8)[:8]for i in'rnbqkbn p . . . . P RNBQKBN'.split()))

1
ยินดีต้อนรับสู่เว็บไซต์! คุณสามารถนำสองไบต์ออกหากคุณลบช่องว่างเพิ่มเติม เช่น[:8]for i in['rnbqkbn'....
DJMcMayhem

1
ความคิดที่ดีด้วยการรวมบรรทัดทั้งหมดและนำ rooks กลับมาใช้ใหม่ 'rnbqkbn p . . . . P RNBQKBN'.split()คุณสามารถเขียนรายการสั้นลง
xnor

@DJMcMayhem ไม่ทราบว่าไม่จำเป็น ขอบคุณ!
zawata

@ xnor นั่นเป็นความคิดที่ดี! ป่วยต้องเพิ่มกลอุบายนั้นให้กับ "คลังแสง" ของฉัน haha
zawata

2

แบตช์ 105 ไบต์

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

รุ่นที่เป็น verbose อย่างจริงจัง ...


2

R, 75 ไบต์

แก้ไข: แก้ไขข้อผิดพลาดที่โง่และเพียงเขียนส่วนของตัวพิมพ์ใหญ่ของบอร์ดทันที

cat("rnbqkbnr\npppppppp\n",rep("........\n",4),"PPPPPPPP\nRNBQKBNR",sep="")

1
ชิ้นส่วนสีดำออกมาผิดปกติเนื่องจากย่อมาจาก: เบี้ยควรอยู่ด้านหน้าชิ้นส่วนอื่น ๆ
JDL

@JDL คุณถูกต้องแน่นอนขอบคุณ ความผิดพลาดโง่ ๆ เมื่อทำการเปลี่ยนแปลงครั้งที่สองครั้งสุดท้าย
Billywob


2

Powershell, 82 73 ไบต์

$x=("rnbqkbnr",$("p"*8),$("."*8),$("."*8));$x+$x[3..0].ToUpper()-join"`n"


@Veskah - มันทำงานอย่างไร ฉันไม่เคยเห็น*perสิ่งนี้มาก่อนและ Google ไม่ได้ให้คำแนะนำใด ๆ มีคำอธิบายไหม?
Chris J

ตรวจสอบที่นี่สำหรับการเขียนแบบเต็มแต่ |% สามารถเรียกคุณสมบัติ / วิธีการ (โดยใช้สัญลักษณ์แทนในชื่อ) ในสิ่งที่ได้รับ
Veskah

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

2

Python 3, 64 ไบต์

จากคำตอบของ DLosc ถึง Python 2 เหมือนของฉันฉันไม่สามารถปรับปรุงได้

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

1 ไบต์น้อยกว่าเมื่อเปรียบเทียบกับการใช้ "\ n" .join

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

2

q, 51 ไบต์

"\n"sv flip{x,"p...P","c"$("i"$x)-32}each"rnbqkbnr"

คุณสามารถโกนหนวดออกสองสามไบต์ด้วยด้านบนและด้านขวา นอกจากนี้ยังมีการพิมพ์ต่อไปนี้เพื่อ stdout -1 flip"p...P"{y,x,upper y}/:"rnbqkbnr";แทนที่จะกลับสตริงที่มีการขึ้นบรรทัดใหม่: 40 ไบต์ ทางออกที่ดีว่า!
ท้องถนน

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)

2

Java 7, 103 99 89 ไบต์

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

10 ไบต์ที่บันทึกไว้เมื่อเทียบกับ hardcoded ขอบคุณออกไป@SLCวิธี 's ในคำตอบ

ลองที่นี่

เอาท์พุท:

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

อะไรประมาณนี้String f(){return"rnbqkbnr\npppppppp\n........\n........\n........\n........\nPPPPPPPP\nRNBQKBNR";}นี้เป็น100 ไบต์
Numberknot

@ เลขที่น่าเบื่อ .. แต่คุณถูกต้องมันสั้นกว่า Btw มันคือ 99 ไบต์ไม่ใช่ 100
Kevin 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));
        }
    }
}

สวัสดียินดีต้อนรับสู่ PPCG! อืมลำดับของคุณดูเหมือนไม่ถูกต้องกับหนึ่งใน OP Btw คุณสามารถบันทึก 1 ไบต์โดยการลบช่องว่างระหว่างดังนั้นจึงกลายเป็น:return " x=>{return"rnbqkbnr\npppppppp\nxxxxPPPPPPPP\nRNBQKBNR".Replace("x","........\n");};คำตอบที่ดีดังนั้น +1 จากฉัน และสนุกกับการพักที่นี่ :)
Kevin Cruijssen

และขอบคุณสำหรับคำตอบของคุณ ผมเคยรังเพลิงวิธีการเดียวกันกับฉัน Java 7 คำตอบ (แน่นอนเลื่อมใสคุณ)ลดไบต์นับจาก 10 :)
เควิน Cruijssen

ฉันได้ปรับปรุงให้ดียิ่งขึ้นแล้ว
NibblyPig

Gah ฉันเพิ่งรู้ว่าไม่ถูกต้อง
NibblyPig

1
วิธีการที่ดี! คุณสามารถลดลงเหลือ 74 ไบต์:x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n");
adrianmp
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.