Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Modify array by sorting nearest perfect squares of array elements having their digits sorted in decreasing order

  • Last Updated : 25 May, 2021

Given an array arr[] of size N (1 ≤ N ≤ 105), the task is to sort digits of each array element in descending order and replace each array element with the nearest perfect square and then print the array in ascending order.

Examples:

Input: arr[ ] = {29, 43, 28, 12}
Output: 25 49 81 100
Explanation:
Sorting digits of each array element in descending order modifies arr[] to {92, 43, 82, 21}.
Replacing elements with the nearest perfect square modifies arr[] to {100, 49, 81, 25}.
Sorting the array in ascending order modifies arr[] to {25, 49, 81, 100}.

Input: arr[ ] = {517, 142, 905}
Output: 441 729 961

Approach: Follow the steps below to solve the problem:

Below is the implementation of the above approach.

C++




// C++ program of the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to sort array in ascending order
// after replacing array elements by nearest
// perfect square of decreasing order of digits
void sortArr(int arr[], int N)
{
 
    // Traverse the array of strings
    for (int i = 0; i < N; i++) {
 
        // Convert the current array
        // element to a string
        string s = to_string(arr[i]);
 
        // Sort each string in descending order
        sort(s.begin(), s.end(), greater<char>());
 
        // Convert the string to
        // equivalent integer
        arr[i] = stoi(s);
 
        // Calculate square root of
        // current array element
        int sr = sqrt(arr[i]);
 
        // Calculate perfect square
        int a = sr * sr;
        int b = (sr + 1) * (sr + 1);
 
        // Find the nearest perfect square
        if ((arr[i] - a) < (b - arr[i]))
            arr[i] = a;
        else
            arr[i] = b;
    }
 
    // Sort the array in ascending order
    sort(arr, arr + N);
 
    // Print the array
    for (int i = 0; i < N; i++) {
        cout << arr[i] << " ";
    }
}
 
// Driver Code
int main()
{
    int arr[] = { 29, 43, 28, 12 };
    int N = sizeof(arr) / sizeof(arr[0]);
    sortArr(arr, N);
 
    return 0;
}
Java



// Java program for the above approach
import java.util.*;
 
class GFG{
  static void reverse(char[] a) 
  {
    int i, n = a.length;
    char t;
    for (i = 0; i < n / 2; i++) 
    {
      t = a[i];
      a[i] = a[n - i - 1];
      a[n - i - 1] = t;
    }
  }
 
  // Function to sort array in ascending order
  // after replacing array elements by nearest
  // perfect square of decreasing order of digits
  static void sortArr(int arr[], int N)
  {
 
    // Traverse the array of strings
    for (int i = 0; i < N; i++) {
 
      // Convert the current array
      // element to a string
      String s = Integer.toString(arr[i]);
      char[] str = s.toCharArray();
 
      // Sort each string in descending order
      Arrays.sort(str);
      reverse(str);
 
      String string = new String(str);
 
 
      // Convert the string to
      // equivalent integer
      arr[i] = Integer.parseInt(string);
 
      // Calculate square root of
      // current array element
      int sr = (int)Math.sqrt(arr[i]);
 
      // Calculate perfect square
      int a = sr * sr;
      int b = (sr + 1) * (sr + 1);
 
      // Find the nearest perfect square
      if ((arr[i] - a) < (b - arr[i]))
        arr[i] = a;
      else
        arr[i] = b;
    }
 
    // Sort the array in ascending order
    Arrays.sort(arr);
 
    // Print the array
    for (int i = 0; i < N; i++) {
      System.out.print(arr[i] + " ");
    }
  }
 
 
  // Driver Code
  public static void main(String[] args)
  {
    int arr[] = { 29, 43, 28, 12 };
    int N = arr.length;
    sortArr(arr, N);
  }
}
 
// This code is contributed by sanjoy_62.
Python3



# Python 3 program of the above approach
import math
 
# Function to sort array in ascending order
# after replacing array elements by nearest
# perfect square of decreasing order of digits
def sortArr(arr, N):
 
    # Traverse the array of strings
    for i in range(N):
 
        # Convert the current array
        # element to a string
        s = str(arr[i])
 
        # Sort each string in descending order
        list1 = list(s)
        list1.sort(reverse = True)
        s = ''.join(list1)
 
        # Convert the string to
        # equivalent integer
        arr[i] = int(s)
 
        # Calculate square root of
        # current array element
        sr = int(math.sqrt(arr[i]))
 
        # Calculate perfect square
        a = sr * sr
        b = (sr + 1) * (sr + 1)
 
        # Find the nearest perfect square
        if ((arr[i] - a) < (b - arr[i])):
            arr[i] = a
        else:
            arr[i] = b
 
    # Sort the array in ascending order
    arr.sort()
 
    # Print the array
    for i in range(N):
        print(arr[i], end=" ")
 
# Driver Code
if __name__ == "__main__":
 
    arr = [29, 43, 28, 12]
    N = len(arr)
    sortArr(arr, N)
 
    # This code is contributed by ukasp.
C#



// C# program of the above approach
 
using System;
using System.Collections.Generic;
 
class GFG{
 
