Gambar papan catur ASCII!

42

Inilah tantangan sederhana untuk Anda: Anda harus membuat representasi papan catur ASCII ini. Putih diwakili oleh karakter huruf besar, dan hitam diwakili oleh huruf kecil. Ubin kosong diwakili oleh a .. Inilah papan lengkapnya:

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

Karena ini adalah pertanyaan kompleksitas-kolmogorov , Anda tidak boleh mengambil input apa pun dan Anda harus mengeluarkan board ini dengan metode default apa pun, misalnya, menyimpan file, mencetak ke STDOUT atau kembali dari suatu fungsi. Anda secara opsional dapat menghasilkan satu baris tambahan. Celah standar berlaku, dan program terpendek dalam byte!

Namun, ingat ini sama banyaknya persaingan antara pengiriman dalam bahasa yang sama. Meskipun tidak mungkin bahwa bahasa seperti Jawa bisa mengalahkan bahasa seperti perl, atau bahasa golf seperti pyth atau cjam, memiliki jawaban Java terpendek masih sangat mengesankan! Untuk membantu Anda melacak jawaban terpendek dalam setiap bahasa, Anda dapat menggunakan papan peringkat ini, yang akan menunjukkan pengajuan terpendek berdasarkan bahasa dan keseluruhan.

Papan peringkat

Untuk memastikan bahwa jawaban Anda muncul, silakan mulai jawaban Anda dengan tajuk utama, menggunakan templat Penurunan harga berikut:

# Language Name, N bytes

di mana Nukuran kiriman Anda. Jika Anda meningkatkan skor Anda, Anda bisa menyimpan skor lama di headline, dengan mencoretnya. Contohnya:

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

Jika Anda ingin memasukkan beberapa angka dalam tajuk Anda (mis. Karena skor Anda adalah jumlah dari dua file atau Anda ingin membuat daftar hukuman penterjemah secara terpisah), pastikan bahwa skor sebenarnya adalah angka terakhir di tajuk:

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

Anda juga dapat membuat tautan nama bahasa yang kemudian akan muncul di cuplikan papan peringkat:

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

Tampilkan cuplikan kode

code-golf  ascii-art  kolmogorov-complexity 
— DJMcMayhem
sumber
1
Tentunya sebuah ASCII artpapan catur akan memiliki perhentian penuh setiap kotak lainnya?
— Shaun Bebbers

Jawaban:

16

Jelly , 25 24 byte

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

Cobalah online!

Terima kasih kepada @Lynn karena bermain golf dengan 1 byte!

Bagaimana itu bekerja

“.“.“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.
— Dennis
sumber
15

Vim, 26 byte

irnbqkbnr<Esc>Y6p5Vr.VrpYGPgUj

Bergantung pada Vim baru, atau 5Vmungkin memilih area yang salah.

  • irnbqkbnr<Esc>: Tulis baris paling atas. Cukup mudah.
  • Y6p: Buat sisa baris, kecuali satu . Tentu saja semua kecuali baris atas dan bawah mengandung karakter yang salah.
  • 5Vr.: Ketika Anda belum menggunakan mode visual dalam sesi ini, Anda dapat melakukan hal-hal seperti ini untuk memilih 5 baris. Jika Anda mengetik hal yang sama segera, itu akan mencoba untuk memilih 25 baris. Vim aneh seperti itu.
  • Vrp: Kami sudah ada di saluran 2, jadi mari kita membuat garis gadai.
  • YGP: Salin garis gadai ke tempatnya di bagian bawah. Inilah mengapa saya menggunakan 6pdaripada 7psebelumnya.
  • gUj: Memanfaatkan potongan putih.
— udioica
sumber
1
Bahasa golf terbaik!
— lagi mengaktifkan counterclock dengan tanggal
10

Brainfuck , 224 byte

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

Butuh hampir satu jam untuk mendapatkan ini.

— Hunter VL
sumber
8

Python 2, 63 byte

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

Sayangnya, pendekatan yang cukup sederhana jauh lebih pendek daripada hal-hal "pintar" yang saya coba pada awalnya ...

Jawaban bonus, juga 63 byte:

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

05AB1E , 24 byte

Menggunakan pengodean CP-1252 .

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

Cobalah online!

Penjelasan

"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
— Emigna
sumber
1
Saya pikir ini adalah pertama kalinya saya mendapatkan jawaban tanpa melihat dan mencocokkan Anda dengan 100% karakter yang digunakan. Harus setuju ini sebagus mendapat haha.
— Magic Octopus Mm
7

Sebenarnya , 26 byte

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

Cobalah online!

Penjelasan:

'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
— Mego
sumber
6

Cheddar, 56 byte

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

