Dessinez un tableau de scrabble vide

28

Un tableau Scrabble standard est une grille d'espaces de 15 × 15 pour placer des tuiles de lettres. La plupart des espaces sont vides, mais certains sont des scores de double mot (rose), des scores de triple mot (rouge), des scores de double lettre (bleu clair) et des scores de triple lettre (bleu). Il y a généralement une étoile au centre (qui compte comme un double score de mot).

Planche de scrabble

Écrivez un programme ou une fonction qui génère une carte Scrabble standard et vide sous forme ASCII où:

  • . représente un espace vide

  • D représente un score de double mot

  • T représente un score de mot triple

  • d représente un score en double lettre

  • t représente un score de triple lettre

  • X représente l'étoile centrale

Autrement dit, votre sortie exacte doit être

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

éventuellement suivi d'une nouvelle ligne de fin.

Le code le plus court en octets gagne.

Loisirs de Calvin
la source
Pourquoi Xet ne *pas représenter l'étoile? : o
Fatalize le
6
*est trop élevé et puissant.
Calvin's Hobbies
Pourquoi ne pas ? : D
mbomb007
5
@ mbomb007 Caractère non ASCII dans un défi ASCII-art? Hérésie !
Luis Mendo

Réponses:

16

MATL , 59 54 52 octets

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

Essayez-le en ligne!

Explication

Le code suit trois étapes principales:

  1. Générez la matrice 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. Étendez-le à la matrice 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. Indexez la chaîne 'DtdTX.'avec cette matrice pour produire le résultat souhaité.

Étape 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

Maintenant, nous devons remplir les entrées hors diagonales non nulles. Nous ne remplirons que ceux en dessous de la diagonale, puis utiliserons la symétrie pour remplir les autres.

Pour remplir chaque valeur, nous utilisons une indexation linéaire (voir cette réponse , extrait de longueur 12). Cela signifie accéder à la matrice comme si elle n'avait qu'une seule dimension. Pour une matrice 8 × 8, chaque valeur de l'indice linéaire fait référence à une entrée comme suit:

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

Ainsi, ce qui suit affecte la valeur 4 à l'entrée en bas à gauche:

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

Le code de la valeur 3 est similaire. Dans ce cas, l'index est un vecteur, car nous devons remplir plusieurs entrées:

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

Et pour 2:

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

Nous avons maintenant la matrice

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

Pour remplir la moitié supérieure, nous exploitons la symétrie:

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

Étape 2

La pile contient maintenant la matrice 8 × 8 issue de l'étape 1. Pour étendre cette matrice, nous utilisons l'indexation, cette fois dans les deux dimensions.

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

Étape 3

La pile contient désormais la matrice 15 × 15 issue de l'étape 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
la source
C'est vraiment, vraiment, cool.
AdmBorkBork
J'aime cette réponse en général, bien qu'elle "démange" un peu car vous utilisez 8 caractères pour créer un vecteur de longueur 8. Avez-vous envisagé d'obtenir les nombres par une séquence mathématique? Je n'ai pas encore trouvé quelque chose de sucré mais surtout les 7 derniers montrent un si joli motif. Par exemple, ceil ((1: 7) ^
4/500
@DennisJ Merci! Oui, c'est trop. Je vais essayer ça plus tard, au téléphone maintenant
Luis Mendo
8

Rubis, 103 97 octets

Merci à Mitch Schwartz pour une amélioration de 6 octets sur les itérations.

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

Une approche similaire mais significativement différente de ma réponse originale ci-dessous. Comme précédemment, nous utilisons le fait qu'une lettre doit être imprimée si i%7-j%7est égale à 0 ou 4. Mais ici, nous stockons cette différence det utilisons la formule i+j+d*d/3pour donner un entier qui est unique (jusqu'à la symétrie) à ce carré coloré particulier. Ensuite, nous cherchons juste dans la chaîne magique.

Juste pour le fun: version C de cette approche, 120 octets

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 octets économisés grâce à 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}

Explication

L'origine est considérée comme le centre du plateau.

Une lettre doit être imprimée si les coordonnées x et y du carré ont des grandeurs identiques ou différentes de 4. Les seules exceptions se trouvent sur le bord extérieur de la planche, mais elles suivent le même modèle que la ligne / colonne centrale du , nous pouvons donc utiliser la même condition si nous prenons les coordonnées x et y modulo 7.

