Narysuj szachownicę ASCII!


42

Oto proste wyzwanie: musisz stworzyć tę reprezentację szachownicy w ASCII. Biały jest reprezentowany wielkimi literami, a czarny małą. Puste kafelki są reprezentowane przez .. Oto pełne wyżywienie:

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

Ponieważ jest to , nie możesz przyjmować żadnych danych wejściowych i musisz tę tablicę dowolną domyślną metodą, na przykład zapisując plik, drukując do STDOUT lub powracając z funkcji. Państwo może ewentualnie produkować jeden kończący znak nowej linii. Obowiązują standardowe luki, a najkrótszy program w bajtach!

Pamiętaj jednak, że jest to tak samo konkurencja między zgłoszeniami w tym samym języku. Chociaż jest mało prawdopodobne, aby języki takie jak Java mogły pokonać język taki jak Perl lub język golfowy, taki jak Pyth lub Cjam, posiadanie najkrótszej odpowiedzi w języku Java jest nadal imponujące! Aby pomóc Ci śledzić najkrótszą odpowiedź w każdym języku, możesz użyć tej tabeli wyników, która pokaże najkrótsze przesłanie według języka i ogólnie.

Liderów

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik jest sumą dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie tabeli wyników:

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


1
Z pewnością ASCII artszachownica miałaby kropkę na każdym kwadracie?
— Shaun Bebbers

Odpowiedzi:


16

Galaretka , 25 24 bajtów

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

Wypróbuj online!

Dzięki @Lynn za grę w golfa na 1 bajcie!

Jak to działa

“.“.“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 bajtów

irnbqkbnr<Esc>Y6p5Vr.VrpYGPgUj

Opiera się na świeżym Vimie, w przeciwnym razie 5Vmoże wybrać niewłaściwy obszar.

  • irnbqkbnr<Esc>: Napisz górny wiersz. Wystarczająco łatwe.
  • Y6p: Zrób resztę wierszy, z wyjątkiem jednego . Oczywiście wszystkie oprócz górnego i dolnego wiersza zawierają nieprawidłowe znaki.
  • 5Vr.: Jeśli nie korzystałeś jeszcze z trybu wizualnego w sesji, możesz zrobić takie rzeczy, aby wybrać 5 linii. Jeśli od razu wpiszesz to samo, spróbuje wybrać 25 linii. Vim jest taki dziwny.
  • Vrp: Jesteśmy już na linii 2, więc stwórzmy linię pionków.
  • YGP: Skopiuj linię pionków na swoje miejsce na dole. Właśnie dlatego użyłem 6pzamiast 7pwcześniej.
  • gUj: Kapitalizuj białe elementy.

1
Najlepszy język golfowy!
— przestał się obracać przeciwnie do zegara

10

Brainfuck , 224 bajty

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

Zajęło to prawie godzinę, aby to zdobyć.


8

Python 2, 63 bajty

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

Niestety, dość proste podejście było znacznie krótsze niż „sprytne” rzeczy, które próbowałem na początku ...

Dodatkowa odpowiedź, również 63 bajty:

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

8

05AB1E , 24 bajty

Wykorzystuje kodowanie CP-1252 .

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

Wypróbuj online!

Wyjaśnienie

"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
Myślę, że to pierwszy raz, kiedy grałem w golfa odpowiedź, nie patrząc i dopasowując cię do 100% użytych postaci. Muszę się zgodzić, że to jest tak dobre, jak to robi haha.
— Magic Octopus Urn

7

Właściwie 26 bajtów

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

Wypróbuj online!

Wyjaśnienie:

'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 bajtów

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

Korzysta z nowej =>funkcji.

Wyjaśnienie

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
Więc odpowiedziałeś na pytanie o „szachy” w „ches”?
— DJMcMayhem

4
@DJMcMayhem .................. czy właśnie .....
— Downgoat 10.10.16

1
mm, to jest piękny ser. miłe nadużycie domyślnych parametrów
— Conor O'Brien

6

Pyke, 28 27 26 bajtów

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

Wypróbuj tutaj!

Nauczyłem się dzisiaj czegoś nowego o moim języku: 1cmożna go wykorzystać jako 2-znakowy sposób dzielenia łańcucha znaków na listę znaków.

"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 bajtów

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

Wypróbuj online!

Wyjaśnienie

'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

1 bajt zapisany dzięki tuxcrafting.

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

To jest 45

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

Próbowanie czegoś mądrzejszego wydaje się po prostu wydłużyć.


Usuń spację przed ciągiem poputs
— TuxCrafting 10.10.16

5

JavaScript (ES6), 69 65 bajtów

Zaoszczędzono 4 bajty dzięki edc65

let f =

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

console.log(f());


1
Bardzo mądry! Może zbyt sprytny, mógłby zaoszczędzić 4 bajty 'rnbqkbnrnp....PRNBQKBNR'.replace(/p|\./ig,c=>c.repeat(8)+'\n')(zmiana \nna dosłowny nowy wiersz)
— edc65 10.10.16

5

C #, 94 92 bajty

Edycja: Dzięki mleku za zaoszczędzenie 1 bajtu poprzez zmianę kolejności ciągów w celu usunięcia białych znaków powrotu.

