Program to sort all even and odd numbers in increasing and decreasing order respectively in Python

Sometimes we need to sort a list where even and odd numbers follow different sorting rules while maintaining their relative positions. This problem requires sorting even numbers in ascending order and odd numbers in descending order.

Problem Statement

Given a list of numbers, we need to sort the array by maintaining the following criteria ?

• Even numbers are sorted in ascending order
• Odd numbers are sorted in descending order
• The relative positions of even and odd numbers should not be changed

For example, if the input is [9, 14, 12, 91, -4, 5], the output will be [91, -4, 12, 9, 14, 5].

Algorithm

To solve this problem, we follow these steps ?

• Extract all even numbers from the list
• Extract all odd numbers from the list
• Sort even numbers in ascending order
• Sort odd numbers in descending order
• Replace original even/odd numbers with sorted values while maintaining positions

Implementation

class Solution:
    def solve(self, nums):
        # Separate even and odd numbers
        evens = [num for num in nums if num % 2 == 0]
        odds = [num for num in nums if num % 2 != 0]
        
        # Sort evens in ascending, odds in descending order
        evens.sort()
        odds.sort(reverse=True)
        
        # Replace original numbers with sorted values
        even_i = 0
        odd_i = 0
        
        for index in range(len(nums)):
            if nums[index] % 2 == 0:
                nums[index] = evens[even_i]
                even_i += 1
            else:
                nums[index] = odds[odd_i]
                odd_i += 1
        
        return nums

# Test the solution
ob = Solution()
result = ob.solve([9, 14, 12, 91, -4, 5])
print("Original:", [9, 14, 12, 91, -4, 5])
print("Sorted:", result)

Original: [9, 14, 12, 91, -4, 5]
Sorted: [91, -4, 12, 9, 14, 5]

How It Works

Let's trace through the example [9, 14, 12, 91, -4, 5] ?

# Original array: [9, 14, 12, 91, -4, 5]
nums = [9, 14, 12, 91, -4, 5]

# Step 1: Extract even and odd numbers
evens = [14, 12, -4]  # Even numbers
odds = [9, 91, 5]     # Odd numbers

# Step 2: Sort them
evens.sort()          # [-4, 12, 14]
odds.sort(reverse=True) # [91, 9, 5]

print("Sorted evens:", evens)
print("Sorted odds:", odds)

# Step 3: Replace in original positions
# Position 0: 9 (odd) ? 91 (first from sorted odds)
# Position 1: 14 (even) ? -4 (first from sorted evens)
# Position 2: 12 (even) ? 12 (second from sorted evens)
# Position 3: 91 (odd) ? 9 (second from sorted odds)
# Position 4: -4 (even) ? 14 (third from sorted evens)
# Position 5: 5 (odd) ? 5 (third from sorted odds)

Sorted evens: [-4, 12, 14]
Sorted odds: [91, 9, 5]

Alternative Approach

Here's a more functional approach using enumerate ?

def sort_even_odd(nums):
    evens = sorted([num for num in nums if num % 2 == 0])
    odds = sorted([num for num in nums if num % 2 != 0], reverse=True)
    
    even_iter = iter(evens)
    odd_iter = iter(odds)
    
    return [next(even_iter) if num % 2 == 0 else next(odd_iter) for num in nums]

# Test the function
numbers = [9, 14, 12, 91, -4, 5]
result = sort_even_odd(numbers)
print("Result:", result)

Result: [91, -4, 12, 9, 14, 5]

Time and Space Complexity

• Time Complexity: O(n log n) due to sorting operations
• Space Complexity: O(n) for storing separate even and odd lists

Conclusion

This solution efficiently sorts even numbers in ascending order and odd numbers in descending order while preserving their relative positions. The key insight is to separate, sort, and then replace the numbers in their original positions.