  // Function to sort array in ascending order
  // after replacing array elements by nearest
  // perfect square of decreasing order of digits
  static void sortArr(int []arr, int N)
  {
 
    // Traverse the array of strings
    for (int i = 0; i < N; i++) {
 
      // Convert the current array
      // element to a string
      int num = arr[i];
      string s = num.ToString();
 
      // Sort each string in descending order
      char []temp = s.ToCharArray();
      Array.Sort(temp);
      int st = 0;
      int ed = temp.Length-1;
      while(st<ed){
        char ch = temp[st];
        temp[st] = temp[ed];
        temp[ed] = ch;
        st++;
        ed--;
      }
      string charsStr = new string(temp);
      // sort(s.begin(), s.end(), greater<char>());
 
      // Convert the string to
      // equivalent integer
      arr[i] = Int32.Parse(charsStr);
 
      // Calculate square root of
      // current array element
      int sr = (int)Math.Sqrt(arr[i]);
 
      // Calculate perfect square
      int a = sr * sr;
      int b = (sr + 1) * (sr + 1);
 
      // Find the nearest perfect square
      if ((arr[i] - a) < (b - arr[i]))
        arr[i] = a;
      else
        arr[i] = b;
    }
 
    // Sort the array in ascending order
    Array.Sort(arr);
 
    // Print the array
    for (int i = 0; i < N; i++) {
      Console.Write(arr[i]+" ");
    }
  }
 
  // Driver Code
  public static void Main()
  {
    int []arr = { 29, 43, 28, 12 };
    int N = arr.Length;
    sortArr(arr, N);
 
  }
}
 
// This code is contributed by ipg2016107.
Javascript



<script>
 
      // JavaScript program of the above approach
      // Function to sort array in ascending order
      // after replacing array elements by nearest
      // perfect square of decreasing order of digits
       
      function sortArr(arr, N) {
        // Traverse the array of strings
        for (var i = 0; i < N; i++) {
          // Convert the current array
          // element to a string
          var num = arr[i];
          var s = num.toString();
 
          // Sort each string in descending order
          var temp = s.split("");
          temp.sort((a, b) => b - a);
          s = temp.join("");
 
          // Convert the string to
          // equivalent integer
          arr[i] = parseInt(s);
 
          // Calculate square root of
          // current array element
          var sr = parseInt(Math.sqrt(arr[i]));
 
          // Calculate perfect square
          var a = sr * sr;
          var b = (sr + 1) * (sr + 1);
 
          // Find the nearest perfect square
          if (arr[i] - a < b - arr[i]) arr[i] = a;
          else arr[i] = b;
        }
 
        // Sort the array in ascending order
        arr.sort((a, b) => a - b);
 
        // Print the array
        for (var i = 0; i < N; i++) {
          document.write(arr[i] + " ");
        }
      }
 
      // Driver Code
      var arr = [29, 43, 28, 12];
      var N = arr.length;
      sortArr(arr, N);
       
</script>
 
 
Output: 
25 49 81 100
 
 
Time Complexity: O(NlogN)
Auxiliary Space: O(1) 
 

My Personal Notes
arrow_drop_up
Previous
MTX Interview Experience for Trainee Consultant | On-Campus 2021
Next

Find the nearest odd and even perfect squares of odd and even array elements respectively
Recommended Articles
Page :
Modify Binary Tree by replacing all nodes at even and odd levels by their nearest even or odd perfect squares respectively
22, Feb 21
Nearest power of 2 of nearest perfect squares of non-repeating array elements
02, Mar 21
Find the nearest odd and even perfect squares of odd and even array elements respectively
05, Mar 21
Replace the odd positioned elements with their cubes and even positioned elements with their squares
26, Mar 19
Check if a number is a perfect square having all its digits as a perfect square
15, Sep 20
Sort an array of strings having characters at odd and even indices sorted in decreasing and increasing order respectively
12, May 21
Modify array by replacing elements with the nearest power of its previous or next element
25, Mar 21
Modify array by replacing each element with nearest power of GCD of all previous elements
16, Feb 21
Sort perfect squares in an array at their relative positions
26, Nov 18
Sorting element of an array by frequency in decreasing order
20, Feb 20
Count of pairs in given range having their ratio equal to ratio of product of their digits
08, Sep 21
Modify a given array by replacing each element with the sum or product of their digits based on a given condition
28, Jun 21
Modify string by rearranging vowels in alphabetical order at their respective indices
19, Feb 21
Modify Binary Tree by replacing each node with nearest power of minimum of previous level
06, Apr 21
Modify Linked List by replacing each node by nearest multiple of K
09, Apr 21
Print all Perfect Numbers from an array whose sum of digits is also a Perfect Number
19, Feb 21
Modify array by removing M smallest elements maintaining the order of remaining elements
29, Jun 21
Modify given array to a non-decreasing array by rotation
22, Feb 21
Find the nearest perfect square for each element of the array
16, Jun 21
Check if a Binary String can be sorted in decreasing order by removing non-adjacent characters
09, Apr 21
Modify an array by sorting after reversal of bits of each array element
01, Apr 21
Largest sub-array whose all elements are perfect squares
22, Nov 18
Count elements in an Array that can be represented as difference of two perfect squares
09, Jun 20
Numbers of Length N having digits A and B and whose sum of digits contain only digits A and B
31, Jan 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
subham348
@subham348
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!