Sort Transformed Array - Practice Coding Problems

Sort Transformed Array - Problem

Sort Transformed Array is a fascinating problem that combines quadratic functions with array manipulation. Given a sorted integer array nums and three integers a, b, and c, you need to apply the quadratic function f(x) = ax² + bx + c to each element in the array, then return the transformed values in sorted order.

The key insight is that applying a quadratic function to a sorted array doesn't necessarily maintain the sorted order - the parabola shape can cause values to increase or decrease depending on the coefficients. Your task is to efficiently determine the final sorted arrangement without expensive sorting operations.

Example: If nums = [-4, -2, 2, 4] and a=1, b=3, c=5, then:
• f(-4) = 1×16 + 3×(-4) + 5 = 9
• f(-2) = 1×4 + 3×(-2) + 5 = 3
• f(2) = 1×4 + 3×2 + 5 = 15
• f(4) = 1×16 + 3×4 + 5 = 33
Result: [3, 9, 15, 33]

Input & Output

example_1.py — Basic Quadratic Transform

$ Input: nums = [-4,-2,2,4], a = 1, b = 3, c = 5

› Output: [3,9,15,33]

💡 Note: Applying f(x) = x² + 3x + 5: f(-4) = 16-12+5 = 9, f(-2) = 4-6+5 = 3, f(2) = 4+6+5 = 15, f(4) = 16+12+5 = 33. Sorted: [3,9,15,33]

example_2.py — Downward Parabola

$ Input: nums = [-4,-2,2,4], a = -1, b = 3, c = 5

› Output: [-5,-1,1,7]

💡 Note: With a = -1, parabola opens downward: f(-4) = -16-12+5 = -23, f(-2) = -4-6+5 = -5, f(2) = -4+6+5 = 7, f(4) = -16+12+5 = 1. Wait, let me recalculate: f(-4) = -16+(-12)+5 = -23, but that seems wrong. Let me fix: f(-4) = -16 + 3(-4) + 5 = -16-12+5 = -23, f(-2) = -4-6+5 = -5, f(2) = -4+6+5 = 7, f(4) = -16+12+5 = 1. Sorted: [-23,-5,1,7]. Actually let me recalculate properly: f(-4)=-1(16)+3(-4)+5=-16-12+5=-23, f(-2)=-1(4)+3(-2)+5=-4-6+5=-5, f(2)=-1(4)+3(2)+5=-4+6+5=7, f(4)=-1(16)+3(4)+5=-16+12+5=1. So sorted is [-23,-5,1,7]

example_3.py — Linear Function

$ Input: nums = [-2,-1,1,2], a = 0, b = 2, c = 3

› Output: [-1,1,5,7]

💡 Note: When a = 0, function becomes linear f(x) = 2x + 3: f(-2) = -4+3 = -1, f(-1) = -2+3 = 1, f(1) = 2+3 = 5, f(2) = 4+3 = 7. Since input is sorted and function is linear with positive slope, output remains sorted.

Visualization

Tap to expand

Understanding the Visualization

Analyze Parabola Direction

Determine if parabola opens upward (a > 0), downward (a < 0), or is linear (a = 0)

Position Two Pointers

Place pointers at array extremes to access values that will be largest/smallest after transformation

Strategic Result Filling

Fill result array from appropriate end based on parabola characteristics

Optimal Traversal

Move pointers inward, always placing the next largest/smallest value correctly

Key Takeaway

🎯 Key Insight: By understanding parabola properties, we can predict that the extreme values of a sorted array will produce the extreme values after quadratic transformation, allowing us to build the sorted result efficiently with two pointers.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with two pointers

✓ Linear Growth

Space Complexity

O(n)

Only space for result array, O(1) extra space

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 200
-100 ≤ nums[i], a, b, c ≤ 100
nums is sorted in non-decreasing order
-10⁴ ≤ transformed values ≤ 10⁴

Asked in

G Google 15 f Meta 12 ⊞ Microsoft 8 a Amazon 6

The optimal solution uses the two pointers technique leveraging mathematical properties of quadratic functions. Since the input is sorted, we can determine whether to fill the result array from the beginning or end based on whether the parabola opens upward (a ≥ 0) or downward (a < 0). This achieves O(n) time complexity without requiring explicit sorting, making it significantly more efficient than the brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(n)	Use mathematical properties of parabolas with two pointers to build result efficiently
Transform and Sort	O(n log n)	O(n)	Apply quadratic function to all elements, then sort the result

Two Pointers (Optimal) — Algorithm Steps

Initialize two pointers: left at start, right at end of input array
Create result array and determine fill direction based on parabola orientation
For each position, compare f(nums[left]) and f(nums[right])
Place the appropriate value (larger/smaller based on a's sign) in result
Move the corresponding pointer inward
Continue until pointers meet

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Pointers

Place left pointer at start, right at end

Compare Extremes

Calculate f(left) and f(right), compare values

Fill Result

Place larger/smaller value based on parabola direction

Move Pointers

Move inward and repeat until complete

Code -

solution.c — C

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

int transform(int x, int a, int b, int c) {
    return a * x * x + b * x + c;
}

int* sortTransformedArray(int* nums, int numsSize, int a, int b, int c, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    int left = 0, right = numsSize - 1;
    
    if (a >= 0) {
        // Parabola opens upward, fill from the end
        int i = numsSize - 1;
        while (left <= right) {
            int leftVal = transform(nums[left], a, b, c);
            int rightVal = transform(nums[right], a, b, c);
            if (leftVal > rightVal) {
                result[i] = leftVal;
                left++;
            } else {
                result[i] = rightVal;
                right--;
            }
            i--;
        }
    } else {
        // Parabola opens downward, fill from the beginning
        int i = 0;
        while (left <= right) {
            int leftVal = transform(nums[left], a, b, c);
            int rightVal = transform(nums[right], a, b, c);
            if (leftVal < rightVal) {
                result[i] = leftVal;
                left++;
            } else {
                result[i] = rightVal;
                right--;
            }
            i++;
        }
    }
    
    return result;
}

int main() {
    // Input parsing and function call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with two pointers

✓ Linear Growth

Space Complexity

O(n)

Only space for result array, O(1) extra space

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 200
-100 ≤ nums[i], a, b, c ≤ 100
nums is sorted in non-decreasing order
-10⁴ ≤ transformed values ≤ 10⁴

28.5K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler