Disegna una tavola Scrabble vuota


28

Una scheda Scrabble standard è una griglia 15 × 15 di spazi per posizionare tessere lettere. La maggior parte degli spazi sono vuoti ma alcuni sono punteggi a doppia parola (rosa), punteggi a tre parole (rosso), punteggi a doppia lettera (blu chiaro) e punteggi a tre lettere (blu). Di solito c'è una stella nel centro (che conta come un punteggio di doppia parola).

Scrabble board

Scrivi un programma o una funzione che emetta una scheda Scrabble standard vuota in formato ASCII dove:

  • . rappresenta uno spazio vuoto

  • D rappresenta un punteggio di doppia parola

  • T rappresenta un punteggio di tre parole

  • d rappresenta un punteggio a doppia lettera

  • t rappresenta un punteggio di tre lettere

  • X rappresenta la stella centrale

Cioè, l'output esatto deve essere

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

facoltativamente seguito da una nuova riga finale.

Vince il codice più breve in byte.


Perché Xe non *rappresentare la stella? : o
Fatalizza il

6
*è troppo alto e potente.
Calvin's Hobbies,

Perché no ? : D
mbomb007,

5
@ mbomb007 Carattere non ASCII in una sfida di arte ASCII? Eresia !
Luis Mendo,

Risposte:


16

MATL , 59 54 52 byte

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

Provalo online!

Spiegazione

Il codice segue tre passaggi principali:

  1. Genera 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. Estendilo alla 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. Indicizza la stringa 'DtdTX.'con quella matrice per produrre il risultato desiderato.

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

Ora dobbiamo riempire le voci fuori diagonale diverse da zero. Riempiremo solo quelli al di sotto della diagonale, quindi utilizzeremo la simmetria per riempire gli altri.

Per riempire ogni valore utilizziamo l'indicizzazione lineare (vedi questa risposta , frammento di lunghezza 12). Ciò significa accedere alla matrice come se avesse solo una dimensione. Per una matrice 8 × 8, ogni valore dell'indice lineare si riferisce a una voce come segue:

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

Quindi, il seguente assegna il valore 4 alla voce in basso a sinistra:

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

Il codice per il valore 3 è simile. In questo caso l'indice è un vettore, perché dobbiamo riempire diverse voci:

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 per 2:

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

Ora abbiamo 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

Per riempire la metà superiore sfruttiamo la simmetria:

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

Passo 2

Lo stack ora contiene la matrice 8 × 8 risultante dal passaggio 1. Per estendere questa matrice utilizziamo l'indicizzazione, questa volta nelle due dimensioni.

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

Passaggio 3

Lo stack ora contiene la matrice 15 × 15 risultante dal passaggio 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

Questo è davvero fantastico.
AdmBorkBork,

Mi piace questa risposta in generale, anche se "prude" un po 'mentre usi 8 caratteri per creare un vettore di lunghezza 8. Hai mai considerato di ottenere i numeri con una sequenza matematica? Non ho ancora trovato nulla di dolce ma soprattutto gli ultimi 7 mostrano un modello così bello. Per esempio ceil ((1: 7) ^
4/500

@DennisJ Grazie! Sì, sembra troppo. Ci proverò più tardi, al telefono adesso
Luis Mendo,

8

Rubino, 103 97 byte

Grazie a Mitch Schwartz per un miglioramento di 6 byte sulle iterazioni.

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 approccio simile ma significativamente diverso alla mia risposta originale di seguito. Come prima, usiamo il fatto che una lettera deve essere stampata se i%7-j%7è uguale a 0 o 4. Ma qui memorizziamo quella differenza de usiamo la formula i+j+d*d/3per dare un numero intero che è unico (fino alla simmetria) a quel particolare quadrato colorato. Quindi lo cerchiamo nella corda magica.

Solo per divertimento: versione C di questo approccio, 120 byte

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

Rubino, 115 113 byte

2 byte risparmiati grazie 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}

Spiegazione

L'origine è considerata il centro del tabellone.

Una lettera deve essere stampata se le coordinate xey del quadrato hanno magnitudini identiche o diverse per 4. Le uniche eccezioni si trovano sul bordo esterno del tabellone, ma seguono lo stesso modello della riga / colonna centrale del board, quindi possiamo usare la stessa condizione se prendiamo le coordinate xey y modulo 7.

