Eine Standard- Scrabble- Tafel besteht aus einem 15 × 15-Raster, auf dem Buchstabenkacheln platziert werden können. Die meisten Leerzeichen sind leer, aber einige sind doppelte Wortbewertungen (pink), dreifache Wortbewertungen (rot), doppelte Buchstabenbewertungen (hellblau) und dreifache Buchstabenbewertungen (blau). In der Mitte befindet sich normalerweise ein Stern (was als doppelte Wortzahl gilt).

Schreiben Sie ein Programm oder eine Funktion, die eine leere Standard-Scrabble-Karte in ASCII-Form ausgibt.

• . steht für einen leeren Raum

• D steht für eine doppelte Wortzahl

• T repräsentiert eine dreifache Wortzahl

• d steht für einen Doppelbuchstaben

• t repräsentiert einen dreifachen Buchstabenwert

• X repräsentiert den Mittelstern

Das heißt, Ihre genaue Ausgabe muss sein

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

optional gefolgt von einem nachgestellten Zeilenumbruch.

Der kürzeste Code in Bytes gewinnt.

MATL , 59 54 52 Bytes

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

Probieren Sie es online!

Erläuterung

Der Code folgt drei Hauptschritten:

1. Generieren Sie die 8x8-Matrix

   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. Erweitern Sie es auf die 15x15-Matrix

   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. Indizieren Sie die Zeichenfolge 'DtdTX.'mit dieser Matrix, um das gewünschte Ergebnis zu erzielen.

Schritt 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

Jetzt müssen wir die nicht diagonalen Einträge ungleich Null ausfüllen. Wir werden nur die unterhalb der Diagonale füllen und dann Symmetrie verwenden, um die anderen zu füllen.

Um jeden Wert zu füllen, verwenden wir die lineare Indizierung (siehe diese Antwort , Länge-12-Snippet). Das bedeutet, auf die Matrix zuzugreifen, als ob sie nur eine Dimension hätte. Bei einer 8 × 8-Matrix bezieht sich jeder Wert des linearen Index wie folgt auf einen Eintrag:

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

Das Folgende weist also dem Eintrag unten links den Wert 4 zu:

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

Der Code für den Wert 3 ist ähnlich. In diesem Fall ist der Index ein Vektor, da wir mehrere Einträge füllen müssen:

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

Und für 2:

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

Wir haben jetzt die Matrix

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

Um die obere Hälfte zu füllen, nutzen wir die Symmetrie:

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

Schritt 2

Der Stapel enthält nun die aus Schritt 1 resultierende 8 × 8-Matrix. Um diese Matrix zu erweitern, verwenden wir die Indizierung, diesmal in den beiden Dimensionen.

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

Schritt 3

Der Stapel enthält jetzt die aus Schritt 2 resultierende 15 × 15-Matrix.

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

Vielen Dank an Mitch Schwartz für die 6-Byte-Verbesserung der Iterationen.

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

Eine ähnliche, aber deutlich andere Herangehensweise an meine ursprüngliche Antwort weiter unten. Wie zuvor verwenden wir die Tatsache, dass ein Buchstabe gedruckt werden muss, wenn er i%7-j%7gleich 0 oder 4 ist. Aber hier speichern wir diesen Unterschied dund verwenden die Formeli+j+d*d/3 , um eine ganze Zahl zu erhalten, die für dieses bestimmte farbige Quadrat eindeutig (bis zur Symmetrie) ist. Dann schauen wir einfach in der Zauberkette nach.

Nur zum Spaß: C-Version dieses Ansatzes, 120 Bytes

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 Bytes

2 Bytes gespart dank 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}

Erläuterung

Der Ursprung wird als Mittelpunkt der Tafel betrachtet.

Ein Buchstabe muss gedruckt werden, wenn die x - und y - Koordinaten des Quadrats identische oder um 4 verschiedene Größen haben. Die einzigen Ausnahmen befinden sich am äußeren Rand der Tafel, aber diese folgen demselben Muster wie die mittlere Zeile / Spalte der board, so können wir die gleiche Bedingung verwenden, wenn wir die x- und y-Koordinaten modulo 7 nehmen.

