introduzione

I tangram sono un puzzle classico che coinvolge l'organizzazione / il montaggio di blocchi in varie forme. Dal cinese 七巧板 - che significa letteralmente "sette assi di abilità". Prendiamo questa idea e usiamo i sette pezzi di Tetrominos per riempire una griglia.

Sfida

Scrivi una funzione o un programma che accetta come input una matrice di coordinate della griglia e genera una griglia 10 per 20 completata riempita con pezzi di Tetris tranne che nelle coordinate specificate.

Ottimizza il tuo punteggio cercando di mantenere uniforme la distribuzione dei pezzi.

criteri

Usa questo insieme di coordinate per completare il tuo compito. Esistono cinque serie di coordinate. Sentiti libero di modificare il formato in cui sono scritte le coordinate, ma non i valori.

Il set di dati n. 2 non può essere risolto: in questo caso, è sufficiente emettere la griglia con le celle di input riempite (ovvero, Xdove sono i fori).

Ingresso

Le coordinate della griglia rappresentano i "buchi" nella griglia. Queste sono celle che non possono contenere alcuna parte di un Tetromino.

Coordinate della griglia:

(0,0), (1,0), (2,0), ... (9,0)
(0,1), (1,1), (2,1), ... (9,1)
.
.
.
(0,19), (1,19), (2,19), ... (9,19)

• Usa lo stile di array scelto dal tuo linguaggio di programmazione per inserire le coordinate.

• Rappresenta i buchi nella griglia con un ASCIIX o altro stampabile .

Produzione

Utilizzando una griglia Tetris standard di 10 celle di larghezza per 20 celle di altezza , stampare una griglia di soluzione se e solo se la griglia può essere riempita completamente e perfettamente usando pezzi di Tetromino.

Pezzi costruiti con le lettere I, O, L, J, T, Z, Scome segue:

I          
I          L      J
I    OO    L      J     T     ZZ      SS
I    OO    LL    JJ    TTT     ZZ    SS

Esempio

Esempio di soluzione di output senza coordinate di input:

ZZIIIILLLI
JZZTTTLLLI
JJJSTLOOLI
SZZSSLOOLI
SSZZSLLJJI
TSOOSLLJII
TTOOSSLJII
TZOOSSLZII
ZZOOSSZZII
ZJJJJSZLLI
TTTJJOOILI
ITZJJOOILI
IZZTTTLIII
IZOOTZLIII
IJOOZZLLII
LJJJZSSTII
LLLTSSTTTI
LLLTTSSZJI
OOLTSSZZJI
OOIIIIZJJI

Con distribuzione come segue:

I          
I          L      J
I    OO    L      J     T     ZZ      SS
I    OO    LL    JJ    TTT     ZZ    SS

11   6     8     6      6     7      6

Appunti

Le coordinate rappresentano un singolo Xe una Yposizione sulla griglia. La griglia è basata su 0, il che significa che le coordinate (0,0)dovrebbero essere la cella in alto a sinistra o in basso a sinistra, a scelta dell'autore.

I mattoni possono:

• essere selezionato a discrezione dell'autore.
• essere ruotato quando l'autore lo ritiene opportuno.
• essere posizionato sulla griglia ovunque a discrezione dell'autore (aka: nessuna gravità Tetris)

I mattoni non possono:

• essere posizionato al di fuori dei limiti della griglia.
• sovrapporre un mattone o un buco esistente nella griglia.
• essere un pezzo tetromino non standard di Tetris.

punteggio

Il tuo punteggio è nel formato:

(1000 - [byte nel codice]) * (M / 10 + 1)

Dove M è un moltiplicatore per la distribuzione di pezzi utilizzati nei set di soluzioni.

Il punteggio più alto ottenuto dalle Ides di marzo vince.

Per calcolare M, aggiungi il valore di distribuzione tetromino individuale più basso per ogni set e quindi prendi la media arrotondata per difetto per calcolare M.

Per esempio:

Set 1: 5
Set 2: 4
Set 3: 5
Set 4: 6
Set 5: 3

6 + 4 + 5 + 4 + 4 = 21/5 = 4.6

Quindi useresti 4come valore M.

Nota: se un set non ha soluzione, non tener conto di quel set nel calcolo di M, poiché non avrebbe distribuzione tetromino.

Python 3 , 819 byte, M = 0, punteggio = 181

