No jogo Flood Paint, o objetivo do jogo é fazer com que todo o tabuleiro fique da mesma cor no menor número de turnos possível.
O jogo começa com um quadro que se parece com isso:
3 3 5 4 1 3 4 1 5
5 1 3 4 1 1 5 2 1
6 5 2 3 4 3 3 4 3
4 4 4 5 5 5 4 1 4
6 2 5 3[3]1 1 6 6
5 5 1 2 5 2 6 6 3
6 1 1 5 3 6 2 3 6
1 2 2 4 5 3 5 1 2
3 6 6 1 5 1 3 2 4
Atualmente, o número (representando uma cor) no centro do tabuleiro é 3. A cada turno, o quadrado no centro muda de cor e todos os quadrados da mesma cor que são alcançáveis a partir do centro, movendo-se horizontal ou verticalmente ( ou seja, na região de inundação da praça central) mudará de cor com ela. Portanto, se o quadrado central mudar de cor para 5:
3 3 5 4 1 3 4 1 5
5 1 3 4 1 1 5 2 1
6 5 2 3 4 3 3 4 3
4 4 4 5 5 5 4 1 4
6 2 5 5[5]1 1 6 6
5 5 1 2 5 2 6 6 3
6 1 1 5 3 6 2 3 6
1 2 2 4 5 3 5 1 2
3 6 6 1 5 1 3 2 4
então o 3 que estava à esquerda do centro 3 também mudará de cor. Agora há um total de sete 5 alcançáveis a partir do centro e, portanto, se mudarmos de cor para 4:
3 3 5 4 1 3 4 1 5
5 1 3 4 1 1 5 2 1
6 5 2 3 4 3 3 4 3
4 4 4 4 4 4 4 1 4
6 2 4 4[4]1 1 6 6
5 5 1 2 4 2 6 6 3
6 1 1 5 3 6 2 3 6
1 2 2 4 5 3 5 1 2
3 6 6 1 5 1 3 2 4
a região pintada aumenta novamente de tamanho dramaticamente.
Sua tarefa é criar um programa que use uma grade de 19 por 19 cores de 1 a 6 como entrada, na forma que você escolher:
4 5 1 1 2 2 1 6 2 6 3 4 2 3 2 3 1 6 3
4 2 6 3 4 4 5 6 4 4 5 3 3 3 3 5 4 3 4
2 3 5 2 2 5 5 1 2 6 2 6 6 2 1 6 6 1 2
4 6 5 5 5 5 4 1 6 6 3 2 6 4 2 6 3 6 6
1 6 4 4 4 4 6 4 2 5 5 3 2 2 4 1 5 2 5
1 6 2 1 5 1 6 4 4 1 5 1 3 4 5 2 3 4 1
3 3 5 3 2 2 2 4 2 1 6 6 6 6 1 4 5 2 5
1 6 1 3 2 4 1 3 3 4 6 5 1 5 5 3 4 3 3
4 4 1 5 5 1 4 6 3 3 4 5 5 6 1 6 2 6 4
1 4 2 5 6 5 5 3 2 5 5 5 3 6 1 4 4 6 6
4 6 6 2 6 6 2 4 2 6 1 5 6 2 3 3 4 3 6
6 1 3 6 3 5 5 3 6 1 3 4 4 5 1 2 6 4 3
2 6 1 3 2 4 2 6 1 1 5 2 6 6 6 6 3 3 3
3 4 5 4 6 6 3 3 4 1 1 6 4 5 1 3 4 1 2
4 2 6 4 1 5 3 6 4 3 4 5 4 2 1 1 4 1 1
4 2 4 1 5 2 2 3 6 6 6 5 2 5 4 5 4 5 1
5 6 2 3 4 6 5 4 1 3 2 3 2 1 3 6 2 2 4
6 5 4 1 3 2 2 1 1 1 6 1 2 6 2 5 6 4 5
5 1 1 4 2 6 2 5 6 1 3 3 4 1 6 1 2 1 2
e retorne uma sequência de cores que o quadrado central mudará a cada turno, novamente no formato de sua escolha:
263142421236425431645152623645465646213545631465
No final de cada sequência de movimentos, os quadrados na grade 19 por 19 devem ter a mesma cor.
Seu programa deve ser totalmente determinístico; Soluções pseudo-aleatórias são permitidas, mas o programa deve gerar sempre a mesma saída para o mesmo caso de teste.
O programa vencedor executará o menor número total de etapas para resolver todos os 100.000 casos de teste encontrados neste arquivo (arquivo de texto compactado, 14,23 MB). Se duas soluções seguirem o mesmo número de etapas (por exemplo, se ambas encontraram a estratégia ideal), o programa mais curto vencerá.
BurntPizza escreveu um programa em Java para verificar os resultados do teste. Para usar este programa, execute sua submissão e canalize a saída para um arquivo chamado steps.txt
. Em seguida, execute este programa com steps.txt
e o floodtest
arquivo no mesmo diretório. Se sua entrada for válida e produzir soluções corretas para todos os arquivos, ela deverá passar em todos os testes e retornarAll boards solved successfully.
import java.io.*;
import java.util.*;
public class PainterVerifier {
public static void main(String[] args) throws FileNotFoundException {
char[] board = new char[361];
Scanner s = new Scanner(new File("steps.txt"));
Scanner b = new Scanner(new File("floodtest"));
int lineNum = 0;
caseloop: while (b.hasNextLine()) {
for (int l = 0; l < 19; l++) {
String lineb = b.nextLine();
if (lineb.isEmpty())
continue caseloop;
System.arraycopy(lineb.toCharArray(), 0, board, l * 19, 19);
}
String line = s.nextLine();
if (line.isEmpty())
continue;
char[] steps = line.toCharArray();
Stack<Integer> nodes = new Stack<Integer>();
for (char c : steps) {
char targetColor = board[180];
char replacementColor = c;
nodes.push(180);
while (!nodes.empty()) {
int n = nodes.pop();
if (n < 0 || n > 360)
continue;
if (board[n] == targetColor) {
board[n] = replacementColor;
if (n % 19 > 0)
nodes.push(n - 1);
if (n % 19 < 18)
nodes.push(n + 1);
if (n / 19 > 0)
nodes.push(n - 19);
if (n / 19 < 18)
nodes.push(n + 19);
}
}
}
char center = board[180];
for (char c : board)
if (c != center) {
s.close();
b.close();
System.out.println("\nIncomplete board found!\n\tOn line " + lineNum + " of steps.txt");
System.exit(0);
}
if (lineNum % 5000 == 0)
System.out.printf("Verification %d%c complete...\n", lineNum * 100 / 100000, '%');
lineNum++;
}
s.close();
b.close();
System.out.println("All boards solved successfully.");
}
}
Além disso, um placar, já que os resultados não são realmente classificados por pontuação e aqui isso realmente importa muito:
- 1.985.078 - smack42, Java
- 2.075.452 - usuário1502040, C
- 2.098.382 - tigrou, C #
- 2.155.834 - CoderTao, C #
- 2.201.995 - MrBackend, Java
- 2.383.569 - CoderTao, C #
- 2.384.020 - Herjan, C
- 2.403.189 - Origineil, Java
- 2.445.761 - Herjan, C
- 2.475.056 - Jeremy List, Haskell
- 2.480.714 - SteelTermite, C (2.395 bytes)
- 2.480.714 - Herjan, Java (4.702 bytes)
- 2.588.847 - BurntPizza, Java (2.748 bytes)
- 2.588.847 - Gero3, node.js (4.641 bytes)
- 2.979.145 - Teun Pronk, Delphi XE3
- 4.780.841 - BurntPizza, Java
- 10.800.000 - Joe Z., Python