Standardowa plansza Scrabble to 15 × 15 pól do umieszczenia kafelków z literami. Większość spacji jest pusta, ale niektóre z nich to podwójne słowa (różowy), potrójne słowa (czerwony), podwójne litery (jasnoniebieski) i trzyosobowe (niebieski). Zwykle w samym centrum znajduje się gwiazda (co liczy się jako wynik podwójnego słowa).

Napisz program lub funkcję, która generuje standardową, pustą kartę Scrabble w postaci ASCII, gdzie:

• . reprezentuje pustą przestrzeń

• D oznacza wynik podwójnego słowa

• T oznacza potrójny wynik słów

• d oznacza wynik podwójnej litery

• t oznacza wynik trzyliterowy

• X reprezentuje gwiazdę środkową

To znaczy, twoja dokładna wydajność musi być

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

opcjonalnie po nim następująca nowa linia.

Najkrótszy kod w bajtach wygrywa.

MATL , 59 54 52 bajtów

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

Wypróbuj online!

Wyjaśnienie

Kod składa się z trzech głównych kroków:

1. Wygeneruj macierz 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. Rozszerz go na matrycę 15x15

   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. Indeksuj ciąg za 'DtdTX.'pomocą tej macierzy, aby uzyskać pożądany wynik.

Krok 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

Teraz musimy wypełnić niezerowe wpisy o przekątnej. Wypełnimy tylko te poniżej przekątnej, a następnie zastosujemy symetrię, aby wypełnić pozostałe.

Aby wypełnić każdą wartość, używamy indeksowania liniowego (patrz ta odpowiedź , fragment długości 12). Oznacza to dostęp do matrycy, jakby miała tylko jeden wymiar. W przypadku macierzy 8 × 8 każda wartość indeksu liniowego odnosi się do następującego wpisu:

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

Zatem poniższe przypisuje wartość 4 do lewego dolnego wpisu:

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

Kod dla wartości 3 jest podobny. W tym przypadku indeks jest wektorem, ponieważ musimy wypełnić kilka wpisów:

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

A dla 2:

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

Mamy teraz macierz

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

Aby wypełnić górną połowę, wykorzystujemy symetrię:

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

Krok 2

Stos zawiera teraz macierz 8 × 8 wynikającą z kroku 1. Aby rozszerzyć tę macierz, używamy indeksowania, tym razem w dwóch wymiarach.

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

Krok 3

Stos zawiera teraz macierz 15 × 15 wynikającą z kroku 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

Ruby, 103 97 bajtów

Podziękowania dla Mitcha Schwartza za 6-bajtową poprawę iteracji.

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]:?.}*''}

Podobne, ale znacznie inne podejście do mojej oryginalnej odpowiedzi poniżej. Tak jak poprzednio, wykorzystujemy fakt, że litera musi być wydrukowana, jeśli i%7-j%7jest równa 0 lub 4. Ale tutaj przechowujemy tę różnicę di używamy formuły, i+j+d*d/3aby podać liczbę całkowitą, która jest unikalna (aż do symetrii) dla tego konkretnego kolorowego kwadratu. Następnie po prostu sprawdzamy to w magicznym sznurku.

Dla zabawy: wersja C tego podejścia, 120 bajtów

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

Rubin, 115 113 bajtów

2 bajty zapisane dzięki 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}

Wyjaśnienie

Pochodzenie uważa się za środek planszy.

Litera musi być wydrukowana, jeśli współrzędne xiy kwadratu mają wielkości, które są identyczne lub różnią się o 4. Jedyne wyjątki znajdują się na zewnętrznej krawędzi planszy, ale są one zgodne z tym samym wzorem, co środkowy rząd / kolumna tablicę, więc możemy użyć tego samego warunku, jeśli weźmiemy współrzędne x i modulo 7.

