# Find sorted Array after raising every Array elements to power of K

• Last Updated : 13 Sep, 2022

Given an integer array arr[] of size N that is sorted in increasing order and an integer K, Return an array with power of K of each number sorted in increasing order.

Examples:

Input: arr[]: {-4, -1, 0, 3, 10}, K = 4
Output:  {0, 1, 81, 256, 10000}
Explanation: After doing power of 4 operation,
the elements array will become {256, 1, 0, 81, 10000},
After sorting thearray will become {0, 1, 81, 256, 10000}.

Input: arr[]: {-7, -3, 2, 3, 11}, K = 4
Output:  {16, 81, 81, 2401, 14641}

Naive Approach: The basic idea is:

Firstly perform power of K operation on the all the elements of the array and sort the array using sort function.

Below is the implementation of the above approach:

## C++

 `// C++ Code for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find the array` `// after performing the operation` `vector<``int``> sortedpower(vector<``int``>& nums, ``int` `K)` `{` `    ``// Loop is used for perforimg power of K` `    ``for` `(``int` `i = 0; i < nums.size(); i++) {` `        ``nums[i] = ``pow``(nums[i], K);` `    ``}`   `    ``// C++ STL function to sort the array` `    ``// One can use different sorting algorithms` `    ``sort(nums.begin(), nums.end());`   `    ``// Returning the vector which is the required answer` `    ``return` `nums;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Defining the vector v` `    ``vector<``int``> arr = { -4, -1, 0, 3, 10 };`   `    ``// Function Call` `    ``int` `K = 4;` `    ``arr = sortedpower(arr, K);` `    ``for` `(``int` `i = 0; i < arr.size(); i++) {` `        ``cout << arr[i] << ``" "``;` `    ``}` `    ``cout << endl;` `    ``return` `0;` `}`

