Un tablero de Scrabble estándar es una cuadrícula de espacios de 15 × 15 para colocar fichas de letras. La mayoría de los espacios están en blanco, pero algunos son puntajes de palabras dobles (rosa), puntajes de palabras triples (rojo), puntajes de letras dobles (azul claro) y puntajes de letras triples (azul). Por lo general, hay una estrella en el centro (que cuenta como una puntuación de doble palabra).

Escriba un programa o función que genere una placa Scrabble vacía estándar en formato ASCII donde:

• . representa un espacio vacío

• D representa una puntuación de doble palabra

• T representa una puntuación de tres palabras

• d representa una puntuación de doble letra

• t representa una puntuación de tres letras

• X representa la estrella central

Es decir, su salida exacta debe ser

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

opcionalmente seguido de una nueva línea final.

El código más corto en bytes gana.

MATL , 59 54 52 bytes

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

Pruébalo en línea!

Explicación

El código sigue tres pasos principales:

1. Genera la matriz 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. Extiéndelo a la matriz 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. Indice la cadena 'DtdTX.'con esa matriz para producir el resultado deseado.

Paso 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

Ahora necesitamos completar las entradas no diagonales distintas de cero. Solo llenaremos los que están debajo de la diagonal y luego haremos uso de la simetría para llenar los otros.

Para completar cada valor usamos indexación lineal (vea esta respuesta , fragmento de longitud 12). Eso significa acceder a la matriz como si solo tuviera una dimensión. Para una matriz de 8 × 8, cada valor del índice lineal se refiere a una entrada de la siguiente manera:

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

Entonces, lo siguiente asigna el valor 4 a la entrada inferior izquierda:

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

El código para el valor 3 es similar. En este caso, el índice es un vector, porque necesitamos llenar varias entradas:

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

Y para 2:

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

Ahora tenemos la matriz

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

Para llenar la mitad superior, explotamos la simetría:

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

Paso 2

La pila ahora contiene la matriz 8 × 8 resultante del paso 1. Para extender esta matriz, usamos indexación, esta vez en las dos dimensiones.

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

Paso 3

La pila ahora contiene la matriz 15 × 15 resultante del paso 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 bytes

Gracias a Mitch Schwartz por una mejora de 6 bytes en las iteraciones.

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

Un enfoque similar pero significativamente diferente a mi respuesta original a continuación. Como antes, usamos el hecho de que una letra debe imprimirse si i%7-j%7es igual a 0 o 4. Pero aquí almacenamos esa diferencia dy usamos la fórmula i+j+d*d/3para dar un número entero que sea único (hasta la simetría) para ese cuadrado de color en particular. Luego lo buscamos en la cuerda mágica.

Solo por diversión: versión C de este enfoque, 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);}

Ruby, 115 113 bytes

2 bytes guardados gracias a 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}

Explicación

El origen se considera el centro del tablero.

Se debe imprimir una letra si las coordenadas x e y del cuadrado tienen magnitudes que son idénticas o difieren en 4. Las únicas excepciones están en el borde exterior del tablero, pero siguen el mismo patrón que la fila / columna central del bordo, por lo que podemos usar la misma condición si tomamos las coordenadas x e y módulo 7.

La elección de la letra que se muestra se basa en la coordenada de magnitud mínima. De esta manera, los dobles y triples en (1,5) y (2,6) siguen la misma regla que en (1,1) y (2,2) y se obtienen de la cadena de 7 caracteres "#{formula}dtDDDD"Esto no cubre todas las variaciones para los cuadrados de borde y línea central, por lo que el primer carácter de la cadena se calcula a partir de la fórmula '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

Consejos de golf bienvenidos.

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

Explicación

Inicialice la cinta a [10 116 68 46 100 84 92] es decir [nl t D. d T \]

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

Cada línea aquí imprime una línea del tablero.
La línea media también disminuye92 to 88 i.e. \ to X

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

Pruébalo en línea!

PowerShell v2 +, 147 bytes

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

Aprovecha cómo el valor predeterminado Write-Outputal final de la ejecución del programa maneja las matrices (es decir, inserta una nueva línea entre los elementos). Podría ser una mejor manera de generar el medio del tablero, todavía estoy trabajando en ello.

La primera línea da salida a la línea superior de la placa, y también la almacena $xpara su uso posterior.

La siguiente línea genera todas las líneas de doble palabra tomando la "mitad" izquierda de cada una, reflejándolas (la -join$_[6..0]declaración) y almacenándolas como elementos en la matriz$y .

La siguiente línea es la fila del medio, con un Xen el medio, gracias a -replace.

La siguiente línea sale $yen orden inverso, dándonos las líneas de doble palabra inferiores.

La línea final es solo $xotra vez.

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

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

Una forma horrible, horrible e ineficiente de hacer las cosas. Actualmente estoy buscando una forma de acortarlo reflejando tanto horizontal como verticalmente correctamente.