Questo è un programma DFS a forza bruta. Costruisce un array intorpidito e inserisce tutti i buchi immessi. Prende quindi la tessera vuota più a sinistra sulla riga più alta che ne ha una e posiziona un tetromino. Ricorsivamente, ora lo facciamo di nuovo: quando non riusciamo a trovare una soluzione, o facciamo un passo indietro e proviamo un altro pezzo alla prima occasione.

Questo ha una M di 0, poiché cerca di usare i pezzi in un ordine determinato e trova quasi sempre una soluzione senza l'ultima nell'elenco. Ho provato a utilizzare un elenco ordinato casualmente ogni ciclo per rendere una distribuzione più uniforme, ma ho ottenuto solo una M di 2, che non valeva i byte necessari per importare random.shuffle .

Non posso commentare il codice qui sotto, dal momento che nel mio golf ho dimenticato da molto che cosa fa. L'idea generale:

• Importa prodotti numpy e itertools, con nomi di 1 lettera
• Rinominare alcuni builtin come funzioni di 1 lettera e definire un lambda per salvare i byte
• Costruisci la matrice di possibili tetrominos come numpy nd-array, incluse tutte le rotazioni
• Nella funzione ricorsiva:
  • Ottieni la posizione della piastrella non riempita desiderata e scorri l'elenco dei pezzi
  • Per ogni pezzo, scorrere le traduzioni di esso (spostandolo su e giù)
  • Se qualcosa non funziona (il pezzo esce dal tabellone, colpisce un altro pezzo, colpisce un buco, ecc.), Prova la traduzione successiva o l'intero pezzo successivo
  • Se funziona, fantastico. Provalo, quindi chiama ricorsivamente la funzione.
  • Se quel percorso non ha funzionato, restituirà "a", quindi riproviamo. Se ha funzionato, restituisce la scheda e la superiamo.
• Finalmente il programma. Costruiamo la scheda 10x20 come un array intorpidito di 1.
• L'input ha la forma (x1, y1); (x2, y2); ... Mettiamo un 9 per ogni buco in esso, quindi otteniamo il risultato di eseguire la funzione su di esso.
• L'istruzione print visualizza quindi il risultato corretto o la scheda vuota, originale riga per riga, sostituendo le lettere o i simboli appropriati per i numeri.

import numpy as n
from itertools import product as e
m,s=range,len
p=[n.rot90(a,k)for a,r in[([[2,2]]*2,1),([[3]*3,[1,3,1]],4),([[0]*4],2),([[1,1,6],[6]*3],4),([[7,1,1],[7]*3],4),([[4,4,1],[1,4,4]],2),([[1,5,5],[5,5,1]],2)]for k in m(r)]
o=lambda a:e(m(s(a)),m(s(a[0])))
def t(l,d=0):
	g=list(zip(*n.where(l==1)))[0]
	for a in p:
		for u,v in o(a):
			w,x=l.copy(),0
			for r,c in o(a):
				if a[r,c]!=1:
					i,j=g[0]+r-u,g[1]+c-v
					if any([i<0,i>19,j<0,j>9])or l[i,j]!=1:
						x=1
						break
					w[i,j]=a[r,c]
			if x==0:
				if len(w[w==1]):
					f=t(w,d+1)
					if type(f)==str:continue
					return f
				return w
	return'a'
b=n.ones((20,10))
b[list(zip(*[eval(k)[::-1]for k in input().split(';')]))]=9
a=t(b)
for r in(a,b)[type(a)==str]:
	print(''.join(map(dict(zip([0,2,3,4,5,6,7,9,1],'IOTZSLJX-')).get,r)))

Provalo online!

Test di esempio:

In: (1,1);(8,1);(4,4);(5,8);(4,11);(5,15);(1,18);(8,18)
Out: 
IIIIOOOOLL
TXOOOOOOXL
TTOOOOOOTL
TOOIOOOOTT
TOOIXOOTTI
TTTITOOTTI
TTTITTTTII
OOTTTTTTII
OOTTTXOOII
TTTTOOOOII
TTTTOOOOII
TTTTXTOOII
ITTTTTTTII
ITTTTTTTII
IITTTLLTTI
IITOOXLTTI
IITOOTLTTI
IITTLTTTTI
IXTLLTJTXI
ILLLLLJJJI