## Java

 `// Java Code for the above approach` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {` `    ``// Function to find the array` `    ``// after performing the operation` `    ``public` `static` `int``[] sortedpower(``int` `nums[], ``int` `K)` `    ``{` `        ``// Loop is used for perforimg power of K` `        ``for` `(``int` `i = ``0``; i < nums.length; i++) {` `            ``nums[i] = (``int``)Math.pow(nums[i], K);` `        ``}`   `        ``// Java library function to sort the array` `        ``// One can use different sorting algorithms` `        ``Arrays.sort(nums);`   `        ``// Returning the array which is the required answer` `        ``return` `nums;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Defining the array v` `        ``int` `arr[] = { -``4``, -``1``, ``0``, ``3``, ``10` `};`   `        ``// Function Call` `        ``int` `K = ``4``;` `        ``arr = sortedpower(arr, K);` `        ``for` `(``int` `i = ``0``; i < arr.length; i++) {` `            ``System.out.print(arr[i] + ``" "``);` `        ``}` `        ``System.out.println();` `    ``}` `}`   `// This code is contributed by Rohit Pradhan`

## Python3

 `# Python3 Code for the above approach`   `# Function to find the array` `# after performing the operation` `def` `sortedpower(nums, K) :`   `    ``# Loop is used for perforimg power of K` `    ``for` `i ``in` `range``(``len``(nums)) :` `        ``nums[i] ``=` `pow``(nums[i], K);`   `    ``# C++ STL function to sort the array` `    ``# One can use different sorting algorithms` `    ``nums.sort();`   `    ``# Returning the vector which is the required answer` `    ``return` `nums;`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"` `:`   `    ``# Defining the vector v` `    ``arr ``=` `[ ``-``4``, ``-``1``, ``0``, ``3``, ``10` `];`   `    ``# Function Call` `    ``K ``=` `4``;` `    ``arr ``=` `sortedpower(arr, K);` `    ``for` `i ``in` `range``(``len``(arr)) :` `        ``print``(arr[i],end``=``" "``);` `        `  `    ``print``()` `    `  `    ``# This code is contributed by AnkThon`

## C#

 `// C# Code for the above approach` `using` `System;`   `public` `class` `GFG {`   `  ``// Function to find the array` `  ``// after performing the operation` `  ``public` `static` `int``[] sortedpower(``int``[] nums, ``int` `K)` `  ``{` `    ``// Loop is used for perforimg power of K` `    ``for` `(``int` `i = 0; i < nums.Length; i++) {` `      ``nums[i] = (``int``)Math.Pow(nums[i], K);` `    ``}`   `    ``// Java library function to sort the array` `    ``// One can use different sorting algorithms` `    ``Array.Sort(nums);`   `    ``// Returning the array which is the required answer` `    ``return` `nums;` `  ``}`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``// Code` `    ``int``[] arr = { -4, -1, 0, 3, 10 };`   `    ``// Function Call` `    ``int` `K = 4;` `    ``arr = sortedpower(arr, K);` `    ``for` `(``int` `i = 0; i < arr.Length; i++) {` `      ``Console.Write(arr[i] + ``" "``);` `    ``}` `    ``Console.WriteLine();` `  ``}` `}`   `// This code is contributed by lokeshmvs21`

## Javascript

 ``

Output

`0 1 81 256 10000 `

Time Complexity: O(N * logN * logK)
Auxiliary Space: O(1)

Efficient Approach:

Find the element in arr[] greater than equal to 0 say at index i and use two pointers to iterate from i-1 to 0 and i to N-1 compare these elements simultaneously and store them in increasing order of magnitude(absolute value).

Follow the below steps to implement the above approach:

• Firstly find the element which is just greater than or equal to 0.
• If K is odd, we will simply perform power of K operation because the array is already sorted and the after performing Pow operation sign of integers will not change.
• If K is even,
• Then there will be 2 cases.
• Case 1: There is no element greater than or equal to 0 i.e array only has negative numbers, then store all the elements of the array in reverse order in a new array.
• Case 2: If elements that are just greater than or equal to 0 exists
• Initialize two pointers.
• First traverse array from that index upto the final element.
• Second traverse array from that index to the first element.
• While traversing check the absolute values of both the elements simultaneously and store the array in increasing order of absolute values.
• After getting the new array, perform power of K operation on all the elements of the new array, which is the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ Code for above approach`   `#include ` `using` `namespace` `std;`   `// Function to find the new array` `vector<``int``> sortedpower(vector<``int``>& nums, ``int` `K)` `{` `    ``// Declaring new vector to store ans` `    ``vector<``int``> v;` `    ``if` `(K % 2 == 0) {` `        ``int` `idx = -1;`   `        ``// Loop to find element which is just grater than or` `        ``// equal to 0` `        ``for` `(``int` `i = 0; i < nums.size(); i++) {` `            ``if` `(nums[i] >= 0) {` `                ``idx = i;` `                ``break``;` `            ``}` `        ``}`   `        ``// If there is no element` `        ``// which is greater than or equal to 0` `        ``if` `(idx == -1) {` `            ``for` `(``int` `i = nums.size() - 1; i >= 0; i--) {` `                ``v.push_back(nums[i]);` `            ``}` `        ``}`   `        ``// If we find that element` `        ``else` `{`   `            ``// Making 2 pointers` `            ``int` `i = idx - 1;` `            ``int` `j = idx;` `            ``while` `((i >= 0) || (j < nums.size())) {`   `                ``// If there no negative number left in the` `                ``// array` `                ``if` `(i == -1) {` `                    ``v.push_back(nums[j]);` `                    ``j++;` `                ``}`   `                ``// If there no positive number left in the` `                ``// array` `                ``else` `if` `(j == nums.size()) {` `                    ``v.push_back(nums[i]);` `                    ``i--;` `                ``}`   `                ``// Compairing absolute values of negative` `                ``// and positive number and arranging them in` `                ``// increasing order of absolute values` `                ``else` `if` `((``abs``(nums[i]) > nums[j])) {` `                    ``v.push_back(nums[j]);` `                    ``j++;` `                ``}` `                ``else` `{` `                    ``v.push_back(nums[i]);` `                    ``i--;` `                ``}` `            ``}` `        ``}` `    ``}` `    ``else` `{` `        ``v = nums;` `    ``}`   `    ``// Performing power of 4 operation on all the array` `    ``// elements` `    ``for` `(``int` `i = 0; i < v.size(); i++) {` `        ``v[i] = ``pow``(v[i], K);` `    ``}` `    ``// Returning the required answer` `    ``return` `v;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Defining the vector v` `    ``vector<``int``> arr = { -4, -1, 0, 3, 10 };` `    ``int` `K = 4;`   `    ``// Function Call` `    ``arr = sortedpower(arr, K);` `    ``for` `(``int` `i = 0; i < arr.size(); i++) {` `        ``cout << arr[i] << ``" "``;` `    ``}` `    ``return` `0;` `}`

## Java

 `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `  ``public` `static` `ArrayList sortedpower(ArrayList nums,``int` `K)` `  ``{` `    ``// Declaring new vector to store ans` `    ``ArrayList v = ``new` `ArrayList<>();` `    ``if` `(K % ``2` `== ``0``) {` `      ``int` `idx = -``1``;`   `      ``// Loop to find element which is just grater than or` `      ``// equal to 0` `      ``for` `(``int` `i = ``0``; i < nums.size(); i++) {` `        ``if` `(nums.get(i) >= ``0``) {` `          ``idx = i;` `          ``break``;` `        ``}` `      ``}`   `      ``// If there is no element` `      ``// which is greater than or equal to 0` `      ``if` `(idx == -``1``) {` `        ``for` `(``int` `i = nums.size() - ``1``; i >= ``0``; i--) {` `          ``v.add(nums.get(i));` `        ``}` `      ``}`   `      ``// If we find that element` `      ``else` `{`   `        ``// Making 2 pointers` `        ``int` `i = idx - ``1``;` `        ``int` `j = idx;` `        ``while` `((i >= ``0``) || (j < nums.size())) {` `          ``// If there no negative number left in the` `          ``// array` `          ``if` `(i == -``1``) {` `            ``v.add(nums.get(j));` `            ``j++;` `          ``}`   `          ``// If there no positive number left in the` `          ``// array` `          ``else` `if` `(j == nums.size()) {` `            ``v.add(nums.get(i));` `            ``i--;` `          ``}`   `          ``// Compairing absolute values of negative` `          ``// and positive number and arranging them in` `          ``// increasing order of absolute values` `          ``else` `if` `(((``int``)Math.abs(nums.get(i)) > nums.get(j))) {` `            ``v.add(nums.get(j));` `            ``j++;` `          ``}` `          ``else` `{` `            ``v.add(nums.get(i));` `            ``i--;` `          ``}` `        ``}` `      ``}` `    ``}` `    ``else` `{` `      ``v = nums;` `    ``}`   `    ``// Performing power of 4 operation on all the array` `    ``// elements` `    ``for` `(``int` `i = ``0``; i < v.size(); i++) {` `      ``v.set(i,(``int``)Math.pow(v.get(i), K));` `    ``}` `    ``// Returning the required answer` `    ``return` `v;` `  ``}`   `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``// Defining the vector v` `    ``ArrayList arr = ``new` `ArrayList( Arrays. asList( -``4``, -``1``, ``0``, ``3``, ``10` `) );` `    ``int` `K = ``4``;`   `    ``// Function Call` `    ``arr = sortedpower(arr, K);` `    ``for` `(``int` `i = ``0``; i < arr.size(); i++) {` `      ``System.out.print(arr.get(i) + ``" "``);` `    ``}` `  ``}` `}`   `// This code is contributed by adityapatil12`

Output

`0 1 81 256 10000 `

Time Complexity: O(N)
Space Complexity: O(N)

Another Efficient Approach:

Use two pointers left and right pointing towards First and Last index of array then move the pointers towards each other i.e. left towards right and right towards left simultaneously compare the Nth power of the pointed index values and store in increasing order.

Follow the below steps to Implement the Idea:

• Make 2 pointers left and right pointing towards the first and the last elements of array respectively.
• Then calculate the power of K of both the values and compare with each other.
• If the left one is bigger, push it at the last of the answer vector and increment the left pointer.
• If the right one is bigger, push it at the last of ans vector and decrement the right pointer.

Below is the implementation of the above approach:

## C++

 `// C++ Code for above approach`   `#include ` `using` `namespace` `std;`   `// Function to find the required array` `vector<``int``> sortedpower(vector<``int``>& nums, ``int` `K)` `{`   `    ``// Creating vector of same size as nums to store the ans` `    ``vector<``int``> v(nums.size());`   `    ``// Make 2 pointer k and j` `    ``int` `k = 0;` `    ``int` `j = nums.size() - 1;`   `    ``// Traversing the vector in reverse order` `    ``for` `(``int` `i = nums.size() - 1; i >= 0; i--) {`   `        ``// Squaring both the elements` `        ``int` `a = ``pow``(nums[k], K);` `        ``int` `b = ``pow``(nums[j], K);` `        ``if` `(a >= b) {` `            ``v[i] = a;` `            ``k++;` `        ``}` `        ``else` `{` `            ``v[i] = b;` `            ``j--;` `        ``}` `    ``}`   `    ``// Returning the required answer` `    ``return` `v;` `}`   `// Driver Code` `int` `main()` `{`   `    ``// Defining the vector v` `    ``vector<``int``> arr = { -4, -1, 0, 3, 10 };`   `    ``int` `K = 4;` `    ``// Function Call` `    ``arr = sortedpower(arr, K);` `    ``for` `(``int` `i = 0; i < arr.size(); i++) {` `        ``cout << arr[i] << ``" "``;` `    ``}` `    ``return` `0;` `}`

## Java

 `// Java code to implement the above approach` `import` `java.util.*;` `class` `GFG {`   `  ``// Function to find the required array` `  ``static` `int``[] sortedpower(``int``[] nums, ``int` `K)` `  ``{`   `    ``// Creating vector of same size as nums to store the ans` `    ``int``[] v = ``new` `int``[(nums.length)];`   `    ``// Make 2 pointer k and j` `    ``int` `k = ``0``;` `    ``int` `j = nums.length - ``1``;`   `    ``// Traversing the vector in reverse order` `    ``for` `(``int` `i = nums.length - ``1``; i >= ``0``; i--) {`   `      ``// Squaring both the elements` `      ``int` `a = (``int``)Math.pow(nums[k], K);` `      ``int` `b = (``int``)Math.pow(nums[j], K);` `      ``if` `(a >= b) {` `        ``v[i] = a;` `        ``k++;` `      ``}` `      ``else` `{` `        ``v[i] = b;` `        ``j--;` `      ``}` `    ``}`   `    ``// Returning the required answer` `    ``return` `v;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main (String[] args) {`   `    ``// Defining the vector v` `    ``int``[] arr = { -``4``, -``1``, ``0``, ``3``, ``10` `};` `    ``int` `K = ``4``;` `    `  `    ``// Function Call` `    ``arr = sortedpower(arr, K);` `    ``for` `(``int` `i = ``0``; i < arr.length; i++) {` `      ``System.out.print( arr[i] + ``" "``);` `    ``}` `  ``}` `}`   `// This code is contributed by sanjoy_62.`

## Python3

 `# Python3 Code for above approach`   `# Function to find the required array` `def` `sortedpower(nums, K) :`   `    ``# Creating vector of same size as nums to store the ans` `    ``v ``=` `[``0``] ``*` `len``(nums);`   `    ``# Make 2 pointer k and j` `    ``k ``=` `0``;` `    ``j ``=` `len``(nums) ``-` `1``;`   `    ``# Traversing the vector in reverse order` `    ``for` `i ``in` `range``(``len``(nums) ``-` `1``, ``-``1``, ``-``1``) :`   `        ``# Squaring both the elements` `        ``a ``=` `nums[k] ``*``*` `K` `        ``b ``=` `nums[j] ``*``*` `K;` `        ``if` `(a >``=` `b) :` `            ``v[i] ``=` `a;` `            ``k ``+``=` `1``;`   `        ``else` `:` `            ``v[i] ``=` `b;` `            ``j ``-``=` `1``;`   `    ``# Returning the required answer` `    ``return` `v;`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"` `:`   `    ``# Defining the vector v` `    ``arr ``=` `[ ``-``4``, ``-``1``, ``0``, ``3``, ``10` `];`   `    ``K ``=` `4``;` `    `  `    ``# Function Call` `    ``arr ``=` `sortedpower(arr, K);` `    ``for` `i ``in` `range``(``len``(arr)) :` `        ``print``(arr[i], end``=``" "``);` `   `  `   ``# This code is contributed by AnkThon`

## C#

 `// C# code to implement the approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG {`   `  ``// Function to find the required array` `  ``static` `int``[] sortedpower(``int``[] nums, ``int` `K)` `  ``{`   `    ``// Creating vector of same size as nums to store the ans` `    ``int``[] v = ``new` `int``[(nums.Length)];`   `    ``// Make 2 pointer k and j` `    ``int` `k = 0;` `    ``int` `j = nums.Length - 1;`   `    ``// Traversing the vector in reverse order` `    ``for` `(``int` `i = nums.Length - 1; i >= 0; i--) {`   `      ``// Squaring both the elements` `      ``int` `a = (``int``)Math.Pow(nums[k], K);` `      ``int` `b = (``int``)Math.Pow(nums[j], K);` `      ``if` `(a >= b) {` `        ``v[i] = a;` `        ``k++;` `      ``}` `      ``else` `{` `        ``v[i] = b;` `        ``j--;` `      ``}` `    ``}`   `    ``// Returning the required answer` `    ``return` `v;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{   `   `    ``// Defining the vector v` `    ``int``[] arr = { -4, -1, 0, 3, 10 };` `    ``int` `K = 4;`   `    ``// Function Call` `    ``arr = sortedpower(arr, K);` `    ``for` `(``int` `i = 0; i < arr.Length; i++) {` `      ``Console.Write( arr[i] + ``" "``);` `    ``}` `  ``}` `}`   `// This code is contributed by code_hunt.`

## Javascript

 ``

Output

`0 1 81 256 10000 `

Time Complexity: O(N)
Space Complexity: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :