Нарисуй ASCII шахматную доску!

42

Вот простая задача для вас: вы должны создать это ASCII представление шахматной доски. Белый цвет представлен заглавными буквами, а черный - строчными. Пустые плитки представлены как .. Вот полный пансион:

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

Поскольку это вопрос сложности по Колмогорову , вы не можете принимать какие-либо входные данные, и вы должны выводить эту плату любым методом по умолчанию, например, сохранением файла, печатью в STDOUT или возвратом из функции. При желании вы можете создать один завершающий перевод строки. Применяются стандартные лазейки и самая короткая программа в байтах!

Тем не менее, помните, что это в равной степени конкуренция между представлениями на одном языке. Хотя маловероятно, что такие языки, как Java, могут превзойти язык, подобный perl, или язык игры в гольф, такой как pyth или cjam, кратчайший ответ на Java по-прежнему впечатляет! Чтобы помочь вам найти самый короткий ответ на каждом языке, вы можете использовать этот список лидеров, который покажет самое короткое представление по языку и в целом.

Leaderboards

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

# Language Name, N bytes

где Nразмер вашего представления. Если вы улучшите свой счет, вы можете сохранить старые результаты в заголовке, вычеркнув их. Например:

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

Если вы хотите включить в заголовок несколько чисел (например, потому что ваш результат равен сумме двух файлов или вы хотите перечислить штрафы за флаг интерпретатора отдельно), убедитесь, что фактический результат является последним числом в заголовке:

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

Вы также можете сделать название языка ссылкой, которая затем будет отображаться во фрагменте списка лидеров:

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

Показать фрагмент кода

code-golf  ascii-art  kolmogorov-complexity 
— DJMcMayhem
источник
1
Конечно, у ASCII artшахматной доски была бы полная остановка каждый второй квадрат?
— Шон Бебберс

Ответы:

16

Желе , 25 24 байта

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

Попробуйте онлайн!

Спасибо @Lynn за вывод 1 байта!

Как это работает

“.“.“p“rnbqkbn”ṁ€8µṚ;ŒuY  Main link. No arguments.

“.“.“p“rnbqkbn”           Yield [".", ".", "p", "rnbqkbnr"].
               ṁ€8        Mold-each 8; reshape each string like the array
                          [1, 2, 3, 4, 5, 6, 7, 8], i.e., cyclically repeat its
                          contents to create strings of length 8.
                          This yields the upper half of the board in reversed
                          order, i.e., the string array
                          A := "........", "........", "pppppppp", "rnbqkbnr"].
                  µ       Begin a new, monadic chain. Argument: A
                   Ṛ      Reverse A.
                     Œu   Convert all characters in A to uppercase.
                    ;     Concatenate the results to both sides.
                       Y  Join the strings, separating by linefeeds.
— Деннис
источник
15

Vim, 26 байт

irnbqkbnr<Esc>Y6p5Vr.VrpYGPgUj

Полагается на свежий Vim, иначе 5Vможет выбрать не ту область.

  • irnbqkbnr<Esc>: Напишите верхний ряд. Достаточно просто.
  • Y6p: Сделать остальные строки, кроме одного . Конечно, все строки, кроме верхней и нижней, содержат неправильные символы.
  • 5Vr.: Когда вы еще не использовали визуальный режим в сеансе, вы можете сделать что-то вроде этого, чтобы выбрать 5 строк. Если вы сразу же наберете ту же самую вещь, она попытается выбрать 25 строк. Vim такой странный.
  • Vrp: Мы уже на второй линии, поэтому давайте сделаем пешку.
  • YGPСкопируйте эту пешечную линию на место внизу. Вот почему я использовал 6pвместо того, чтобы 7pраньше.
  • gUj: Заглавные буквы.
— udioica
источник
1
Лучший язык для гольфа!
— перестал поворачиваться против часовой стрелки с
10

Brainfuck , 224 байта

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

Потребовался почти час, чтобы получить это.

— Охотник В.Л.
источник
8

Python 2, 63 байта

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