Menggunakan =>fitur baru .

Penjelasan

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
— Downgoat
sumber
5
Jadi Anda menjawab pertanyaan tentang 'catur' di 'ches'?
— DJMcMayhem
4
@DJMcMayhem .................. apakah Anda baru saja .....
— Downgoat
1
mm ini keju yang indah. penyalahgunaan params default
— Conor O'Brien
6

Pyke, 28 27 26 byte

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

Coba di sini!

Saya belajar sesuatu yang baru tentang bahasa saya hari ini: 1cdapat digunakan sebagai cara 2 karakter untuk memecah string menjadi daftar karakter.

"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
— Biru
sumber
5

MATL , 26 byte

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

Cobalah online!

Penjelasan

'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
— Luis Mendo
sumber
5

Ruby, 45 44

1 byte disimpan berkat tuxcrafting.

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

Ini adalah 45

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

Mencoba sesuatu yang lebih pintar sepertinya membuatnya lebih lama.

— Level River St
sumber
Hapus spasi sebelum string setelahputs
— TuxCrafting
5

JavaScript (ES6), 69 65 byte

Disimpan 4 byte berkat edc65

let f =

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

console.log(f());
Luaskan cuplikan

— Arnauld
sumber
1
Sangat pintar! Mungkin terlalu pintar, bisa menghemat 4 byte dengan 'rnbqkbnrnp....PRNBQKBNR'.replace(/p|\./ig,c=>c.repeat(8)+'\n')(ubah \nke baris literal)
— edc65
5

C #, 94 92 byte

Sunting: Terima kasih untuk susu karena telah menghemat 1 byte dengan mengubah urutan string untuk menghapus spasi kosong kembali.

Sunting: Disimpan 1 byte lebih banyak dengan menambahkan parameter dummy ( x bukannya () ) untuk fungsi anonim dan memanggilnya dengan objek apa pun.

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

Program lengkap menggunakan fungsi di atas:

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 # adalah bahasa yang sangat verbose ...

Program penuh C #, 131 byte

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

Tidak Disatukan:

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());
    }
}
— adrianmp
sumber
2
"C # adalah bahasa yang sangat verbose ...". Anda belum mencoba VB.NET kalau begitu ...;)
— TyCobb
2
Anda dapat menghemat satu byte dengan mendefinisikan adan bsebagai huruf besar maka Anda dapat menghilangkan ruang setelah return:return(a+b).ToLower()+...
— susu
@ TyCobb Saya mencoba VB.NET beberapa waktu yang lalu. Saya tidak tahu tentang kode golf saat itu: P
— adrianmp
dapatkah Anda menggunakan varbukan string?
— NibblyPig
@ SCLC Saya belum diprogram dalam C # untuk sementara waktu, jadi perbaiki saya jika saya salah, tapi saya tidak berpikir Anda dapat menggunakan vardengan beberapa deklarasi pada satu baris. Jadi string a="rnbqkbnr\n",b="pppppppp\n",c="........\n";akan menjadi var a="rnbqkbnr\n";var b="pppppppp\n";var c="........\n";, yang meningkatkan jumlah byte. EDIT: Ini akan memberikan sebuah " Sebuah diketik implisit variabel deklarasi lokal tidak dapat menyertakan beberapa declarators " kesalahan .
— Kevin Cruijssen
4

Python 2, 68 byte

Tetap memposting walaupun versi Python 2 di atas lebih pendek. Itu tidak harus menjadi satu liner untuk jumlah byte, hanya bermain dengannya.

x,y,z="rnbqkbnr\n","p"*8+"\n","."*8+"\n";print x,y,4*z,(y+x).upper()
— DomPar
sumber
Karena zhanya digunakan sekali Anda dapat menyingkirkannya dan menghasilkan titik-titik dalam pernyataan cetak.
— Karl Napf
3

Haskell, 53 byte

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

adigunakan sebagai baris pertama dan untuk menentukan panjang string yang terbuat dari p, .dan P(-> <$a). .

— nimi
sumber
3

JavaScript (ES6), 73

.toUpperCase terlalu panjang

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

— edc65
sumber
Saya pikir (r=c=>c[0].repeat(8)+\ n ,b=r. )=>menghemat satu byte.
— Neil
@Neil Saya tidak melihat penghematan. Saya mencoba untuk menulis ulang kode meningkatkan readibility (sedikit), tetapi jumlah byte tetap sama
— edc65
Ah, saya melihat apa yang saya lakukan salah di sana, entah bagaimana saya kehilangan garis baru di sepanjang jalan. Maaf soal itu.
— Neil
3

PowerShell v2 +, 44 byte

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

