Counting Pairs (x, y) in an Array Where x^y > y^x

In this tutorial, we will write the Python program to find the number of pairs such that x^y>y^x. We have given two arrays X[] and Y[] containing positive integers, we need to determine the count of pairs (x, y) where x is an element from X[] and y is an element from Y[], and the condition x^y > y^x is satisfied.

Example 5:

Input:

M = 3, X[] = [3 4 2]  
N = 2, Y[] = [1 5]

Output

Explanation:

- 3^1 > 1^3 (3^1 > 1^3)

- 4^5 > 5^4 (4^5 > 5^4)

- 2^1 > 1^2 (2^1 > 1^2)

Solution - 1:

Let's understand the code snippet -

Example -

def count_pairs(X, Y, m, n):
    count = 0
    for i in range(m):
        for j in range(n):
            if (X[i] ** Y[j] > Y[j] ** X[i]):
                count += 1
    return count
X = [2, 1, 6]
Y = [1, 5]
m = len(X)
n = len(Y)
result = count_pairs(X, Y, m, n)
print(result)

Output

Explanation -

Let's understand the following explanation -

In the above code we create a function count_pairs() is defined, which takes four arguments: X which represents an array of positive integers, Y which is another array of positive integers, m is the length of array X, and n is the length of array Y.
Then we define the variable count and assigned 0. This variable will be used to keep track of the number of pairs that satisfy the condition x^y > y^x.
We used two nested loops to iterate through the elements of arrays X and Y in a double-loop manner. The outer loop iterates over the elements of X, and the inner loop iterates over the elements of Y.
Within the nested loops, it verifies the condition x^y > y^x for each pair (x, y) using the ** operator to calculate the powers.
If the condition x^y > y^x is satisfied for a pair, the count variable is incremented by 1.
After both loops complete, the function returns the value of the count variable, which represents the number of pairs (x, y) that meet the condition `x^y > y^x`.

Time Complexity: O(M*N) where M and N are sizes of given arrays.

Auxiliary Space: O(1)

Solution - 2:

Following is the more efficient approach to solve the problem

Example -

import bisect
def count_pairs_with_condition(x, Y, n, counts_of_Y):
    if x == 0:
        return 0
    if x == 1:
        return counts_of_Y[0]
    
    idx = bisect.bisect_right(Y, x)
    result = n - idx
    result += counts_of_Y[0] + counts_of_Y[1]
    
    if x == 2:
        result -= counts_of_Y[3] + counts_of_Y[4]
    
    if x == 3:
        result += counts_of_Y[2]
    
    return result

def count_pairs_satisfying_condition(X, Y, m, n):
    counts_of_Y = [0] * 5
    for i in range(n):
        if Y[i] < 5:
            counts_of_Y[Y[i]] += 1
    
    Y.sort()
    total_pairs = 0
    
    for x in X:
        total_pairs += count_pairs_with_condition(x, Y, n, counts_of_Y)
    
    return total_pairs

if __name__ == '__main':
    X_values = [2, 1, 6]
    Y_values = [1, 5]
    result = count_pairs_satisfying_condition(X_values, Y_values, len(X_values), len(Y_values))
    print("Total pairs satisfying the condition:", result)

Output

Explanation -

In the above code, first we imported the bisect module and defined count_pairs_with_condition() function which calculates the count of pairs satisfying the condition for a given x.

If x is 0, it returns 0, as there cannot be any value in Y that satisfies the condition.

If x is 1, it returns the count of zeroes in Y since any number raised to the power of 0 is 1, and therefore, x^0 is always greater than y^x for x greater than 1.

It sorts the array Y and uses the bisect.bisect_right() function to find the index where x should be inserted in the sorted array. This index represents the count of elements in Y greater than x.

Then we defined the count_pairs_satisfying_condition() function

This function calculates the total count of pairs satisfying the condition for all values in array X.

It initializes an array counts_of_Y to store counts of elements in Y with values less than 5. These counts help in counting pairs efficiently.

It sorts the array Y to enable binary search in the next step.

It initializes total_pairs to keep track of the total count of pairs.

Time Complexity: O((n + m) * log(n + m)), where `n` is the length of array X and m is the length of array Y, and the primary factor affecting the time complexity is the sorting of both arrays, which takes O((n + m) * log(n + m)) time.

Auxiliary Space: O(n + m), the additional space used by the code for arrays counts_of_Y and the sorted Y.

Conclusion

In this tutorial, we explored how to find the number of pairs (x, y) in two arrays such that x^y > y^x. We provided a step-by-step explanation of the solution, including a more efficient approach that optimizes the counting process. The efficient solution uses sorting and clever counting to reduce time complexity. It's a valuable technique for solving similar problems efficiently. By understanding these methods, you can tackle such challenges effectively in your programming knowledge.

Next TopicFind-the-next-greater-element-for-every-element

← prev next →