Sort an array after applying the given equation

Last Updated : 11 Mar, 2024

We have an integer array that is sorted in ascending order. We also have 3 integers A, B and C. We need to apply A*x*x + B*x + C for each element x in the array and sort the modified array.

Example:

Input : arr[] = {-1, 0, 1, 2, 3, 4} 
       A = -1, B = 2, C = -1
Output : {-9, -4, -4, -1, -1, 0}  
Expalnation:
Input array is {-1, 0, 1, 2, 3, 4}. After
applying the equation A*x*x + B*x + C on
every element x we get, {-4,-1, 0, -1, -4, -9}
After sorting, we get {-9, -4, -4, -1, -1, 0}

Method 1 (Simple) :

Apply the given equation to all the elements. O(n)
Sort the modified array. O(n log n)

Steps:

Initialize an array arr of size n with given elements.
Initialize three integers A, B, and C.
For each element x in arr, apply the given equation Axx + B*x + C and store the result in arr.
Sort the array arr using a sorting algorithm.
Print the sorted array arr.

Below is the implementation of the approach:

C++

// C++ code for the approach
 
#include<bits/stdc++.h>
using namespace std;
 
// Function to apply the given equation on each element of the array
void applyEquation(int arr[], int n, int a, int b, int c) {
      // traversing array and updating each value
      // as per equation
    for(int i=0; i<n; i++) {
        arr[i] = a*arr[i]*arr[i] + b*arr[i] + c;
    }
}
 
// Driver's code
int main() {
      // Input array
    int arr[] = { -21 ,-15, 12, 13, 14 };
    int n = sizeof(arr)/sizeof(arr[0]);
 
    int a = -6, b = -7, c = 2;
 
    // Funciton call
    applyEquation(arr, n, a, b, c);
 
    // Sorting the modified array
    sort(arr, arr+n);
 
    // Printing the sorted array
      cout << "Array after sorting is : ";
    for(int i=0; i<n; i++) {
        cout << arr[i] << " ";
    }
 
    return 0;
}

Java

import java.util.Arrays;
 
public class ArrayEquation {
    // Function to apply the given equation on each element of the array
    public static void applyEquation(int[] arr, int n, int a, int b, int c) {
        // Traversing the array and updating each value as per the equation
        for (int i = 0; i < n; i++) {
            arr[i] = a * arr[i] * arr[i] + b * arr[i] + c;
        }
    }
 