Pruébalo en línea! (Si no quieres estar allí todo el día, asegúrate de establecer la velocidad de ejecución al máximo o correr sin la animación).

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

Pruébalo en línea!

1 byte 5 bytes guardados gracias a Level River St

Esto explota el patrón diagonal de la placa para la codificación. En particular, si tomamos el cuadrante superior izquierdo del tablero y alineamos la diagonal, obtenemos:

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

... muchas de las columnas ahora se alinean. Si codificamos columnas en una línea de esta manera:

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

... entonces el patrón del tablero se puede plegar en una cadena de 15 caracteres: T..12..0..12..0; y simplemente necesitamos las asignaciones correctas para cada fila.

Con eso en mente, aquí hay una versión ampliada con comentarios:

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

Código

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

Utiliza la codificación CP-1252 . Pruébalo en línea!

Explicación (obsoleta)

El •4ç“–šã&$W§ñçvßÖŠ_æá_VFÛÞýi~7¾¬ÏXôc•5Bdescomprime a este número:

1002000100020010400030003000400040002020004002004000200040020000400000400000300030003000300020002020002001002000

Con 4ÝJ".TdtD"‡, transcribimos lo siguiente en este gran número:

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

Bifurcamos toda la cadena, dejando la cadena y la cadena invertidas en la pila y las unimos "X"usando ý. Dividimos la cadena completa en pedazos de 15 usando el 15ôcódigo th y unimos toda la matriz mediante líneas nuevas usando ».

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"‡

Pruébalo en línea!

Explicado:

Empujar: 1003000104000200004000303004000300004000020002000030003010030005

Dividir en trozos de 8, palindromize cada uno.

Palindromizar de nuevo.

Reemplazar números con caracteres.

Otra idea (alguien intente esto en MATL)

Ya que TODO está comprometido a tener un período intermedio ...

Cuente el número de ceros entre cada pieza:

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

131424334342233135 => w\F6ß¿

Tomando los recuentos de ceros se ejecuta:

23134312344343123 => ì:¼˜¾

Entonces los descifraría y los transpondría juntos.

Usarlos en 05AB1E (resulta en un aumento de +5 bytes):

05AB1E , 27 bytes

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

Intentalo...

Entrada de meta-golf:

05AB1E , 104 bytes

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

¡Intentalo!

Meta-golfed usando mi meta-jugador de golf para el arte ASCII: https://tio.run/nexus/05ab1e#JY9NSgNBEIWvUo4/qAQxyfi30yAioiAiuBM6M9U9DT3doao7ccBFrhI3ooss3QguJniRXCR2x01RfK9479Xqtf2@XHy2H78/tw/L6aydq8VXr5sPsuX0LeP1jCwbJD3r54v3dp5mFGbZzWp1wXBPyLpE6@GRQj0C1spiCQJ4gjjSVgG@YBG8HiM4KpHAWbgiXYqmA1wF79ONrxCGa5nBOyCUQSEyCFuCi2LEklwNjGO0YAQpNA3cBTa6hsIF60kjd9Y@jAWhF9SAk1C5Gk1yiTSQ9g1MBKcKAp4q7RGuXWCMFlYioS3iKowBhf@9Kh2DNbEHGSIexhSZeDRIUcq4oTDxDS09aAsjZ3TRHGycb25tP@/s7@51e/386Pjk9OzwDw

Javascript (ES6), 150 bytes

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

Cómo funciona

La cadena "T2d3T3d2T.D3t3t3D3D3d.d3D2d2D3d3D2d4D5D5t3t3t3t3d3d.d3d2T2d3"describe el tablero desde su esquina superior izquierda hasta el cuadrado justo antes de la 'X', con cuadrados vacíos consecutivos codificados como dígitos. La replace()función desempaqueta los cuadrados vacíos y crea la cadena de espejo rpara la parte inferior del tablero. Luego se juntan ambas partes y se insertan retornos de carro cada 15 caracteres.

Manifestación

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 bytes

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>

Desde que me tomé la molestia de crear esto, pensé en publicarlo de todos modos, aunque hay una solución claramente superior disponible.

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

Aquí está la salida:

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

Carbón , 33 bytes (sin competencia)

Todo el crédito por esta respuesta va a @DLosc .

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

Pruébalo en línea!

Verboso

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

Pruébalo en línea!

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"

gen una versión sin puntos es g x = x ++ (reverse (init x)). Se aplica una vez por (media) línea y nuevamente sobre el resultado.

sh + coreutils, 119 bytes

Este es un archivo binario. Mostrado como 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

Aquí está el formulario base64 para que pueda copiarlo / pegarlo:

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

pruébalo en ideone

Este es un intento de mejorar la versión C original publicada que tenía un cuarto de placa almacenada en una matriz C. No tan corto como esperaba. Esta versión solo tiene un octavo de la placa almacenada.

Sin golf:

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, 219205 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

Aprovechando la simetría de espejo del tablero, la segunda mitad es la primera que se almacenó en orden inverso en el espacio de espera.