Die Auswahl des angezeigten Buchstabens basiert auf der Koordinate der minimalen Größe. Auf diese Weise folgen die Doppel- und Dreifachzahlen bei (1,5) und (2,6) der gleichen Regel wie bei (1,1) und (2,2) und werden aus der 7-stelligen Zeichenfolge erhalten. "#{formula}dtDDDD"Dies deckt nicht alle Variationen ab Für die Kanten- und Mittellinienquadrate wird also das erste Zeichen der Zeichenfolge aus der Formel berechnet '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
}

Brainfuck , 598 596 590 Bytes

Golftipps willkommen.

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

Erläuterung

Initialisieren Sie das Band mit [10 116 68 46 100 84 92], dh [nl t D. d T \]

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

Jede Zeile hier druckt dann eine Zeile der Tafel.
Die Mittellinie nimmt ebenfalls ab92 to 88 i.e. \ to X

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

Probieren Sie es online!

PowerShell v2 +, 147 Byte

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

Nutzt den Vorteil, wie der Standard Write-Outputam Ende der Programmausführung Arrays behandelt (dh es wird eine neue Zeile zwischen Elementen eingefügt). Könnte ein besserer Weg sein, um die Mitte des Boards zu generieren - ich arbeite immer noch daran.

Die erste Zeile gibt die oberste Zeile der Karte aus und speichert sie $xzur späteren Verwendung.

Die nächste Zeile generiert alle Doppelwortzeilen, indem die linke "Hälfte" jeder Zeile genommen, gespiegelt (die -join$_[6..0]Anweisung) und als Elemente in einem Array gespeichert wird $y.

Die nächste Zeile ist die mittlere Zeile, mit einem Xin der Mitte, danke an -replace.

Die nächste Zeile wird $yin umgekehrter Reihenfolge ausgegeben, sodass die untersten Doppelwortzeilen angezeigt werden.

Die letzte Zeile ist nur noch $xeinmal.

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

> <> (Fisch), 153 Bytes

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

Eine schrecklich, schrecklich, ineffiziente Art, Dinge zu tun. Derzeit wird nach einer Möglichkeit gesucht, diese zu verkürzen, indem sowohl horizontal als auch vertikal richtig gespiegelt wird.

Probieren Sie es online! (Wenn Sie nicht den ganzen Tag anwesend sein möchten, stellen Sie sicher, dass Sie entweder die maximale Ausführungsgeschwindigkeit festlegen oder ohne Animation ausführen.)

C 146, 145, 142, 138 Bytes

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

Probieren Sie es online!

1 Byte 5 Byte gespart dank Level River St

Dies nutzt das diagonale Muster der Karte zum Codieren aus. Insbesondere wenn wir den oberen linken Quadranten der Tafel nehmen und die Diagonale ausrichten, erhalten wir:

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

... viele der Spalten stehen jetzt in einer Reihe. Wenn wir Spalten in einer Zeile folgendermaßen kodieren:

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

... dann kann das Brettmuster zu einer 15-stelligen Zeichenfolge zusammengefasst werden T..12..0..12..0:; und wir brauchen einfach die richtigen Zuordnungen für jede Zeile.

In diesem Sinne ist hier eine erweiterte Version mit Kommentaren:

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 Bytes

Code

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Erklärung (veraltet)

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

1002000100020010400030003000400040002020004002004000200040020000400000400000300030003000300020002020002001002000

Mit 4ÝJ".TdtD"‡transliterieren wir in dieser großen Zahl:

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

Wir teilen die gesamte Zeichenkette auf, lassen die Zeichenkette und die Zeichenkette auf dem Stapel vertauscht und verbinden sie "X"mit ý. Wir teilen die gesamte Saite mit th in 15er-Stücke15ô Code und fügen das gesamte Array mit den Zeilenumbrüchen hinzu ».

Python 3, 138 Bytes

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 Bytes

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

Probieren Sie es online!

Erklärt:

