// Solucion brute force: pasa las pruebas con id 1 y 2
public int Solve(LocateTheTimeStone g)
{
int N = g.NumStones;
for (int i = 0; i < N; i++)
{
for (int j = i + 1; j < N; j++)
{
int resultadoComparacion = g.Compare(i, i, j, j);
if (resultadoComparacion > 0)
{
return(j);
}
else if (resultadoComparacion < 0)
{
return(i);
}
}
}
return(-1); // Ninguna de las piedras es el Time Stone
}
public static void Main()
{
// ===========================================================
// Test 0 o negativo: entre 2 a 100 piedras, 100 comparaciones
// ===========================================================
/*
* {
* LocateTheTimeStone g = new LocateTheTimeStone(0);
* InteractiveTest(g);
* }
*/
// ===========================================================
// Test 1: 10 piedras, 100 comparaciones
// ===========================================================
{
Solution s = new BruteForceSolution();
LocateTheTimeStone g = new LocateTheTimeStone(1);
int answer = s.Solve(g);
g.VerifyAnswer(answer);
Console.WriteLine(
"Test {0} OK #Comparisons: {1} of {2}",
1, g.CurNumComparisons, g.MaxNumComparisons);
}
// ===========================================================
// Test 2: 10 piedras, todas falsas, 100 comparaciones
// ===========================================================
{
Solution s = new BruteForceSolution();
LocateTheTimeStone g = new LocateTheTimeStone(1);
int answer = s.Solve(g);
g.VerifyAnswer(answer);
Console.WriteLine(
"Test {0} OK #Comparisons: {1} of {2}",
2, g.CurNumComparisons, g.MaxNumComparisons);
}
// ===========================================================
// Tests 3-100: 1000 piedras, 1000 comparaciones
// ===========================================================
for (int testNum = 3; testNum <= 100; testNum++)
{
Solution s = new YourSolution();
LocateTheTimeStone g = new LocateTheTimeStone(testNum);
int answer = s.Solve(g);
g.VerifyAnswer(answer);
Console.WriteLine(
"Test {0} OK #Comparisons: {1} of {2}",
testNum, g.CurNumComparisons, g.MaxNumComparisons);
}
// ===========================================================
// Tests 101-200: 1000 piedras, 501 comparaciones
// ===========================================================
for (int testNum = 101; testNum <= 200; testNum++)
{
Solution s = new YourSolution();
LocateTheTimeStone g = new LocateTheTimeStone(testNum);
int answer = s.Solve(g);
g.VerifyAnswer(answer);
Console.WriteLine(
"Test {0} OK #Comparisons: {1} of {2}",
testNum, g.CurNumComparisons, g.MaxNumComparisons);
}
// ===========================================================
// Tests 201-300: 10000 piedras, 15 comparaciones
// ===========================================================
for (int testNum = 201; testNum <= 300; testNum++)
{
Solution s = new YourSolution();
LocateTheTimeStone g = new LocateTheTimeStone(testNum);
int answer = s.Solve(g);
g.VerifyAnswer(answer);
Console.WriteLine(
"Test {0} OK #Comparisons: {1} of {2}",
testNum, g.CurNumComparisons, g.MaxNumComparisons);
}
// ===========================================================
// Tests 301-400: 100000 piedras, 15 comparaciones
// ===========================================================
for (int testNum = 301; testNum <= 400; testNum++)
{
Solution s = new YourSolution();
LocateTheTimeStone g = new LocateTheTimeStone(testNum);
int answer = s.Solve(g);
g.VerifyAnswer(answer);
Console.WriteLine(
"Test {0} OK #Comparisons: {1} of {2}",
testNum, g.CurNumComparisons, g.MaxNumComparisons);
}
// ===========================================================
// Tests 401-500: 1000000 piedras, 15 comparaciones
// ===========================================================
for (int testNum = 401; testNum <= 500; testNum++)
{
Solution s = new YourSolution();
LocateTheTimeStone g = new LocateTheTimeStone(testNum);
int answer = s.Solve(g);
g.VerifyAnswer(answer);
Console.WriteLine(
"Test {0} OK #Comparisons: {1} of {2}",
testNum, g.CurNumComparisons, g.MaxNumComparisons);
}
// ===========================================================
// Tests 401-500: 10000000 piedras, 17 comparaciones
// ===========================================================
for (int testNum = 501; testNum <= 600; testNum++)
{
Solution s = new YourSolution();
LocateTheTimeStone g = new LocateTheTimeStone(testNum);
int answer = s.Solve(g);
g.VerifyAnswer(answer);
Console.WriteLine(
"Test {0} OK #Comparisons: {1} of {2}",
testNum, g.CurNumComparisons, g.MaxNumComparisons);
}
}
// Para probar tus ideas desde la consola
public static void InteractiveTest(LocateTheTimeStone g)
{
Console.WriteLine("Prueba interactiva con {0} piedras y {1} intentos",
g.NumStones, g.MaxNumComparisons);
Console.WriteLine("Escriba uno de los siguientes comandos:");
Console.WriteLine("C <L1> <R1> <L2> <R2>");
Console.WriteLine("E <pos>");
Console.WriteLine("* El comando C compara el peso del intervalo L1 a R1");
Console.WriteLine(" contra el intervalo L2 a R2");
Console.WriteLine("* El comando E termina la prueba y sometes la posicion");
Console.WriteLine(" pos como tu respuesta final");
while (true)
{
Console.Write("[{0}/{1}] > ", g.CurNumComparisons, g.MaxNumComparisons);
string line = Console.ReadLine();
if (line == null)
{
break;
}
if (line.Length == 0)
{
continue;
}
string[] parts = line.Split(' ');
if (parts.Length == 0)
{
continue;
}
if (parts[0] == "C")
{
if (parts.Length != 5)
{
Console.WriteLine("Comando acepta cuatro parametros");
continue;
}
int L1 = int.Parse(parts[1]);
int R1 = int.Parse(parts[2]);
int L2 = int.Parse(parts[3]);
int R2 = int.Parse(parts[4]);
int resultadoComparacion = g.Compare(L1, R1, L2, R2);
if (resultadoComparacion < 0)
{
Console.WriteLine(
"Intervalo [{0} .. {1}] es mas liviano que intervalo [{2} .. {3}]",
L1, R1, L2, R2);
}
else if (resultadoComparacion > 0)
{
Console.WriteLine(
"Intervalo [{0} .. {1}] es mas pesado que intervalo [{2} .. {3}]",
L1, R1, L2, R2);
}
else
{
Console.WriteLine(
"Intervalo [{0} .. {1}] tiene el mismo peso que intervalo [{2} .. {3}]",
L1, R1, L2, R2);
}
}
else if (parts[0] == "E")
{
if (parts.Length != 2)
{
Console.WriteLine("Comando acepta un (solo) parametro");
continue;
}
int answer = int.Parse(parts[1]);
try
{
g.VerifyAnswer(answer);
Console.WriteLine("Felicidades! Tu respuesta es correcta");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
break;
}
else
{
Console.WriteLine("Comando invalido");
continue;
}
}
}
public int Solve(LocateTheTimeStone g)
{
// TODO: Implementar un algoritmo para localizar el Time Stone.
// Debes devolver la posicion del Time Stone o -1 si todas las
// piedras son falsas.
// Valor: 4 puntos si logras pasar los tests con IDs del 1 al 100
// 4 puntos adicionales si logras pasar los tests con IDs del 101 al 200
// 4 puntos adicionales si logras pasar los tests con IDs del 201 al 300
// 4 puntos extras si logras pasar los tests con IDs del 301 al 400
int L1 = 0, R1 = g.NumStones / 3 - 1, L2 = R1 + 1, R2 = (R1 * 2) + 1, L3 = R2 + 1, R3 = g.NumStones - 1;
int balance, stones1, stones2, stones3, remaining = -1;
while (true)
{
stones1 = (R1 - L1 + 1); // La cantidad de piedras en cada intervalo para verificar que sean iguales.
stones2 = (R2 - L2 + 1);
stones3 = (R3 - L3 + 1);
while (stones1 != stones2 || stones2 != stones3 || stones3 != stones1) // Balanceo de las piedras para que sean iguales, guardando como remaining la ultima piedra
{
if (stones1 > stones2 && stones1 > stones3)
{
R1--;
L2--;
}
else if (stones2 > stones3 && stones2 > stones1)
{
R2--;
L3--;
}
else if (stones3 > stones1 && stones3 > stones2)
{
remaining = R3;
R3--;
}
if (stones1 < stones2 && stones1 < stones3)
{
if (L1 - 1 < 0)
{
R1++;
}
else
{
L1--;
}
}
else if (stones2 < stones3 && stones2 < stones1)
{
if (R2 + 1 == L3 || L2 - 1 != R1)
{
L2--;
}
}
else if (stones3 < stones1 && stones3 < stones2)
{
if (R3 + 1 >= g.NumStones)
{
L1--;
R1--;
L2--;
R2--;
L3--;
}
else
{
R3++;
}
}
stones1 = (R1 - L1 + 1);
stones2 = (R2 - L2 + 1);
stones3 = (R3 - L3 + 1);
}
balance = g.Compare(L1, R1, L2, R2);
if (stones1 == 1 || stones2 == 1 || stones3 == 1)
{
if (balance > 0)
{
return(L2);
}
else if (balance < 0)
{
return(L1);
}
else
{
if (remaining != L3)
{
balance = g.Compare(remaining, remaining, L3, R3);
}
else
{
balance = g.Compare(remaining, remaining, L1, R1);
}
if (balance > 0)
{
return(L3);
}
else if (balance < 0)
{
return(remaining);
}
else
{
return(-1);
}
}
}
if (balance < 0) //Los cortes de intervalos......... Este es el primer tercio
{
R3 = R1;
R1 = (R1 - L1) / 3 + L1;
L2 = R1 + 1;
R2 = (R3 - L2) / 2 + L2;
L3 = R2 + 1;
}
else if (balance > 0) // Este es el segundo tercio
{
R3 = R2;
R1 = (R2 - L2) / 3 + L2 - 1;
L1 = L2;
L2 = R1 + 1;
R2 = (R2 - L2) / 2 + L2;
L3 = R2 + 1;
}
else
{
if (remaining == R3 + 1) // Y este el ultimo tercio , tomando en cuenta el remaining que tenemos al final.
{
R3++;
}
L1 = L3;
R1 = (R3 - L3) / 3 + L3;
L2 = R1 + 1;
R2 = (R3 - L2) / 2 + L2;
L3 = R2 + 1;
}
}
}
