Bir ASCII satranç tahtası çizin!


42

İşte size basit bir zorluk: Bu satranç tahtasının ASCII temsilini oluşturmalısınız. Beyaz, büyük harflerle, siyah ise küçük harflerle gösterilir. Boş fayanslar a ile temsil edilir .. İşte tam pansiyon:

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

Bu bir , herhangi bir giriş yapamazsınız ve bu kartı herhangi bir varsayılan yöntemle (örneğin bir dosyayı kaydetmek, STDOUT'a yazdırmak veya bir işlevden geri dönmek) çıkarmanız gerekir. Bu olabilir , isteğe bağlı olarak bir arka yeni satır üretir. Standart boşluklar ve bayt cinsinden en kısa program geçerlidir!

Ancak, bunun aynı dilde yapılan gönderimler arasında bir rekabet kadar eşit olduğunu unutmayın. Java gibi dillerin perl gibi bir dili veya pyth veya cjam gibi bir golf dilini yenmesi pek mümkün olmasa da, en kısa Java cevabını almak hala çok etkileyici! Her dilde en kısa cevabı izlemenize yardımcı olmak için, dil ve genel olarak en kısa bildirimi gösterecek olan bu afişi kullanabilirsiniz.

Liderler

Cevabınızın göründüğünden emin olmak için, lütfen aşağıdaki Markdown şablonunu kullanarak cevabınızı bir başlık ile başlatın:

# Language Name, N bytes

Gönderinizin Nbüyüklüğü nerede ? Puanınızı artırmak varsa, olabilir onları içinden vurarak, başlığa eski hesapları tutmak. Örneğin:

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

Başlığınıza birden fazla sayı eklemek istiyorsanız (örneğin, puanınız iki dosyanın toplamı olduğundan veya tercüman bayrağı cezalarını ayrı ayrı listelemek istediğiniz için), gerçek puanın başlıktaki son sayı olduğundan emin olun :

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

Dil adını, daha sonra büyük afiş snippet'inde görünecek bir bağlantı da yapabilirsiniz:

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


1
Elbette bir ASCII artsatranç tahtası her karede tam durağı olurdu?
Shaun Bebbers

Yanıtlar:


16

Jöle , 25 24 bayt

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

Çevrimiçi deneyin!

1 byte kapalı golf için @Lynn teşekkürler!

Nasıl çalışır

“.“.“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

Vim, 26 bayt

irnbqkbnr<Esc>Y6p5Vr.VrpYGPgUj

Taze bir Vim'e güvenir veya 5Vyanlış bölgeyi seçebilir.

  • irnbqkbnr<Esc>: En üstteki satırı yazın. Yeterince kolay.
  • Y6p: Biri hariç diğer satırları da hazırlayın . Tabii ki, tümü üst ve alt satırlarda yanlış karakterler içeriyor.
  • 5Vr.: Henüz oturumda görsel modu kullanmadıysanız, 5 satır seçmek için bunun gibi şeyler yapabilirsiniz. Hemen aynı şeyi tekrar yazdıysanız, 25 satır seçmeye çalışır. Vim böyle garip.
  • Vrp: Şimdiden 2. satırdayız, öyleyse bir piyon çizgisi yapalım.
  • YGP: O piyon çizgisini alttaki yerine kopyalayın. Bu yüzden daha önce 6pyerine kullandım 7p.
  • gUj: Beyaz parçaları büyük harfle yaz.

1
En iyi golf dili var!
saat

10

Brainfuck , 224 bayt

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

Bunu almak için neredeyse bir saat sürdü.


8

Python 2,63 bayt

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

Ne yazık ki, oldukça basit bir yaklaşım ilk başta denediğim "akıllı" şeylerden çok daha kısaydı ...

Bonus cevabı, ayrıca 63 bayt:

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

8

05AB1E , 24 bayt

CP-1252 kodlamasını kullanır .

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

Çevrimiçi deneyin!

açıklama

"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
Sanırım bu, şimdiye kadar kullanılan karakterlerin% 100'üne bakmadan ve size eşleştirmeden bir cevabı aradığım ilk zamandı. Bunun haha ​​kadar iyi olduğuna katılıyorum.
Magic Octopus Urn

7

Aslında , 26 bayt

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

Çevrimiçi deneyin!

Açıklama:

'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

Çedar, 56 bayt

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

Yeni =>özelliği kullanır .

açıklama

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
Yani 'ches'de' satranç 'ile ilgili bir soruyu cevapladın mı?
DJMcMayhem

4
@DJMcMayhem .....................................
Downgoat

1
mm bu biraz güzel peynir. varsayılan params güzel istismar
Conor O'Brien,

6

Pyke, 28 27 26 bayt

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

Burada dene!

Bugün dilimle ilgili yeni bir şey öğrendim: 1ckarakter dizisine dize ayırmanın 2 karakterli bir yolu olarak kullanılabilir.

"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

MATL , 26 bayt

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

Çevrimiçi deneyin!

açıklama

'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

5

Ruby, 45 44

Smokinleme sayesinde 1 bayt kaydedildi.

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

Bu 45

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

Daha akıllıca bir şey denemek sadece daha uzun sürecek gibi görünüyor.


puts
İpin

5

JavaScript (ES6), 69 65 bayt

Edc65 sayesinde 4 byte kurtarıldı

let f =

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

console.log(f());


1
Çok zeki! Belki de çok zekice, 4 bayt ile 'rnbqkbnrnp....PRNBQKBNR'.replace(/p|\./ig,c=>c.repeat(8)+'\n')(değişmeyen \nbir yeni
satırda

5

C #, 94 92 bayt

Düzenleme: dönüş boşluğu kaldırmak için dize sırasını değiştirerek 1 bayt tasarruf için süt için teşekkürler .

Düzenleme: Anonim işlev için yapay bir parametre (( yerine x ) ) ekleyerek ve herhangi bir nesneyle çağırarak 1 bayt daha kaydedildi .

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

Yukarıdaki işlevi kullanarak tam program:

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 # çok ayrıntılı bir dildir ...


C # tam program, 131 bayt

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 # çok ayrıntılı bir dildir ...".
VB.NET'i

2
Tanımlayarak ave bbüyük harf olarak bir baytı koruyabilir ve sonra boşluktan kurtulabilirsiniz return:return(a+b).ToLower()+...
süt

@TyCobb VB.NET'i bir süre önce denedim. O zamanlar golf kodlarını bilmiyordum: P
adrianmp

varyerine kullanabilir misin string?
NibblyPig

@SLC Bir süredir C # programlamamıştım, bu yüzden hatalıysam beni düzelt, ancak vartek bir satırda birden fazla bildirimle kullanabileceğini sanmıyorum . Böylece , bayt sayısını artıran string a="rnbqkbnr\n",b="pppppppp\n",c="........\n";olur var a="rnbqkbnr\n";var b="pppppppp\n";var c="........\n";. EDIT: " Örtük şekilde yazılmış bir yerel değişken bildirimi birden fazla bildirici içeremez " hatası verirdi .
Kevin Cruijssen

4

Python 2,68 bayt

Yine de yukarıdaki Python 2 versiyonu daha kısa olmasına rağmen yayınlanıyor. Sadece onunla oynanan bayt miktarı için tek bir astar olmak zorunda kalmayacaktı.

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

Çünkü zyalnızca bir kez kullanıldığından ondan kurtulabilir ve print deyiminde noktaları oluşturabilirsiniz.
Karl Napf

3

Haskell, 53 bayt

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

abirinci hat olarak kullanılır ve yapılmış şeritlerinin uzunluğunu belirlemek için p, .ve P(-> <$a). .


3

JavaScript (ES6), 73

.toUpperCase sadece çok uzun

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


Bence (r=c=>c[0].repeat(8)+\ n ,b=r. )=>size bir bayt kazandırır.
Neil

@Neil Tasarruf göremiyorum.
Okunabilirliği

Ah, orada ne yanlış yaptığımı anladım, bir şekilde yol boyunca yeni bir hat kaybettim. Bunun için üzgünüm.
Neil

3

PowerShell v2 +, 44 bayt

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

Boru hattında bırakılan diziler dolaylı Write-Outputolarak program yürütülürken yazdırılır . Dizinin virgül operatörüyle birlikte dört satırlık satırlar üretmesini öntanımlı yeni satır davranışıyla birleştiririz.

PS C:\Tools\Scripts\golfing> .\draw-ascii-chess-board.ps1
rnbqknbr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKNBR

Noktalardaki yeni çizgiler nerede? ", ('.' * 8) * 4" sanırım ',' sanırım ...
RosLuP

@RosLuP Virgül operatörü ,bir dizi oluşturur (bu durumda bir dizi dizisi). Write-OutputProgram bitiminde varsayılan , ayrı dizi elemanları dahil olmak üzere boru hattında bırakılan elemanlar arasına yeni bir satır ekler. Bu nedenle, kodda açıkça yeni satırlar yazmanıza gerek kalmaması için varsayılan çıktı davranışını kötüye kullanıyoruz.
AdmBorkBork

3

V , 27 , 26 bayt

i¸P
RNBQKBNRäkgujddppÒ.4Ä

Çevrimiçi deneyin!

Bu, bazı yazdırılamayan karakterler içeriyor, bu yüzden okunabilir sürüm:

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

burada <esc>temsil eder 0x1B. Açıklama:

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

Emotinomicon, 89 bayt

Ne yazık ki Emotinomicon yinelenen bir yığın işlevi gibisi yoktur. Faydalı olur. Ama en azından Java'dan daha kısa. :)

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

Açıklama:

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

Hmm ... bu yararlı bir fonksiyon olur, şimdi olmazdı ...
Conor O'Brien

Program bile üzücü. 😭 = Ne yazık ki
A _

3

Brain-Flak , 366 350 + 3 = 353 bayt

Çevrimiçi deneyin!

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

Bu artı 3 alır çünkü gerektirir. -A bayrağın düzgün çalışması gerekir.

açıklama

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.

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

((((((((((((((((((((()()()()()){}){}){}()){})[()()()()])[([][][]){}])[][][])[]()())[[][][]])[][])()()()())<([]()())>[()()]))))))))Sizi 16 bayt kurtaracağını düşündüğüm ilk iki satırı itebilirsiniz . Bu alternatif yığını hiç kullanmaz, bu yüzden muhtemelen daha da kısa olabilir.
DJMcMayhem

3

Python 3.5, 56 bayt

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

Bu, her satırı , 8 kez tekrarlanan ve uzunluğa göre kesilmiş bir dize olarak kodlamak için zawata'nın kullandığı bir fikri kullanır . Piyonlar ve boş satırlar sadece vardır , ve hiçbir kırpma ile. İlk satır , çarpıldığında ve kırpıldığında sağda başka bir kale dahil olmak üzere kullanır . Son satır aynıdır ancak büyük harfle yazılır.(r*8)[:8]8'p'*8'.'*8'P'*8'rnbqkbn'('rnbqkbn'*8)[:8]

Python 3.5'in genel açma paketini ['rnbqkbn','p','.','.','.','.','P','RNBQKBN']kullanarak sıralı parça listesini kompakt bir şekilde ifade ediyoruz . İlk ve son girişleri yazıyoruz ve geri kalan tek karakterli olanlar dizgeden çıkarılıyor.

Python 2'de split60 bayt yerine razı olabiliriz :

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

3

Python 3, 82 80 75 Bayt

Python'daki en kısa cevap değil ama bu benim ilk ve bence ilk defa oldukça iyi

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

1
Siteye Hoşgeldiniz! Fazladan boşluk kaldırırsanız iki byte çıkarabilirsiniz. Eg[:8]for i in['rnbqkbn'....
DJMcMayhem

1
Tüm çizgileri birleştirmek ve kaleleri yeniden kullanmak güzel bir fikir. Listeyi daha kısa olarak yazabilirsiniz 'rnbqkbn p . . . . P RNBQKBN'.split().
xnor

@DJMcMayhem bunların gerekli olmadığını bilmiyordu. Teşekkürler!
Zawata

@ xnor bu harika bir fikir! Bu numarayı benim "cephanelik"
hahama

2

Toplu iş, 105 bayt

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

Toplu olarak ciddi bir şekilde ayrıntılı ...


2

R, 75 bayt

Düzenleme: Aptalca bir hata düzeltildi ve panonun büyük bölümünü şimdi yazmanız yeterli.

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

1
Siyah parçalar bu durumdan dolayı yanlış çıkıyor: piyonlar diğer parçaların önünde olmalı.
JDL

@JDL Elbette haklısınız, teşekkürler. Son saniye değişiklik yaparken aptalca hata.
Billywob


2

Powershell, 82 73 bayt

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


@Veskah - bu nasıl çalışır? Daha önce hiçbir *perşey görmedim ve bir google bana herhangi bir işaretçi vermiyor. Bir açıklama var mı?
Chris J,

Yazının tamamı için buraya bakın ancak |% verilenlere ilişkin özellikleri / yöntemleri (adındaki joker karakterlerle birlikte)
arayabilir

2

J, 55 52 bayt

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

Test ve ara adımlar

   '.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 bayt

Python 2'nin DLosc cevabına dayanarak benimki gibi geliştiremedim.

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

"\ N" .join kullanmaya kıyasla 1 bayt daha az

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

2

q, 51 bayt

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

Üstte ve sağda birkaç byte'ı tıraş edebilirsiniz. Ayrıca aşağıdaki baskılar yenisatırlar ile bir dize dönen yerine stdout'a: -1 flip"p...P"{y,x,upper y}/:"rnbqkbnr";. 40 bayt. Yine de güzel bir çözüm!
streetster

2

GNU sed, 54 bayt

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

Çevrimiçi deneyin!

Açıklama:

İlk önce siyah parçalar basılarak, ilişkili iki tahta sırasını tutma alanında ters sırayla kaydedebilirsiniz. Beyaz parçalar, tutma alanını büyük harflere dönüştürerek yazdırılır.

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 bayt

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

C # cevabındaki @SLC'nin yaklaşımı sayesinde, kodlanmış çıktıya kıyasla 10 bayt tasarruf etti .

Burada dene.

Çıktı:

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

Peki ya bu String f(){return"rnbqkbnr\npppppppp\n........\n........\n........\n........\nPPPPPPPP\nRNBQKBNR";}. Bu 100 bayttır .
Sayı

@Numberknot Ne kadar sıkıcı .. ama haklısın, daha kısa. BTW, 99 bayt, 100 değil.
Kevin Cruijssen

2

C #, 85 84 83 74 bayt

Düzenleme: Yanlışlıkla çok fazla boş satır sırası vardı!

Düzenleme: Fazladan bir karakter serbest bırakıldı ve sipariş düzeltildi (yanlışlıkla ters çevrildi), @KevinCruijssen sayesinde

Düzenleme: 83'e geri döndü, çünkü karidesleri yanlış yere çevirdim.

Düzenleme: @adrianmp sayesinde geri dönüşü engelleyerek daha da küçültmeme yardımcı oldu

Yukarıdaki @adrianmp cevabıyla aynı formatı kullanmak:

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

Yukarıdaki işlevi kullanarak tam program:

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

Merhaba, PPCG'ye hoş geldiniz! Hmm, OP'lerden birinin sırası yanlış görünüyor. Btw, sen arasında boşluk kaldırarak 1 byte kaydedebilirsiniz return ", bu nedenle olur: x=>{return"rnbqkbnr\npppppppp\nxxxxPPPPPPPP\nRNBQKBNR".Replace("x","........\n");};. Güzel cevap, benden +1. Ve burada kaldınız. :)
Kevin Cruijssen

Ve cevabınız için teşekkürler. Aynı yaklaşımı Java 7 cevabım için (elbette size kredilendirme) , bayt sayısını 10'a
düşürdüm

Daha da geliştirdim
NibblyPig 11:16

Gah, bunun doğru olmadığını farkettim
NibblyPig 11:16

1
Güzel yaklaşım! Aslında onu 74 bayta azaltabilirsiniz:x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n");
adrianmp 11:16
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.