Стандартная доска 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

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

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

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

Рубин, 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
}

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

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

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

объяснение

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

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

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

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

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

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

> <> (Рыба), 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

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

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

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

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ôкода и соединяем весь массив с помощью новых строк ».

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')

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

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

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>

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

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

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

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

T↑↑↘tdd↗→→↖XdtDDDD↓T..d‖Ｏ⟦↗→↓⟧ＵＢ.

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

Подробный

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(".")

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

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)). Он применяется один раз на (половину) строки и снова на результат.

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

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

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

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