34

Crea un programma o una funzione per sbloccare un quadrato di cifre capovolgendo (invertendo il punto centrale) solo righe e colonne.

Ingresso

L'input sarà una griglia di 9x9 cifre sotto forma di una stringa di 9 righe come la seguente:

Questo formato di input non è negoziabile: qualsiasi soluzione "creativa" con il formato di input verrà considerata non valida.

Produzione

L'output dovrebbe essere un elenco di movimenti di inversione che, quando applicati all'input nell'ordine dato, dovrebbero ricreare la griglia di destinazione.

Un esempio di output (non una soluzione al precedente esempio di input):

28IF5D3EAB9G3

Anche questo formato di output non è negoziabile. Non dovrebbero esserci nuove righe o spazi nell'output, ma solo i caratteri 1- 9e A- I(i caratteri minuscoli sono accettabili al posto dei caratteri maiuscoli se si preferisce).

La griglia di destinazione (lo stato che è necessario ricreare) è la seguente:

I numeri 1- 9dovrebbero essere usati come istruzioni per capovolgere le righe e le lettere A- Idovrebbero essere usati per le colonne. Questo è mostrato di seguito con la griglia nel suo stato ripristinato.

     ABCDEFGHI
     |||||||||
     vvvvvvvvv
1 -> 123456789
2 -> 234567891
3 -> 345678912
4 -> 456789123
5 -> 567891234
6 -> 678912345
7 -> 789123456
8 -> 891234567
9 -> 912345678

Quindi un 8mezzo capovolge la seconda fila dal basso e un Fmezzo capovolge la sesta colonna.

Nel caso in cui non sia possibile alcuna soluzione, il programma dovrebbe terminare senza generare nulla.

Esempi

Ingresso:

Produzione:

In questo caso, solo la riga superiore deve essere capovolta per tornare allo stato obiettivo.

Ingresso:

Produzione:

In questo caso, solo la colonna finale (colonna I) deve essere ruotata per ricreare lo stato dell'obiettivo.

Ingresso:

Produzione:

2I

In questo caso è necessario capovolgere la riga 2e poi capovolgere la colonna Iper tornare allo stato obiettivo.

Gli appunti:

Includi un esempio di utilizzo nella tua risposta.
L'output fornito non deve essere la sequenza più breve che restituirà lo stato dell'obiettivo - qualsiasi sequenza che restituisce lo stato dell'obiettivo farà tutto il tempo in cui funziona (cioè fino a quando posso provarlo)
Mi impegnerò a testare ogni risposta e voterò a favore di tutti quelli che funzionano e che hanno ovviamente tentato di giocare a golf.
Questa è una competizione a tempo indeterminato: accetterò la risposta più breve la prossima settimana, ma se arriva una risposta valida più recente, che sarà più corta in qualsiasi momento in futuro, cambierò la risposta accettata per riflettere quella .
La taglia è stata fissata a 200 reputazione per la risposta più breve ricevuta da 23:59:59 (GMT) il 26/01/2014. La taglia è stata assegnata a Howard per la sua soluzione GolfScript da 268 caratteri .

analisi

Fornisci l'output del tuo programma per le seguenti tre griglie di test con la tua risposta:

Ho creato un piccolo programma Python per generare griglie valide a scopo di test:

import random

def output(array):
  print '\n'.join([''.join(row) for row in array])

def fliprow(rownum, array):
  return [row[::1-2*(rownum==idx)] for idx,row in enumerate(array)]

def flipcol(colnum, array):
  return zip(*fliprow(colnum, zip(*array)))

def randomflip(array):
  op=random.randint(0,1)
  row=random.randint(0,9)
  if(op==1):
    return fliprow(row, array)
  else:
    return flipcol(row, array)

def jumble(array):
  arraycopy=array
  for i in range(10, 1000):
    arraycopy=randomflip(arraycopy)
  return arraycopy

startarray=[
['1','2','3','4','5','6','7','8','9'],
['2','3','4','5','6','7','8','9','1'],
['3','4','5','6','7','8','9','1','2'],
['4','5','6','7','8','9','1','2','3'],
['5','6','7','8','9','1','2','3','4'],
['6','7','8','9','1','2','3','4','5'],
['7','8','9','1','2','3','4','5','6'],
['8','9','1','2','3','4','5','6','7'],
['9','1','2','3','4','5','6','7','8']]

