Desenhe um tabuleiro vazio de Scrabble

28

Uma placa Scrabble padrão é uma grade de 15 × 15 para colocar blocos de letras. A maioria dos espaços está em branco, mas alguns são notas duplas de palavras (rosa), notas triplas de palavras (vermelho), notas duplas de letras (azul claro) e notas triplas de letras (azul). Geralmente, há uma estrela no centro (que conta como uma pontuação de duas palavras).

Prancha de Scrabble

Escreva um programa ou função que produza uma placa Scrabble vazia e padrão no formato ASCII, onde:

  • . representa um espaço vazio

  • D representa uma pontuação de palavra dupla

  • T representa uma pontuação tripla de palavras

  • d representa uma pontuação de duas letras

  • t representa uma pontuação de três letras

  • X representa a estrela central

Ou seja, sua saída exata deve 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 por uma nova linha à direita.

O código mais curto em bytes vence.

Passatempos de Calvin
fonte
Por que Xe não *representar a estrela? : o
Fatalize
6
*é muito alto e poderoso.
Hobbies de Calvin
Por que não ? : D
mbomb007 02/09
5
@ mbomb007 Caractere não ASCII em um desafio de arte ASCII? Heresia !
Luis Mendo

Respostas:

16

MATL , 59 54 52 bytes

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

Experimente online!

Explicação

O código segue três etapas principais:

  1. Gere a 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. Estenda-o para a 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. Indexe a string 'DtdTX.'com essa matriz para produzir o resultado desejado.

Passo 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

Agora precisamos preencher as entradas fora de diagonal diferentes de zero. Apenas preencheremos os que estão abaixo da diagonal e usaremos simetria para preencher os outros.

Para preencher cada valor, usamos a indexação linear (consulte esta resposta , trecho de comprimento 12). Isso significa acessar a matriz como se tivesse apenas uma dimensão. Para uma matriz 8 × 8, cada valor do índice linear refere-se a uma entrada da seguinte maneira:

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

Portanto, o seguinte atribui o valor 4 à entrada inferior esquerda:

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

O código para o valor 3 é semelhante. Nesse caso, o índice é um vetor, porque precisamos preencher várias 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

E para 2:

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

Agora temos a 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 preencher a metade superior, exploramos a simetria:

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

Passo 2

A pilha agora contém a matriz 8 × 8 resultante da etapa 1. Para estender essa matriz, usamos a indexação, desta vez nas duas dimensões.

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

etapa 3

A pilha agora contém a matriz 15 × 15 resultante da etapa 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
Luis Mendo
fonte
Isto é muito, muito legal.
AdmBorkBork 02/09
Eu gosto dessa resposta em geral, embora ela 'coça' um pouco quando você usa 8 caracteres para criar um vetor de comprimento 8. Você já pensou em obter os números por uma sequência matemática? Ainda não encontrou nada doce, mas especialmente os últimos 7 mostram um padrão tão bom. Por exemplo ceil ((1: 7) ^
4/500
@DennisJ Thanks! Sim, parece demais. Vou tentar isso mais tarde, agora por telefone
Luis Mendo
8

Ruby, 103 97 bytes

Agradecemos a Mitch Schwartz por uma melhoria de 6 bytes nas iterações.

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

Uma abordagem semelhante, mas significativamente diferente da minha resposta original abaixo. Como antes, usamos o fato de que uma letra deve ser impressa se i%7-j%7for igual a 0 ou 4. Mas aqui armazenamos essa diferença de usamos a fórmula i+j+d*d/3para fornecer um número inteiro único (até simetria) para esse quadrado colorido específico. Então nós apenas procuramos na corda mágica.

Apenas por diversão: versão C dessa abordagem, 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 salvos graças ao 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}

Explicação

A origem é considerada o centro do quadro.

Uma letra deve ser impressa se as coordenadas xey do quadrado tiverem magnitudes idênticas ou diferentes de 4. As únicas exceções estão na borda externa do quadro, mas seguem o mesmo padrão que a linha / coluna central da para que possamos usar a mesma condição se usarmos o módulo 7 das coordenadas x e y.

A escolha da letra exibida é baseada na coordenada de magnitude mínima. Dessa maneira, os duplos e triplos em (1,5) e (2,6) seguem a mesma regra que em (1,1) e (2,2) e são obtidos a partir da sequência de 7 caracteres. "#{formula}dtDDDD"Isso não cobre todas as variações para os quadrados da aresta e da linha central, então o primeiro caractere da sequência é calculado a partir da 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
}
Level River St
fonte
(k=-7..7).map{|y|k.map{...é 2 bytes menor que sua -7.upto(7)técnica dupla .
Value Ink
Algumas modificações para salvar 6 bytes: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]:?.}*''}
Mitch Schwartz
7

brainfuck , 598 596 590 bytes

Dicas de golfe são bem-vindas.

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

Explicação

Inicialize a fita para [10 116 68 46 100 84 92] ou seja, [nl t D. d T \]

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

Cada linha aqui imprime uma linha do quadro.
A linha do meio também diminui92 to 88 i.e. \ to X

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

Experimente online!

Emigna
fonte
1
Dicas para AM: não jogue golfe em AM; boa estratégia embora.
Magic Octopus Urn
5

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

Aproveita como o padrão Write-Outputno final da execução do programa lida com matrizes (ou seja, ele insere uma nova linha entre os elementos). Pode ser uma maneira melhor de gerar o meio do quadro - ainda estou trabalhando nisso.

A primeira linha gera a linha superior da placa, também a armazena $xpara uso posterior.

A próxima linha gera todas as linhas de palavra dupla pegando a "metade" esquerda de cada uma, espelhando-as (a -join$_[6..0]instrução) e armazenando-as como elementos na matriz $y.

