Нарисуйте пустую доску Эрудит

28

Стандартная доска Scrabble - это сетка 15 × 15 для размещения буквенных плиток. Большинство пробелов являются пустыми, но некоторые представляют собой двойные баллы (розовый), тройные баллы (красный), двухбуквенные (светло-голубой) и трехбуквенные (синие). Обычно в центре находится звезда (которая считается двойной оценкой).

Доска для скрэббл

Напишите программу или функцию, которая выводит стандартную пустую доску Scrabble в форме ASCII, где:

  • . представляет собой пустое пространство

  • D представляет счет двойного слова

  • T представляет тройную оценку слова

  • d представляет двойную букву

  • t представляет тройной счет буквы

  • X представляет звезду центра

То есть ваш точный вывод должен быть

T..d...T...d..T
.D...t...t...D.
..D...d.d...D..
d..D...d...D..d
....D.....D....
.t...t...t...t.
..d...d.d...d..
T..d...X...d..T
..d...d.d...d..
.t...t...t...t.
....D.....D....
d..D...d...D..d
..D...d.d...D..
.D...t...t...D.
T..d...T...d..T

необязательно сопровождаемый завершающим переводом строки.

Самый короткий код в байтах побеждает.

Кальвин Хобби
источник
Почему бы Xи не *представлять звезду? : o
Fatalize
6
*слишком высокий и могучий
Увлечения Кэлвина
Почему нет ? : D
mbomb007
5
@ mbomb007 Не-ASCII-символ в вызове ASCII-art? Ересь !
Луис Мендо

Ответы:

16

MATL , 59 54 52 байта

