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

• Last Updated : 07 Nov, 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 <bits/stdc++.h>
using namespace std;

// Function to find the array
// after performing the operation
vector<int> sortedpower(vector<int>& nums, int K)
{
// Loop is used for performing 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 performing 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 performing 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 performing 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

```<script>
// Function to find the array
// after performing the operation
function compare(a, b)
{
return a - b;
}

function sortedpower(nums, K)
{

// Loop is used for performing power of K
for (let i = 0; i < nums.length; i++)
{
nums[i] = Math.pow(nums[i], K);
}

// One can use different sorting algorithms
nums.sort();

// Returning the vector which is the required answer
return nums;
}

// Driver Code

// Defining the vector v
var arr = [ -4, -1, 0, 3, 10 ];

// Function Call
let K = 4;
arr = sortedpower(arr, K);
for (let i = 0; i < arr.length; i++) {
document.write(arr[i]+ " ");
}
document.write( "<br>");

// This code is contributed by satwik4409.
</script>```
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 <bits/stdc++.h>
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 greater 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--;
}

// comparing 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);
}
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<Integer> sortedpower(ArrayList<Integer> nums,int K)
{
// Declaring new vector to store ans
ArrayList<Integer> v = new ArrayList<>();
if (K % 2 == 0) {
int idx = -1;

// Loop to find element which is just greater 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--) {
}
}

// 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) {
j++;
}

// If there no positive number left in the
// array
else if (j == nums.size()) {
i--;
}

// comparing 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))) {
j++;
}
else {
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));
}
return v;
}

public static void main(String[] args)
{
// Defining the vector v
ArrayList<Integer> arr = new ArrayList<Integer>( 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```

## Python3

```# Python code for the above approach

# Function to find the new array
def sortedpower(nums, K):
# Declaring new array to store ans
v = []
if(K % 2 is 0):
idx = -1

# loop to find element which is just greater than equal to 0
for i in range(len(nums)):
if(nums[i] >= 0):
idx = i
break

# If there is no element which is greater than or equal to 0
if(idx is -1):
for i in range(len(nums)-1, -1, -1):
v.append(nums[i])

# If we find that element
else:
# Making 2 pointers
i = idx - 1
j = idx
while(i >= 0 or j < len(nums)):
# If there no negative number left in the array
if(i is -1):
v.append(nums[j])
j += 1

# If there no positive number left in the array
elif(j is len(nums)):
v.append(nums[i])
i -= 1

# Comparing absolute values of negative and positive
# number and arranging them increasing order of absolute
# values
elif(abs(nums[i]) > nums[j]):
v.append(nums[j])
j += 1

else:
v.append(nums[i])
i -= 1

else:
v = nums

# performing power of 4 operation on all the array elements
for i in range(len(v)):
v[i] = pow(v[i], K)

return 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 lokeshmvs21.
```

## 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)];
int k = 0;
if (k % 2 == 0) {
int idx = -1;

// Loop to find element which is just greater
// than or equal to 0
for (int i = 0; i < nums.Length; 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.Length - 1; i >= 0; i--) {
v[k++] = nums[i];
}
}
// If we find that element
else {

// Making 2 pointers
int i = idx - 1;
int j = idx;
while ((i >= 0) || (j < nums.Length)) {

// If there no negative number left in
// the array
if (i == -1) {
v[k++] = nums[j];
j++;
}

// If there no positive number left in
// the array
else if (j == nums.Length) {
v[k++] = nums[i];
i--;
}

// comparing absolute values of negative
// and positive number and arranging
// them in increasing order of absolute
// values
else if ((Math.Abs(nums[i])
> nums[j])) {
v[k++] = nums[j];
j++;
}
else {
v[k++] = nums[i];
i--;
}
}
}
}
else {
for (int i = 0; i < nums.Length; i++) {
v[k++] = nums[i];
}
}

// Performing power of 4 operation on all the array
// elements
for (int i = 0; i < v.Length; i++) {
v[i] = (int)Math.Pow(v[i], K);
}
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 garg28harsh.```

## Javascript

```// Javascript Code for above approach

// Function to find the new array
function sortedpower( nums, K)
{

// Declaring new vector to store ans
const v=[];
if (K % 2 == 0) {
let idx = -1;

// Loop to find element which is just greater than or
// equal to 0
for (let i = 0; i < nums.length; 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 (let i = nums.length - 1; i >= 0; i--) {
v.push(nums[i]);
}
}

// If we find that element
else {

// Making 2 pointers
let i = idx - 1;
let j = idx;
while ((i >= 0) || (j < nums.length)) {

// If there no negative number left in the
// array
if (i == -1) {
v.push(nums[j]);
j++;
}

// If there no positive number left in the
// array
else if (j == nums.length) {
v.push(nums[i]);
i--;
}

// comparing absolute values of negative
// and positive number and arranging them in
// increasing order of absolute values
else if ((Math.abs(nums[i]) > nums[j])) {
v.push(nums[j]);
j++;
}
else {
v.push(nums[i]);
i--;
}
}
}
}
else {
for(let i=0;i<nums.length;i++)
{
v.push(nums[i]);
}
}

// Performing power of 4 operation on all the array
// elements
for (let i = 0; i < v.length; i++) {
v[i] = Math.pow(v[i], K);
}

return v;
}

// Driver Code
// Defining the vector v
let arr = [ -4, -1, 0, 3, 10];
let K = 4;

// Function Call
arr = sortedpower(arr, K);
var str = arr.join(' ');
document.write(str);

// This code is contributed by garg28harsh.```
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 <bits/stdc++.h>
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--;
}
}

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--;
}
}

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;

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--;
}
}

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

```<script>
// Javascript Code for the above approach

// Function to find the required array
function sortedpower(nums, K)
{
// Creating vector of same size as nums to store the ans
let v = new Array(nums.length);

// Make 2 pointer k and j
let k = 0;
let j = nums.length - 1;

// Traversing the vector in reverse order
for (let i = nums.length - 1; i >= 0; i--) {

// Squaring both the elements
let a = Math.pow(nums[k], K);
let b = Math.pow(nums[j], K);
if (a >= b) {
v[i] = a;
k++;
}
else {
v[i] = b;
j--;
}
}

return v;
}

// Driver Code

// Defining the vector v
let arr = [ -4, -1, 0, 3, 10 ];

// Function Call
let K = 4;
arr = sortedpower(arr, K);
for (let i = 0; i < arr.length; i++) {
document.write(arr[i]+ " ");
}
document.write( "<br>");

// This code is contributed by satwik4409.
</script>
```
Output

`0 1 81 256 10000 `

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

My Personal Notes arrow_drop_up
Related Articles