Zeichne ein ASCII-Schachbrett!

42

Hier ist eine einfache Herausforderung für Sie: Sie müssen diese ASCII-Darstellung eines Schachbretts erstellen. Weiß wird durch Großbuchstaben und Schwarz durch Kleinbuchstaben dargestellt. Leere Kacheln werden durch a dargestellt .. Hier ist die Vollpension:

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

Da es sich um eine Frage der Kolmogorov-Komplexität handelt , dürfen Sie keine Eingaben vornehmen und müssen diese Karte nach einer Standardmethode ausgeben, z. B. Speichern einer Datei, Drucken in STDOUT oder Zurückkehren von einer Funktion. Optional können Sie eine nachgestellte Newline erstellen. Es gelten Standardlücken und das kürzeste Programm in Bytes!

Denken Sie jedoch daran, dass dies ebenso ein Wettbewerb zwischen Einreichungen in derselben Sprache ist. Während es unwahrscheinlich ist, dass eine Sprache wie Java eine Sprache wie Perl oder eine Golfsprache wie Pyth oder Cjam schlagen kann, ist es immer noch beeindruckend, die kürzeste Java-Antwort zu haben! Um die kürzeste Antwort in jeder Sprache zu ermitteln, können Sie diese Rangliste verwenden, in der die kürzeste Einsendung nach Sprache und Gesamtsprache angezeigt wird.

Bestenlisten

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Wenn Sie mehrere Nummern in Ihrem Header enthalten sein sollen (zB weil Ihre Punktzahl ist die Summe von zwei Dateien oder Sie wollen Liste Dolmetscher Flagge Strafen separat), stellen Sie sicher , dass die tatsächliche Punktzahl der ist letzte Nummer in der Kopfzeile:

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

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

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

Code-Snippet anzeigen

code-golf  ascii-art  kolmogorov-complexity 
— DJMcMayhem
quelle
1
Sicherlich hätte ein ASCII artSchachbrett auf jedem zweiten Platz den Punkt?
— Shaun Bebbers

Antworten:

16

Jelly , 25 24 Bytes

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

Probieren Sie es online!

Vielen Dank an @Lynn für das Golfen ab 1 Byte!

Wie es funktioniert

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

Vim, 26 Bytes

irnbqkbnr<Esc>Y6p5Vr.VrpYGPgUj

Verlässt sich auf einen neuen Vim oder 5Vwählt den falschen Bereich aus.

  • irnbqkbnr<Esc>: Schreiben Sie die oberste Zeile. Leicht genug.
  • Y6p: Machen Sie den Rest der Zeilen, mit einer Ausnahme . Natürlich enthalten alle außer der oberen und unteren Zeile die falschen Zeichen.
  • 5Vr.: Wenn Sie in der Sitzung den visuellen Modus noch nicht verwendet haben, können Sie wie folgt vorgehen, um 5 Zeilen auszuwählen. Wenn Sie das Gleiche sofort noch einmal eingeben, werden 25 Zeilen ausgewählt. Vim ist so komisch.
  • Vrp: Wir sind bereits in Zeile 2, machen wir also eine Bauernzeile.
  • YGP: Kopiere diese Pfandlinie in den unteren Bereich. Deshalb habe ich früher 6pverwendet 7p.
  • gUj: Großschreiben Sie die weißen Teile.
— udioica
quelle
1
Beste Golfsprache, die es gibt!
— hörte
10

Brainfuck , 224 Bytes

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

Es dauerte fast eine Stunde, um das zu bekommen.

— Hunter VL
quelle
8

Python 2, 63 Bytes

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

Leider war der ziemlich einfache Ansatz viel kürzer als das "clevere" Zeug, das ich zuerst ausprobiert habe ...

Bonusantwort, auch 63 Bytes:

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

05AB1E , 24 Byte

Verwendet die CP-1252- Codierung.

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

Probieren Sie es online!

Erläuterung

"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
quelle
1
Ich denke, dies ist das ERSTE Mal, dass ich jemals eine Antwort gespielt habe, ohne Sie anzusehen, und auf 100% der verwendeten Zeichen abgestimmt habe. Ich muss zustimmen, dass dies so gut ist, wie es nur geht, haha.
— Magic Octopus Urn
7

Eigentlich 26 Bytes

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

Probieren Sie es online!

Erläuterung:

'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
quelle
6

Cheddar, 56 Bytes

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

Verwendet die neue =>Funktion.

Erläuterung

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
quelle
5
Du hast also eine Frage zu 'chess' in 'ches' beantwortet?
— DJMcMayhem
4
@ DJMcMayhem .................. hast du gerade .....
— Downgoat
1
mm das ist ein schöner Käse. netter Missbrauch von Standardparams
— Conor O'Brien
6