    // Driver's code
    public static void main(String[] args) {
        // Input array
        int[] arr = { -21, -15, 12, 13, 14 };
        int n = arr.length;
 
        int a = -6, b = -7, c = 2;
 
        // Function call
        applyEquation(arr, n, a, b, c);
 
        // Sorting the modified array
        Arrays.sort(arr);
 
        // Printing the sorted array
        System.out.print("Array after sorting is: ");
        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

C#

using System;
 
public class ArrayEquation
{
    // Function to apply the given equation on each element of the array
    public static void ApplyEquation(int[] arr, int n, int a, int b, int c)
    {
        // Traversing the array and updating each value as per the equation
        for (int i = 0; i < n; i++)
        {
            arr[i] = a * arr[i] * arr[i] + b * arr[i] + c;
        }
    }
 
    // Driver's code
    public static void Main(string[] args)
    {
        // Input array
        int[] arr = { -21, -15, 12, 13, 14 };
        int n = arr.Length;
 
        int a = -6, b = -7, c = 2;
 
        // Function call
        ApplyEquation(arr, n, a, b, c);
 
        // Sorting the modified array
        Array.Sort(arr);
 
        // Printing the sorted array
        Console.Write("Array after sorting is: ");
        foreach (int num in arr)
        {
            Console.Write(num + " ");
        }
    }
}

Javascript

function applyEquation(arr, a, b, c) {
    // Traversing the array and updating each value as per the equation
    for (let i = 0; i < arr.length; i++) {
        arr[i] = a * arr[i] * arr[i] + b * arr[i] + c;
    }
}
 
// Driver's code
function main() {
    // Input array
    const arr = [-21, -15, 12, 13, 14];
    const a = -6, b = -7, c = 2;
 
    // Function call
    applyEquation(arr, a, b, c);
 
    // Sorting the modified array
    arr.sort((x, y) => x - y);
 
    // Printing the sorted array
    console.log("Array after sorting is: " + arr.join(" "));
}
 
main();

Python3

# Function to apply the given equation on each element of the array
def applyEquation(arr, n, a, b, c):
    # Traversing array and updating each value as per equation
    for i in range(n):
        arr[i] = a * arr[i] * arr[i] + b * arr[i] + c
 
# Driver's code
if __name__ == '__main__':
    # Input array
    arr = [-21, -15, 12, 13, 14]
    n = len(arr)
 
    a = -6
    b = -7
    c = 2
 
    # Function call
    applyEquation(arr, n, a, b, c)
 
    # Sorting the modified array
    arr.sort()
 
    # Printing the sorted array
    print("Array after sorting is:", arr)

Output

Array after sorting is : -2497 -1272 -1243 -1103 -946

Time Complexity: O(n * log₂n) as sort function has been called. Here, n is the size of the input array.
Auxiliary Space: O(1) as no extra space has been used.

Method 2(Efficient): Parabolic Property:

The equation given is parabolic. So the result of applying it to a sorted array will result in an array that will have a maximum/minimum with the sub-arrays to its left and right sorted.
In the above example, maximum is 0 and the subarray to its left {-4, -1} is sorted in ascending order and the sub-array to its right {-1, -4, -9} is sorted in descending order.
All we need to do is merge these sorted arrays which are linear in time.

So the algorithm is:

Apply equation on each element.
Find maximum/minimum.
Merge sub-arrays.

Note: The below code assumes that the modified array is first increasing then decreasing.

Implementation:

C++

// C program to sort an array after applying equation
// A*x*x + B*x + C
#include<bits/stdc++.h>
using namespace std;
 
// Function to sort an array after applying given
// equation.
void sortArray(int arr[], int n, int A, int B, int C)
{
   // Apply equation on all elements
    for (int i = 0; i < n; i++)
        arr[i] = A*arr[i]*arr[i] + B*arr[i] + C;
 
    // Find maximum element in resultant array
    int index, maximum = INT_MIN;
    for (int i = 0; i< n; i++)
    {
        if (maximum < arr[i])
        {
            index = i;
            maximum = arr[i];
        }
    }
 
    // Use maximum element as a break point
    // and merge both subarrays using simple
    // merge function of merge sort
    int i = 0, j = n-1;
    int new_arr[n], k = 0;
    while (i < index && j > index)
    {
        if (arr[i] < arr[j])
            new_arr[k++] = arr[i++];
        else
            new_arr[k++] = arr[j--];
    }
 
    // Merge remaining elements
    while (i < index)
        new_arr[k++] = arr[i++];
    while (j > index)
        new_arr[k++] = arr[j--];
 
    new_arr[n-1] = maximum;
 
    // Modify original array
    for (int i = 0; i < n ; i++)
        arr[i] = new_arr[i];
}
 
// Driver code
int main()
{
    int arr[] = {-21 ,-15, 12, 13, 14 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int A = -6, B =-7, C = 2;
 
    sortArray(arr, n, A, B, C);
 
    cout << "Array after sorting is : ";
    for (int i=0; i<n; i++)
       cout << arr[i] << " ";
 
    return 0;
}

Java

// Java program to sort an array after applying equation
// A*x*x + B*x + C
 
class Main
{
    // Function to sort an array after applying given
    // equation.
    static void sortArray(int arr[], int n, int A, int B, int C)
    {
       // Apply equation on all elements
        for (int i = 0; i < n; i++)
            arr[i] = A*arr[i]*arr[i] + B*arr[i] + C;
      
        // Find maximum element in resultant array
        int index=-1;
        int maximum = -999999;
        for (int i = 0; i< n; i++)
        {
            if (maximum < arr[i])
            {
                index = i;
                maximum = arr[i];
            }
        }
      
        // Use maximum element as a break point
        // and merge both subarrays using simple
        // merge function of merge sort
        int i = 0, j = n-1;
        int[] new_arr = new int[n];
        int k = 0;
        while (i < index && j > index)
        {
            if (arr[i] < arr[j])
                new_arr[k++] = arr[i++];
            else
                new_arr[k++] = arr[j--];
        }
      
        // Merge remaining elements
        while (i < index)
            new_arr[k++] = arr[i++];
        while (j > index)
            new_arr[k++] = arr[j--];
      
        new_arr[n-1] = maximum;
      
        // Modify original array
        for (int p = 0; p < n ; p++)
            arr[p] = new_arr[p];
    }
     
    // main function
    public static void main (String[] args) 
    {
        int arr[] = {-21 ,-15, 12, 13, 14 };
        int n = arr.length;
        int A = -6, B =-7, C = 2;
      
        sortArray(arr, n, A, B, C);
      
        System.out.println("Array after sorting is : ");
        for (int i=0; i<n; i++)
           System.out.print(arr[i]+" ");
    }
}
 
/* This code is contributed by Harsh Agarwal */

C#

// C# program to sort an array after applying equation 
// A*x*x + B*x + C 
  
using System; 
class MAIN 
{ 
    // Function to sort an array after applying given 
    // equation. 
    static void sortArray(int[] arr, int n, int A, int B, int C) 
    { 
       // Apply equation on all elements 
        for (int i = 0; i < n; i++) 
            arr[i] = A*arr[i]*arr[i] + B*arr[i] + C; 
        
        // Find maximum element in resultant array 
        int index=-1; 
        int maximum = -999999; 
        for (int i = 0; i< n; i++) 
        { 
            if (maximum < arr[i]) 
            { 
                index = i; 
                maximum = arr[i]; 
            } 
        } 
        
        // Use maximum element as a break point 
        // and merge both subarrays using simple 
        // merge function of merge sort 
        int l = 0, j = n-1; 
        int[] new_arr = new int[n]; 
        int k = 0; 
        while (l < index && j > index) 
        { 
            if (arr[l] < arr[j]) 
                new_arr[k++] = arr[l++]; 
            else
                new_arr[k++] = arr[j--]; 
        } 
        
        // Merge remaining elements 
        while (l < index) 
            new_arr[k++] = arr[l++]; 
        while (j > index) 
            new_arr[k++] = arr[j--]; 
        
        new_arr[n-1] = maximum; 
        
        // Modify original array 
        for (int p = 0; p < n ; p++) 
            arr[p] = new_arr[p]; 
    } 
       
    // main function 
    public static void Main ()  
    { 
        int[] arr = {-21 ,-15, 12, 13, 14 }; 
        int n = arr.Length; 
        int A = -6, B =-7, C = 2; 
        
        sortArray(arr, n, A, B, C); 
        
        Console.Write("Array after sorting is : "+"\n"); 
        for (int i=0; i<n; i++) 
           Console.Write(arr[i]+" "); 
    } 
} 

Javascript

<script>
     
    function sortArray(arr,n,A,B,C)
    {
        // Apply equation on all elements
        for (let i = 0; i < n; i++)
            arr[i] = A*arr[i]*arr[i] + B*arr[i] + C;
        
        // Find maximum element in resultant array
        let index=-1;
        let maximum = -999999;
        for (let i = 0; i< n; i++)
        {
            if (maximum < arr[i])
            {
                index = i;
                maximum = arr[i];
            }
        }
        
        // Use maximum element as a break point
        // and merge both subarrays using simple
        // merge function of merge sort
        let i = 0, j = n-1;
        let new_arr = new Array(n);
        for(let i=0;i<n;i++)
        {
            new_arr[i]=0;
        }
        let k = 0;
        while (i < index && j > index)
        {
            if (arr[i] < arr[j])
                new_arr[k++] = arr[i++];
            else
                new_arr[k++] = arr[j--];
        }
        
        // Merge remaining elements
        while (i < index)
            new_arr[k++] = arr[i++];
        while (j > index)
            new_arr[k++] = arr[j--];
        
        new_arr[n-1] = maximum;
        
        // Modify original array
        for (let p = 0; p < n ; p++)
            arr[p] = new_arr[p];
    }
     
    let arr=[-21 ,-15, 12, 13, 14];
    let n = arr.length;
    let A = -6, B =-7, C = 2;
    sortArray(arr, n, A, B, C);
        
    document.write("Array after sorting is : <br>");
    for (let i=0; i<n; i++)
        document.write(arr[i]+" ");
     
     
     
    // This code is contributed by avanitrachhadiya2155
</script>

PHP

<?php
// PHP program to sort an array after 
// applying equation A*x*x + B*x + C
 
// Function to sort an array after 
// applying given   equation.
function sortArray(&$arr, $n, $A, $B, $C)
{
     
    // Apply equation on all elements
    for ($i = 0; $i < $n; $i++)
        $arr[$i] = $A * $arr[$i] * $arr[$i] +
                   $B * $arr[$i] + $C;
 
    // Find maximum element in 
    // resultant array
    $index = 0; 
    $maximum = PHP_INT_MIN;
    for ($i = 0; $i < $n; $i++)
    {
        if ($maximum < $arr[$i])
        {
            $index = $i;
            $maximum = $arr[$i];
        }
    }
 
    // Use maximum element as a break point
    // and merge both subarrays using simple
    // merge function of merge sort
    $i = 0;
    $j = $n - 1;
    $new_arr = array();
    while ($i < $index && $j > $index)
    {
        if ($arr[$i] < $arr[$j])
            array_push($new_arr, $arr[$i++]);
        else
            array_push($new_arr, $arr[$j--]);
    }
 
    // Merge remaining elements
    while ($i < $index)
        array_push($new_arr, $arr[$i++]);
    while ($j > $index)
        array_push($new_arr, $arr[$j--]);
 
    array_push($new_arr, $maximum);
 
    // Modify original array
    for ($i = 0; $i < count($new_arr) ; $i++)
        $arr[$i] = $new_arr[$i];
}
 
// Driver code
$arr = array(-21 ,-15, 12, 13, 14 );
$n = count($arr);
$A = -6;
$B = -7;
$C = 2;
 
sortArray($arr, $n, $A, $B, $C);
 
echo "Array after sorting is : \n";
for ($i = 0; $i < $n; $i++)
    echo $arr[$i] . " ";
 
// This code is contributed by mits
?>

Python3

# Python3 program to sort an 
# array after applying equation 
# A*x*x + B*x + C 
import sys
 
# Function to sort an array 
# after applying given equation. 
def sortArray(arr, n, A, B, C):
 
    # Apply equation on all elements 
    for i in range(n):
        arr[i] = (A * arr[i] * arr[i] +
                  B * arr[i] + C)
    index = -(sys.maxsize - 1)
    maximum = -(sys.maxsize - 1)
     
    # Find maximum element in
    # resultant array
    for i in range(n):
        if maximum < arr[i]:
            index = i
            maximum = arr[i]
     
    # Use maximum element as a break point 
    # and merge both subarrays using simple 
    # merge function of merge sort 
    i = 0; j = n - 1;
    new_arr = [0] * n
    k = 0
    while i < index and j > index:
        if arr[i] < arr[j]:
            new_arr[k] = arr[i]
            k += 1
            i += 1
        else:
            new_arr[k] = arr[j]
            k += 1
            j -= 1
 
    # Merge remaining elements 
    while i < index:
        new_arr[k] = arr[i]
        k += 1
        i += 1
 
    # Modify original array 
    while j > index:
        new_arr[k] = arr[j]
        k += 1
        j -= 1
        new_arr[n - 1] = maximum 
 
    for i in range(n):
        arr[i] = new_arr[i]
 
# Driver code
arr = [-21, -15, 12, 13, 14]
n = len(arr)
A = -6
B= -7
C = 2
sortArray(arr, n, A, B, C)
print("Array after sorting is:")
for i in range(n):
    print(arr[i], end = " ")
 
# This code is contributed 
# by Shrikant13

Output

Array after sorting is : n-2497 -1272 -1243 -1103 -946

Time Complexity: O(n)
Auxiliary Space: O(n)

Suggest improvement

Find whether it is possible to make array elements same using one external number

Print array of strings in sorted order without copying one string into another

Share your thoughts in the comments

Most Common Sorting Algorithms

Other Sorting Algorithms

Comparison with other Sorting Algorithm

Easy problems on Sorting algorihtms

Medium problems on Sorting algorithms

Hard problem on Sorting algorithms

Most Common Sorting Algorithms

Other Sorting Algorithms

Comparison with other Sorting Algorithm

Easy problems on Sorting algorihtms

Medium problems on Sorting algorithms

Hard problem on Sorting algorithms

Sort an array after applying the given equation

C++

Java

C#

Javascript

Python3

C++

Java

C#

Javascript

PHP

Python3

Please Login to comment...

Similar Reads

What kind of Experience do you want to share?