introduzione

Un disco è un contenitore lineare con blocchi indicizzati 0attraverso size-1.

Un file è un elenco denominato di indici di blocco utilizzati da quel file.

Un filesystem di esempio è espresso in questo modo:

15 ALPHA=3,5 BETA=11,10,7

"Il disco ha 15 blocchi, il primo blocco del file ALPHA è il blocco del disco all'indice 3 ..."

La mappa del disco potrebbe essere disegnata in questo modo:

Block Index  00  01  02  03  04  05  06  07  08  09  10  11  12  13  14
Contents    |   |   |   |A0 |   |A1 |   |B2 |   |   |B1 |B0 |   |   |   |

Un disco viene considerato deframmentato quando tutti i file al suo interno vengono memorizzati in modo contiguo.

IL TUO OBIETTIVO:

Emettere una sequenza più breve di mosse legali che deframmenteranno un determinato disco.

Mosse legali

Una mossa contiene tre informazioni: il nome di un file, un indice del blocco nel file da spostare e l'indice del blocco del disco su cui si sposta.

Per esempio

ALPHA:1>4

"Sposta il blocco 1 del file ALPHA sul blocco 4 del disco."

Dopo questa mossa, il file system di esempio è ora questo

15 ALPHA=3,4 BETA=11,10,7

Block Index  00  01  02  03  04  05  06  07  08  09  10  11  12  13  14
Contents    |   |   |   |A0 |A1 |   |   |B2 |   |   |B1 |B0 |   |   |   |

Il blocco del disco precedentemente abitato viene cancellato implicitamente. Allo stesso modo, puoi vederlo come scambio di due blocchi sul disco ma uno dei blocchi nello scambio deve essere vuoto .

I dati non possono essere distrutti. I file non possono condividere i blocchi in nessuna fase e i movimenti devono trovarsi nel raggio d'azione del disco. Le seguenti mosse sono illegali : ALPHA:0>10(di proprietà di BETA), ALPHA:3>0(nessun tale blocco in ALPHA), ALPHA:0>-1(nessun tale indice del disco), ALPHA:0>15(indice del disco troppo grande)

Esempio 1

Risolve l'intero esempio sopra.

ALPHA:0>4
BETA:0>9
BETA:2>11

I file non devono essere adiacenti nella soluzione, solo continui all'interno di se stessi.

Esempio 2

Ecco un caso più limitato

Ingresso:

10 A=1,2,3 B=6,7,8 C=4,5,0

Produzione:

B:2>9
B:1>8
B:0>7
C:2>6

La progressione di questo filesystem è:

Block Index  00  01  02  03  04  05  06  07  08  09
Contents    |C2 |A0 |A1 |A2 |C0 |C1 |BO |B1 |B2 |   |
            |C2 |A0 |A1 |A2 |C0 |C1 |BO |B1 |   |B2 |
            |C2 |A0 |A1 |A2 |C0 |C1 |BO |   |B1 |B2 |
            |C2 |A0 |A1 |A2 |C0 |C1 |   |B0 |B1 |B2 |
            |   |A0 |A1 |A2 |C0 |C1 |C2 |B0 |B1 |B2 |

Un modo alternativo per deframmentare ciò consiste nel C:2>9portare Agiù un gradino, quindi Cabbassare un gradino, quindi farlo, C:2>5ma questa non sarebbe una soluzione legale perché contiene più mosse rispetto all'alternativa .

Rappresentazione

È possibile utilizzare qualsiasi rappresentazione per l'input purché sia ​​ragionevolmente vicina a una stringa di base. A seconda della lingua, l'ingresso al primo esempio potrebbe essere annotato come

"15 ALPHA=3,5 BETA=11,10,7"
[15," ","ALPHA","=",3,",",5," ","BETA","=",11,",",10,",",7]
(15,(("ALPHA",(3,5)),("BETA",(11,10,7))))
etc

Allo stesso modo, l'output può essere qualsiasi cosa sia conveniente per la tua lingua come log in quanto è stampato, leggibile dall'uomo e rappresenta un elenco ordinato di mosse legali, ogni mossa è descritta da 1) nome-file, 2) indice-file-blocco-indice , 3) indice-nuovo-disco-blocco

"ALPHA:1>6 BETA:2>9"
(0=>(0=>"ALPHA",1=>"1",2=>"6"), 1=>(0=>"BETA",1=>"2",2=>"9"))
["ALPHA",1,6,"BETA",2,9]
etc

Requisiti

Il codice deve accettare dischi di qualsiasi dimensione e qualsiasi numero e dimensione di file.

Gli input che non descrivono gli stati legali iniziali del filesystem possono portare a comportamenti indefiniti.

Il tuo codice deve produrre una soluzione di spostamenti più brevi , per qualsiasi input ben definito.

Tutte le mosse che produci devono essere legali; il filesystem deve essere in uno stato valido dopo aver applicato ogni passaggio che produci.

Il codice deve terminare per tutti gli input validi, ovvero non dovrebbe mai bloccarsi in un ciclo, il file system dovrebbe essere in uno stato nettamente nuovo dopo aver applicato ogni spostamento.

Laddove esiste più di una soluzione più breve, è possibile selezionarne una valida.

Il codice più corto vince. Pubblica almeno un nuovo input di esempio non banale e il suo output con il tuo codice.

Python 3 , 295 byte

S,F=eval(input());d=[0]*S;E=enumerate
for n,P in F:
 for j,p in E(P):d[int(p)]=n,j
Z=[(d,())]
while Z:d,p=Z.pop(0);any(e and(e[0],e[1]+1)in d and(S<j+2or(e[0],e[1]+1)!=d[j+1])for j,e in E(d))or print(p).q;{d[j]or exec("D=d[:];D[j]=e;D[k]=0;Z+=(D,p+(e,j)),")for j,_ in E(d)for k,e in E(d)if d[k]}

Provalo online!

Un altro caso di test

Ingresso:
   7 ALEF = 6,4,0 BET = 5,1 GIMEL = 3

Stato iniziale del disco:
   A2 B1 __ G0 A1 B0 A0

Soluzione:
   ALEF: 2> 2
   ALEF: 0> 0
   BET: 1> 6
   ALEF: 1> 1

Soluzione visualizzata:
   A2 B1 __ G0 A1 B0 A0
   __ B1 A2 G0 A1 B0 A0
   A0 B1 A2 G0 A1 B0 __
   A0 __ A2 G0 A1 B0 B1
   A0 A1 A2 G0 __ B0 B1

Versione Ungolfed .