Pyke, 28 27 26 Bytes

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

Probieren Sie es hier aus!

Ich habe heute etwas Neues über meine Sprache gelernt: 1cKann als 2-Zeichen-Methode zum Aufteilen einer Zeichenfolge in eine Liste von Zeichen verwendet werden.

"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
— Blau
quelle
5

MATL , 26 Bytes

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

Probieren Sie es online!

Erläuterung

'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
quelle
5

Rubin, 45 44

1 Byte gespart dank Tuxcrafting.

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

Das ist 45

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

Wenn man etwas Klügeres probiert, scheint es nur länger zu dauern.

— Level River St
quelle
Entfernen Sie das Leerzeichen vor dem String nach demputs
— TuxCrafting 10.10.16
5

JavaScript (ES6), 69 bis 65 Byte

4 Bytes gespart dank edc65

let f =

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

console.log(f());
Erweitern Sie das Snippet

— Arnauld
quelle
1
Sehr schlau! Vielleicht zu schlau, könnte 4 Bytes mit 'rnbqkbnrnp....PRNBQKBNR'.replace(/p|\./ig,c=>c.repeat(8)+'\n')(Änderung \nzu einer wörtlichen Newline)
— edc65
5

C #, 94 92 Bytes

Bearbeiten: Dank Milch für das Speichern von 1 Byte durch Ändern der Zeichenfolgenreihenfolge, um das zurückgegebene Leerzeichen zu entfernen.

Bearbeiten: 1 weiteres Byte wurde gespeichert, indem ein Dummy-Parameter ( x anstelle von () ) für die anonyme Funktion hinzugefügt und mit einem beliebigen Objekt aufgerufen wurde.

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

Volles Programm mit der obigen Funktion:

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 # ist eine sehr ausführliche Sprache ...

Volles C # -Programm, 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());
    }
}
— adrianmp
quelle
2
"C # ist eine sehr ausführliche Sprache ...". Du hast VB.NET damals noch nicht ausprobiert ...;)
— TyCobb
2
Sie können ein Byte speichern, indem Sie Folgendes definieren aund dann bals Großbuchstaben das Leerzeichen entfernen return:return(a+b).ToLower()+...
— melken Sie
@ TyCobb Ich habe VB.NET vor einiger Zeit ausprobiert. Ich wusste damals noch nichts über Code
— Golfing
kannst du varstatt verwenden string?
— NibblyPig
@SLC Ich habe eine Weile nicht in C # programmiert. Korrigieren Sie mich, wenn ich falsch liege, aber ich glaube nicht, dass Sie varmehrere Deklarationen in einer einzelnen Zeile verwenden können. So string a="rnbqkbnr\n",b="pppppppp\n",c="........\n";würde es werden var a="rnbqkbnr\n";var b="pppppppp\n";var c="........\n";, was die Byteanzahl erhöht. BEARBEITEN: Es würde ein Fehler " Eine implizit typisierte lokale Variablendeklaration kann nicht mehrere Deklaratoren enthalten " angezeigt .
— Kevin Cruijssen
4

Python 2, 68 Bytes

Poste trotzdem obwohl die obige Python 2 Version kürzer ist. Es müsste kein Einzeiler für die Anzahl der Bytes sein, nur damit gespielt.

x,y,z="rnbqkbnr\n","p"*8+"\n","."*8+"\n";print x,y,4*z,(y+x).upper()
— DomPar
quelle
Da zes nur einmal verwendet wird, können Sie es loswerden und die Punkte in der print-Anweisung erzeugen.
— Karl Napf
3

Haskell, 53 Bytes

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

awird als erste Linie verwendet , und die Länge der Zeichenkette aus , um zu bestimmen p, .und P(-> <$a). .

— nimi
quelle
3

JavaScript (ES6), 73

.toUpperCase ist einfach zu lang