К сожалению, довольно простой подход был намного короче, чем "умные" вещи, которые я попробовал сначала ...

Бонусный ответ, также 63 байта:

print"\n".join(["rnbqkbnr"]+[c*8for c in"p....P"]+["RNBQKBNR"])
— DLosc
источник
8

05AB1E , 24 байта

Использует кодировку CP-1252 .

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

Попробуйте онлайн!

объяснение

"rnbqkbnr"                # push the string "rnbqkbnr"
                          # STACK: "rnbqkbnr"
          'p8×            # push the char "p" repeated 8 times
                          # STACK: "rnbqkbnr", "pppppppp"
              '.8×        # push the char "." repeated 8 times
                          # STACK: "rnbqkbnr", "pppppppp", "........"
                  D       # duplicate
                          # STACK: "rnbqkbnr", "pppppppp", "........", "........"
                   )      # wrap in list
                          # STACK: ["rnbqkbnr", "pppppppp", "........", "........"]
                    Â     # push a reversed copy of the list
                          # STACK: ["rnbqkbnr", "pppppppp", "........", "........"], 
                                   ["........", "........", "pppppppp", "rnbqkbnr"]
                     u«   # convert to upper-case and concatenate
                          # STACK: ['rnbqkbnr', 'pppppppp', '........', '........', 
                                    '........', '........', 'PPPPPPPP', 'RNBQKBNR']
                       »  # join list by newline
— Emigna
источник
1
Я думаю, что это ПЕРВЫЙ раз, когда я когда-либо играл в гольф, не глядя и не подбирая вас к 100% использованных персонажей. Должен согласиться, это так же хорошо, как это получается, ха-ха.
— Волшебная урна осьминога
7

На самом деле , 26 байтов

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

Попробуйте онлайн!

Объяснение:

'p8*"rnbqkbnr"│û@û4'.8*n((
'p8*                        "p"*8 ["pppppppp"]
    "rnbqkbnr"              that string ["rnbqkbnr", "pppppppp"]
              │             duplicate stack ["rnbqkbnr", "pppppppp", "rnbqkbnr", "pppppppp"]
                û@û         uppercase the dupes ["RNBQKBNR", "PPPPPPPP", "rnbqkbnr", "pppppppp"]
               4   '.8*n    "."*8, 4 times ["RNBQKBNR", "PPPPPPPP", "........", "........", "........", "........", "rnbqkbnr", "pppppppp"]
                        ((  move the uppercase strings to the bottom of the stack, implicitly print
— Мего
источник
6

Чеддер, 56 байт

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

Использует новую =>функцию.

объяснение

a=                      // set a to the first half
  ['rnbqkbnr','p'*8] +  // First two rows
  ['.'*8]*2             // Next two dots
->(
   a +
   a.rev=>@.upper       // Reverse and map all items to uppercase
).vfuse                 // Join on newlines
— Downgoat
источник
5
Таким образом, вы ответили на вопрос о шахматах в ches?
— DJMcMayhem
4
@DJMcMayhem .................. ты только что .....
— Downgoat
1
мм это какой-то красивый сыр. хорошее злоупотребление параметрами по умолчанию
— Конор О'Брайен
6

Пайк, 28 27 26 байт

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

Попробуй это здесь!

Сегодня я узнал что-то новое о своем языке: 1cего можно использовать как способ разбиения строки на список символов, состоящий из двух символов.

"rnbqkbnr"i                - i = "rnbqkbnr"
                             stack = ["rnbqkbnr"])
           "P..p"1c        -  chunk("P..p", 1)
                             stack = ["rnbqkbnr", ["P", ".", ".", "p"]]
                   8m*     - map(8*>, ^)
                             stack = ["rnbqkbnr", ["PPPPPPPP", "........", "........", "pppppppp"]]
                      X    - splat(^)
                             stack = ["rnbqkbnr", "pppppppp", "........", "........", "PPPPPPPP"]
                       il3 - i.changecase()
                             stack = ["rnbqkbnr", "pppppppp", "........", "........", "PPPPPPPP", "RNBQKBNR"]
                           - implicit join with newlines

rnbqkbnr
pppppppp
........
........
PPPPPPPP
RNBQKBNR
— синий
источник
5

MATL , 26 байт

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

Попробуйте онлайн!

объяснение

'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

Руби, 45 44

1 байт сохранен благодаря tuxcrafting.

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

Это 45

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

Попытка сделать что-нибудь более умное, кажется, делает это дольше.

— Уровень реки St
источник
Уберите пробел перед строкой послеputs
— TuxCrafting
5

JavaScript (ES6), 69 65 байт

Сохранено 4 байта благодаря edc65

let f =

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

console.log(f());
Развернуть фрагмент

— Arnauld
источник
1
Очень умно! Может быть, слишком умный, мог бы сохранить 4 байта с 'rnbqkbnrnp....PRNBQKBNR'.replace(/p|\./ig,c=>c.repeat(8)+'\n')(изменить \nна буквальный
— перевод
5

C #, 94 92 байта

Изменить: Спасибо молоко за сохранение 1 байта путем изменения порядка строк, чтобы удалить возвращаемые пробелы.

Редактирование: сохранил еще 1 байт, добавив фиктивный параметр ( x вместо () ) для анонимной функции и вызвав его с любым объектом.

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

Полная программа с использованием вышеуказанной функции:

using System;

namespace DrawAnASCIIChessBoard
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<object,string>f= x=>{string a="RNBQKBNR\n",b="PPPPPPPP\n",c="........\n";return(a+b).ToLower()+c+c+c+c+b+a;};
            Console.WriteLine(f(1));
        }
    }
}

C # очень многословный язык ...

C # полная программа, 131 байт

class P{static void Main(){string a="rnbqkbnr\n",b="pppppppp\n",c="........\n";System.Console.Write(a+b+c+c+c+c+(b+a).ToUpper());}}

Ungolfed:

class P
{
    static void Main()
    {
        string a="rnbqkbnr\n",
            b="pppppppp\n",
            c="........\n";
        System.Console.Write(a+b+c+c+c+c+(b+a).ToUpper());
    }
}
— adrianmp
источник
2
«C # - очень многословный язык ...». Вы еще не пробовали VB.NET ...;)
— TyCobb
2
Вы можете сохранить байт, определив aи bв верхнем регистре, после чего вы можете избавиться от пробела после return:return(a+b).ToLower()+...
— молока
@TyCobb Я пробовал VB.NET довольно давно. Я не знал о коде в гольф тогда: P
— adrianmp
ты можешь использовать varвместо string?
— NibblyPig
@SLC Я давно не программировал на C #, так что поправьте меня, если я ошибаюсь, но я не думаю, что вы можете использовать varнесколько объявлений в одной строке. Так string a="rnbqkbnr\n",b="pppppppp\n",c="........\n";стало бы var a="rnbqkbnr\n";var b="pppppppp\n";var c="........\n";, что увеличивает количество байтов. РЕДАКТИРОВАТЬ: Это приведет к ошибке « Неявно типизированное объявление локальной переменной не может включать несколько деклараторов » .
— Кевин Круйссен
4

Python 2, 68 байт

Публикация в любом случае, хотя вышеприведенная версия Python 2 короче. Это не должно быть одним вкладышем для количества байтов, просто играл с ним.

x,y,z="rnbqkbnr\n","p"*8+"\n","."*8+"\n";print x,y,4*z,(y+x).upper()
— DomPar
источник
Так zкак используется только один раз, вы можете избавиться от него и получить точки в операторе печати.
— Карл Напф
3

Haskell, 53 байта

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

aиспользуется в качестве первой строки и для определения длины строк, из которых p, .и P(-> <$a). ,

— Ними
источник
3

JavaScript (ES6), 73

.toUpperCase просто слишком долго

_=>`rnbqkbnr
${r=c=>c[0].repeat(8)+`
`,r`p`+(b=r`.`)+b+b+b+r`P`}RNBQKBNR`

O.textContent=(
  
_=>`rnbqkbnr
${r=c=>c[0].repeat(8)+`
`,r`p`+(b=r`.`)+b+b+b+r`P`}RNBQKBNR`

)()
<pre id=O></pre>
Развернуть фрагмент

— edc65
источник
Я думаю (r=c=>c[0].repeat(8)+\ n ,b=r. )=>экономит вам байт.
— Нил
@ Нейл Я не вижу сбережений. Я попытался переписать код, увеличивающий читабельность (немного), но количество байтов
— осталось
Ах, я вижу, что я сделал не так, как-то я потерял новую строку по пути. Прости за это.
— Нил
3

PowerShell v2 +, 44 байта

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

Строки, оставленные на конвейере, неявно печатаются Write-Output при выполнении программы. Мы соединяем это с поведением новой строки по умолчанию для массива, чтобы получить четыре строки точек с помощью оператора запятой.

PS C:\Tools\Scripts\golfing> .\draw-ascii-chess-board.ps1
rnbqknbr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKNBR
— AdmBorkBork
источник
Где новые линии в линиях точек? ", ('.' * 8) * 4" это ", я полагаю ...
— RosLuP
@RosLuP Запятая-оператор ,создает массив (в данном случае массив строк). По умолчанию Write-Outputпри завершении программы вставляется новая строка между элементами, оставленными в конвейере, включая отдельные элементы массива. Итак, мы злоупотребляем выходным поведением по умолчанию, чтобы не нужно было писать явные символы новой строки в коде.
— AdmBorkBork
3

V , 27 , 26 байтов

i¸P
RNBQKBNRäkgujddppÒ.4Ä

Попробуйте онлайн!

Это содержит некоторые непечатаемые символы, поэтому вот читаемая версия:

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

где <esc>представляет 0x1B. Объяснение:

i                               " Enter insert mode
 ¸P                             " Enter 8 'P' characters
                                " and a newline
RNBQKBNR<esc>                   " Enter the first row and escape to normal mode.
             äk                 " Duplicate this line and the line above
               guj              " Convert this line, and the line below to lowercase
                  dd            " Delete this line
                    pp          " And paste it twice below us
                      Ò.        " Replace this whole line with '.' chars
                        4Ä      " And create four copies of this line
— DJMcMayhem
источник
3

Emotinomicon, 89 байт

К сожалению, Emotinomicon не имеет ничего общего с функцией дублирования стека. Было бы полезно. Но, по крайней мере, короче, чем Java. :)

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