A próxima linha é a linha do meio, com um Xno meio, graças a -replace.

A próxima linha é impressa $yna ordem inversa, fornecendo as linhas inferiores de duas palavras.

A linha final é apenas $xnovamente.

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
fonte
5

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

Uma maneira horrível, terrivelmente ineficiente de fazer as coisas. Atualmente, procurando uma maneira de reduzi-lo, espelhando horizontal e verticalmente corretamente.

Experimente online! (Se você não quiser ficar lá o dia todo, defina a velocidade de execução como max ou execute sem a animação.)

Callum Kerr
fonte
4

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

Experimente online!

1 byte 5 bytes economizados graças ao Level River St

Isso explora o padrão diagonal da placa para codificação. Em particular, se pegarmos o quadrante superior esquerdo do quadro e alinhar a diagonal, obtemos:

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

... muitas colunas agora estão alinhadas. Se codificarmos colunas em uma linha desta maneira:

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

... então o padrão de bordo podem ser recolhidas em uma seqüência de 15 caracteres: T..12..0..12..0; e simplesmente precisamos dos mapeamentos certos para cada linha.

Com isso em mente, aqui está uma versão expandida com comentários:

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 Walters
fonte
Muito agradável. 1. você pode enviar uma função em vez de um programa, tudo i,r,c;f()bem. 2. (i%16-7)%8-> i%16-7&73. Eu acho c-48-> c%4funciona, não é?
Level River St
Opa, desculpe, as funções precisam ser reutilizáveis, por f()isso exigiria um adicional i=0dentro da função para não salvar nada.
Level River St
Obrigado pelos comentários! 2 também não funcionará ( %8usa os módulos negativos da implementação para mapear% 16 valores 0..15 a -7..7; mapeará &7isso para 0..7,0..7). Mas, sim, 3 funcionará absolutamente ... será atualizado quando eu tiver uma chance.
H Walters
@LevelRiverSt Mea culpa; 2 ainda não funciona estritamente, mas eu não precisava disso de qualquer maneira.
perfil completo de H Walters
3

05AB1E , 57 53 bytes

Código

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

Usa a codificação CP-1252 . Experimente online!


Explicação (desatualizada)

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

1002000100020010400030003000400040002020004002004000200040020000400000400000300030003000300020002020002001002000

Com 4ÝJ".TdtD"‡, transliteramos o seguinte neste grande número:

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

Bifurcamos a string inteira, deixando a string e a string invertidas na pilha e juntando-as "X"usando ý. Dividimos a sequência inteira em pedaços de 15 usando o 15ôcódigo th e juntamos toda a matriz por novas linhas usando ».

Adnan
fonte
û€ûdeve ser um built-in;).
Magia Octopus Urna
2

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')
RootTwo
fonte
Mude list(map(A))para [*map(A)], economiza 3 bytes (requer Python 3.5+).
Shooqie
2

05AB1E , 49 44 bytes

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

Experimente online!

Explicado:

Empurrar: 1003000104000200004000303004000300004000020002000030003010030005

Divida em pedaços de 8, palindromize cada um.

Palindromize novamente.

Substitua números por caracteres.


Outra idéia (alguém tente fazer isso em MATL)

Visto que TUDO é voluntário para ter um período entre ele ...

Conte o número de zeros entre cada peça:

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

131424334342233135 => w\F6ß¿

Tomando a contagem de zeros:

23134312344343123 => ì:¼˜¾

Então você os descriptografaria e transporia juntos.

Utilizando-os em 05AB1E (resulta em um aumento de +5 bytes):

05AB1E , 27 bytes

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

Tente...


Entrada com meta-golfe:

05AB1E , 104 bytes

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

Tente!

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

Urna de polvo mágico
fonte
1

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

Como funciona

A string "T2d3T3d2T.D3t3t3D3D3d.d3D2d2D3d3D2d4D5D5t3t3t3t3d3d.d3d2T2d3"descreve o quadro do canto superior esquerdo ao quadrado imediatamente antes do 'X', com quadrados vazios consecutivos codificados como dígitos. A replace()função descompacta os quadrados vazios e constrói a sequência de espelhos rpara a parte inferior do tabuleiro. Em seguida, ambas as peças são reunidas e os retornos de carro são inseridos a cada 15 caracteres.

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

Arnauld
fonte
1

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 tive o trabalho de criar isso, pensei em publicá-lo de qualquer maneira, mesmo que exista uma solução claramente superior disponível.

Neil
fonte
1

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

Aqui está a saída:

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
fonte
1

Carvão , 33 bytes (não competitivo)

Todo o crédito para esta resposta vai para @DLosc .

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

Experimente online!

Verbose

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

Experimente online!

Somente ASCII
fonte
A ferramenta perfeita para esse desafio, com seus recursos de impressão na diagonal. +1 (e também esfriar para ver um método de fundo como que para ASCII)
Kevin Cruijssen
0

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"

gem uma versão não pointfree é g x = x ++ (reverse (init x)). É aplicado uma vez por (meia) linha e novamente no resultado.

nimi
fonte
0

sh + coreutils, 119 bytes

Este é um arquivo binário. 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

Aqui está o formulário base64 para que você possa copiá-lo / colá-lo:

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

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

experimente ideone

Esta é uma tentativa de melhorar a versão C original postada que tinha um quarto de placa armazenado em uma matriz C. Não tão curto quanto eu esperava. Esta versão possui apenas um oitavo do quadro armazenado.

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
fonte
0

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

Aproveitando a simetria de espelho da placa, a segunda metade é a primeira que foi armazenada em ordem inversa no espaço de espera.

seshoumara
fonte