_=>`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>
Erweitern Sie das Snippet

— edc65
quelle
Ich denke (r=c=>c[0].repeat(8)+\ n ,b=r. )=>Spart dir ein Byte.
— Neil
@Neil Ich sehe die Ersparnis nicht. Ich habe versucht, den Code neu zu schreiben, um die Lesbarkeit zu erhöhen (ein wenig), aber die Anzahl der Bytes bleibt gleich
— edc65
Ah, ich sehe, was ich dort falsch gemacht habe, irgendwie habe ich auf dem Weg eine neue Zeile verloren. Das tut mir leid.
— Neil
3

PowerShell v2 +, 44 Byte

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

In der Pipeline verbleibende Zeichenfolgen werden implizit mit gedruckt Write-Output bei der Programmausführung . Wir koppeln dies mit dem Standardverhalten für Zeilenumbrüche für ein Array, um die vier Zeilen mit dem Kommaoperator zu erzeugen.

PS C:\Tools\Scripts\golfing> .\draw-ascii-chess-board.ps1
rnbqknbr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKNBR
— AdmBorkBork
quelle
Wo sind die neuen Linien in den Punktelinien? ", ('.' * 8) * 4", nehme ich an ...
— RosLuP
@RosLuP Der Komma-Operator ,erstellt ein Array (in diesem Fall ein Array von Strings). Die Standardeinstellung Write-Outputbei Programmabschluss fügt eine neue Zeile zwischen Elementen ein, die in der Pipeline verbleiben, einschließlich einzelner Array-Elemente. Wir missbrauchen also das Standardausgabeverhalten, um keine expliziten Zeilenumbrüche im Code zu schreiben.
— AdmBorkBork
3

V , 27 , 26 Bytes

i¸P
RNBQKBNRäkgujddppÒ.4Ä

Probieren Sie es online!

Dies enthält einige nicht druckbare Zeichen. Hier ist die lesbare Version:

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

wo <esc>repräsentiert 0x1B. Erläuterung:

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

Emotinomicon, 89 Bytes

Leider hat Emotinomicon nichts Besseres als eine Duplikat-Stack-Funktion. Wäre nützlich. Aber zumindest kürzer als Java. :)

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

Erläuterung:

😭(...)😲⏪⏬⏩
😭(...)😲            String literal
         ⏪  ⏩      Loop
           ⏬        Pop one char and output
— Roman Gräf
quelle
Hmm ... das wäre eine nützliche Funktion, nicht wahr ...
— Conor O'Brien
Auch das Programm ist traurig. 😭 = Leider
— A _
3

Brain-Flak , 366 350 + 3 = 353 Bytes

Probieren Sie es online!

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

Dies ergibt ein Plus von 3, da das -AFlag ordnungsgemäß ausgeführt werden muss.

Erläuterung

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.

(((()()()()()){})<((((((((([][]()()()()))))))))<>)<>>)(((()()()){})(({}()()())(([{}(()()())](([{}()](<>({}()())<>)<>)<>)<>)<>))){<>({}<>)}{}
— Weizen-Assistent
quelle
Sie können die ersten beiden Zeilen, mit ((((((((((((((((((((()()()()()){}){}){}()){})[()()()()])[([][][]){}])[][][])[]()())[[][][]])[][])()()()())<([]()())>[()()]))))))))denen ich denke, Sie 16 Bytes sparen würde, drücken . Der alternative Stack wird hier überhaupt nicht verwendet, daher könnte er möglicherweise noch kürzer sein.
— DJMcMayhem
3

Python 3.5, 56 Bytes

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

Hierbei wird eine Idee von zawata verwendet , um jede Zeile wie folgt zu codieren: (r*8)[:8]Eine Zeichenfolge wird achtmal wiederholt und auf die Länge gekürzt8 . Die Bauern und leere Zeilen sind nur 'p'*8, '.'*8und 'P'*8, ohne Besatz. Die erste Reihe wird verwendet 'rnbqkbn', wobei ein ('rnbqkbn'*8)[:8]weiterer Turm rechts eingefügt wird, wenn er multipliziert und getrimmt wird. Die letzte Zeile ist die gleiche, aber groß geschrieben.

Wir drücken die Liste der Zeilenteile ['rnbqkbn','p','.','.','.','.','P','RNBQKBN']mithilfe des allgemeinen Entpackens von Python 3.5 kompakt aus . Wir schreiben den ersten und den letzten Eintrag aus, und die verbleibenden Einzelzeichen werden aus einer Zeichenfolge entpackt.

In Python 2 könnten wir uns splitstattdessen mit 60 Bytes begnügen:

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

Python 3, 82 80 75 Bytes

Nicht die kürzeste Antwort in Python, aber es ist meine erste und ich denke, es ist zum ersten Mal ziemlich gut

print('\n'.join((i*8)[:8]for i in'rnbqkbn p . . . . P RNBQKBN'.split()))
— zawata
quelle
1
Willkommen auf der Seite! Sie könnten zwei Bytes entfernen, wenn Sie einige zusätzliche Leerzeichen entfernen. ZB[:8]for i in['rnbqkbn'....
— DJMcMayhem
1
Gute Idee, alle Linien zu vereinheitlichen und die Türme wiederzuverwenden. Sie können die Liste kürzer schreiben als 'rnbqkbn p . . . . P RNBQKBN'.split().
— Xnor
@DJMcMayhem wusste nicht, dass diese nicht notwendig waren. Vielen Dank!
— Zawata
@ xnor das ist eine tolle Idee! Ich muss diesen Trick meinem "Arsenal" hinzufügen haha
— zawata
2

Batch, 105 Bytes

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

Batch ist ernsthaft ausführlich ...

— Neil
quelle
2

R, 75 Bytes

Bearbeiten: Ein dummer Fehler wurde behoben und der Großbuchstaben-Teil der Tafel wurde jetzt einfach ausgeschrieben. 

cat("rnbqkbnr\npppppppp\n",rep("........\n",4),"PPPPPPPP\nRNBQKBNR",sep="")
— Billywob
quelle
1
Die schwarzen Steine ​​fallen hier falsch aus: Die Bauern sollten vor den anderen Steinen liegen.
— JDL
@JDL Du hast natürlich recht, danke. Dummer Fehler beim Ändern der letzten Sekunde.
— Billywob
— Giuseppe
2

J, 55 52 Bytes

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

Test und Zwischenschritte

   '.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
quelle
2

Python 3, 64 Bytes

Basierend auf DLosc Antwort auf Python 2 konnte ich mich nicht verbessern.

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

1 Byte weniger im Vergleich zu "\ n" .join

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

q, 51 Bytes

"\n"sv flip{x,"p...P","c"$("i"$x)-32}each"rnbqkbnr"
— Boston Walker
quelle
Sie können ein paar Bytes mit Upper und Each-Right abschneiden. Auch die folgenden Drucke nach stdout anstatt einen String mit Zeilenumbrüchen Rückkehr: -1 flip"p...P"{y,x,upper y}/:"rnbqkbnr";. 40 Bytes. Gute Lösung!
— Streetster
2

GNU sed, 54 Bytes

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

Probieren Sie es online!

Erläuterung:

Die schwarzen Teile werden zuerst gedruckt, wobei die beiden zugeordneten Board-Ränge im Laderaum in umgekehrter Reihenfolge gespeichert werden. Die weißen Teile werden gedruckt, indem der Haltebereich in Großbuchstaben umgewandelt wird.

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

Java 7, 103 99 89 Bytes

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

10 Bytes gespart im Vergleich zur hardcodierten Ausgabe dank @SLCs Ansatz in seiner C # -Antwort wurden eingespart .

Probieren Sie es hier aus.

Ausgabe:

rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR
— Kevin Cruijssen
quelle
Was ist damit String f(){return"rnbqkbnr\npppppppp\n........\n........\n........\n........\nPPPPPPPP\nRNBQKBNR";}? Das sind 100 Bytes .
— Numberknot
@Numberknot Wie langweilig .. aber du hast recht, es ist kürzer. Übrigens, es ist 99 Bytes, nicht 100.
— Kevin Cruijssen
2

C #, 85 84 83 74 Bytes

Edit: Hatte versehentlich zu viele Zeilen Leerzeichen!

Bearbeiten: Befreie einen zusätzlichen Charakter und behebe die Reihenfolge (hatte versehentlich alles umgekehrt), vielen Dank an @KevinCruijssen

Edit: Zurückgesetzt auf 83, da ich die Garnelen in der falschen Zeile hatte

Edit: Danke an @adrianmp, der mir geholfen hat, es weiter zu verkleinern, indem er Return weggelassen hat

Verwenden Sie dasselbe Format wie bei der @ adrianmp-Antwort oben:

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

Volles Programm mit der obigen Funktion:

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
quelle
Hallo, willkommen bei PPCG! Hmm, die Reihenfolge deiner Teile scheint mit der von OP nicht zu stimmen. Btw, können Sie 1 Byte speichern , indem Sie den Raum zwischen Entfernung return ", so wird es: x=>{return"rnbqkbnr\npppppppp\nxxxxPPPPPPPP\nRNBQKBNR".Replace("x","........\n");};. Schöne Antwort, also +1 von mir. Und genießen Sie Ihren Aufenthalt hier. :)
— Kevin Cruijssen
Und danke für deine Antwort. Ich habe den gleichen Ansatz für meine Java 7-Antwort portiert (
— natürlich, danke
Ich habe es weiter verbessert
— NibblyPig
Gah, ich habe gerade gemerkt, dass das nicht richtig ist
— NibblyPig
1
Netter Ansatz! Sie können es tatsächlich auf 74 Bytes reduzieren:x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n");
— adrianmp
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.