Wybór wyświetlanej litery zależy od współrzędnej minimalnej wielkości. W ten sposób podwójne i potrójne w (1,5) i (2,6) stosują tę samą zasadę jak w (1,1) i (2,2) i są otrzymywane z ciągu 7 znaków. "#{formula}dtDDDD"Nie obejmuje wszystkich odmian dla kwadratów krawędzi i linii środkowej, więc pierwszy znak ciągu jest obliczany ze wzoru '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
}

pieprzenie mózgu , 598 596 590 bajtów

Zapraszamy do gry w golfa.

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

Wyjaśnienie

Zainicjuj taśmę do [10 116 68 46 100 84 92] tj. [Nl t D. d T \]

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

Każda linia tutaj drukuje następnie jedną linię planszy.
Środkowa linia również maleje92 to 88 i.e. \ to X

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

Wypróbuj online!

PowerShell v2 +, 147 bajtów

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

Korzysta z tego, jak domyślna Write-Outputpod koniec wykonywania programu obsługuje tablice (tj. Wstawia nową linię między elementami). Może to być lepszy sposób na wygenerowanie środka planszy - wciąż nad tym pracuję.

Pierwszy wiersz wypisuje górny wiersz planszy, a także przechowuje go $xdo późniejszego wykorzystania.

Kolejny wiersz generuje wszystkie wiersze z podwójnym słowem, biorąc lewą „połowę” każdego z nich, odbijając je ( -join$_[6..0]instrukcja) i przechowując je jako elementy w tablicy $y.

Kolejny wiersz to środkowy rząd, ze Xśrodkowym, dzięki -replace.

Następny wiersz wyświetla się $yw odwrotnej kolejności, co daje nam dolne wiersze z podwójnym słowem.

Ostatnia linia jest po $xraz kolejny.

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

> <> (Ryba), 153 bajtów

\!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

Okropnie, okropnie, nieefektywnie. Obecnie poszukujemy sposobu skrócenia go poprzez prawidłowe odbicie lustrzane zarówno w poziomie, jak i w pionie.

Wypróbuj online! (Jeśli nie chcesz tam być przez cały dzień, upewnij się, że ustawiłeś maksymalną szybkość wykonywania lub działasz bez animacji.)

C, 146 145 142 138 bajtów

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

Wypróbuj online!

1 bajt 5 bajtów zapisanych dzięki Level River St

Wykorzystuje to przekątny wzór płytki do kodowania. W szczególności, jeśli weźmiemy lewą górną ćwiartkę planszy i wyrównamy przekątną, otrzymamy:

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

... wiele kolumn ustawia się teraz w linii. Jeśli kodujemy kolumny w linii w ten sposób:

       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./

... wtedy wzór deska można zwinąć w ciąg 15 znaków: T..12..0..12..0; i po prostu potrzebujemy odpowiednich mapowań dla każdego wiersza.

Mając to na uwadze, oto rozszerzona wersja z komentarzami:

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

Kod

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Wyjaśnienie (nieaktualne)

•4ç“–šã&$W§ñçvßÖŠ_æá_VFÛÞýi~7¾¬ÏXôc•5BDekompresji tej liczbie:

1002000100020010400030003000400040002020004002004000200040020000400000400000300030003000300020002020002001002000

Za pomocą 4ÝJ".TdtD"‡transliterujemy następujące elementy w tej dużej liczbie:

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

Rozgałęziamy cały łańcuch, pozostawiając łańcuch i łańcuch odwrócony na stosie i łączymy je za "X"pomocą ý. Dzielimy cały ciąg na 15 części za pomocą tego 15ôkodu i łączymy całą tablicę za pomocą znaku nowej linii ».

Python 3, 138 bajtów

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

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

Wypróbuj online!

Wyjaśnił:

Pchać: 1003000104000200004000303004000300004000020002000030003010030005

Podziel się na 8-częściowe, palindromizuj każde.

Znowu palindromuj.

Zamień cyfry na znaki.

Inny pomysł (ktoś wypróbuje to w MATL)

Widząc, że WSZYSTKO to czas, aby między nimi ...