4t:g2I5vXdK8(3K23h32h(H14(t!XR+8: 7:Pht3$)'DtdTX.'w)

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

объяснение

Код состоит из трех основных этапов:

  1. Создать матрицу 8x8

    4 0 0 3 0 0 0 4
    0 1 0 0 0 2 0 0
    0 0 1 0 0 0 3 0
    3 0 0 1 0 0 0 3
    0 0 0 0 1 0 0 0
    0 2 0 0 0 2 0 0
    0 0 3 0 0 0 3 0
    4 0 0 3 0 0 0 5
    
  2. Расширить его до матрицы 15х15

    4 0 0 3 0 0 0 4 0 0 0 3 0 0 4
    0 1 0 0 0 2 0 0 0 2 0 0 0 1 0
    0 0 1 0 0 0 3 0 3 0 0 0 1 0 0
    3 0 0 1 0 0 0 3 0 0 0 1 0 0 3
    0 0 0 0 1 0 0 0 0 0 1 0 0 0 0
    0 2 0 0 0 2 0 0 0 2 0 0 0 2 0
    0 0 3 0 0 0 3 0 3 0 0 0 3 0 0
    4 0 0 3 0 0 0 5 0 0 0 3 0 0 4
    0 0 3 0 0 0 3 0 3 0 0 0 3 0 0
    0 2 0 0 0 2 0 0 0 2 0 0 0 2 0
    0 0 0 0 1 0 0 0 0 0 1 0 0 0 0
    3 0 0 1 0 0 0 3 0 0 0 1 0 0 3
    0 0 1 0 0 0 3 0 3 0 0 0 1 0 0
    0 1 0 0 0 2 0 0 0 2 0 0 0 1 0
    4 0 0 3 0 0 0 4 0 0 0 3 0 0 4
    
  3. Индексируйте строку 'DtdTX.'с этой матрицей, чтобы получить желаемый результат.

Шаг 1

4        % Push 4
t:       % Duplicate, range: pushes [1 2 3 4]
g        % Logical: convert to [1 1 1 1]
2I5      % Push 2, then 3, then 5
v        % Concatenate all stack vertically into vector [4 1 1 1 1 2 3 5]
Xd       % Generate diagonal matrix from that vector

Теперь нам нужно заполнить ненулевые недиагональные записи. Мы будем заполнять только те, что ниже диагонали, а затем использовать симметрию, чтобы заполнить остальные.

Для заполнения каждого значения мы используем линейное индексирование (см. Этот ответ , фрагмент длины 12). Это означает доступ к матрице, как если бы она имела только одно измерение. Для матрицы 8 × 8 каждое значение линейного индекса относится к записи следующим образом:

1   9         57
2  10         58
3  11
4  
5  ...       ...
6  
7             63
8  16 ... ... 64

Итак, следующее присваивает значение 4 нижнему левому элементу:

K        % Push 4
8        % Push 8
(        % Assign 4 to the entry with linear index 8

Код для значения 3 аналогичен. В этом случае индекс является вектором, потому что нам нужно заполнить несколько записей:

3        % Push 3
K        % Push 4
23h      % Push 23 and concatenate horizontally: [4 23]
32h      % Push 32 and concatenate horizontally: [4 23 32]
(        % Assign 4 to the entries specified by that vector

И для 2:

H        % Push 2
14       % Push 14
(        % Assign 2 to that entry

Теперь у нас есть матрица

4 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0
0 0 1 0 0 0 0 0
3 0 0 1 0 0 0 0
0 0 0 0 1 0 0 0
0 2 0 0 0 2 0 0
0 0 3 0 0 0 3 0
4 0 0 3 0 0 0 5

Для заполнения верхней половины мы используем симметрию:

t!       % Duplicate and transpose
XR       % Keep the upper triangular part without the diagonal
+        % Add element-wise

Шаг 2

Стек теперь содержит матрицу 8 × 8, полученную на шаге 1. Чтобы расширить эту матрицу, мы используем индексирование, на этот раз в двух измерениях.

8:       % Push vector [1 2 ... 7 8]
7:P      % Push vector [7 6 ... 1]
h        % Concatenate horizontally: [1 2 ... 7 8 7 ... 2 1]. This will be the row index
t        % Duplicate. This will be the column index
3$       % Specify that the next function will take 3 inputs
)        % Index the 8×8 matrix with the two vectors. Gives a 15×15 matrix

Шаг 3

Стек теперь содержит матрицу 15 × 15, полученную на шаге 2.

'DtdTX.' % Push this string
w        % Swap the two elements in the stack. This brings the matrix to the top
)        % Index the string with the matrix
Луис Мендо
источник
Это действительно круто.
AdmBorkBork
Мне вообще нравится этот ответ, хотя он немного «чешется», когда вы используете 8 символов для создания вектора длины 8. Рассматривали ли вы получение чисел с помощью математической последовательности? Ничего сладкого пока не нашел, но особенно последние 7 показывают такую ​​хорошую картину. Например, ceil ((1: 7) ^
4/500
@DennisJ Спасибо! Да, это слишком много. Я попробую это позже, по телефону сейчас
Луис Мендо
8

Рубин, 103 97 байт

Спасибо Митчу Шварцу за 6-байтовое улучшение итераций.

a=(-7..7).map &:abs
a.map{|i|puts a.map{|j|(d=i%7-j%7)%4<1?'X d t DTDdDdDtT d'[i+j+d*d/3]:?.}*''}

Подобный, но значительно отличающийся подход к моему первоначальному ответу ниже. Как и прежде, мы используем тот факт, что письмо должно быть напечатано, если i%7-j%7оно равно 0 или 4. Но здесь мы сохраняем эту разницу dи используем формулуi+j+d*d/3 чтобы дать целое число, уникальное (с точностью до симметрии) этому конкретному цветному квадрату. Тогда мы просто смотрим в волшебную строку.

Просто для удовольствия: C версия этого подхода, 120 байт

z,i,j,d;f(){for(z=240;z--;)i=abs(z%16-8),j=abs(z/16-7),putchar(i-8?(d=i%7-j%7)%4?46:"X d t DTDdDdDtT d"[i+j+d*d/3]:10);}

Руби, 115 113 байт

2 байта сохранены благодаря Value Ink.

(k=-7..7).map{|y|k.map{|x|i=x.abs;j=y.abs
$><<=(i%7-j%7)%4<1?"#{'XdTdT'[(i+j)/3]}dtDDDD"[[i%7,j%7].min]:?.}
puts}

объяснение

Происхождение считается центром доски.

Письмо должно быть напечатано, если координаты x и y квадрата имеют величины, которые идентичны или отличаются на 4. Единственные исключения находятся на внешнем краю доски, но они следуют той же схеме, что и центральная строка / столбец таблицы. доска, поэтому мы можем использовать то же условие, если мы берем координаты х и у по модулю 7.

Выбор отображаемой буквы основан на координате минимальной величины. Таким образом, двойные и тройные числа в (1,5) и (2,6) следуют тому же правилу, что и в (1,1) и (2,2), и получаются из 7-символьной строки. "#{formula}dtDDDD"Это не охватывает все варианты для квадратов ребер и центральной линии, поэтому первый символ строки рассчитывается по формуле 'XdTdT'[(i+j)/3].

(k=-7..7).map{|y|
  k.map{|x|
    i=x.abs;j=y.abs
    print (i%7-j%7)%4<1?      #IF this expression is true print a letter 
    "#{'XdTdT'[(i+j)/3]       #select 1st character of magic string where [i%7,j%7].min==0 
     }dtDDDD"[[i%7,j%7].min]: #remaining 6 characters of magic string for diagonal
    ?.                        #ELSE print .
  }
  puts                        #at the end of the row print a newline
}
Уровень реки St
источник
(k=-7..7).map{|y|k.map{...на 2 байта короче, чем ваша двойная -7.upto(7)техника.
Value Ink
Несколько модификаций для сохранения 6 байтов:a=(-7..7).map &:abs;a.map{|i|puts a.map{|j|(d=i%7-j%7)%4<1?'X d t DTDdDdDtT d'[i+j+d*d/3]:?.}*''}
Митч Шварц
7

Брейнфук , 598 596 590 байт

Гольф советы приветствуются.

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

объяснение

Инициализируйте ленту на [10 116 68 46 100 84 92], т.е. [nl t D. д т \]

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

Затем каждая строка печатает одну строку доски.
Средняя линия также уменьшается92 to 88 i.e. \ to X

.<<..>.<...>>.<<...>.<..>>.<<<<<.
>>>.<.>...<<.>>...<<.>>...<.>.<<<.
>>>..<.>...>.<.>.<...<.>..<<<.
>>>>.<..<.>...>.<...<.>..>.<<<<.
>>>....<.>.....<.>....<<<.
>>>.<<.>>...<<.>>...<<.>>...<<.>>.<<<.
>>>..>.<...>.<.>.<...>.<..<<<.
>>>>>.<<..>.<...>>>----.<<<...>.<..>>.<<<<<.
>>>..>.<...>.<.>.<...>.<..<<<.
>>>.<<.>>...<<.>>...<<.>>...<<.>>.<<<.
>>>....<.>.....<.>....<<<.
>>>>.<..<.>...>.<...<.>..>.<<<<.
>>>..<.>...>.<.>.<...<.>..<<<.
>>>.<.>...<<.>>...<<.>>...<.>.<<<.
>>>>>.<<..>.<...>>.<<...>.<..>>.

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

Emigna
источник
1
Советы для BF: не играйте в гольф в BF; хорошая стратегия, хотя
Волшебный Осьминог Урна
5

PowerShell v2 +, 147 байт

($x='T..d...T...d..T')
($y='.D...t..','..D...d.','d..D...d','....D...','.t...t..','..d...d.'|%{$_+-join$_[6..0]})
$x-replace'.T.','.X.'
$y[5..0]
$x

Использует преимущества того, как значение Write-Outputпо умолчанию в конце выполнения программы обрабатывает массивы (т. Е. Вставляет новую строку между элементами). Может быть, лучший способ создать середину доски - я все еще работаю над этим.

Первая строка выводит верхнюю строку доски, также сохраняя ее в $x для последующего использования.

Следующая строка генерирует все строки двойного слова, беря левую «половину» каждой, отражая их ( -join$_[6..0] инструкцию) и сохраняя их как элементы в массиве$y .

Следующая строка - средний ряд, с Xсерединой, благодаря-replace .

Следующая строка выводит $y в обратном порядке, давая нам нижние строки двойного слова.

Финальная строка просто $xснова.

PS C:\Tools\Scripts\golfing> .\draw-empty-scrabble-board.ps1
T..d...T...d..T
.D...t...t...D.
..D...d.d...D..
d..D...d...D..d
....D.....D....
.t...t...t...t.
..d...d.d...d..
T..d...X...d..T
..d...d.d...d..
.t...t...t...t.
....D.....D....
d..D...d...D..d
..D...d.d...D..
.D...t...t...D.
T..d...T...d..T
AdmBorkBork
источник
5

> <> (Рыба), 153 байта

\!o;!?l
\'T..d...T...d..T'a'.D...t...t...D.'a'..D...d.d...D..'a'd..D...d...D..d'a'....D.....D....'a'.t...t...t...t.'a'..d...d.d...d..'a'T..d...'
\'X/'02p

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

Попробуйте онлайн! (Если вы не хотите быть там весь день, убедитесь, что вы установили максимальную скорость выполнения или работаете без анимации.)

Каллум Керр
источник
4

C 146 145 142 138 байт

i,r,c;main(){for(;i<240;)r=abs(i/16-7),c="T..12..0..12..0"[r+7-abs(i%16-7)],putchar(++i%16?c&4?c:"Xd.dd.tt.D..D.dD.dD.tTd."[c%4+r*3]:10);}

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

1 байт 5 байтов сохранено благодаря Level River St

Это использует диагональный рисунок платы для кодирования. В частности, если мы возьмем верхний левый квадрант доски и выровняем диагональ, мы получим:

       T..d...T
      .D...t..
     ..D...d.
    d..D...d
   ....D...
  .t...t..
 ..d...d.
T..d...X

... много столбцов теперь выстраиваются в линию. Если мы закодируем столбцы в строке следующим образом:

       0..12..0 y/012/Td./
      .0..12..  y/012/D.t/
     ..0..12.   y/012/D.d/
    2..0..12    y/012/D.d/
   12..0..1     y/012/D../
  .12..0..      y/012/tt./
 ..12..0.       y/012/dd./
T..12..0        y/012/Xd./

... то плата шаблон может быть свернут в строку в 15 символов: T..12..0..12..0; и нам просто нужны правильные отображения для каждого ряда.

Имея это в виду, вот расширенная версия с комментариями:

i,r,c;
main() {
   for(;i<240;)  // one char per output including new line
   r=abs(i/16-7) // row; goes from 7 to 0 and back to 7.
   , c="T..12..0..12..0"[r+7-abs(i%16-7)] // pattern char
   , putchar(++i%16 // if this is 0 we need a new line
   ? c&4 // hash to distinguish 'T' and '.' from '0', '1', '2'
     ? c // print 'T' and '.' literally
     : "Xd.dd.tt.D..D.dD.dD.tTd."[c%4+r*3] // otherwise look up replacement char
   : 10 // print the new line
   );
}
H Уолтерс
источник
Очень хорошо. 1. Вы можете отправить функцию вместо программы, так что i,r,c;f()все в порядке. 2. (i%16-7)%8-> i%16-7&73. Я думаю c-48-> c%4работает, не так ли?
Уровень Река St
Ой, извините, функции должны быть многократно используемыми, поэтому f()потребуется дополнительная i=0функция внутри функции, чтобы она ничего не сохраняла.
Уровень Река
Спасибо за комментарии! 2 также не будет работать ( %8использует отрицательные модули реализации для сопоставления% 16 значений от 0..15 до -7..7; &7отобразит это в 0..7,0..7). Но да, 3 будет абсолютно работать ... будет обновляться, когда я получу шанс
H Уолтерс
@LevelRiverSt Mea culpa; 2 все еще не будет работать строго, но мне все равно это не нужно.
H Уолтерс
3

05AB1E , 57 53 байта

Код

•jd]31‚ŽÔc¦Ïïì¹Ep.Üì8Ìa;“•6B4ÝJ".TdDt"‡5'.3×:Â'Xý15ô»

Использует кодировку CP-1252 . Попробуйте онлайн!


Объяснение (устарело)

•4ç“–šã&$W§ñçvßÖŠ_æá_VFÛÞýi~7¾¬ÏXôc•5BРаспаковывает на этот номер:

1002000100020010400030003000400040002020004002004000200040020000400000400000300030003000300020002020002001002000

С 4ÝJ".TdtD"‡помощью этого большого числа мы транслитерируем следующее:

0 -> .
1 -> T
2 -> d
3 -> t
4 -> D

Мы раздваиваем всю строку, оставляя строку и строку перевернутыми в стеке, и соединяем их, "X"используя ý. Мы разбиваем всю строку на части по 15 с помощью th- 15ôкода и соединяем весь массив с помощью новых строк ».

Аднан
источник
û€ûдолжен быть встроенным;).
Волшебный Осьминог Урна
2

Python 3, 138 байт

d=lambda s:s+s[-2::-1]
print(*d(list(map(d,'T..d...T .D...t.. ..D...d. d..D...d ....D... .t...t.. ..d...d. T..d...X '.split()))),sep='\n')
RootTwo
источник
Изменить list(map(A))на [*map(A)], экономит 3 байта (требуется Python 3.5+).
Shooqie
2

05AB1E , 49 44 байта

•1nÑ=}íge/Þ9,ÑT‰yo¬iNˆå•6B8ôû€û»5ÝJ".TtdDX"‡

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

Разъяснение:

От себя: 1003000104000200004000303004000300004000020002000030003010030005

Разделить на куски по 8, палиндромизировать каждый.

Палиндромиз снова.

Заменить цифры на символы.


Другая идея (кто-то попробует это в MATL)

Видя, что ВСЁ гарантированно имеет промежуток между ними ...

Подсчитайте количество нулей между каждой частью:

1003000104000200004000303004000300004000020002000030003010030005
^  ^   ^ ^   ^    ^   ^ ^  ^   ^    ^    ^   ^    ^   ^ ^  ^   ^

131424334342233135 => w\F6ß¿

Взятие отсчетов нулей проходит:

23134312344343123 => ì:¼˜¾

Тогда вы расшифровываете и переносите их вместе.

Использование их в 05AB1E (приводит к увеличению на 5 байт):

05AB1E , 27 байт

•w\F6ß¿•6BS•ì:¼˜¾•5BS0ׂøJJ

Попытайся...


Meta-golfed entry:

05AB1E , 104 байта

•G¨J´JÏÍ?»"”Ö3úoÙƒ¢y”vf%¯‚6À°IÕNO’Å2Õ=ÙŠxn®žÑŸ¶¼t¨š,Ä]ÓŽÉéȺÂ/ø‡ŸÖ|e³J—Ë'~!hj«igċ΂wî’©•7BžLR"
.DTXdt"‡

Попытайся!

Мета-golfed с помощью моего мета-гольфист для ASCII искусства: https://tio.run/nexus/05ab1e#JY9NSgNBEIWvUo4/qAQxyfi30yAioiAiuBM6M9U9DT3doao7ccBFrhI3ooss3QguJniRXCR2x01RfK9479Xqtf2@XHy2H78/tw/L6aydq8VXr5sPsuX0LeP1jCwbJD3r54v3dp5mFGbZzWp1wXBPyLpE6@GRQj0C1spiCQJ4gjjSVgG@YBG8HiM4KpHAWbgiXYqmA1wF79ONrxCGa5nBOyCUQSEyCFuCi2LEklwNjGO0YAQpNA3cBTa6hsIF60kjd9Y@jAWhF9SAk1C5Gk1yiTSQ9g1MBKcKAp4q7RGuXWCMFlYioS3iKowBhf@9Kh2DNbEHGSIexhSZeDRIUcq4oTDxDS09aAsjZ3TRHGycb25tP@/s7@51e/386Pjk9OzwDw

Урна волшебного осьминога
источник
1

Javascript (ES6), 150 байт

_=>(r='',"T2d3T3d2T.D3t3t3D3D3d.d3D2d2D3d3D2d4D5D5t3t3t3t3d3d.d3d2T2d3".replace(/./g,c=>(c=+c?'.'.repeat(c):c,r=c+r,c))+'X'+r).match(/.{15}/g).join`
`

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

Строка "T2d3T3d2T.D3t3t3D3D3d.d3D2d2D3d3D2d4D5D5t3t3t3t3d3d.d3d2T2d3"описывает доску от ее верхнего левого угла до квадрата непосредственно перед 'X', с последовательными пустыми квадратами, закодированными как цифры. replace()Функция и распаковывает пустые квадраты и строит строку зеркалаr для нижней части доски. Затем обе части соединяются и символы возврата каретки вставляются каждые 15 символов.

демонстрация

let f =
_=>(r='',"T2d3T3d2T.D3t3t3D3D3d.d3D2d2D3d3D2d4D5D5t3t3t3t3d3d.d3d2T2d3".replace(/./g,c=>(c=+c?'.'.repeat(c):c,r=c+r,c))+'X'+r).match(/.{15}/g).join`
`
console.log(f())

Arnauld
источник
1

JavaScript (ES6), 221 байт

f=
_=>(a=[...Array(15)].map(_=>Array(15).fill`.`),r=([c,i,j])=>[a[i][j]=a[k=14-i][j]=a[i][j=14-j]=a[k][j]=c,j,i],[..."TDDDDtdX"].map((c,i)=>r([c,i,i])),"d30t51d62d73T70".replace(/.../g,s=>r(r(s))),a.map(a=>a.join``).join`
`)
;o.textContent=f()
<pre id=o>

Так как я занялся созданием этого, я решил опубликовать его в любом случае, даже несмотря на то, что существует явно превосходящее решение.

Нил
источник
1

C 234 байта

#define g(t) while(i++<8)putchar(*b++);b-=2;--i;while(--i>0)putchar(*b--);putchar('\n');b+=t;
char*r="T..d...T.D...t....D...d.d..D...d....D....t...t....d...d.T..d...X";i;f(){char*b=r;do{g(9);}while(*b);b-=16;do{g(-7);}while(b>=r);}

Вот вывод:

T..d...T...d..T
.D...t...t...D.
..D...d.d...D..
d..D...d...D..d
....D.....D....
.t...t...t...t.
..d...d.d...d..
T..d...X...d..T
..d...d.d...d..
.t...t...t...t.
....D.....D....
d..D...d...D..d
..D...d.d...D..
.D...t...t...D.
T..d...T...d..T
cleblanc
источник
1

Древесный уголь , 33 байта (неконкурентный)

Вся заслуга в этом ответе принадлежит @DLosc .

T↑↑↘tdd↗→→↖XdtDDDD↓T..d‖O⟦↗→↓⟧UB.

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

Подробный

Print("T")
Move(:Up)
Move(:Up)
Print(:DownRight, "tdd")
Move(:UpRight)
Move(:Right)
Move(:Right)
Print(:UpLeft, "XdtDDDD")
Print(:Down, "T..d")
ReflectOverlap([:UpRight, :Right, :Down])
SetBackground(".")

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

ASCII-только
источник
Идеальный инструмент для этой задачи, с его возможностями диагональной печати. +1 (а также здорово видеть такой фоновый метод для ASCII)
Кевин Круйссен,
0

Haskell, 114 байт

g=(++)<*>reverse.init
unlines$g$g<$>words"T..d...T .D...t.. ..D...d. d..D...d ....D... .t...t.. ..d...d. T..d...X"

gв неточечной версии есть g x = x ++ (reverse (init x)). Он применяется один раз на (половину) строки и снова на результат.

Ними
источник
0

sh + coreutils, 119 байт

Это бинарный файл. Показано как hexdump:

00000000  74 61 69 6c 20 2d 63 39  34 20 24 30 7c 67 75 6e  |tail -c94 $0|gun|
00000010  7a 69 70 0a 65 78 69 74  0a 1f 8b 08 00 2e ec ca  |zip.exit........|
00000020  57 00 03 65 4f c9 0d c0  30 08 fb 7b 18 4f 91 11  |W..eO...0..{.O..|
00000030  fc e8 00 1e a1 fb ab 08  68 a4 90 07 60 d9 98 43  |........h...`..C|
00000040  a4 49 8a 59 05 ae 40 6f  c7 22 98 84 b3 29 10 fc  |.I.Y..@o."...)..|
00000050  13 59 1d 7a 11 9d b1 bd  15 a8 56 77 26 54 c4 b3  |.Y.z......Vw&T..|
00000060  f7 0d fd f6 9f f3 ef fd  e7 7d f3 7e 8d ff 3e 05  |.........}.~..>.|
00000070  57 d9 a0 f0 00 00 00                              |W......|
00000077

Вот форма base64, чтобы вы могли скопировать / вставить ее:

begin-base64 755 test.sh
dGFpbCAtYzk0ICQwfGd1bnppcApleGl0Ch+LCAAu7MpXAANlT8kNwDAI+3sY
T5ER/OgAHqH7qwhopJAHYNmYQ6RJilkFrkBvxyKYhLMpEPwTWR16EZ2xvRWo
VncmVMSz9w399p/z7/3nffN+jf8+BVfZoPAAAAA=
====
Джошуа
источник
0

C 230 228 байт

char *s="T.D..Dd..D....D.t...t..d...dT..d...X";
int x,y,a,b;
#define X(N) {putchar(s[a]);N y<=x?1:y;}
#define P for(y=1;y<8;y++)X(a+=)for(y--;y+1;y--)X(a-=)puts("");
main(){for(;x<8;x++){a=b+=x;P}for(x=6;x+1;x--){a=b-=(x+1);P}}

попробуйте это на Ideone

Это попытка улучшить исходную опубликованную версию C, в которой четверть доски сохранена в массиве C. Не так коротко, как я надеялся. В этой версии хранится только одна восьмая часть доски.

Ungolfed:

char *s="T.D..Dd..D....D.t...t..d...dT..d...X";
int x,y,a,b;
main(){
    for(x = 0; x < 8; x++){
        a=b+=x;
        for(y = 1; y < 8; y++){
            putchar(s[a]);
            a += y<=x ? 1 : y;
        }
        for(y--; y >= 0; y--){
            putchar(s[a]);
            a -= y<=x ? 1 : y;
        }
        puts("");
    }
    for(x=6; x >= 0; x--){
        a=b-=(x+1);
        for(y = 1; y < 8; y++){
            putchar(s[a]);
            a += y<=x ? 1 : y;
        }
        for(y--; y >= 0; y--){
            putchar(s[a]);
            a-= y<=x ? 1 : y;
        }
        puts("");
    }
}
bnf679
источник
0

GNU sed, 219 205 байт

s/$/T..d...T...d..T/p;h
s/.*/.D...t...t...D./p;G;h
s/.*/..D...d.d...D../p;G;h
s/.*/d..D...d...D..d/p;G;h
s/.*/....D.....D..../p;G;h
s/.*/.t...t...t...t./p;G;h
s/.*/..d...d.d...d../p;G;h
s/.*\n//;s/T/X/2p;g

Используя зеркальную симметрию платы, вторая половина является первой, которая была сохранена в обратном порядке в пространстве удержания.

seshoumara
источник