Program to find maximum size of any sequence of given array where every pair is nice in Python

Suppose we have a sequence nums of size n. We have to find the maximum size of subsequence of nums in which every pair (p, q) is a nice pair. A pair is said to be nice if it satisfies at least one of these conditions:

• The parity of the number of distinct prime divisors of p is equal to that of q
• The parity of the sum of all positive divisors of p is same as q

For example, the value 18 has two distinct prime divisors: 2 and 3, so it has an even number of prime divisors.

So, if the input is like nums = [2, 3, 6, 8], then the output will be 3.

Algorithm Steps

To solve this problem, we follow these steps −

• For each number, calculate the parity of distinct prime divisors count
• For each number, calculate the parity of sum of all divisors
• Find pairs that satisfy at least one nice pair condition
• Return the maximum subsequence size where all pairs are nice

Implementation

Let us see the following implementation to get better understanding −

def solve(nums):
    n = len(nums)
    prime_parity = []
    divisor_parity = []
    
    # Calculate prime factor parity and divisor sum parity for each number
    for num in nums:
        # Count distinct prime factors
        prime_count = 0
        temp = num
        
        # Check for factor 2
        if temp % 2 == 0:
            prime_count += 1
            while temp % 2 == 0:
                temp //= 2
        
        # Check for odd factors from 3 onwards
        i = 3
        while i * i <= temp:
            if temp % i == 0:
                prime_count += 1
                while temp % i == 0:
                    temp //= i
            i += 2
        
        # If temp > 1, then it's a prime
        if temp > 1:
            prime_count += 1
        
        prime_parity.append(prime_count % 2)
        
        # Calculate sum of divisors
        divisor_sum = 0
        for j in range(1, num + 1):
            if num % j == 0:
                divisor_sum += j
        
        divisor_parity.append(divisor_sum % 2)
    
    # Find maximum subsequence where all pairs are nice
    result = set()
    
    for i in range(n):
        for j in range(i + 1, n):
            # Check if pair (i, j) is nice
            if (prime_parity[i] == prime_parity[j] or 
                divisor_parity[i] == divisor_parity[j]):
                result.add(nums[i])
                result.add(nums[j])
    
    return len(result)

# Test the function
nums = [2, 3, 6, 8]
print(solve(nums))

The output of the above code is −

3

How It Works

The algorithm works by:

• Prime Factor Analysis: For each number, we count distinct prime factors and determine if the count is odd or even
• Divisor Sum Analysis: We calculate the sum of all positive divisors and check its parity
• Nice Pair Detection: Two numbers form a nice pair if they have the same prime factor parity OR the same divisor sum parity
• Result: We collect all numbers that participate in at least one nice pair

Example Walkthrough

For nums = [2, 3, 6, 8]:

• 2: Prime factors [2] (odd count), divisors sum = 3 (odd)
• 3: Prime factors [3] (odd count), divisors sum = 4 (even)
• 6: Prime factors [2,3] (even count), divisors sum = 12 (even)
• 8: Prime factors [2] (odd count), divisors sum = 15 (odd)

Nice pairs: (2,3) same prime parity, (2,8) same divisor parity, (3,6) same divisor parity. All numbers participate, so the answer is 3.

Conclusion

This solution efficiently finds the maximum subsequence size by analyzing prime factor parities and divisor sum parities. The key insight is that numbers form nice pairs when they share at least one parity characteristic.