String yang tersisa di pipeline dicetak secara implisit Write-Outputsaat eksekusi program. Kami menyamakan dengan perilaku baris baru default untuk array untuk menghasilkan empat baris periode dengan koma-operator.

PS C:\Tools\Scripts\golfing> .\draw-ascii-chess-board.ps1
rnbqknbr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKNBR
— AdmBorkBork
sumber
Di mana baris baru di garis titik? ", ('.' * 8) * 4" itu adalah ',' kurasa ...
— RosLuP
@RosLuP Operator-koma ,, menciptakan sebuah array (dalam hal ini, sebuah array string). Default Write-Outputpada penyelesaian program memasukkan baris baru antara elemen yang tersisa di pipa, termasuk elemen array individual. Jadi, kami menyalahgunakan perilaku keluaran default untuk tidak perlu menulis baris baru eksplisit dalam kode.
— AdmBorkBork
3

V , 27 , 26 byte

i¸P
RNBQKBNRäkgujddppÒ.4Ä

Cobalah online!

Ini berisi beberapa karakter yang tidak dapat dicetak, jadi ini adalah versi yang dapat dibaca:

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

di mana <esc>mewakili 0x1B. Penjelasan:

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
sumber
3

Emotinomicon, 89 byte

Sedihnya Emotinomicon tidak memiliki fungsi tumpukan duplikat. Akan bermanfaat. Namun setidaknya lebih pendek dari Jawa. :)

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

Penjelasan:

😭(...)😲⏪⏬⏩
😭(...)😲            String literal
         ⏪  ⏩      Loop
           ⏬        Pop one char and output
— Roman Gräf
sumber
Hmm ... itu akan menjadi fungsi yang berguna, sekarang kan ...
— Conor O'Brien
Bahkan programnya sedih. 😭 = Sedih
— A _
3

Brain-Flak , 366 350 + 3 = 353 byte

Cobalah online!

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

Ini mendapat plus 3 karena membutuhkan -Abendera untuk berjalan dengan baik.

Penjelasan

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.

(((()()()()()){})<((((((((([][]()()()()))))))))<>)<>>)(((()()()){})(({}()()())(([{}(()()())](([{}()](<>({}()())<>)<>)<>)<>)<>))){<>({}<>)}{}
— Wisaya Gandum
sumber
Anda dapat menekan dua baris pertama ((((((((((((((((((((()()()()()){}){}){}()){})[()()()()])[([][][]){}])[][][])[]()())[[][][]])[][])()()()())<([]()())>[()()]))))))))yang saya pikir akan menghemat 16 byte. Ini tidak menggunakan tumpukan alternatif sama sekali, jadi mungkin bisa lebih pendek.
— DJMcMayhem
3

Python 3.5, 56 byte

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

Ini menggunakan ide oleh zawata untuk mengkodekan setiap baris (r*8)[:8], dengan string yang diulang 8 kali dan dipangkas menjadi panjang 8. Pion dan baris kosong hanya 'p'*8, '.'*8dan 'P'*8, tanpa pemangkasan. Baris pertama menggunakan 'rnbqkbn', dengan ('rnbqkbn'*8)[:8]memasukkan benteng lain di sebelah kanan saat dikalikan dan dipangkas. Baris terakhir adalah sama tetapi ditulis dengan huruf besar.

Kami mengungkapkan daftar bagian-baris dengan ringkas ['rnbqkbn','p','.','.','.','.','P','RNBQKBN']menggunakan pembongkaran umum Python 3.5 . Kami menulis entri pertama dan terakhir, dan yang satu karakter yang tersisa diurai dari sebuah string.

Dalam Python 2, kita bisa splitmenerima 60 byte:

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

Python 3, 82 80 75 Bytes

Bukan jawaban terpendek dalam python tetapi ini adalah yang pertama dan saya pikir itu cukup bagus untuk pertama kalinya

