Crie um programa ou função para desordenar um quadrado de dígitos, invertendo (invertendo o ponto central) apenas as linhas e colunas.
Entrada
A entrada será uma grade 9x9 de dígitos na forma de uma sequência de 9 linhas, como a seguir:
986553229
264564891
759176443
643982153
567891234
526917874
685328912
891732537
117644378
Esse formato de entrada não é negociável - todas as soluções "criativas" com o formato de entrada serão consideradas inválidas.
Saída
A saída deve ser uma lista de movimentos que, quando aplicados à entrada na ordem especificada, devem recriar a grade de destino.
Um exemplo de saída (não uma solução para o exemplo de entrada anterior):
28IF5D3EAB9G3
Esse formato de saída também não é negociável. Não deve haver novas linhas ou espaços na saída, apenas os caracteres 1
- 9
e A
- I
(caracteres minúsculos são aceitáveis no lugar de caracteres maiúsculos, se preferir).
A grade de destino (o estado que você precisa recriar) é a seguinte:
123456789
234567891
345678912
456789123
567891234
678912345
789123456
891234567
912345678
Os números 1
- 9
devem ser usados como instruções para virar as linhas e as letras A
- I
devem ser usados para as colunas. Isso é mostrado abaixo com a grade em seu estado restaurado.
ABCDEFGHI
|||||||||
vvvvvvvvv
1 -> 123456789
2 -> 234567891
3 -> 345678912
4 -> 456789123
5 -> 567891234
6 -> 678912345
7 -> 789123456
8 -> 891234567
9 -> 912345678
Então, um 8
meio vira a segunda linha da parte inferior e um F
meio vira a sexta coluna.
Caso nenhuma solução seja possível, o programa deve terminar sem gerar nada.
Exemplos
Entrada:
987654321
234567891
345678912
456789123
567891234
678912345
789123456
891234567
912345678
Saída:
1
Nesse caso, apenas a linha superior precisa ser invertida para retornar ao estado da meta.
Entrada:
123456788
234567897
345678916
456789125
567891234
678912343
789123452
891234561
912345679
Saída:
I
Nesse caso, apenas a coluna final (coluna I
) precisa ser invertida para recriar o estado da meta.
Entrada:
123456788
798765432
345678916
456789125
567891234
678912343
789123452
891234561
912345679
Saída:
2I
Nesse caso, precisamos inverter a linha 2
e, em seguida, inverter a coluna I
para retornar ao estado do objetivo.
Notas:
- Inclua um exemplo de uso em sua resposta.
- A saída fornecida não precisa ser a sequência mais curta que retornará o estado do objetivo - qualquer sequência que retorne o estado do objetivo funcionará enquanto funcionar (ou seja, desde que eu possa testá-lo)
- Vou me esforçar para testar cada resposta e aprovar todas as que funcionam e obviamente tiveram uma tentativa de jogar golfe.
- Esta é uma competição aberta - aceitarei a resposta mais curta na próxima semana, mas se surgir uma resposta válida mais nova que seja mais curta a qualquer momento no futuro, alterarei a resposta aceita para refletir isso .
A recompensa foi definida como 200 reputação para a resposta mais curta recebida até 23:59:59 (GMT) em 26/01/2014A recompensa foi concedida a Howard por sua solução GolfScript de 268 caracteres .
Teste
Forneça a saída do seu programa para as três grades de teste a seguir com sua resposta:
986553229
264564891
759176443
643982153
567891234
526917874
685328912
891732537
117644378
927354389
194762537
319673942
351982676
567891234
523719844
755128486
268534198
812546671
813654789
738762162
344871987
341989324
567891234
576217856
619623552
194435598
926543271
Eu criei um pequeno programa Python para gerar grades válidas para fins de teste:
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))
(-2, 4)
, (2, 4)
, (2, -4)
, ou (-2, -4)
.
A1
) e mova-o para B1
. Você pode obter um 1
para a posição B1
, mas será o bloco de B9
, não o bloco de A1
. Como só é permitido o lançamento de linhas / colunas inteiras, o canto superior esquerdo 1 estará sempre em um dos quatro cantos mais externos. Se eu tiver errado as regras, entre em contato.