Объяснение:

😭(...)😲⏪⏬⏩
😭(...)😲            String literal
         ⏪  ⏩      Loop
           ⏬        Pop one char and output
— Роман Греф
источник
Хм ... это была бы полезная функция, не правда ли ...
— Конор О'Брайен
Даже программа грустная. 😭 = К сожалению
— A _
3

Brain-Flak , 366 350 + 3 = 353 байта

Попробуйте онлайн!

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

Это получает плюс 3, потому что это требует, чтобы -Aфлаг работал правильно.

объяснение

First we push the last 5 letters to the active stack.
We also push copies of last 3 numbers to the inactive stack.
This is done with fairly simple methods I won't go into for the sake of brevity.

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

We Move Everything from the offstack to the onstack.
The first 3 letters are the same as the last 3 letters in the first line

{<>({}<>)}{}

We push 10 for a new line

((()()()()()){})

Using the value of Q we create a P and push it 8 times

((((((((<...>[()]))))))))

We loop 4 times each time pushing 8 dots and a newline

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

We push the last two lines in a very similar way to the first two.

(((()()()()()){})<((((((((([][]()()()()))))))))<>)<>>)(((()()()){})(({}()()())(([{}(()()())](([{}()](<>({}()())<>)<>)<>)<>)<>))){<>({}<>)}{}
— Мастер пшеницы
источник
Вы можете нажать первые две строки, ((((((((((((((((((((()()()()()){}){}){}()){})[()()()()])[([][][]){}])[][][])[]()())[[][][]])[][])()()()())<([]()())>[()()]))))))))которые, я думаю, сэкономят вам 16 байтов. Здесь вообще не используется альтернативный стек, поэтому он может быть еще короче.
— DJMcMayhem
3

