Stampa un rettangolo pentomino


16

Scrivi un programma o una funzione che non accetta input ma stampa o restituisce una rappresentazione testuale costante di un rettangolo costituito da 12 pentomini distinti :

12 pentomini

Il rettangolo può avere qualsiasi dimensione ed essere in qualsiasi orientamento, ma tutti i 12 pentomini devono essere usati esattamente una volta, quindi avrà un'area 60. Ogni pentomino diverso deve essere composto da un diverso carattere ASCII stampabile (non è necessario utilizzare il lettere dall'alto).

Ad esempio, se si è scelto di produrre questa soluzione pentomino rettangolo 20 × 3:

Soluzione 3x20

L'output del tuo programma potrebbe essere simile al seguente:

00.@@@ccccF111//=---
0...@@c))FFF1//8===-
00.ttttt)))F1/8888=-

In alternativa, potresti trovare più facile giocare a golf con questa soluzione 6 × 10:

000111
203331
203431
22 444
2   46
57 666
57769!
58779!
58899!
5889!!

Qualunque soluzione di rettangolo farà, il tuo programma deve solo stamparne uno. (Una nuova riga finale nell'output va bene.)

Questo fantastico sito Web offre moltissime soluzioni per varie dimensioni di rettangoli e probabilmente vale la pena consultarle per assicurarsi che la soluzione sia il più corta possibile. Questo è code-golf, vince la risposta più breve in byte.


15
Bonus se è un "quine" in Piet.
mbomb007,

@ mbomb007 È praticamente impossibile con soli 12 blocchi con cui giocare: P
Sp3000,

Non penso che gli spazi dovrebbero essere ammessi ai confini. Ma dato che lo sono, posso omettere gli spazi finali? Ricevo un bonus se stampo una soluzione 5x12 verticale con un I di spazi alla fine?
John Dvorak,

@ Sp3000 che ne dici di un programma Piet composto interamente da soluzioni rettangolari pentomino?
John Dvorak,

@JanDvorak Non puoi omettere spazi finali se li hai. Sono personaggi come il resto dell'ASCII stampabile.
Hobby di Calvin il

Risposte:


1

Pyth, 37 byte

jc4.HC"&f3ªªwril3:[·)ÌDU[r)ÌDA»

Dimostrazione

Utilizza un approccio molto semplice: usa i byte esadecimali come numeri. Converti in un numero esadecimale, la base 256 lo codifica. Questo dà la corda magica sopra. Per decodificare, usa la funzione di decodifica 256 di base di Pyth, converti in esadecimale, dividi in 4 blocchi e unisciti su nuove righe.


5

CJam (44 byte)

Dato in formato xxd perché contiene caratteri di controllo (inclusa una scheda non elaborata , che gioca davvero male con MarkDown):

0000000: 2202 7e0d 8ef3 570d e085 e168 cf27 092c
0000010: a235 0c22 3235 3662 3562 332f 5f2c 2c2e
0000020: 7b32 2f27 412b 662b 7d7a 4e2a 

che decodifica in qualcosa del genere

"MAGIC STRING"256b5b3/_,,.{2/'A+f+}zN*

Demo online leggermente non golfata che non contiene caratteri di controllo e quindi funziona bene con le funzioni della libreria di decodifica dell'URI del browser.

Il principio di base è che poiché nessun pezzo si estende su più di 5 righe possiamo codificare un offset rispetto a una funzione lineare del numero di riga in modo compatto (in base 5, in effetti, anche se non ho provato a determinare se questo sarebbe sempre il caso ).


5

Bash + utility Linux comuni, 50

xxd -s20 -p -c2 $0
#<30 bytes of binary data>

Per ricreare questo da base64 codificato:

base64 -d <<< eHhkIC1zMjAgLXAgLWMyICQwCiMiImaSaZlmkDAAMwSjRKNEqoGogYhRVVF7UXu7d3s= > pent.sh

Poiché ci sono 12 pentomini, i loro colori sono facilmente codificati in nybbles esadecimali.

Produzione:

$ ./pent.sh
2222
6692
6999
6690
3000
3304
a344
a344
aa81
a881
8851
5551
7b51
7bbb
777b
$ 

4

J, 49 byte

u:64++/\|:3#.inv 1377859090 1567813024 1337683230

Puoi scegliere le lettere in modo che gli incrementi massimi tra le lettere adiacenti in verticale siano 2. Usiamo questo fatto per codificare gli incrementi verticali in base3. Successivamente creiamo le somme correnti e aggiungiamo un offset per ottenere i codici ASCII delle lettere.

Decisamente golfabile. (Devo ancora trovare un modo per inserire numeri base36 di precisione estesa, ma base36 semplice dovrebbe salvare solo 3 byte.)

Produzione:

AAA
ABA
BBB
DBC
DCC
DCC
DEE
DFE
FFE
FGE
FGG
GGH
HHH
IIH
JII
JJI
JKK
JKL
KKL
LLL

Provalo online qui.


Molto bella. Con la codifica Base-256 che applica questa differenza, la codifica in CJam fornisce 33 byte ( versione a 48 byte senza b256 ).
Peter Taylor,

Questo e spettacolare! Funzionerebbe anche con il 4x15, che funzionerebbe bene per impacchettare quattro numeri in un byte, se si memorizzano i dati in larghezza anziché in lunghezza. Avresti bisogno di un layout con U pentomino rivolto nella direzione giusta. Ci sono molti nel link alla domanda.
Level River St,

@steveverrill Avresti bisogno di un offset iniziale per questo perché ci saranno più di 4 pezzi a partire dalla prima riga, quindi non puoi codificarli in base4. Con questo offset aggiuntivo (ad es. 3#i.5Quale è 0 0 0 1 1 1 ... 4 4 4) può funzionare ma probabilmente non sarà più breve (almeno nel modo in cui ho provato).
randomra,

2

Microscript II , 66 byte

Cominciamo con la risposta semplice.

"00.@@@ccccF111//=---\n0...@@c))FFF1//8===-\n00.ttttt)))F1/8888=-"

Evviva stampa implicita.


1

Rubino

Rev 3, 55bytes

i=1
'S, OJ1*$HCH(#%0'.bytes{|e|puts "%x"%i+=e*130&9011}

Come ulteriore sviluppo dell'idea di Randomra, prendere in considerazione l'output e la tabella delle differenze di seguito. La tabella delle differenze può essere compressa come prima ed espansa moltiplicando per 65 = binario 1000001 e applicando una maschera 11001100110011. Tuttavia, Ruby non funziona in modo prevedibile con caratteri a 8 bit (tende a interpretarli come Unicode).

Sorprendentemente, l'ultima colonna è del tutto uniforme. Per questo motivo, nella compressione possiamo eseguire uno spostamento dei diritti sui dati. Ciò garantisce che tutti i codici siano ASCII a 7 bit. In espansione, moltiplichiamo semplicemente per 65 * 2 = 130 anziché 65.

Anche la prima colonna è del tutto uniforme. Pertanto, è possibile aggiungere 1 a ciascun elemento (32 per ogni byte) ove necessario, per evitare qualsiasi carattere di controllo. 1 indesiderato viene rimosso utilizzando la maschera 10001100110011 = 9011 anziché 11001100110011.

Solution 59 of document linked in question

Start0001

Out  Diff
2223 2222
2433 0210
2433 0000
4445 2012
6555 2110
6577 0022
6687 0110
6887 0200
8897 2010
aa99 2202
caa9 2010
cab9 0010
cbbb 0102
cdbd 0202
cddd 0020

Sebbene io usi 15 byte per la tabella, uso davvero solo 6 bit di ogni byte, per un totale di 90 bit. Vi sono infatti solo 36 possibili valori per ogni byte, che è 2.21E23 possibilità in totale. Ciò si adatterebbe a 77 bit di entropia.

Rev 2, 58 byte, usando l'approccio incrementale di Randomra

i=0
'UPEIP@bPHPBETTEPRADT'.bytes{|e|puts "%x"%i+=e*65&819}

Finalmente qualcosa di più corto della soluzione ingenua. Approccio incrementale di Randomra, con il metodo bytepacking di Rev 1.

Rev 1, 72 byte, versione golfata di rev 0

Sono state apportate alcune modifiche alla linea di base per adattarsi al riordino del codice per motivi di golf, ma sono ancora arrivati ​​più a lungo della soluzione ingenua.

i=0
'UPUIYD&!)$&V*).);c+*'.bytes{|e|i+=1;puts "%x"%(i/2*273+(e*65&819))}

Gli offset sono codificati in ciascun carattere della stringa magica nel formato base 4 BAC, ovvero con gli 1 che rappresentano il simbolo di destra, i 16 che rappresentano il simbolo di mezzo e il simbolo di sinistra calzato nella posizione del 4. Per estrarli, il codice ascii viene moltiplicato per 65 (binario 1000001) per dare BACBAC, quindi viene aggiunto con 819 (binario 1100110011) per dare .A.B.C.

Alcuni dei codici ascii hanno il settimo bit impostato, cioè sono 64 più alti del valore richiesto, per evitare i caratteri di controllo. Poiché questo bit viene rimosso dalla maschera 819, ciò è irrilevante, tranne quando il valore di Cè 3, che provoca un riporto. Questo deve essere corretto in un solo posto (invece di gusarlo c.)

Rev 0, versione non golfata

a= %w{000 010 000 201 100 100 011 021 110 120 011 112 111 221 211 221 122 123 112 222}
i=2
a.each{|e|puts "%x"%(i/2*273+e.to_i(16));i+=1} 

Produzione

111
121
222
423
433
433
455
465
665
675
677
778
888
998
a99
aa9
abb
abc
bbc
ccc

Spiegazione

Dalla seguente soluzione, sottraggo la linea di base, fornendo l'offset che memorizzo come dati. La linea di base viene rigenerata come numero esadecimale nel codice di i/2*273(273 decimale = 111 esadecimale).

solution   baseline   offset
AAA        AAA        000
ABA        AAA        010
BBB        BBB        000
DBC        BBB        201
DCC        CCC        100
DCC        CCC        100
DEE        DDD        011
DFE        DDD        021
FFE        EEE        110
FGE        EEE        120
FGG        FFF        011
GGH        FFF        112
HHH        GGG        111
IIH        GGG        221
JII        HHH        211
JJI        HHH        221
JKK        III        122
JKL        III        123
KKL        JJJ        112
LLL        JJJ        222

Sembra essenzialmente lo stesso approccio del mio, ma sei riuscito a evitare il delta singolo di 4 che mi ha costretto a codificare in base 5. Sembra che abbia scelto l'etichettatura sbagliata per i pezzi.
Peter Taylor,

Ho visto la tua risposta dopo aver pubblicato la mia. Non posso seguire Cjam, ma da quello che hai detto nella tua risposta è un approccio simile. In realtà ne ho solo uno 3in tutta la tabella (proprio vicino al fondo), quindi penso che aumentando la linea di base di poco più di 0,5 ogni riga potrebbe effettivamente essere possibile utilizzare la base 3. Sentiti libero di provarlo. (Per motivi di golf sembra che dovrò cambiare leggermente la linea di base, il che mi dà un po 'più di 3, e sfortunatamente sembra che sarà 1 byte più lungo della soluzione ingenua in Ruby.)
Level River St

Nel caso in cui non fossi stato chiaro prima, la mia intenzione era di congratularmi con te per aver fatto un lavoro migliore di me, non di accusarti di aver copiato. E non proverò a utilizzare un tasso di crescita di 2,5 perché non penso che batterà l'approccio di codifica delle differenze di randomra.
Peter Taylor,

@PeterTaylor grazie, ho capito che mi stavi congratulando con me. D'altra parte, sei entrato per primo con la stessa idea e l'hai reso molto più breve, quindi anche congratulazioni a te. Con l'approccio alla differenza di randomra finalmente posso diventare più breve della soluzione ingenua. Funzionerebbe bene anche su 4x15 (dato il giusto layout pentomino). Questo è il modo in cui lo farei in C o in qualsiasi altro linguaggio che funzioni bene con le stringhe 8.bit. Poiché Ruby supporta unicode, cerca di interpretare le stringhe a 8 bit come unicode e può dare alcuni fastidiosi messaggi di errore.
Level River St,

0

Foo, 66 byte

"00.@@@ccccF111//=---\n0...@@c))FFF1//8===-\n00.ttttt)))F1/8888=-"

Questo è carattere per carattere identico alla soluzione di Microscript II sopra ... Presumo che queste lingue siano correlate?
Darrel Hoffman,

1
@DatrelHoffman non proprio, praticamente praticamente stampa tutto tra virgolette
Teoc,
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.