Forma matematica de comparar un par de 3 variables

Me dieron la tarea de comparar un par de 3 variables dobles positivas, ignorando su orden, en Java. Hice lo siguiente:

if ((a1 == a2 && b1 == b2 && c1 == c2) ||
    (a1 == a2 && b1 == c2 && c1 == b2) ||
    (a1 == b2 && b1 == a2 && c1 == c2) ||
    (a1 == b2 && b1 == c2 && c1 == a2) ||
    (a1 == c2 && b1 == a2 && c1 == b2) ||
    (a1 == c2 && b1 == b2 && c1 == a2))
    // if true

He escuchado del maestro que hay una forma matemática de comparar este par de 3 números.

Hasta ahora, he tratado de comparar su suma, resta, la suma de su poder por 2, pero siempre encontré un caso en el que el par era diferente y la afirmación era cierta.

¿Algunas ideas?

EDITAR:

Ya envié la tarea y la maestra dijo que mi respuesta era verdadera. Estoy preguntando por curiosidad.

TL; DR

Compare la suma de cada triplete, el producto de cada triplete y la suma de los productos de todas las combinaciones posibles de cada triplete.

The Nitty Gritty

Según el teorema fundamental del álgebra , para un polinomio de grado N, debemos tener N raíces.

Usando este hecho, dejamos que nuestros ceros sean a1, a2, and a3. Ahora, encontramos los coeficientes de este polinomio.

(x - a1) * (x - a2) * (x - a3)
(x^2 - (a1 + a2) * x + a1a2) * (x - a3) 
x^3 - (a1 + a2) * x^2 + (a1a2) * x - a3 * x^2 + (a1a3 + a2a3) * x - a1a2a3

x^3 + (-1 * (a1 + a2 + a3)) * x^2 + (a1a2 + a1a3 + a2a3) * x + (-1 * a1a2a3)

Si dos polinomios son equivalentes, deben tener las mismas raíces (nuevamente por el TLC). Por lo tanto, todo lo que tenemos que hacer es comparar los coeficientes de los polinomios generados.

Así que si,

(-1 * (a1 + a2 + a3) == (-1 * (b1 + b2 + b3))
      ---equivalently---
a1 + a2 + a3 == b1 + b2 + b3

Y

(a1a2 + a1a3 + a2a3) == (b1b2 + b1b3 + b2b3)

Y

-1 * a1a2a3 == -1 * b1b2b3
      ---equivalently---
a1a2a3 == b1b2b3

Entonces podemos concluir los trillizos a1, a2, a3y b1, b2, b3son equivalentes.

¿Vale la pena?

Desde un punto de vista práctico, veamos si esto es realmente más eficiente que la verificación de la fuerza bruta como lo ilustra el OP.

Primera verificación: Sumar y comparar. Esto requiere 4 adiciones totales y 1 verificación de igualdad.

Comprobar total = 5; Total acumulado = 5

Segunda verificación: Producto, Suma y Comparar. Esto requiere 6 multiplicaciones totales, 4 adiciones totales y 1 verificación de igualdad.

Comprobar total = 11; Total acumulado = 16

Tercer chequeo: Producto y Comparar. Esto requiere 4 multiplicaciones totales y 1 verificación de igualdad.

Comprobar total = 5; Total acumulado = 21

Sumando las dos operaciones lógicas AND, el número total de operaciones binarias para los "coeficientes del enfoque polinómico generado" solo requiere:

23 operaciones binarias

La verificación de la fuerza bruta requiere 18 verificaciones de igualdad total, 12 comparaciones lógicas Y y 5 comparaciones lógicas O para un total de:

35 operaciones binarias

Entonces, estrictamente hablando , la respuesta es sí, los "coeficientes del enfoque polinomial generado" son de hecho más eficientes. Sin embargo, como señala @WJS, el enfoque de fuerza bruta tiene muchas más oportunidades para cortocircuitos y, por lo tanto, ejecutar manera más eficiente que el enfoque matemático.

Para completa minuciosidad

No podemos omitir la comprobación de la suma de los productos de todas las combinaciones posibles de cada triplete. Si dejamos esto fuera, hay innumerables ejemplos en los que esto falla. Considere (23, 32, 45)y (24, 30, 46)^* :

23 + 32 + 45 = 100
24 + 30 + 46 = 100

23 * 32 * 45 = 33120
24 * 30 * 46 = 33120

No son equivalentes pero dan la misma suma y producto. Sin embargo, no dan la misma suma de productos de todas las combinaciones posibles:

23 * 32 + 23 * 45 + 32 * 45 = 3211
24 * 30 + 24 * 46 + 30 * 46 = 3204

^* En caso de que uno tenga curiosidad sobre cómo derivar un ejemplo similar al anterior, primero genere todas las particiones enteras de un entero M de longitud 3, tome su producto, encuentre los duplicados y elija un par.

Si puede ordenar (a1 <= b1 <= c1 y a2 <= b2 <= c2), intente comparar 2 ^ a1 * 3 ^ b1 * 5 ^ c1 con 2 ^ a2 * 3 ^ b2 * 5 ^ c2 (usando los números primos 2, 3, 5 como base)