Python 3.5, 56 байт

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

Это использует идею zawata для кодирования каждой строки как (r*8)[:8], когда строка повторяется 8 раз и обрезается до длины8 . Пешки и пустые строки являются просто 'p'*8, '.'*8и 'P'*8, без обрезки. Первый ряд использует 'rnbqkbn', с('rnbqkbn'*8)[:8] включая другую ладью на правом при умножении и обрезается. Последний ряд такой же, но с заглавной буквы.

Мы выражаем список частей строки компактно, ['rnbqkbn','p','.','.','.','.','P','RNBQKBN']используя обобщенную распаковку Python 3.5 . Мы записываем первые и последние записи, а оставшиеся односимвольные записи распаковываются из строки.

В Python 2 мы могли бы согласиться splitна 60 байтов:

for i in'rnbqkbn p . . . . P RNBQKBN'.split():print(i*8)[:8]
— XNOR
источник
3

Python 3, 82 80 75 байт

Не самый короткий ответ в Python, но это мой первый, и я думаю, что это довольно хорошо в первый раз

print('\n'.join((i*8)[:8]for i in'rnbqkbn p . . . . P RNBQKBN'.split()))
— zawata
источник
1
Добро пожаловать на сайт! Вы можете удалить два байта, если уберете лишние пробелы. Например[:8]for i in['rnbqkbn'....
— DJMcMayhem
1
Хорошая идея с объединением всех линий и повторным использованием ладей. Вы можете написать список короче как 'rnbqkbn p . . . . P RNBQKBN'.split().
— xnor
@DJMcMayhem не знал, что в этом нет необходимости. Благодарность!
— Завата
@xnor это отличная идея! больной должен добавить этот трюк в мой «арсенал» ха - ха
— zawata
2

Пакетная, 105 байт

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

Партия серьезно многословна ...

— Нил
источник
2

R 75 байт

Изменить: Исправлена ​​глупая ошибка и просто выписать заглавную часть доски сейчас. 

cat("rnbqkbnr\npppppppp\n",rep("........\n",4),"PPPPPPPP\nRNBQKBNR",sep="")
— Billywob
источник
1
Черные фигуры получаются неправильными, поскольку это стоит: пешки должны быть перед остальными фигурами.
— JDL
@JDL Ты, конечно, прав, спасибо. Глупая ошибка при внесении последних секундных изменений.
— Billywob
— Джузеппе
2

Powershell, 82 73 байта

$x=("rnbqkbnr",$("p"*8),$("."*8),$("."*8));$x+$x[3..0].ToUpper()-join"`n"
— Крис Дж
источник
— Веска
@Veskah - как это работает? Я не видел *perничего раньше, и Google не дает мне никаких указателей. Есть объяснение?
— Крис Дж
Проверьте здесь для полной записи, но |% может вызывать свойства / методы (с подстановочными знаками в имени) для того, что это дано
— Веска
2

J, 55 52 байта

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

Тест и промежуточные этапы

   '.rnbkqpPQKBNR'{~(+-@|.)8 8$1 2 3 4 5 3 2 1,8 48#6 0
rnbkqbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBKQBNR
   8 48#6 0
6 6 6 6 6 6 6 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   1 2 3 4 5 3 2 1,8 48#6 0
1 2 3 4 5 3 2 1 6 6 6 6 6 6 6 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   8 8$1 2 3 4 5 3 2 1,8 48#6 0
1 2 3 4 5 3 2 1
6 6 6 6 6 6 6 6
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
   (+-@|.)8 8$1 2 3 4 5 3 2 1,8 48#6 0
 1  2  3  4  5  3  2  1
 6  6  6  6  6  6  6  6
 0  0  0  0  0  0  0  0
 0  0  0  0  0  0  0  0
 0  0  0  0  0  0  0  0
 0  0  0  0  0  0  0  0
_6 _6 _6 _6 _6 _6 _6 _6
_1 _2 _3 _4 _5 _3 _2 _1
   '.rnbkqpPQKBNR'{~(+-@|.)8 8$1 2 3 4 5 3 2 1,8 48#6 0
rnbkqbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBKQBNR
— Конор О'Брайен
источник
2

Python 3, 64 байта

Исходя из ответа DLosc на Python 2, так как по моему я не смог улучшить.

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

На 1 байт меньше по сравнению с использованием "\ n" .join

print("\n".join(["rnbqkbnr","p"*8]+["."*8]*4+["P"*8,"RNBQKBNR"]))
— DomPar
источник
2

q, 51 байт

"\n"sv flip{x,"p...P","c"$("i"$x)-32}each"rnbqkbnr"
— Бостон Уокер
источник
Вы можете сбрить несколько байтов с верхним и каждым правым. Также следующие печатает на стандартный вывод , а не возвращает строку с символами новой строки: -1 flip"p...P"{y,x,upper y}/:"rnbqkbnr";. 40 байтов. Хорошее решение, хотя!
— streetster
2

GNU sed, 54 байта

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

Попробуйте онлайн!

Объяснение:

Черные фигуры печатаются первыми, сохраняя два связанных ряда досок в обратном порядке в области удержания. Белые кусочки печатаются путем преобразования пространства для хранения в заглавные буквы.

s:^:rnbqkbnr:p;h   # change pattern and hold spaces to 'rnbqkbnr' and print string
s:.:p:gp           # replace each pattern space letter with a 'p', then print
G;h                # append hold space, then copy pattern space to hold space
s:[^\n]:.:gp       # replace each pattern space letter with a '.', then print
G;s:.:\U&:g        # append hold space and convert pattern space to uppercase
                   # (automatic printing of pattern space at the end)
— seshoumara
источник
2

Java 7, 103 99 89 байт

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

10 байт сэкономлено по сравнению с жестко закодированным выводом благодаря подходу @SLC в его ответе на C # .

Попробуй это здесь.

Выход:

rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR
— Кевин Круйссен
источник
Как насчет этого. String f(){return"rnbqkbnr\npppppppp\n........\n........\n........\n........\nPPPPPPPP\nRNBQKBNR";}Это 100 байтов .
— Numberknot
@Numberknot Как скучно .. но ты прав, это короче. Кстати, это 99 байтов, а не 100.
— Кевин Круйссен
2

C #, 85 84 83 74 байта

Изменить: Случайно было слишком много строк пустых пространств!

Редактировать: освободил лишнего персонажа и исправил порядок (случайно все изменилось) большое спасибо @KevinCruijssen

Изменить: вернуться к 83, потому что у меня были креветки на неправильной линии

Редактировать: Спасибо @adrianmp, который помог мне уменьшить его, опустив return

Используя тот же формат, что и ответ @adrianmp выше:

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

Полная программа с использованием вышеуказанной функции:

using System;

namespace DrawAnASCIIChessBoard
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<object, string> f = 
                x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n");
                    Console.WriteLine(f(1));
        }
    }
}
— NibblyPig
источник
Привет, добро пожаловать в PPCG! Хм, порядок ваших фигур кажется неправильным с тем, что у OP. Кстати, вы можете сохранить 1 байт, удаляя пространство между return ", поэтому она становится: x=>{return"rnbqkbnr\npppppppp\nxxxxPPPPPPPP\nRNBQKBNR".Replace("x","........\n");};. Хороший ответ, так что +1 от меня. И приятного пребывания здесь. :)
— Кевин Круйссен
И спасибо за ваш ответ. Я перенес такой же подход к своему ответу на Java 7 (конечно , зачет),
— уменьшив
Я улучшил это далее
— NibblyPig
Гах, я только что понял, что это не правильно
— NibblyPig
1
Хороший подход! Вы можете уменьшить его до 74 байт:x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n");
— adrianmp 11.10.16
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.