Drücken: 1003000104000200004000303004000300004000020002000030003010030005

In 8er-Stücke teilen, jeweils palindromisieren.

Wieder palindromieren.

Ersetzen Sie Zahlen durch Zeichen.

Andere Idee (Jemand versucht dies in MATL)

Sehen, wie ALLES gewollt ist, um eine Periode dazwischen zu haben ...

Zählen Sie die Anzahl der Nullen zwischen jedem Stück:

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

131424334342233135 => w\F6ß¿

Das Zählen von Nullen läuft:

23134312344343123 => ì:¼˜¾

Dann würden Sie sie entschlüsseln und zusammen transponieren.

Verwendung in 05AB1E (führt zu einer Erhöhung um +5 Byte):

05AB1E , 27 Bytes

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

Versuch es...

Meta-Golf Eintrag:

05AB1E , 104 Bytes

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

Versuch es!

Meta-golfed meines Meta-Golfer für ASCII - Art mit: https://tio.run/nexus/05ab1e#JY9NSgNBEIWvUo4/qAQxyfi30yAioiAiuBM6M9U9DT3doao7ccBFrhI3ooss3QguJniRXCR2x01RfK9479Xqtf2@XHy2H78/tw/L6aydq8VXr5sPsuX0LeP1jCwbJD3r54v3dp5mFGbZzWp1wXBPyLpE6@GRQj0C1spiCQJ4gjjSVgG@YBG8HiM4KpHAWbgiXYqmA1wF79ONrxCGa5nBOyCUQSEyCFuCi2LEklwNjGO0YAQpNA3cBTa6hsIF60kjd9Y@jAWhF9SAk1C5Gk1yiTSQ9g1MBKcKAp4q7RGuXWCMFlYioS3iKowBhf@9Kh2DNbEHGSIexhSZeDRIUcq4oTDxDS09aAsjZ3TRHGycb25tP@/s7@51e/386Pjk9OzwDw

Javascript (ES6), 150 Byte

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

Wie es funktioniert

Die Zeichenfolge "T2d3T3d2T.D3t3t3D3D3d.d3D2d2D3d3D2d4D5D5t3t3t3t3d3d.d3d2T2d3"beschreibt die Tafel von der oberen linken Ecke bis zum Quadrat kurz vor dem 'X', wobei aufeinanderfolgende leere Quadrate als Ziffern codiert sind. Die replace()Funktion entpackt sowohl die leeren Felder als auch die Spiegelzeichenfolge rfür die Unterseite des Boards. Dann werden beide Teile zusammengefügt und alle 15 Zeichen ein Wagenrücklauf eingefügt.

Demo

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 Byte

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>

Da ich mir die Mühe gemacht habe, dies zu erstellen, dachte ich, ich würde es trotzdem posten, obwohl es eine eindeutig überlegene Lösung gibt.

C 234 Bytes

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

Hier ist die Ausgabe:

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

Holzkohle , 33 Bytes (nicht konkurrierend)

Der gesamte Kredit für diese Antwort geht an @ DLosc .

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

Probieren Sie es online!

Ausführlich

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

Probieren Sie es online!

Haskell, 114 Bytes

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"

gin einer nicht pointfree version ist g x = x ++ (reverse (init x)). Es wird einmal pro (Halb-) Zeile und erneut auf das Ergebnis angewendet.

sh + coreutils, 119 Bytes

Dies ist eine Binärdatei. Dargestellt als 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

Hier ist das base64-Formular, damit Sie es kopieren und einfügen können:

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

C 230 228 Bytes

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

probier es auf ideone aus

Dies ist ein Versuch, die ursprüngliche C-Version zu verbessern, bei der ein Viertel der Platine in einem C-Array gespeichert war. Nicht so kurz, wie ich es mir erhofft hatte. In dieser Version ist nur ein Achtel der Karte gespeichert.

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 Bytes

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

Unter Ausnutzung der Spiegelsymmetrie der Platine ist die zweite Hälfte die erste, die in umgekehrter Reihenfolge im Laderaum abgelegt wurde.