Le choix de la lettre affichée est basé sur les coordonnées de magnitude minimale. De cette façon, les doubles et triples en (1,5) et (2,6) suivent la même règle qu'en (1,1) et (2,2) et sont obtenus à partir de la chaîne de 7 caractères "#{formula}dtDDDD"Cela ne couvre pas toutes les variations pour les carrés de bord et de ligne médiane, donc le premier caractère de la chaîne est calculé à partir de la formule '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
la source
(k=-7..7).map{|y|k.map{...est 2 octets plus court que votre -7.upto(7)technique double .
Value Ink
Quelques modifications pour économiser 6 octets: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 octets

Conseils de golf bienvenus.

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

Explication

Initialisez la bande sur [10 116 68 46 100 84 92], c'est-à-dire [nl t D. d T \]

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

Chaque ligne ici imprime ensuite une ligne du tableau.
La ligne médiane diminue également92 to 88 i.e. \ to X

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

Essayez-le en ligne!

Emigna
la source
1
Conseils pour BF: ne faites pas d'ascii golf en BF; belle stratégie cependant.
Urne de poulpe magique le
5

PowerShell v2 +, 147 octets

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

Profite de la façon dont la valeur par défaut Write-Output à la fin de l'exécution du programme gère les tableaux (c'est-à-dire qu'elle insère une nouvelle ligne entre les éléments). Cela pourrait être une meilleure façon de générer le milieu du tableau - j'y travaille toujours.

La première ligne sort la ligne supérieure de la carte, la stockant également dans $x pour une utilisation ultérieure.

La ligne suivante génère toutes les lignes de double mot en prenant la "moitié" gauche de chacune, en les mettant en miroir (l' -join$_[6..0]instruction) et en les stockant en tant qu'éléments dans un tableau$y .

La ligne suivante est la rangée du milieu, avec un Xau milieu, grâce à -replace.

La ligne suivante sort $ydans l'ordre inverse, ce qui nous donne les lignes inférieures de Double-Word.

La dernière ligne est juste de $xnouveau.

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
la source
5

> <> (Poisson), 153 octets

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

Une façon horrible, horrible et inefficace de faire les choses. Actuellement à la recherche d'un moyen de le raccourcir en reflétant correctement à la fois horizontalement et verticalement.

Essayez-le en ligne! (Si vous ne voulez pas être là toute la journée, assurez-vous de régler la vitesse d'exécution au maximum ou d'exécuter sans l'animation.)

Callum Kerr
la source
4

C, 146 145 142 138 octets

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

Essayez-le en ligne!

1 octet 5 octets enregistrés grâce à Level River St

Cela exploite le motif diagonal de la carte pour l'encodage. En particulier, si nous prenons le quadrant supérieur gauche de la planche et alignons la diagonale, nous obtenons:

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

... beaucoup de colonnes s'alignent maintenant. Si nous encodons des colonnes dans une ligne de cette façon:

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

... alors le modèle de carte peut être réduit en une chaîne de 15 caractères: T..12..0..12..0 ; et nous avons simplement besoin des bons mappages pour chaque ligne.

Dans cet esprit, voici une version étendue avec des commentaires:

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
la source
Très agréable. 1. vous pouvez soumettre une fonction au lieu d'un programme, tout i,r,c;f()va bien. 2. (i%16-7)%8-> i%16-7&73. Je pense c-48-> c%4ça marche, n'est-ce pas?
Level River St
Oups, désolé, les fonctions doivent être réutilisables, il f()faudrait donc un ajout i=0à l'intérieur de la fonction pour ne rien enregistrer.
Level River St
Merci pour les commentaires! 2 ne fonctionnera pas non plus ( %8utilise les modules négatifs de l'implémentation pour mapper les valeurs% 16 0..15 à -7..7; mapperait &7cela à 0..7,0..7). Mais, oui, 3 fonctionnera absolument ... sera mis à jour lorsque j'en aurai l'occasion.
H Walters du
@LevelRiverSt Mea culpa; 2 ne fonctionnera toujours pas strictement, mais je n'en avais pas besoin de toute façon.
H Walters du
3

05AB1E , 57 53 octets

Code

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

Utilise l' encodage CP-1252 . Essayez-le en ligne!


Explication (obsolète)

Le •4ç“–šã&$W§ñçvßÖŠ_æá_VFÛÞýi~7¾¬ÏXôc•5Bdécompresse à ce nombre:

1002000100020010400030003000400040002020004002004000200040020000400000400000300030003000300020002020002001002000

Avec 4ÝJ".TdtD"‡, nous translittérons ce qui suit dans ce grand nombre:

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

Nous bifurquons la chaîne entière, laissant la chaîne et la chaîne inversées sur la pile et les joignons en "X"utilisant ý. Nous divisons la chaîne entière en morceaux de 15 en utilisant le 15ôcode e et joignons le tableau entier par des sauts de ligne en utilisant ».

Adnan
la source
û€ûdevrait être un intégré;).
Urne de poulpe magique le
2

Python 3, 138 octets

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
la source
Remplacez list(map(A))par [*map(A)], enregistre 3 octets (nécessite Python 3.5+).
shooqie
2

05AB1E , 49 44 octets

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

Essayez-le en ligne!

Expliqué:

Pousser: 1003000104000200004000303004000300004000020002000030003010030005

Diviser en morceaux de 8, palindromiser chacun.

Palindromisez à nouveau.

Remplacez les chiffres par des caractères.


Autre idée (quelqu'un essaie ceci en MATL)

Vu que TOUT est volontaire pour avoir une période entre les deux ...

Comptez le nombre de zéros entre chaque pièce:

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

131424334342233135 => w\F6ß¿

Prendre le compte des zéros:

23134312344343123 => ì:¼˜¾

Ensuite, vous les décryptez et les transposez ensemble.

Les utiliser dans 05AB1E (entraîne une augmentation de +5 octets):

05AB1E , 27 octets

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

Essayez-le ...


Entrée méta-golf:

05AB1E , 104 octets

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

Essayez!

Meta-golfed utilisant mon méta-golfeur pour l' art ASCII: https://tio.run/nexus/05ab1e#JY9NSgNBEIWvUo4/qAQxyfi30yAioiAiuBM6M9U9DT3doao7ccBFrhI3ooss3QguJniRXCR2x01RfK9479Xqtf2@XHy2H78/tw/L6aydq8VXr5sPsuX0LeP1jCwbJD3r54v3dp5mFGbZzWp1wXBPyLpE6@GRQj0C1spiCQJ4gjjSVgG@YBG8HiM4KpHAWbgiXYqmA1wF79ONrxCGa5nBOyCUQSEyCFuCi2LEklwNjGO0YAQpNA3cBTa6hsIF60kjd9Y@jAWhF9SAk1C5Gk1yiTSQ9g1MBKcKAp4q7RGuXWCMFlYioS3iKowBhf@9Kh2DNbEHGSIexhSZeDRIUcq4oTDxDS09aAsjZ3TRHGycb25tP@/s7@51e/386Pjk9OzwDw

Urne de poulpe magique
la source
1

Javascript (ES6), 150 octets

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

Comment ça marche

La chaîne "T2d3T3d2T.D3t3t3D3D3d.d3D2d2D3d3D2d4D5D5t3t3t3t3d3d.d3d2T2d3"décrit la carte de son coin supérieur gauche au carré juste avant le «X», avec des carrés vides consécutifs codés en chiffres. lereplace() fonction à la fois décompresse les cases vides et crée la chaîne miroir rpour le bas de la carte. Ensuite, les deux parties sont assemblées et les retours chariot sont insérés tous les 15 caractères.

Démo

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
la source
1

JavaScript (ES6), 221 octets

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>

Depuis que j'ai pris la peine de créer cela, j'ai pensé que je le publierais de toute façon même s'il existe une solution clairement supérieure.

Neil
la source
1

C 234 octets

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

Voici la sortie:

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
la source
1

charbon , 33 octets (non compétitif)

Tout le mérite de cette réponse va à @DLosc .

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

Essayez-le en ligne!

Verbeux

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

Essayez-le en ligne!

ASCII uniquement
la source
L'outil parfait pour ce défi, avec ses capacités d'impression en diagonale. +1 (et aussi cool de voir une méthode d'arrière-plan comme celle-là pour ASCII)
Kevin Cruijssen
0

Haskell, 114 octets

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"

gdans une version non-pointfree est g x = x ++ (reverse (init x)). Il est appliqué une fois par (demi) ligne et à nouveau sur le résultat.

nimi
la source
0

sh + coreutils, 119 octets

Ceci est un fichier binaire. Montré comme 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

Voici le formulaire base64 pour que vous puissiez le copier / coller:

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

C 230 228 octets

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

essayez-le sur ideone

Il s'agit d'une tentative d'amélioration de la version C d'origine publiée qui avait un quart de carte stocké dans un tableau C. Pas aussi court que je l'espérais. Cette version n'a qu'un huitième de la carte stockée.

Non 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("");
    }
}
bnf679
la source
0

GNU sed, 219 205 octets

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

Profitant de la symétrie miroir de la planche, la seconde moitié est la première qui a été stockée dans l'ordre inverse dans l'espace de maintien.

seshoumara
la source