Sort the given Array as per given conditions

• Difficulty Level : Basic
• Last Updated : 28 Oct, 2022

Given an array arr[] consisting of N positive integers, the task is to sort the array such that –

• All even numbers must come before all odd numbers.
• All even numbers that are divisible by 5 must come first than even numbers not divisible by 5.
• If two even numbers are divisible by 5 then the number having a greater value will come first
• If two even numbers were not divisible by 5 then the number having a greater index in the array will come first.
• All odd numbers must come in relative order as they are present in the array.

Examples:

Input: arr[] = {5, 10, 30, 7}
Output: 30 10 5 7
Explanation: Even numbers = [10, 30]. Odd numbers = [5, 7]. After sorting of even numbers, even numbers = [30, 10] as both 10 and 30 divisible by 5 but 30 has a larger value so it will come before 10.
After sorting A = [30, 10, 5, 7] as all even numbers must come before all odd numbers.

Approach: This problem can be solved by using sorting. Follow the steps below to solve the problem:

• Create three vectors say v1, v2, and v3 where v1 stores the numbers which are even and divisible by 5, v2 stores the numbers which are even but not divisible by 5, and v3 stores the numbers which are odd.
• Iterate in the range [0, N-1] using the variable i and perform the following steps-
• If arr[i]%2 = 0 and arr[i]%5=0, then insert arr[i] in v1.
• If arr[i]%2 = 0 and arr[i]%5 != 0, then insert arr[i] in v2.
• If arr[i]%2 = 1 then insert arr[i] in v3.
• Sort the vector v1 in descending order.
• After performing the above steps, print vector v1 then print vector v2 in reverse order, and then v3 as the answer.

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to sort array in the way``// mentioned above``void` `AwesomeSort(vector<``int``> m, ``int` `n)``{``    ``// Create three vectors``    ``vector<``int``> v1, v2, v3;` `    ``int` `i;` `    ``// Traverse through the elements``    ``// of the array``    ``for` `(i = 0; i < n; i++) {` `        ``// If elements are even and``        ``// divisible by 10``        ``if` `(m[i] % 10 == 0)``            ``v1.push_back(m[i]);` `        ``// If number is even but not divisible``        ``// by 5``        ``else` `if` `(m[i] % 2 == 0)``            ``v2.push_back(m[i]);``        ``else``            ``// If number is odd``            ``v3.push_back(m[i]);``    ``}` `    ``// Sort  v1 in descending orde``    ``sort(v1.begin(), v1.end(), greater<``int``>());` `    ``for` `(``int` `i = 0; i < v1.size(); i++) {``        ``cout << v1[i] << ``" "``;``    ``}``    ``for` `(``int` `i = v2.size()-1; i >= 0; i--) {``        ``cout << v2[i] << ``" "``;``    ``}``    ``for` `(``int` `i = 0; i < v3.size(); i++) {``        ``cout << v3[i] << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``vector<``int``> arr{ 5, 10, 30, 7 };``    ``int` `N = arr.size();` `    ``// FunctionCall``    ``AwesomeSort(arr, N);` `    ``return` `0;``}`

Java

 `// Java program for the above approach``import` `java.util.Collections;``import` `java.util.Vector;` `public` `class` `GFG_JAVA {` `    ``// Function to sort array in the way``    ``// mentioned above``    ``static` `void` `AwesomeSort(Vector m, ``int` `n)``    ``{``        ``// Create three vectors``        ``Vector v1 = ``new` `Vector<>();``        ``Vector v2 = ``new` `Vector<>();``        ``Vector v3 = ``new` `Vector<>();` `        ``int` `i;` `        ``// Traverse through the elements``        ``// of the array``        ``for` `(i = ``0``; i < n; i++) {` `            ``// If elements are even and``            ``// divisible by 10``            ``if` `(m.get(i) % ``10` `== ``0``)``                ``v1.add(m.get(i));` `            ``// If number is even but not divisible``            ``// by 5``            ``else` `if` `(m.get(i) % ``2` `== ``0``)``                ``v2.add(m.get(i));``            ``else``                ``// If number is odd``                ``v3.add(m.get(i));``        ``}` `        ``// Sort  v1 in descending orde``        ``Collections.sort(v1, Collections.reverseOrder());` `        ``for` `(``int` `ii = ``0``; ii < v1.size(); ii++) {``            ``System.out.print(v1.get(ii) + ``" "``);``        ``}``        ``for` `(``int` `ii = v2.size()-``1``; ii >= ``0``; ii--) {``            ``System.out.print(v2.get(ii) + ``" "``);``        ``}``        ``for` `(``int` `ii = ``0``; ii < v3.size(); ii++) {``            ``System.out.print(v3.get(ii) + ``" "``);``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given Input``        ``Vector arr = ``new` `Vector<>();``        ``arr.add(``5``);``        ``arr.add(``10``);``        ``arr.add(``30``);``        ``arr.add(``7``);` `        ``int` `N = arr.size();` `        ``// FunctionCall``        ``AwesomeSort(arr, N);``    ``}``}` `// This code is contributed by abhinavjain194`