Policz liczbę zer między poszczególnymi elementami:

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

131424334342233135 => w\F6ß¿

Biorąc pod uwagę liczbę zer:

23134312344343123 => ì:¼˜¾

Następnie odszyfrujesz je i przetransponujesz.

Używanie ich w 05AB1E (powoduje wzrost o +5 bajtów):

05AB1E , 27 bajtów

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

Spróbuj...

Wejście do gry w golfa:

05AB1E , 104 bajty

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

Spróbuj!

Meta-golfed przy moim meta-golfa dla sztuki ASCII: https://tio.run/nexus/05ab1e#JY9NSgNBEIWvUo4/qAQxyfi30yAioiAiuBM6M9U9DT3doao7ccBFrhI3ooss3QguJniRXCR2x01RfK9479Xqtf2@XHy2H78/tw/L6aydq8VXr5sPsuX0LeP1jCwbJD3r54v3dp5mFGbZzWp1wXBPyLpE6@GRQj0C1spiCQJ4gjjSVgG@YBG8HiM4KpHAWbgiXYqmA1wF79ONrxCGa5nBOyCUQSEyCFuCi2LEklwNjGO0YAQpNA3cBTa6hsIF60kjd9Y@jAWhF9SAk1C5Gk1yiTSQ9g1MBKcKAp4q7RGuXWCMFlYioS3iKowBhf@9Kh2DNbEHGSIexhSZeDRIUcq4oTDxDS09aAsjZ3TRHGycb25tP@/s7@51e/386Pjk9OzwDw

JavaScript (ES6), 150 bajtów

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

Jak to działa

Ciąg "T2d3T3d2T.D3t3t3D3D3d.d3D2d2D3d3D2d4D5D5t3t3t3t3d3d.d3d2T2d3"opisuje planszę od lewego górnego rogu do kwadratu tuż przed „X”, z kolejnymi pustymi kwadratami zakodowanymi jako cyfry. Ta replace()funkcja rozpakowuje puste kwadraty i buduje łańcuch lustrzany rna dole planszy. Następnie obie części są łączone, a zwroty karetki są wstawiane co 15 znaków.

Próbny

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

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>

Ponieważ zadałem sobie trud stworzenia tego i tak, pomyślałem, że i tak to opublikuję, mimo że dostępne jest wyraźnie lepsze rozwiązanie.

C 234 bajtów

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

Oto wynik:

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

Węgiel drzewny , 33 bajty (niekonkurencyjny)

Wszystkie podziękowania za tę odpowiedź należą do @DLosc .

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

Wypróbuj online!

Gadatliwy

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

Wypróbuj online!

Haskell, 114 bajtów

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"

gw wersji bez punktowej jest g x = x ++ (reverse (init x)). Stosuje się go raz na (pół) linii i ponownie na wynik.

sh + coreutils, 119 bajtów

To jest plik binarny. Pokazane jako zrzut heksowy:

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

Oto formularz base64, dzięki czemu możesz go skopiować / wkleić:

begin-base64 755 test.sh
dGFpbCAtYzk0ICQwfGd1bnppcApleGl0Ch+LCAAu7MpXAANlT8kNwDAI+3sY
T5ER/OgAHqH7qwhopJAHYNmYQ6RJilkFrkBvxyKYhLMpEPwTWR16EZ2xvRWo
VncmVMSz9w399p/z7/3nffN+jf8+BVfZoPAAAAA=
====

C 230 228 bajtów

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

spróbuj na ideone

Jest to próba ulepszenia oryginalnej opublikowanej wersji C, która miała ćwiartkę płyty zapisaną w macierzy C. Nie tak krótki, jak się spodziewałem. Ta wersja ma tylko jedną ósmą płyty.

Nie golfowany:

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

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

Korzystając z lustrzanej symetrii planszy, druga połowa jest pierwszą, która była przechowywana w odwrotnej kolejności w przestrzeni ładunkowej.