Maneira matematical de comparar um par de 3 variáveis

Foi-me atribuída a tarefa de comparar um par de três variáveis ​​duplas positivas, enquanto ignorava sua ordem, em Java. Eu fiz o seguinte:

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

Ouvi do professor que existe uma maneira matemática de comparar esse par de três números.

Até agora, tentei comparar sua adição, subtração e a soma de seu poder por 2, mas sempre achei um caso em que o par era diferente e a afirmação era verdadeira.

Alguma ideia?

EDITAR:

Já enviei a tarefa e a professora disse que minha resposta era verdadeira. Estou perguntando por curiosidade.

TL; DR

Compare a soma de cada trigêmeo, o produto de cada trigêmeo e a soma dos produtos de todas as combinações possíveis de cada trigêmeo.

O âmago da questão

Pelo Teorema Fundamental da Álgebra , para um polinômio de grau N, devemos ter N raízes.

Usando esse fato, deixamos nossos zeros a1, a2, and a3. Agora, encontramos os coeficientes desse polinômio.

(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)

Se dois polinômios são equivalentes, eles devem ter as mesmas raízes (novamente pelo TLC). Portanto, tudo o que precisamos fazer é comparar os coeficientes dos polinômios gerados.

Então se,

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

E

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

E

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

Então podemos concluir os trigêmeos a1, a2, a3e b1, b2, b3são equivalentes.

Vale a pena?

Do ponto de vista prático, vamos ver se isso é realmente mais eficiente do que a verificação de força bruta, conforme ilustrado pelo OP.

Primeira verificação: soma e comparação. Isso requer 4 adições no total e 1 verificação de igualdade.

Cheque total = 5; Total em execução = 5

Segunda verificação: Produto, Soma e Comparação. Isso requer 6 multiplicações totais, 4 adições totais e 1 verificação de igualdade.

Cheque total = 11; Total em execução = 16

Terceira verificação: produto e comparação. Isso requer 4 multiplicações totais e 1 verificação de igualdade.

Cheque total = 5; Total em execução = 21

Adicionando as duas operações AND lógicas, o número total de operações binárias para os "coeficientes da abordagem polinomial gerada" requer apenas:

23 operações binárias

A verificação de força bruta requer 18 verificações totais de igualdade, 12 comparações lógicas E e 5 comparações lógicas OU para um total de:

35 operações binárias

Então, estritamente falando , a resposta é sim, os "coeficientes da abordagem polinomial gerada" são realmente mais eficientes. No entanto, como o @WJS aponta, a abordagem de força bruta tem muito mais oportunidades para curtos-circuitos e, portanto, é executada com mais eficiência do que a abordagem matemática.

Para uma completa integridade

Não podemos deixar de verificar a soma dos produtos de todas as combinações possíveis de cada trigêmeo. Se deixarmos isso de fora, há inúmeros exemplos em que isso falha. Considere (23, 32, 45)e (24, 30, 46)^* :

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

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

Eles não são equivalentes, mas fornecem a mesma soma e produto. No entanto, eles não fornecem a mesma soma dos produtos de todas as combinações possíveis:

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

^* Caso alguém esteja curioso para obter um exemplo semelhante ao exemplo acima, primeiro gere todas as partições inteiras de um número M de comprimento 3, pegue seu produto, encontre as duplicatas e escolha um par.

Se você pode classificar (a1 <= b1 <= c1 e a2 <= b2 <= c2), tente comparar 2 ^ a1 * 3 ^ b1 * 5 ^ c1 com 2 ^ a2 * 3 ^ b2 * 5 ^ c2 (usando os números primos 2, 3, 5 como base)