Edycja: Zapisano jeszcze 1 bajt, dodając parametr zastępczy ( x zamiast () ) dla funkcji anonimowej i wywołując go z dowolnym obiektem.

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

Pełny program korzystający z powyższej funkcji:

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 # jest bardzo pełnym językiem ...


C # pełny program, 131 bajtów

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

Nie golfowany:

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 # jest bardzo pełnym językiem ...”. Nie próbowałeś wtedy VB.NET ...;)
— TyCobb 10.10.16

2
Możesz zapisać bajt, definiując ai bjako wielkie litery, możesz pozbyć się miejsca po return:return(a+b).ToLower()+...
— mleku

@TyCobb Już dawno próbowałem VB.NET. Nie wiedziałem wtedy o
— grze w

czy możesz użyć varzamiast string?
— NibblyPig,

@SLC Przez jakiś czas nie programowałem w C #, więc poprawcie mnie, jeśli się mylę, ale nie sądzę, że można użyć varwielu deklaracji w jednym wierszu. Tak string a="rnbqkbnr\n",b="pppppppp\n",c="........\n";by się stało var a="rnbqkbnr\n";var b="pppppppp\n";var c="........\n";, co zwiększa liczbę bajtów. EDYCJA: Wystąpiłby błąd „ Niejawnie wpisana lokalna deklaracja zmiennej nie może zawierać wielu deklaratorów ” .
— Kevin Cruijssen

4

Python 2, 68 bajtów

Publikowanie mimo to, chociaż powyższa wersja Python 2 jest krótsza. Nie musiałby to być jeden linijka dla ilości bajtów, po prostu się nim bawił.

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

Ponieważ zjest używany tylko raz, kiedy możesz się go pozbyć i wygenerować kropki w wyciągu.
— Karl Napf

3

Haskell, 53 bajty

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

astosuje się w pierwszej linii, a do określenia długości łańcuchów wykonane z p, .i P(- » <$a). .


3

JavaScript (ES6), 73

.toUpperCase jest po prostu za długi

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


Myślę, że (r=c=>c[0].repeat(8)+\ n ,b=r. )=>oszczędza bajt.
— Neil,

@Neil Nie widzę oszczędności. Próbowałem przepisać kod, zwiększając czytelność (trochę), ale liczba bajtów pozostaje taka sama
— edc65 10.10.16

Ach, widzę, co zrobiłem tam źle, jakoś zgubiłem po drodze nową linię. Przepraszam za to.
— Neil,

3

PowerShell v2 +, 44 bajty

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

Ciągi pozostawione w potoku są domyślnie drukowane Write-Outputpodczas wykonywania programu. Łączymy to z domyślnym zachowaniem nowego wiersza dla tablicy, aby utworzyć cztery wiersze kropek z przecinkiem.

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

Gdzie są nowe linie na liniach punktów? „, („. ”* 8) * 4„ to ”, przypuszczam…
— RosLuP,

@RosLuP Operator przecinkowy ,tworzy tablicę (w tym przypadku tablicę ciągów). Domyślnie Write-Outputpo zakończeniu programu wstawia nowy wiersz między elementami pozostawionymi w potoku, w tym poszczególnymi elementami tablicy. Dlatego nadużywamy domyślnego zachowania wyjściowego, aby nie musieć pisać wyraźnych znaków nowej linii w kodzie.
— AdmBorkBork,

3

V , 27 , 26 bajtów

i¸P
RNBQKBNRäkgujddppÒ.4Ä

Wypróbuj online!

Zawiera niektóre niedrukowalne znaki, więc oto wersja do odczytu:

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

gdzie <esc>reprezentuje 0x1B. Wyjaśnienie:

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 bajtów

Niestety Emotinomicon nie ma funkcji duplikowania stosu. Przydałby się. Ale przynajmniej krótszy niż Java. :)

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

Wyjaśnienie:

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

Hmm ... to byłaby przydatna funkcja, teraz nie byłoby ...
— Conor O'Brien

Nawet program jest smutny. 😭 = Niestety
— A _

3

Brain-Flak , 366 350 + 3 = 353 bajtów

Wypróbuj online!

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

Otrzymuje plus 3, ponieważ wymaga -A poprawnego działania flagi.

Wyjaśnienie

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.

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

Możesz wcisnąć pierwsze dwa wiersze, dzięki ((((((((((((((((((((()()()()()){}){}){}()){})[()()()()])[([][][]){}])[][][])[]()())[[][][]])[][])()()()())<([]()())>[()()]))))))))którym zaoszczędzę 16 bajtów. To wcale nie używa alternatywnego stosu, więc prawdopodobnie może być jeszcze krótszy.
— DJMcMayhem

3

Python 3.5, 56 bajtów

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

Wykorzystuje to pomysł zawata, aby zakodować każdą linię jako (r*8)[:8], za pomocą łańcucha powtarzanego 8 razy i przycinanego na długość 8. Pionki i puste wiersze są po prostu 'p'*8, '.'*8i 'P'*8, bez przycinania. Pierwszy wiersz używa 'rnbqkbn', z('rnbqkbn'*8)[:8] tym kolejną wieżę po prawej stronie po pomnożeniu i przycięciu. Ostatni wiersz jest taki sam, ale pisany wielką literą.