Python3

 `# Python program for the above approach` `# Function to sort array in the way``# mentioned above``def` `AwesomeSort(m, n):``  ` `    ``# Create three vectors``    ``v1, v2, v3 ``=` `[],[],[]``    ` `    ``# Traverse through the elements``    ``# of the array``    ``for` `i ``in` `range``(n):``      ` `        ``# If elements are even and``        ``# divisible by 10``        ``if` `(m[i] ``%` `10` `=``=` `0``):``            ``v1.append(m[i])` `        ``# If number is even but not divisible``        ``# by 5``        ``elif` `(m[i] ``%` `2` `=``=` `0``):``            ``v2.append(m[i])``        ``else``:``            ``# If number is odd``            ``v3.append(m[i])` `    ``# Sort  v1 in descending orde``    ``v1 ``=` `sorted``(v1)[::``-``1``]` `    ``for` `i ``in` `range``(``len``(v1)):``        ``print``(v1[i], end ``=` `" "``)` `    ``for` `i ``in` `range``(``len``(v2)``-``1``,``-``1``,``-``1``):``        ``print``(v2[i], end ``=` `" "``)` `    ``for` `i ``in` `range``(``len``(v3)):``        ``print` `(v3[i], end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Given Input``    ``arr ``=` `[``5``, ``10``, ``30``, ``7``]``    ``N ``=` `len``(arr)` `    ``# FunctionCall``    ``AwesomeSort(arr, N)` `    ``# This code is contributed by mohit kumar 29.`

C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG {``    ` `    ``// Function to sort array in the way``    ``// mentioned above``    ``static` `void` `AwesomeSort(List<``int``> m, ``int` `n)``    ``{``      ` `        ``// Create three vectors``        ``List<``int``> v1 = ``new` `List<``int``>();``        ``List<``int``> v2 = ``new` `List<``int``>();``        ``List<``int``> v3 = ``new` `List<``int``>();`` ` `        ``int` `i;`` ` `        ``// Traverse through the elements``        ``// of the array``        ``for` `(i = 0; i < n; i++) {`` ` `            ``// If elements are even and``            ``// divisible by 10``            ``if` `(m[i] % 10 == 0)``                ``v1.Add(m[i]);`` ` `            ``// If number is even but not divisible``            ``// by 5``            ``else` `if` `(m[i] % 2 == 0)``                ``v2.Add(m[i]);``            ``else``                ``// If number is odd``                ``v3.Add(m[i]);``        ``}`` ` `        ``// Sort  v1 in descending orde``        ``v1.Sort();``        ``v1.Reverse();`` ` `        ``for` `(``int` `ii = 0; ii < v1.Count; ii++) {``            ``Console.Write(v1[ii] + ``" "``);``        ``}``        ``for` `(``int` `ii = 0; ii < v2.Count; ii++) {``            ``Console.Write(v2[ii] + ``" "``);``        ``}``        ``for` `(``int` `ii = 0; ii < v3.Count; ii++) {``            ``Console.Write(v3[ii] + ``" "``);``        ``}``    ``}``    ` `  ``static` `void` `Main()``  ``{``    ` `    ``// Given Input``    ``List<``int``> arr = ``new` `List<``int``>();``    ``arr.Add(5);``    ``arr.Add(10);``    ``arr.Add(30);``    ``arr.Add(7);` `    ``int` `N = arr.Count;` `    ``// FunctionCall``    ``AwesomeSort(arr, N);``  ``}``}` `// This code is contributed by divyeshrabadiya07.`

Javascript

 ``

Output

`30 10 5 7 `

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

My Personal Notes arrow_drop_up