print output(jumble(startarray))

code-golf

— Gareth
fonte

8

Ho appena scritto una breve soluzione che ha capovolto casualmente righe / colonne fino al completamento dell'ordinamento. Dopo 500 milioni di iterazioni non ha ancora risolto il primo puzzle che hai dato (dove devi solo girare la riga 1). La casualità non sembra essere una soluzione utilizzabile per questo problema!

— Josh,

3

@Josh Non sorprende. Questo problema sembra essere molto simile alla risoluzione di un cubo di Rubik. Penso che una sorta di ricerca in prima fila sarebbe la migliore forza bruta. Detto questo, l'algoritmo casuale deve teoricamente terminare alla fine e sembra adattarsi alle regole specificate.

— Cruncher,

4

La forza bruta non è necessaria. Considera il fatto che ogni riquadro della griglia può finire solo in una delle quattro posizioni: posizione corretta, X capovolto, Y capovolto o XY capovolto. Può aiutarti a trattare mentalmente la griglia come (0,0) la tessera più centrale. Se stai risolvere piastrella (-2, 4), gli unici luoghi il numero di destinazione potrebbe essere è (-2, 4), (2, 4), (2, -4), o (-2, -4).

— Mr. Llama,

2

@ Cruncher: l'uso di lanci di riga / colonna interi lo rende impossibile. Ad esempio, prova a prendere la parte più in alto 1 ( A1) e spostala su B1. Puoi ottenere un 1dalla posizione B1, ma sarà la tessera da B9, non la tessera da A1. Poiché sono consentiti solo capovolgimenti di riga / colonna, il primo più in alto 1 sarà sempre e solo in uno dei quattro angoli più esterni. Se ho sbagliato le regole, per favore fatemi sapere.

— Mr. Llama,

7

Congratulazioni, Gareth. Questo è un problema ben progettato. Inoltre, abbastanza impegnativo.

— DavidC,

7

GolfScript, 300 279 268 caratteri

n%`{\5,{.9+}%{;.2/\2%},\;''{1${.9/7+7*+}%+:z;}:?~{{.9<77*{\zip\9-}>:Z~{1$!{-1%}*\(\}@%\Z;}/}:E~{:^;{:c;.`{[\E[.^=\8^-=]{.c=\8c-=}%[^c+^8c-+8^-c+16c-^-]{9%49+}%=}+[[]]:K[[8^- 17c-][^9c+]1$]{:s;{[[]s.+.2$+]{1$+}/}%.&}/\,K+0=z?E}5,/}5,/{{+9%)}+9,%''*}9,%={z:u;}*}+1024,/u

Si noti che questo codice è estremamente lento (anche a causa della pesante manipolazione del blocco di codice) e potrebbe durare diversi minuti. Il codice è molto non golfscript-ish con molte variabili e loop espliciti.

Avevo scritto una soluzione più analitica che ha funzionato per meno di un secondo. L'ho completamente rotto durante il golf. Sfortunatamente, non sono stato in grado di tornare indietro o riparare il codice negli ultimi due giorni. Pertanto, ho prodotto questa versione di prova che è comunque più corta.

Le risposte per i puzzle indicati sopra:

1A2C4D9G9G9G9G1C1C1C1C9F9F9F9F1D1D1D1D2A2A2A2A8H8H8H8H2B2B2B2B2C2C8F8F2D2D2D2D3A3A7I7I3B3B7H7H7G7G7G7G3D3D7F7F6I6I6I6I4A4A4A4A6H6H6H6H6G6G4C4C4C4C6F6F4D4D

1AB39I9I1A1A9I9I1B1B9F9F8I8I8I8I2B2B8H8H8G8G8G8G2D2D2D2D3A3A3A3A7H7H7H7H3C3C3C3C3D3D7F7F6I6I4A4A6I6I4B4B4B4B6G6G4C4C4C4C6F6F6F6F4D4D

1A34D9I9I9I9I1A1A1A1A1B1B1B1B9G9G1C1C1C1C9F9F9F9F1D1D9F9F8I8I2A2A2A2A8H8H8H8H2C2C2C2C8F8F2D2D8F8F7I7I7I7I3A3A3B3B7G7G7G7G3C3C3C3C6I6I6I6I6H6H6H6H4B4B4B4B6G6G6G6G4C4C6G6G6F6F4D4D6F6F