print('\n'.join((i*8)[:8]for i in'rnbqkbn p . . . . P RNBQKBN'.split()))
— zawata
sumber
1
Selamat datang di situs ini! Anda bisa melepas dua byte jika Anda menghapus beberapa ruang ekstra. Misalnya[:8]for i in['rnbqkbn'....
— DJMcMayhem
1
Ide bagus dengan menyatukan semua lini dan menggunakan kembali benteng. Anda dapat menulis daftar lebih pendek sebagai 'rnbqkbn p . . . . P RNBQKBN'.split().
— xnor
@DJMcMayhem tidak tahu itu tidak perlu. Terima kasih!
— zawata
@ xnor itu ide bagus! Aku harus menambahkan trik itu ke "gudang" haha
— zawata
2

Batch, 105 byte

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

Batch benar-benar bertele-tele ...

— Neil
sumber
2

R, 75 byte

Sunting: Memperbaiki kesalahan konyol dan cukup menuliskan bagian huruf besar dari papan sekarang. 

cat("rnbqkbnr\npppppppp\n",rep("........\n",4),"PPPPPPPP\nRNBQKBNR",sep="")
— Billywob
sumber
1
Potongan hitam keluar salah karena berdiri: pion harus di depan potongan lainnya.
— JDL
@JDL Anda tentu saja benar, terima kasih. Kesalahan konyol ketika melakukan perubahan detik terakhir.
— Billywob
— Giuseppe
2

Powershell, 82 73 byte

$x=("rnbqkbnr",$("p"*8),$("."*8),$("."*8));$x+$x[3..0].ToUpper()-join"`n"
— Chris J
sumber
— Veskah
@ Veska - bagaimana cara kerjanya? Saya belum pernah melihat *perhal itu sebelumnya, dan google tidak memberi saya petunjuk. Punya penjelasan?
— Chris J
Periksa di sini untuk luncuran lengkap tetapi |% dapat memanggil properti / metode (dengan wildcard dalam nama) pada apa yang diberikan
— Veskah
2

J, 55 52 byte

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

Tes dan langkah menengah

   '.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
— Conor O'Brien
sumber
2

Python 3, 64 byte

Didasarkan jawaban DLosc ke Python 2 seperti pada saya, saya tidak bisa memperbaiki.

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

1 byte lebih sedikit dibandingkan dengan menggunakan "\ n" .gabung

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

q, 51 byte

"\n"sv flip{x,"p...P","c"$("i"$x)-32}each"rnbqkbnr"
— Boston Walker
sumber
Anda dapat memangkas beberapa byte dengan bagian atas, dan kanan. Juga cetak berikut untuk stdout daripada kembali string dengan baris baru: -1 flip"p...P"{y,x,upper y}/:"rnbqkbnr";. 40 byte Solusi yang bagus!
— streetster
2

GNU sed, 54 byte

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

Cobalah online!

Penjelasan:

Potongan hitam dicetak terlebih dahulu, menyimpan dua peringkat papan terkait dalam urutan terbalik di ruang penahanan. Potongan putih dicetak dengan mengubah ruang penahanan menjadi huruf besar.

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
sumber
2

Java 7, 103 99 89 byte

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

10 byte disimpan dibandingkan dengan keluaran hardcod berkat pendekatan @SLC dalam jawaban C # nya .

Coba di sini.

Keluaran:

rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR
— Kevin Cruijssen
sumber
Bagaimana dengan ini String f(){return"rnbqkbnr\npppppppp\n........\n........\n........\n........\nPPPPPPPP\nRNBQKBNR";}. Ini adalah 100 byte .
— Numberknot
@Numberknot Betapa membosankan .. tapi Anda benar, itu lebih pendek. Btw, ini 99 byte, bukan 100.
— Kevin Cruijssen
2

C #, 85 84 83 74 byte

Sunting: Secara tidak sengaja memiliki terlalu banyak baris ruang kosong!

Sunting: Membebaskan karakter tambahan dan memperbaiki pemesanan (secara tidak sengaja semuanya terbalik) terima kasih banyak kepada @KevinCruijssen

Sunting: Dikembalikan ke 83 karena saya memiliki udang di jalur yang salah

Sunting: Terima kasih kepada @adrianmp yang membantu saya mengecilkannya lebih jauh dengan menghilangkan return

Menggunakan format yang sama dengan jawaban @adrianmp di atas:

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

Program lengkap menggunakan fungsi di atas:

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
sumber
Hai, selamat datang di PPCG! Hmm, urutan potongan Anda tampaknya salah dengan OP. Btw, Anda dapat menyimpan 1 byte dengan menghapus ruang antara return ", sehingga menjadi: x=>{return"rnbqkbnr\npppppppp\nxxxxPPPPPPPP\nRNBQKBNR".Replace("x","........\n");};. Jawaban yang bagus, jadi +1 dari saya. Dan nikmati masa tinggal Anda di sini. :)
— Kevin Cruijssen
Dan terima kasih atas jawaban Anda. Saya telah mem-porting pendekatan yang sama dengan jawaban Java 7 saya (tentu saja mengkredit Anda) , menurunkan byte-count dengan 10. :)
— Kevin Cruijssen
Saya telah memperbaikinya lebih lanjut
— NibblyPig
Gah, aku baru sadar itu tidak benar
— NibblyPig
1
Pendekatan yang bagus! Anda sebenarnya dapat menguranginya menjadi 74 byte:x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n");
— adrianmp
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.