Wyrażamy listę części wierszy w sposób kompaktowy ['rnbqkbn','p','.','.','.','.','P','RNBQKBN']za pomocą uogólnionego rozpakowywania w Pythonie 3.5 . Wypisujemy pierwsze i ostatnie wpisy, a pozostałe jednoznakowe są rozpakowywane z ciągu.

W Pythonie 2 splitzamiast tego moglibyśmy zadowolić się 60 bajtami:

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

3

Python 3, 82 80 75 bajtów

Nie jest to najkrótsza odpowiedź w pythonie, ale to moja pierwsza i myślę, że jest całkiem dobra po raz pierwszy

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

1
Witamy na stronie! Możesz usunąć dwa bajty, jeśli usuniesz dodatkowe spacje. Np.[:8]for i in['rnbqkbn'....
— DJMcMayhem

1
Fajny pomysł z unifikacją wszystkich linii i ponownym wykorzystaniem wież. Możesz napisać listę krótszą jako 'rnbqkbn p . . . . P RNBQKBN'.split().
— xnor

@DJMcMayhem nie wiedział, że nie są konieczne. dzięki!
— zawata

@ xnor to świetny pomysł! nie muszę dodawać tej sztuczki do mojego „arsenału” haha
— zawata

2

Partia, 105 bajtów

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

Partia jest poważnie pełna ...


2

R, 75 bajtów

Edycja: Naprawiono głupi błąd i po prostu wypisz teraz dużą część planszy.

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

1
Czarne pionki wychodzą źle, gdy stoi: pionki powinny znajdować się przed innymi kawałkami.
— JDL,

@JDL Oczywiście masz rację, dzięki. Głupi błąd podczas dokonywania ostatnich zmian.
— Billywob,



2

J, 55 52 bajtów

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

Kroki testowe i pośrednie

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

Oparty na odpowiedzi DLosc na Python 2, jak na mojej nie mogłem poprawić.

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

1 bajt mniej w porównaniu do używania „\ n” .join

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

2

q, 51 bajtów

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

Możesz ogolić kilka bajtów górną i każdą z prawej strony. Również następujące drukuje do stdout zamiast powrocie ciąg z nowymi liniami: -1 flip"p...P"{y,x,upper y}/:"rnbqkbnr";. 40 bajtów. Fajne rozwiązanie!
— streetster

2

GNU sed, 54 bajty

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

Wypróbuj online!

Wyjaśnienie:

Czarne elementy są drukowane jako pierwsze, co pozwala zaoszczędzić dwa powiązane szeregi planszy w odwrotnej kolejności w miejscu przechowywania. Białe elementy są drukowane przez konwersję miejsca wstrzymania na wielkie litery.

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 bajtów

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

10 bajtów zapisanych w porównaniu do wyjścia zakodowanego na stałe dzięki podejściu @SLC w jego odpowiedzi w języku C # .

Wypróbuj tutaj.

Wynik:

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

Co z tym. String f(){return"rnbqkbnr\npppppppp\n........\n........\n........\n........\nPPPPPPPP\nRNBQKBNR";}To jest 100 bajtów .
— Numberknot

@Numberknot Jak nudno .. ale masz rację, jest krótszy. Btw, to 99 bajtów, a nie 100.
— Kevin Cruijssen

2

C #, 85 84 83 74 bajty

Edycja: Przypadkowo miał za dużo rzędów pustych miejsc!

Edycja: Uwolniłem dodatkową postać i naprawiłem porządkowanie (przypadkowo cofnęło to wszystko) wiele dzięki @KevinCruijssen

Edycja: przywrócono do 83, ponieważ miałem krewetki w niewłaściwym wierszu

Edycja: Dzięki @adrianmp, który pomógł mi jeszcze bardziej go zmniejszyć, pomijając return

Używając tego samego formatu, co odpowiedź @adrianmp powyżej:

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

Pełny program korzystający z powyższej funkcji:

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

Cześć, witamy w PPCG! Hmm, kolejność twoich kawałków wydaje się niepoprawna z kolejnością OP. Btw, można zaoszczędzić 1 bajt usuwając przestrzeń pomiędzy return ", więc staje się: x=>{return"rnbqkbnr\npppppppp\nxxxxPPPPPPPP\nRNBQKBNR".Replace("x","........\n");};. Dobra odpowiedź, więc daj +1 ode mnie. I miłego pobytu tutaj. :)
— Kevin Cruijssen

I dzięki za odpowiedź. Przesunąłem to samo podejście do mojej odpowiedzi Java 7 (oczywiście, dziękuję) , zmniejszając liczbę bajtów o 10. :)
— Kevin Cruijssen

Udoskonaliłem go jeszcze bardziej
— NibblyPig,

Gah Właśnie zdałem sobie sprawę, że to nie w porządku
— NibblyPig

1
Niezłe podejście! Można go faktycznie zmniejszyć do 74 bajtów:x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n");
— adrianmp,
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.