— Howard
fonte

Bene, sarà un duro lavoro battere questo ...

— Gareth,

Sembra che mi sbagliassi ...

— Gareth,

@Gareth Sapevo che questa è una sfida che sarebbe difficile con golfscript contro, ad esempio, la matematica.

— Howard,

1

@Howard - che approccio hai usato? Qual è la "versione di prova" che hai citato?

— SergeyS,

24

Mathematica 582 575 503 464 282

Per combattere con i golfisti devo usare l'artiglieria pesante!

i = "986553229
264564891
759176443
643982153
567891234
526917874
685328912
891732537
117644378";

a=Array;h@M_:=Join@@a[9(M〚##〛/. 9->9⌈2Random[]⌉)+Abs[{##}-5]&,n={9,9}];
For[i_~t~j_:=i{#2,10-#2}+j#-9&~a~{9,4},!ListQ[e=GroupElementToWord[
PermutationGroup[Cycles/@Join[1~t~9,9~t~1]],
h[ToCharacterCode@StringSplit@i-48]~FindPermutation~h@a[Mod[8+##,9,1]&,n]]],];
e~IntegerString~36<>""

Produzione:

g69g69g8g8g7g7gd96d96d8d8d7d7dh6h64a6a46d6d4g4g6b6b7h7h7c7c2a8a27b7bd8db8b7f7fg8g82c2c94a4a3a3aigfdc91

Qui PermutationGroup[...]imposta possibili ribaltamenti e GroupElementToWord[...]risolve il problema (circa 0.2sec). Il problema principale è che è difficile identificare la corrispondenza tra la posizione della 9griglia iniziale e quella finale. Per il golf lo faccio a caso (ci vogliono diversi secondi). Ci sono alcuni avvisi ma si possono ignorarli.

Altro per testare le griglie:

g69g69g8g8g7g7gh89h89h7h7h6h6hf6f6g6g64f4f4h4hg7g73g3g2a8a28d8db8b83d3dg8g82c2c9a3a643a3a2g9f9d9c9ga
h89h89h7h7h6h6h6h6h6f6f6g6g6d6d3a7a37g7g7h7h3c3c2a8a27b7b8d8d2f2f8b8b3f3f2b2ba2a764a8aih9g9c9gb1i

Riproduce completamente gli esempi:

1
i
2i

Soluzione precedente (464)

senza funzioni integrate intelligenti e con runtime 4 ms:

M=ToCharacterCode@StringSplit@i-48;
S="";s=Signature;H=(S=S<>{#,#2+9}~IntegerString~36)&;
A=(m=M〚##〛)-9Mod[m+##,2]&[s@{2#3,5}#,2#2#3~Mod~2-#2]&~Array~{4,4,4};
u=s/@Join@@A;
H@@({k,l}=#&@@@#~Position~1&/@{v=u〚13;;〛;{h=#2u〚2〛,-#u〚5〛,-#u〚9〛}&@@v,v〚4〛=u〚4〛h;v});
A〚k〛=A〚k,;;,{2,1,3,4}〛;A〚;;,l〛=A〚;;,l,{3,2,1,4}〛;
MapIndexed[4#≠#4&&H@@@If[#2<3,#0[#3,#,#2,#4];k,#0[#,#3,#4,#2];10-k]&@@
If[s@#<0,#〚{1,3,2,4}〛,#]&@Ordering[k={#2,#2};#]&,A,{2}];
M〚5,1〛<5&&5~H~{};M〚1,5〛<5&&{}~H~5;S

Tutte le nuove linee qui non sono necessarie.

Produzione:

3b9i9i1a1a1a1a9i9i1a1a9h9h1b1b1b1b9h9h9g9g1c1c9g9g9f9f1d1d9f9f8h8h2b2b8f8f8f8f7i7i7h7h3b3b3b3b7h7h3b3b7h7h7g7g3c3c7g7g3c3c7f7f6i6i4a4a6h6h4b4b4b4b6g6g4c4c6g6g4c4c6f6f4d4d4d4d6f6f4d4d6f6f4d4d

Altre due griglie di prova:

13ab9i9i1a1a9i9i9h9h1b1b1b1b9h9h9f9f8i8i8i8i8h8h2b2b2b2b8h8h8h8h8g8g8g8g8f8f2d2d2d2d8f8f2d2d7i7i3a3a3a3a7i7i7h7h3b3b7h7h3b3b7g7g3c3c3c3c7g7g3c3c7f7f3d3d3d3d7f7f7f7f6i6i4a4a6i6i6h6h4b4b4b4b6h6h4b4b6g6g4c4c4c4c6f6f4d4d4d4d6f6f4d4d6f6f
2bc9i9i1a1a9i9i9g9g1c1c9g9g1c1c9f9f1d1d1d1d8i8i8i8i8h8h2b2b2b2b8f8f2d2d7i7i7h7h3b3b3b3b7h7h3b3b7g7g3c3c7f7f3d3d3d3d7f7f3d3d6i6i4a4a4a4a6h6h4b4b6g6g6g6g6f6f4d4d

visualizzazione:

anim = Reap[Fold[Function[{m, i}, 
 If[i > 9, (Sow@Grid[#, Background -> {i - 9 -> Pink, None}] & /@ {m, #}; #) &@
   Transpose@MapAt[Reverse, Transpose@m, i - 9], (Sow@Grid[#, 
         Background -> {None, i -> Pink}] & /@ {m, #}; #) &@
   MapAt[Reverse, m, i]]], M, IntegerDigits[FromDigits[S, 36], 36]]];

ListAnimate[Join[{#, #} &@Grid@M, anim[[2, 1]], {#, #} &@Grid@anim[[1]]], 5]

inserisci qui la descrizione dell'immagine

La stringa di input ipuò essere generata casualmente da

M = Array[Mod[8 + ##, 9, 1] &, {9, 9}];
(M[[#]] = Reverse@M[[#]]; M[[All, #2]] = Reverse@M[[All, #2]];) & @@@
   RandomInteger[{1, 9}, {10000, 2}];
i = ToString /@ # <> "\n" & /@ M <> ""

Breve discussione

I flip possono scambiare solo questi elementi ("quadrupla"):
È possibile scambiare questi elementi separatamente dagli altri elementi solo se l'ordine iniziale e quello finale hanno la stessa firma.
I lanci di questi quattro elementi formano il gruppo alternato di grado 4 (= gruppo di rotazioni del tetraedrico). Ogni elemento di questo gruppo è una composizione di 2 elementi generatori. Quindi, se conosciamo la posizione iniziale e finale, possiamo scomporre la trasformazione corrispondente come una combinazione di semplici capovolgimenti.

Dettagli

Per sportività, pubblico i dettagli prima della fine della taglia!

M=ToCharacterCode@StringSplit@i-48;

Converti la stringa inella matrice M.

S="";s=Signature;H=(S=S<>{#,#2+9}~IntegerString~36)&;

Aggiungeremo i caratteri a S. Ora è la stringa vuota. H[i,j]aggiungerà il carattere i( 1,2,3,...,9) e il carattere j( a,b,c,...,iin base-36).

A=(m=M〚##〛)-9Mod[m+##,2]&[s@{2#3,5}#,2#2#3~Mod~2-#2]&~Array~{4,4,4};

Converto elementi come

inserisci qui la descrizione dell'immagine

per ottenere la matrice target nella seguente forma

inserisci qui la descrizione dell'immagine

Quindi ci sono due passaggi principali nel mio algoritmo

Trova i flip per ottenere le firme come nella matrice target (ad es. La firma di {-7,-1,1,7}is 1e la firma di {-6,2,-2,6}is -1):

u=s/@Join@@A;
H@@({k,l}=#&@@@#~Position~1&/@{v=u〚13;;〛;{h=#2u〚2〛,-#u〚5〛,-#u〚9〛}&@@v,v〚4〛=u〚4〛h;v});
A〚k〛=A〚k,;;,{2,1,3,4}〛;A〚;;,l〛=A〚;;,l,{3,2,1,4}〛;

Ruota ogni "quadrupla" per ottenere il giusto ordine:
```
MapIndexed[4#≠#4&&H@@@If[#2<3,#0[#3,#,#2,#4];k,#0[#,#3,#4,#2];10-k]&@@
If[s@#<0,#〚{1,3,2,4}〛,#]&@Ordering[k={#2,#2};#]&,A,{2}];
```
È la parte più non banale dell'algoritmo. Ad esempio, la trasformazione 1b1bverrà convertita {-7,-1,1,7}in {-1,1,-7,7}. La trasformazione 9h9hverrà convertita {-7,-1,1,7}in {-7,7,-1,1}. Quindi abbiamo due mappe
```
{1,2,3,4} -> {2,3,1,4}
{1,2,3,4} -> {1,4,2,3}
```
e vogliamo convertire un ordine arbitrario {x,y,z,w}in {1,2,3,4}. Il metodo semplice è (tranne una ricerca casuale)
```
repeat   
{x, y, z, w} -> If[z < 3, {y, z, x, w}, {x, w, y, z}]
until {1,2,3,4}
```
Non posso provarlo, ma funziona!

L'ultimo passo è

M〚5,1〛<5&&5~H~{};M〚1,5〛<5&&{}~H~5;S

Esegue banali capovolgimenti della riga centrale e della colonna centrale e restituisce il risultato.

— ybeltukov
fonte

@Gareth Posso usare caratteri piccoli nell'output? Mi fa risparmiare un certo numero di personaggi.

— ybeltukov,

Sì, accetterò caratteri minuscoli nell'output (cambierò la domanda per annotarlo). Non ho Mathematica, quindi qualche altro utente di Mathematica potrebbe confermare che il codice genera effettivamente l'output? Ho convalidato le tre soluzioni di test e sono tutte corrette, quindi +1. Bel lavoro!

— Gareth,

Solo curioso: qual è la performance del tuo approccio? Hai testato gli input generati da migliaia di lanci?

— SergeyS,

@SergeyS Sì, ci vogliono circa 50 ms :)

— ybeltukov

@Gareth riscrivo il mio programma, potresti controllare i risultati? I miei test hanno dimostrato che tutto è corretto.

— ybeltukov,

7

J 487 438

q=:3 :'(>:9|+/~i.9)=/&((,{;/(,.8&-)y){])g'
l=:2 :0
:
o=:o,(m+x){a.
x&(|.@{`[`]})&.v y
)
r=:49 l]
c=:97 l|:
w=:2 :'g=:4 v^:(4=(<m){g)g'
p=:_1=C.!.2@,@:I.@q
t=:2 :'for_i.>:i.3 do.g=:i v^:(p m*i)g end.'
z=:2 :0
'i j I J'=.y,8-y
g=:".'(',(,' ',.,(I.m{q y){,;._1 n),'])^:2 g'
)
d=:3 :0
g=:9 9$".,_ list,' ',.y
o=:''
0 4 w c
4 0 w r
0 1 t c
g=:0 c^:(-.(p 1 0)=p 1 2)g
1 0 t r
for_k.>,{;~i.4 do.0 z';;jcir;irjc;Irjc'k
3 z';;IrJc;JcIr;'k end.o
)

d è un verbo che accetta una stringa di griglia nel formato specificato e restituisce una stringa di soluzione nel formato specificato.

Esempio di utilizzo:

   d '987654321',LF,'234567891',LF,'345678912',LF,'456789123',LF,'567891234',LF,'678912345',LF,'789123456',LF,'891234567',LF,'912345678'
bcda2341a1a1b1b1c1c1d1da2a2b2b2c2c2d2d2a3a3b3b3c3c3d3d3a4a4b4b4c4c4d4d4

Ora accetta entrambi i tipi di newline.

Soluzioni per le reti di prova:

b3a1a11b1bc9c99g9gd9d99f9fb8b8f8f87i7i7h7hc3c3g7g77f7fa6a64b4bh6h6c4c4g6g6d6d6f6f6
cd24a9a91c1c1d1d9f9fa2a2i8i88h8hc2c2g8g82d2d3b3bh7h7d3d37f7fa6a64b4bg6g64d4d6f6f
bc2a9a99i9ic1c1g9g91d1df9f9i8i8b2b2h8h82c2cd8d87i7ib3b3c7c7d3d34a4ai6i6b6b6g6g6d6d6

Sono abbastanza nuovo per J; questo potrebbe probabilmente essere ulteriormente giocato a golf.

Il controllo di griglie non valide / irrisolvibili comporta una penalità di 123 caratteri. Non credo che le altre risposte finora abbiano un tale controllo degli errori.

Per fare ciò, cambia la prima riga din questo:

if.-.+./89 90=#y do.0 return.end.if.-.*./(/:~y)=/:~(#y)$'123456789',LF do.0 return.end.g=:9 9$".,_ list,' ',.y

e l'ultima riga a questo:

3 z';;IrJc;JcIr;'k end.if.*./,g=>:9|+/~i.9 do.o return.end.0

Ho scelto di tornare 0su tali errori in quanto restituire una stringa vuota sarebbe indistinguibile dalla risoluzione corretta di una griglia completamente risolta. Si noti che ciò presuppone che le nuove righe UNIX (di nuovo).

— AlliedEnvy
fonte

Congratulazioni, sei appena entrato in testa. :-)

— Gareth,

Sembra che il tuo input non sia una stringa come richiesto dalle regole o mi manca qualcosa?

— SergeyS,

@SergeyS: potresti essere confuso. Per quanto ne so, J non ha modo di posizionare le fughe (come la nuova riga) nei letterali delle stringhe. La costruzione 'a', LF, 'b' in J è simile a "a" + "\ n" + "b" nelle lingue in cui + lavora per aggiungere stringhe.

— AlliedEnvy,

Ok, ha senso che, grazie.

— SergeyS,

Stavo solo leggendo la sezione sui file del libro APL del 1962 e penso che @AlliedEnvy sia corretto. Ecco come appariranno i dati al programma se letti da un file nel formato della domanda. Le LFs rappresentano le partizioni del file sequenziale.

— Luser droog

5

C # 540 399

Bene, prestazioni sacrificate (ora ci vogliono fino a 30 secondi), introdotto variabili dinamiche, leggermente modificato la logica della soluzione. E sì, ora si aspetta l'input come una stringa con interruzioni di riga (come richiesto nelle regole).

Naturalmente C # non ha funzioni matematiche predefinite, quindi sarebbe difficile combattere con i ragazzi di Mathematica. Tuttavia, questa è stata una grande sfida, grazie all'autore!

string S(string _){for(i=0,e=1>0;e;){
for(h=v=j=0;j<89;)m[j/10,j%10+9]=_[j++]-49;a="";
for(j=i++;j>0;v++,j/=2)if(j%2>0)F(v);
for(;h<9&(h<4|!e);h+=j/36,j%=36)if((e=m[h,g=j++%9+9]!=(t=(h+g)%9))|m[v=8-h,g]==t){F(v);F(g);F(v);F(g);}
}return a;}void F(int z){for(f=z<9;++l<9;)m[0,l]=m[f?z:l,f?9+l:z];for(;l-->0;)m[f?z:l,f?9+l:z]=m[0,8-l];a+=(char)(z+=f?49:56);}
dynamic h,v,i,j,e,t,l=-1,g,a,m=new int[9,19],f;

Griglie di prova:

3B9A9A9B9B9C9C9D9D9F9F9G9G9H9H9I9I9B9B9C9C9D9D9F9F9G9G9H9H9C9C9D9D9C9C9D9D8B8B8F8F8H8H8B8B8F8F8B8B8H8H7B7B7C7C7F7F7H7H7I7I7H7H6A6A6B6B6C6C6D6D6F6F6H6H6A6A6B6B6D6D6F6F6D6D6D6D6F6F5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I

13AB9A9A9B9B9F9F9H9H9A9A9B9B9H9H9I9I8B8B8D8D8F8F8G8G8H8H8I8I8B8B8G8G8H8H8I8I8H8H7A7A7B7B7C7C7D7D7F7F7G7G7I7I7A7A7D7D7F7F7I7I7F7F6A6A6B6B6C6C6D6D6F6F6G6G6H6H6I6I6A6A6C6C6F6F6I6I6A6A6A6A5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I

2BC9A9A9C9C9D9D9F9F9A9A9D9D9I9I8B8B8D8D8H8H8I8I8B8B8D8D8I8I7B7B7C7C7D7D7F7F7G7G7H7H7I7I7C7C7C7C7G7G6A6A6B6B6D6D6F6F6G6G6I6I6A6A6B6B6D6D6G6G6D6D6F6F5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I

Vecchia soluzione (540)

Funziona in meno di un secondo su qualsiasi input (testato su migliaia di griglie generate casualmente). La lunghezza massima della stringa di output è 165 (inizialmente qualsiasi griglia è stata risolta in non più di 82 lanci, ma durante il golf ho sacrificato questo).

string S(string[]_){for(i=0;i<1<<18;){
for(j=0;j<81;)m[j/9+49,j%9+65]=_[j/9][j++%9]-49;a="";char g,h='1',v='9',b,x=h,y;
for(j=i;j>0;x=x==v?'A':++x,j/=2)if(j%2>0)F(x);j=i+1;
for(i+=1<<19;h<58;h++,v--)for(g='A',b='I';g<74;g++,b--){
t=(h+g-6)%9;e=m[h,g];q=m[v,g];i=h>52&t!=e?j:i;
if(e!=t|q==t){x=q==t?v:g;y=q==t?g:v;
if(m[h,b]==t){x=b;y=h;}
F(x);F(y);F(x);F(y);}}}return a;}
void F(char z){var f=z<65;for(l=0;l<4;l++){n=m[d=f?z:49+l,s=f?65+l:z];m[d,s]=m[o=f?z:57-l,u=f?73-l:z];m[o,u]=n;}a+=z;}
int i,j,q,e,t,l,s,d,n,u,o;int[,]m=new int[99,99];string a;

Risposta per esempio 1:

15A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

Risposta per esempio 2:

19AI1I1H1H1G1G1F1F19F9F9G9G9H9H9I9I8A8AI8I87A7AI7I76A6AI6I65A5A5B5B5C5C5D
5DE5E55F5F5G5G5H5H5I5I

Risposta per esempio 3:

129AI1I1H1H1G1G1F1F19F9F9G9G9H9H9I9I8A8AI8I87A7AI7I76A6AI6I65A5A5B5B5C5C5
D5DE5E55F5F5G5G5H5H5I5I

Risposte per i quadrati di prova:

346B9A9AH1H1C9C9D9D99F9F9G9GH9H99I9IB8B8F8F87B7B7C7C7F7FH7H77I7I6A6A6B6BC6C66D6DG6G6H6H66I6I5A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

1346ABA9A9H1H19F9FH9H99I9IH2H28D8D8F8FG8G8I8I8I3I37B7B7C7CF3F37G7GI7I7H4H4D6D66F6F5A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

2BCA9A99C9CF1F19F9F9I9IH2H2D8D88H8HI8I87B7BC7C77D7D7F7F7H7H7I7II4I4B6B6D6D6G6G66I6I5A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

— SergeyS
fonte

Sto solo scaricando Mono per il mio Mac ora in modo da poter testare il programma stesso, ma ho già un validatore che esegue una determinata soluzione su una determinata griglia e mi dice se la soluzione è una soluzione valida per quella griglia - ed è dicendomi che le tre soluzioni di esempio che mi hai fornito non sono valide. Sto solo indagando sul perché adesso.

— Gareth,

Aha! Ho capito cosa è successo qui! Le risposte fornite sembrano essere le risposte ai 3 esempi e non alle tre griglie di test (che sono più in basso nella domanda). Sono davvero soluzioni corrette a quelle griglie, anche se sono un po 'più lunghe di 1, Ae 2Iquali sono le soluzioni più semplici - ma questo non importa in realtà poiché non sto giudicando sulla lunghezza della soluzione della griglia :-) Se potessi modificare e fornisco le risposte per le 3 griglie di test (vedrò se riesco a farlo funzionare sul mio Mac ora) Posso darti il tuo +1.

— Gareth,

@Gareth - oops, ho perso le risposte per i quadrati dei test, grazie per averlo sottolineato. Li ho aggiunti ora alla mia risposta.

— SergeyS,

Eccellente, grazie per quello. Hanno tutti validato bene. Xamarin non funzionerebbe sul mio Mac per qualche motivo, quindi dovrò testare il programma al lavoro tra un paio d'ore.

— Gareth,

@Gareth - In realtà non c'è nulla di specifico per C # in quel codice, probabilmente uno può convertirlo in Java o anche in C ++ senza molto dolore e ... golf alcuni caratteri da esso :) Inoltre, sentiti libero di convertirlo in GolfScript o qualcosa di più conciso - questo può apparire due o più volte più breve;)

— SergeyS

Flippin 'Squares

GolfScript, 300 279 268 caratteri

Mathematica 582 575 503 464 282

Soluzione precedente (464)

Breve discussione

Dettagli

J 487 438

C # 540 399

Vecchia soluzione (540)