Find sorted Array after raising every Array elements to power of K
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++
#include <bits/stdc++.h>
using namespace std;
vector< int > sortedpower(vector< int >& nums, int K)
{
for ( int i = 0; i < nums.size(); i++) {
nums[i] = pow (nums[i], K);
}
sort(nums.begin(), nums.end());
return nums;
}
int main()
{
vector< int > arr = { -4, -1, 0, 3, 10 };
int K = 4;
arr = sortedpower(arr, K);
for ( int i = 0; i < arr.size(); i++) {
cout << arr[i] << " " ;
}
cout << endl;
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
public static int [] sortedpower( int nums[], int K)
{
for ( int i = 0 ; i < nums.length; i++) {
nums[i] = ( int )Math.pow(nums[i], K);
}
Arrays.sort(nums);
return nums;
}
public static void main(String[] args)
{
int arr[] = { - 4 , - 1 , 0 , 3 , 10 };
int K = 4 ;
arr = sortedpower(arr, K);
for ( int i = 0 ; i < arr.length; i++) {
System.out.print(arr[i] + " " );
}
System.out.println();
}
}
|
Python3
def sortedpower(nums, K) :
for i in range ( len (nums)) :
nums[i] = pow (nums[i], K);
nums.sort();
return nums;
if __name__ = = "__main__" :
arr = [ - 4 , - 1 , 0 , 3 , 10 ];
K = 4 ;
arr = sortedpower(arr, K);
for i in range ( len (arr)) :
print (arr[i],end = " " );
print ()
|
C#
using System;
public class GFG {
public static int [] sortedpower( int [] nums, int K)
{
for ( int i = 0; i < nums.Length; i++) {
nums[i] = ( int )Math.Pow(nums[i], K);
}
Array.Sort(nums);
return nums;
}
static public void Main()
{
int [] arr = { -4, -1, 0, 3, 10 };
int K = 4;
arr = sortedpower(arr, K);
for ( int i = 0; i < arr.Length; i++) {
Console.Write(arr[i] + " " );
}
Console.WriteLine();
}
}
|
Javascript
<script>
function compare(a, b)
{
return a - b;
}
function sortedpower(nums, K)
{
for (let i = 0; i < nums.length; i++)
{
nums[i] = Math.pow(nums[i], K);
}
nums.sort();
return nums;
}
var arr = [ -4, -1, 0, 3, 10 ];
let K = 4;
arr = sortedpower(arr, K);
for (let i = 0; i < arr.length; i++) {
document.write(arr[i]+ " " );
}
document.write( "<br>" );
</script>
|
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++
#include <bits/stdc++.h>
using namespace std;
vector< int > sortedpower(vector< int >& nums, int K)
{
vector< int > v;
if (K % 2 == 0) {
int idx = -1;
for ( int i = 0; i < nums.size(); i++) {
if (nums[i] >= 0) {
idx = i;
break ;
}
}
if (idx == -1) {
for ( int i = nums.size() - 1; i >= 0; i--) {
v.push_back(nums[i]);
}
}
else {
int i = idx - 1;
int j = idx;
while ((i >= 0) || (j < nums.size())) {
if (i == -1) {
v.push_back(nums[j]);
j++;
}
else if (j == nums.size()) {
v.push_back(nums[i]);
i--;
}
else if (( abs (nums[i]) > nums[j])) {
v.push_back(nums[j]);
j++;
}
else {
v.push_back(nums[i]);
i--;
}
}
}
}
else {
v = nums;
}
for ( int i = 0; i < v.size(); i++) {
v[i] = pow (v[i], K);
}
return v;
}
int main()
{
vector< int > arr = { -4, -1, 0, 3, 10 };
int K = 4;
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)
{
ArrayList<Integer> v = new ArrayList<>();
if (K % 2 == 0 ) {
int idx = - 1 ;
for ( int i = 0 ; i < nums.size(); i++) {
if (nums.get(i) >= 0 ) {
idx = i;
break ;
}
}
if (idx == - 1 ) {
for ( int i = nums.size() - 1 ; i >= 0 ; i--) {
v.add(nums.get(i));
}
}
else {
int i = idx - 1 ;
int j = idx;
while ((i >= 0 ) || (j < nums.size())) {
if (i == - 1 ) {
v.add(nums.get(j));
j++;
}
else if (j == nums.size()) {
v.add(nums.get(i));
i--;
}
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;
}
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)
{
ArrayList<Integer> arr = new ArrayList<Integer>( Arrays. asList( - 4 , - 1 , 0 , 3 , 10 ) );
int K = 4 ;
arr = sortedpower(arr, K);
for ( int i = 0 ; i < arr.size(); i++) {
System.out.print(arr.get(i) + " " );
}
}
}
|
Python3
def sortedpower(nums, K):
v = []
if (K % 2 is 0 ):
idx = - 1
for i in range ( len (nums)):
if (nums[i] > = 0 ):
idx = i
break
if (idx is - 1 ):
for i in range ( len (nums) - 1 , - 1 , - 1 ):
v.append(nums[i])
else :
i = idx - 1
j = idx
while (i > = 0 or j < len (nums)):
if (i is - 1 ):
v.append(nums[j])
j + = 1
elif (j is len (nums)):
v.append(nums[i])
i - = 1
elif ( abs (nums[i]) > nums[j]):
v.append(nums[j])
j + = 1
else :
v.append(nums[i])
i - = 1
else :
v = nums
for i in range ( len (v)):
v[i] = pow (v[i], K)
return v
arr = [ - 4 , - 1 , 0 , 3 , 10 ]
K = 4
arr = sortedpower(arr, K)
for i in range ( len (arr)):
print (arr[i], end = " " )
|
C#
using System;
using System.Collections.Generic;
public class GFG {
static int [] sortedpower( int [] nums, int K)
{
int [] v = new int [(nums.Length)];
int k = 0;
if (k % 2 == 0) {
int idx = -1;
for ( int i = 0; i < nums.Length; i++) {
if (nums[i] >= 0) {
idx = i;
break ;
}
}
if (idx == -1) {
for ( int i = nums.Length - 1; i >= 0; i--) {
v[k++] = nums[i];
}
}
else {
int i = idx - 1;
int j = idx;
while ((i >= 0) || (j < nums.Length)) {
if (i == -1) {
v[k++] = nums[j];
j++;
}
else if (j == nums.Length) {
v[k++] = nums[i];
i--;
}
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];
}
}
for ( int i = 0; i < v.Length; i++) {
v[i] = ( int )Math.Pow(v[i], K);
}
return v;
}
public static void Main( string [] args)
{
int [] arr = { -4, -1, 0, 3, 10 };
int K = 4;
arr = sortedpower(arr, K);
for ( int i = 0; i < arr.Length; i++) {
Console.Write(arr[i] + " " );
}
}
}
|
Javascript
function sortedpower( nums, K)
{
const v=[];
if (K % 2 == 0) {
let idx = -1;
for (let i = 0; i < nums.length; i++) {
if (nums[i] >= 0) {
idx = i;
break ;
}
}
if (idx == -1) {
for (let i = nums.length - 1; i >= 0; i--) {
v.push(nums[i]);
}
}
else {
let i = idx - 1;
let j = idx;
while ((i >= 0) || (j < nums.length)) {
if (i == -1) {
v.push(nums[j]);
j++;
}
else if (j == nums.length) {
v.push(nums[i]);
i--;
}
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]);
}
}
for (let i = 0; i < v.length; i++) {
v[i] = Math.pow(v[i], K);
}
return v;
}
let arr = [ -4, -1, 0, 3, 10];
let K = 4;
arr = sortedpower(arr, K);
var str = arr.join( ' ' );
document.write(str);
|
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++
#include <bits/stdc++.h>
using namespace std;
vector< int > sortedpower(vector< int >& nums, int K)
{
vector< int > v(nums.size());
int k = 0;
int j = nums.size() - 1;
for ( int i = nums.size() - 1; i >= 0; i--) {
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;
}
int main()
{
vector< int > arr = { -4, -1, 0, 3, 10 };
int K = 4;
arr = sortedpower(arr, K);
for ( int i = 0; i < arr.size(); i++) {
cout << arr[i] << " " ;
}
return 0;
}
|
Java
import java.util.*;
class GFG {
static int [] sortedpower( int [] nums, int K)
{
int [] v = new int [(nums.length)];
int k = 0 ;
int j = nums.length - 1 ;
for ( int i = nums.length - 1 ; i >= 0 ; i--) {
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;
}
public static void main (String[] args) {
int [] arr = { - 4 , - 1 , 0 , 3 , 10 };
int K = 4 ;
arr = sortedpower(arr, K);
for ( int i = 0 ; i < arr.length; i++) {
System.out.print( arr[i] + " " );
}
}
}
|
Python3
def sortedpower(nums, K) :
v = [ 0 ] * len (nums);
k = 0 ;
j = len (nums) - 1 ;
for i in range ( len (nums) - 1 , - 1 , - 1 ) :
a = nums[k] * * K
b = nums[j] * * K;
if (a > = b) :
v[i] = a;
k + = 1 ;
else :
v[i] = b;
j - = 1 ;
return v;
if __name__ = = "__main__" :
arr = [ - 4 , - 1 , 0 , 3 , 10 ];
K = 4 ;
arr = sortedpower(arr, K);
for i in range ( len (arr)) :
print (arr[i], end = " " );
|
C#
using System;
using System.Collections.Generic;
public class GFG {
static int [] sortedpower( int [] nums, int K)
{
int [] v = new int [(nums.Length)];
int k = 0;
int j = nums.Length - 1;
for ( int i = nums.Length - 1; i >= 0; i--) {
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;
}
public static void Main( string [] args)
{
int [] arr = { -4, -1, 0, 3, 10 };
int K = 4;
arr = sortedpower(arr, K);
for ( int i = 0; i < arr.Length; i++) {
Console.Write( arr[i] + " " );
}
}
}
|
Javascript
<script>
function sortedpower(nums, K)
{
let v = new Array(nums.length);
let k = 0;
let j = nums.length - 1;
for (let i = nums.length - 1; i >= 0; i--) {
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;
}
let arr = [ -4, -1, 0, 3, 10 ];
let K = 4;
arr = sortedpower(arr, K);
for (let i = 0; i < arr.length; i++) {
document.write(arr[i]+ " " );
}
document.write( "<br>" );
</script>
|
Time Complexity: O(N)
Space Complexity: O(N)
Last Updated :
07 Nov, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...