Home/ Questions/Q 8090647
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-06-05T19:47:30+00:00

{ ans += (a[i] > a[j]) != (b[i] > b[j]); //ans += ((a[i] >

  • 0
{
ans += (a[i] > a[j]) != (b[i] > b[j]);
//ans += ((a[i] > a[j]) && (b[j] > b[i])) || ((a[j] > a[i]) && (b[i] > b[j]));
}

What you see above is a snippet I took from some where. There are two logic expressions. Supposedly, the one commented out is the same as the one not commented out.

How do you get from:

((a[i] > a[j]) && (b[j] > b[i])) || ((a[j] > a[i]) && (b[i] > b[j]))

to something like this

(a[i] > a[j]) != (b[i] > b[j])

Are there any guides or books for these kind of logic expression simplifications?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    The code you posted is right if you assume that

    !(p > q) == (p < q)

    Meaning that for some reason, you’re ignoring equality.

    With this in mind, let’s say that:

    a1 = a[i]
a2 = a[j]
b1 = b[i]
b2 = b[j]

    Then you have:

    ans += ((a1 > a2) && (b2 > b1)) || ((a2 > a1) && (b1 > b2));

    Which, since we’re ignoring equality, is the same as:

    ans += ((a1 > a2) && !(b1 > b2)) || (!(a1 > a2) && (b1 > b2));

    If you take a closer look, you’ll see that the expressions are repeated, so they can be simplified:

    A = a1 > a2
B = b1 > b2

    Then:

    ans += (A && !B) || (!A && B);

    Which means either A or B, but no both
    This is a known boolean operation called XOR, which in your case is the same as different (!=)

    Therefore:

    ans += A != B;

    And expanding:

    ans += (a1 > a2) != (b1 > b2)

    So:

    ans += (a[i] > a[j]) != (b[i] > b[j])

    Hope it’s clear now.

    • 0