La scelta della lettera visualizzata si basa sulle coordinate di magnitudine minima. In questo modo i doppi e i tripli in (1,5) e (2,6) seguono la stessa regola di (1,1) e (2,2) e sono ottenuti dalla stringa di 7 caratteri "#{formula}dtDDDD"Questo non copre tutte le variazioni per i quadrati del bordo e della mezzeria, quindi il primo carattere della stringa viene calcolato dalla formula '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
}

(k=-7..7).map{|y|k.map{...è 2 byte più breve della tua doppia -7.upto(7)tecnica.
Value Ink

Alcune modifiche per salvare 6 byte: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 byte

Suggerimenti per il golf benvenuti.

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

Spiegazione

Inizializza il nastro su [10 116 68 46 100 84 92] ovvero [nl t D. d T \]

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

Ogni riga qui quindi stampa una riga della scheda.
Anche la linea mediana diminuisce92 to 88 i.e. \ to X

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

Provalo online!


1
Suggerimenti per BF: non asciugare il golf in BF; bella strategia però.
Magic Octopus Urn

5

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

Sfrutta il modo in cui il default Write-Outputalla fine dell'esecuzione del programma gestisce le matrici (cioè inserisce una nuova riga tra gli elementi). Potrebbe essere un modo migliore per generare il centro del tabellone - ci sto ancora lavorando.

La prima riga emette la riga superiore della scheda, memorizzandola anche $xper un utilizzo successivo.

La riga successiva genera tutte le righe a doppia parola prendendo la "metà" sinistra di ciascuna, rispecchiandole (l' -join$_[6..0]istruzione) e memorizzandole come elementi nella matrice $y.

La riga successiva è la riga centrale, con una Xal centro, grazie a -replace.

La riga successiva viene visualizzata $yin ordine inverso, dandoci le righe doppie di fondo.

L'ultima riga è di $xnuovo.

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

5

> <> (Pesce), 153 byte

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

Un modo orribile, terribilmente, inefficiente di fare le cose. Attualmente sto cercando un modo per accorciarlo rispecchiando correttamente sia in orizzontale che in verticale.

Provalo online! (Se non vuoi essere lì tutto il giorno, assicurati di impostare la velocità di esecuzione al massimo o di correre senza l'animazione.)


4

C, 146 145 142 138 byte

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

Provalo online!

1 byte 5 byte salvati grazie a Level River St

Questo sfrutta il modello diagonale della scheda per la codifica. In particolare, se prendiamo il quadrante in alto a sinistra della tavola e allineamo la diagonale, otteniamo:

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

... molte colonne ora si allineano. Se codifichiamo le colonne in una riga in questo modo:

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

... allora il modello scheda può essere compresso in una stringa di 15 caratteri: T..12..0..12..0; e abbiamo semplicemente bisogno dei giusti mapping per ogni riga.

Con questo in mente, ecco una versione estesa con commenti:

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

Molto bella. 1. è possibile inviare una funzione anziché un programma, quindi i,r,c;f()va bene. 2. (i%16-7)%8-> i%16-7&73. Penso che c-48-> c%4funzioni, vero?
Level River St

Spiacenti, le funzioni devono essere riutilizzabili, quindi f()richiederebbe un'aggiunta i=0all'interno della funzione in modo da non salvare nulla.
Level River St

Grazie per i commenti! %8Nemmeno 2 funzionerà ( usa i moduli negativi dell'implementazione per mappare i valori di% 16 da 0..15 a -7..7; lo &7farebbe su 0..7,0..7). Ma sì, 3 funzionerà assolutamente ... si aggiornerà quando ne avrò la possibilità.
H Walters,

@LevelRiverSt Mea culpa; 2 non funzionerà ancora rigorosamente, ma comunque non avevo bisogno di quella roba.
H Walters,

3

05AB1E , 57 53 byte

Codice

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

Utilizza la codifica CP-1252 . Provalo online!


Spiegazione (obsoleta)

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

1002000100020010400030003000400040002020004002004000200040020000400000400000300030003000300020002020002001002000

Con 4ÝJ".TdtD"‡, trascriviamo quanto segue in questo grande numero:

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

Biforciamo l'intera stringa, lasciando la stringa e la stringa invertite nello stack e le uniamo "X"usando ý. Dividiamo l'intera stringa in pezzi di 15 usando il 15ôcodice th e uniamo l'intero array con le nuove linee usando ».


û€ûdovrebbe essere integrato;).
Magic Octopus Urn

2

Python 3, 138 byte

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

Cambio list(map(A))a [*map(A)], consente di risparmiare 3 byte (richiede Python 3.5+).
shooqie,

2

05AB1E , 49 44 byte

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

Provalo online!

Ha spiegato:

Spingere: 1003000104000200004000303004000300004000020002000030003010030005

Dividi in blocchi di 8, palindromizza ciascuno.

Palindromizza di nuovo.

Sostituisci i numeri con i caratteri.


Altra idea (qualcuno lo prova in MATL)

Visto che TUTTO è garantito per avere un periodo tra di esso ...

Conta il numero di zeri tra ogni pezzo:

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

131424334342233135 => w\F6ß¿

Prendendo i conteggi delle serie di zeri:

23134312344343123 => ì:¼˜¾

Quindi decrittografarli e trasporli insieme.

Usandoli in 05AB1E (comporta un aumento di +5 byte):

05AB1E , 27 byte

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

Provalo...


Ingresso meta-golf:

05AB1E , 104 byte

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

Provalo!

Meta-golfed usando la mia meta-giocatore di golf per l'arte ASCII: https://tio.run/nexus/05ab1e#JY9NSgNBEIWvUo4/qAQxyfi30yAioiAiuBM6M9U9DT3doao7ccBFrhI3ooss3QguJniRXCR2x01RfK9479Xqtf2@XHy2H78/tw/L6aydq8VXr5sPsuX0LeP1jCwbJD3r54v3dp5mFGbZzWp1wXBPyLpE6@GRQj0C1spiCQJ4gjjSVgG@YBG8HiM4KpHAWbgiXYqmA1wF79ONrxCGa5nBOyCUQSEyCFuCi2LEklwNjGO0YAQpNA3cBTa6hsIF60kjd9Y@jAWhF9SAk1C5Gk1yiTSQ9g1MBKcKAp4q7RGuXWCMFlYioS3iKowBhf@9Kh2DNbEHGSIexhSZeDRIUcq4oTDxDS09aAsjZ3TRHGycb25tP@/s7@51e/386Pjk9OzwDw


1

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

Come funziona

La stringa "T2d3T3d2T.D3t3t3D3D3d.d3D2d2D3d3D2d4D5D5t3t3t3t3d3d.d3d2T2d3"descrive la tavola dal suo angolo in alto a sinistra al quadrato appena prima della "X", con quadrati vuoti consecutivi codificati come cifre. La replace()funzione disimballa i quadrati vuoti e crea la stringa speculare rper il fondo del tabellone. Quindi entrambe le parti vengono unite e i ritorni a capo vengono inseriti ogni 15 caratteri.

dimostrazione

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


1

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>

Dal momento che mi sono preso la briga di creare questo ho pensato di pubblicarlo comunque anche se c'è una soluzione chiaramente superiore disponibile.


1

C 234 byte

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

Ecco l'output:

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

1

Carbone , 33 byte (non competitivo)

Tutto il merito di questa risposta va a @DLosc .

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

Provalo online!

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

Provalo online!


Lo strumento perfetto per questa sfida, con le sue capacità di stampa diagonale. +1 (e anche bello vedere un metodo di background come quello per ASCII)
Kevin Cruijssen

0

Haskell, 114 byte

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 una versione non pointfree è g x = x ++ (reverse (init x)). Viene applicato una volta per (mezza) linea e di nuovo sul risultato.


0

sh + coreutils, 119 byte

Questo è un file binario. Mostrato come 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

Ecco il modulo base64 in modo da poterlo copiare / incollare:

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

0

C 230 228 byte

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

provalo su ideone

Questo è un tentativo di migliorare la versione C originale pubblicata che aveva un quarto di scheda memorizzato in un array C. Non così breve come speravo. Questa versione ha solo un ottavo della scheda memorizzata.

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

0

GNU sed, 219 205 byte

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

Sfruttando la simmetria speculare della tavola, la seconda metà è la prima che è stata memorizzata in ordine inverso nello spazio di attesa.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.