The classic problem of arranging two sequences to maximize pairwise advantages can be modeled as an optimizaton task. Given two arrays of equal length, the goal is to permute the first array so that the count of positions where its element exceeds the corresponding element in the second array is maximized.

Consider two arrays, A and B. The objective is to rearrange A to produce array A' such that the number of indices i where A'[i] > B[i] is as large as possible.

For example: A = [12, 24, 8, 32] B = [13, 25, 32, 11] An optimal arrangement for A is [24, 32, 8, 12], resulting in three positions of advantage.

The strategy involves a greedy approach. First, sort array A in ascending order. For array B, we must track the original indices because the final arrangement must correspond to B's order. We pair each element in B with its index and sort these pairs based on the element values in descending order.

We then employ a two-pointer technique on the sorted A. One pointer (low) starts at the smallest element, and another (high) starts at the largest. Iterate through the sorted B pairs from largest to smallest value. If the current largest element in A (at high) can beat the currrent largest element from B, assign it to the result at the original index from the pair and decrement high. If it cannot, assign the current smallest element from A (at low) to that position and increment low. This "sacrifices" a weak element when a win isn't possible, preserving stronger elements for future comparisons.

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int original_index;
    int val;
} IndexedValue;

int compare_asc(const void *a, const void *b) {
    return *(int*)a - *(int*)b;
}

int compare_desc(const void *a, const void *b) {
    return ((IndexedValue*)b)->val - ((IndexedValue*)a)->val;
}

int* maximize_advantage(int* arr_a, int size_a, int* arr_b, int size_b, int* result_size) {
    // Sort arr_a in ascending order
    qsort(arr_a, size_a, sizeof(int), compare_asc);

    // Create and sort indexed version of arr_b in descending order
    IndexedValue *b_indexed = malloc(size_b * sizeof(IndexedValue));
    for (int i = 0; i < size_b; i++) {
        b_indexed[i].original_index = i;
        b_indexed[i].val = arr_b[i];
    }
    qsort(b_indexed, size_b, sizeof(IndexedValue), compare_desc);

    int *result = calloc(size_b, sizeof(int));
    int left = 0, right = size_a - 1;

    for (int i = 0; i < size_b; i++) {
        int current_b_val = b_indexed[i].val;
        int target_idx = b_indexed[i].original_index;

        if (arr_a[right] > current_b_val) {
            // Use largest available from A to win
            result[target_idx] = arr_a[right];
            right--;
        } else {
            // Sacrifice the smallest available from A
            result[target_idx] = arr_a[left];
            left++;
        }
    }

    free(b_indexed);
    *result_size = size_b;
    return result;
}

int main() {
    int A[] = {4, 6, 2, 8, 5};
    int B[] = {5, 7, 1, 9, 3};
    int size = sizeof(A) / sizeof(A[0]);
    int output_size;

    int *optimal_arrangement = maximize_advantage(A, size, B, size, &output_size);

    printf("Optimal arrangement for A: ");
    for (int i = 0; i < output_size; i++) {
        printf("%d ", optimal_arrangement[i]);
    }
    printf("\n");

    free(optimal_arrangement);
    return 0;
}

The algorithm operates in O(n log n) time due to sorting. The two-pointer traversal is O(n). The space complexity is O(n) for storing the indexed version of B and the result array.