Dada una array arr[] que consta de N enteros positivos, la tarea es ordenar la array de manera que:
- Todos los números pares deben ir antes de todos los números impares.
- Todos los números pares que son divisibles por 5 deben ir primero que los números pares que no son divisibles por 5.
- Si dos numeros pares son divisibles por 5 entonces el numero que tenga mayor valor ira primero
- Si dos números pares no fueran divisibles por 5, entonces el número que tenga un índice mayor en la array aparecerá primero.
- Todos los números impares deben venir en orden relativo, ya que están presentes en la array.
Ejemplos:
Entrada: arr[] = {5, 10, 30, 7}
Salida: 30 10 5 7
Explicación: Números pares = [10, 30]. Números impares = [5, 7]. Después de clasificar los números pares, los números pares = [30, 10] como 10 y 30 divisibles por 5, pero 30 tiene un valor mayor, por lo que vendrá antes que 10. Después de clasificar A = [30, 10,
5, 7] como todos los números pares deben ir antes que todos los números impares.
Enfoque: Este problema se puede resolver utilizando la clasificación. Siga los pasos a continuación para resolver el problema:
- Cree tres vectores , digamos v1 , v2 , v3, donde v1 almacena el número que es par y divisible por 5 , v2 almacena el número que es par pero no divisible por 5 , y v3 almacena los números que son impares.
- Iterar en el rango [0, N-1] usando la variable i y realizar los siguientes pasos:
- Si arr[i]%2 = 0 y arr[i]%5=0 , inserte arr[i] en v1 .
- Si arr[i]%2 = 0 y arr[i]%5 != 0, inserte arr[i] en v2 .
- Si arr[i]%2 entonces inserte arr[i] en v3 .
- Ordene el vector v1 en orden descendente.
- Después de realizar los pasos anteriores, imprima el vector v1 , luego imprima el vector v2 y luego v3 como la respuesta.
A continuación se muestra la implementación del enfoque anterior:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
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<Integer> m, int n)
{
// Create three vectors
Vector<Integer> v1 = new Vector<>();
Vector<Integer> v2 = new Vector<>();
Vector<Integer> 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<Integer> 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)): 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
<script>
// JavaScript program for the above approach
// Function to sort array in the way
// mentioned above
function AwesomeSort(m, n)
{
// Create three vectors
let v1 = [];
let v2 = [];
let v3 = [];
let 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(m[i]);
// If number is even but not divisible
// by 5
else if (m[i] % 2 == 0)
v2.push(m[i]);
else
// If number is odd
v3.push(m[i]);
}
// Sort v1 in descending orde
v1.sort((a, b) => b - a);
for (let i = 0; i < v1.length; i++) {
document.write(v1[i] + " ");
}
for (let i = 0; i < v2.length; i++) {
document.write(v2[i] + " ");
}
for (let i = 0; i < v3.length; i++) {
document.write(v3[i] + " ");
}
}
// Driver Code
// Given Input
let arr = [5, 10, 30, 7];
let N = arr.length;
// FunctionCall
AwesomeSort(arr, N);
</script>
Producción
30 10 5 7
Complejidad temporal: O(NlogN)
Espacio auxiliar: O(N)