Se nos da una matriz de n números distintos. La tarea consiste en ordenar todos los números pares en números crecientes y en números impares en orden decreciente. La matriz modificada debe contener todos los números pares ordenados seguidos de los números impares ordenados al revés.
Tenga en cuenta que el primer elemento se considera par debido a su índice 0.
Ejemplos:
Aporte: arreglo[] = {0 1 2 3 4 5 6 7}
Producción: arreglo[] = {0 2 4 6 7 5 3 1}
Explicación:
Elementos pares : 0 2 4 6
Elementos de lugares impares: 1 3 5 7
Elementos pares en orden creciente:
0 2 4 6
Elementos de lugares impares en orden decreciente:
7 5 3 1
Aporte: arreglo[] = {3 1 2 4 5 9 13 14 12}
Producción: {2 3 5 12 13 14 9 4 1}
Explicación:
Elementos pares : 3 2 5 13 12
Elementos de lugares impares: 1 4 9 14
Elementos pares en orden creciente:
2 3 5 12 13
Elementos de lugares impares en orden decreciente:
14 9 4 1
[Enfoque ingenuo] - O(n Log n) Tiempo y O(n) Espacio
La idea es sencilla. Creamos dos matrices auxiliares evenArr[] y oddArr[] respectivamente. Atravesamos la matriz de entrada y colocamos todos los elementos pares en evenArr[] y los elementos impares en oddArr[]. Luego ordenamos EvenArr[] en orden ascendente y oddArr[] en orden descendente. Finalmente copie evenArr[] y oddArr[] para obtener el resultado requerido.
C++// Program to separately sort even-placed and odd // placed numbers and place them together in sorted // array. #include
// Program to separately sort even-placed and odd // placed numbers and place them together in sorted // array. import java.util.*; public class Main { public static void bitonicGenerator(int[] arr) { // create evenArr[] and oddArr[] List<Integer> evenArr = new ArrayList<>(); List<Integer> oddArr = new ArrayList<>(); // Put elements in oddArr[] and evenArr[] as // per their position for (int i = 0; i < arr.length; i++) { if (i % 2 == 0) evenArr.add(arr[i]); else oddArr.add(arr[i]); } // sort evenArr[] in ascending order // sort oddArr[] in descending order Collections.sort(evenArr); Collections.sort(oddArr Collections.reverseOrder()); int i = 0; for (int num : evenArr) arr[i++] = num; for (int num : oddArr) arr[i++] = num; } public static void main(String[] args) { int[] arr = { 1 5 8 9 6 7 3 4 2 0 }; bitonicGenerator(arr); for (int num : arr) System.out.print(num + ' '); } }
# Program to separately sort even-placed and odd # placed numbers and place them together in sorted # array. def bitonic_generator(arr): # create evenArr[] and oddArr[] evenArr = [] oddArr = [] # Put elements in oddArr[] and evenArr[] as # per their position for i in range(len(arr)): if i % 2 == 0: evenArr.append(arr[i]) else: oddArr.append(arr[i]) # sort evenArr[] in ascending order # sort oddArr[] in descending order evenArr.sort() oddArr.sort(reverse=True) i = 0 for num in evenArr: arr[i] = num i += 1 for num in oddArr: arr[i] = num i += 1 # Driver Program arr = [1 5 8 9 6 7 3 4 2 0] bitonic_generator(arr) print(' '.join(map(str arr)))
// Program to separately sort even-placed and odd // placed numbers and place them together in sorted // array. using System; using System.Collections.Generic; using System.Linq; class Program { static void BitonicGenerator(int[] arr) { // create evenArr[] and oddArr[] List<int> evenArr = new List<int>(); List<int> oddArr = new List<int>(); // Put elements in oddArr[] and evenArr[] as // per their position for (int i = 0; i < arr.Length; i++) { if (i % 2 == 0) evenArr.Add(arr[i]); else oddArr.Add(arr[i]); } // sort evenArr[] in ascending order // sort oddArr[] in descending order evenArr.Sort(); oddArr.Sort((a b) => b.CompareTo(a)); int index = 0; foreach (var num in evenArr) arr[index++] = num; foreach (var num in oddArr) arr[index++] = num; } static void Main() { int[] arr = { 1 5 8 9 6 7 3 4 2 0 }; BitonicGenerator(arr); Console.WriteLine(string.Join(' ' arr)); } }
// Program to separately sort even-placed and odd // placed numbers and place them together in sorted // array. function bitonicGenerator(arr) { // create evenArr[] and oddArr[] const evenArr = []; const oddArr = []; // Put elements in oddArr[] and evenArr[] as // per their position for (let i = 0; i < arr.length; i++) { if (i % 2 === 0) evenArr.push(arr[i]); else oddArr.push(arr[i]); } // sort evenArr[] in ascending order // sort oddArr[] in descending order evenArr.sort((a b) => a - b); oddArr.sort((a b) => b - a); let i = 0; for (const num of evenArr) arr[i++] = num; for (const num of oddArr) arr[i++] = num; } // Driver Program const arr = [1 5 8 9 6 7 3 4 2 0]; bitonicGenerator(arr); console.log(arr.join(' '));
// Program to separately sort even-placed and odd // placed numbers and place them together in sorted // array. function bitonicGenerator(&$arr) { // create evenArr[] and oddArr[] $evenArr = []; $oddArr = []; // Put elements in oddArr[] and evenArr[] as // per their position foreach ($arr as $i => $value) { if ($i % 2 === 0) $evenArr[] = $value; else $oddArr[] = $value; } // sort evenArr[] in ascending order // sort oddArr[] in descending order sort($evenArr); rsort($oddArr); $i = 0; foreach ($evenArr as $num) { $arr[$i++] = $num; } foreach ($oddArr as $num) { $arr[$i++] = $num; } } // Driver Program $arr = [1 5 8 9 6 7 3 4 2 0]; bitonicGenerator($arr); echo implode(' ' $arr);
Producción
1 2 3 6 8 9 7 5 4 0
[Aproximación esperada - 1] - O(n Log n) Tiempo y O(1) Espacio
El problema también se puede solucionar sin el uso de espacio auxiliar. La idea es intercambiar las posiciones del índice impar de la primera mitad con las posiciones del índice par de la segunda mitad y luego ordenar la primera mitad de la matriz en orden creciente y la segunda mitad de la matriz en orden decreciente.
C++#include
import java.util.Arrays; class BitonicGenerator { public static void bitonicGenerator(int[] arr) { // first odd index int i = 1; // last index int n = arr.length; int j = n - 1; // if last index is odd if (j % 2 != 0) // decrement j to even index j--; // swapping till half of array while (i < j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; i += 2; j -= 2; } // Sort first half in increasing order Arrays.sort(arr 0 (n + 1) / 2); // Sort second half in decreasing order Arrays.sort(arr (n + 1) / 2 n); reverse(arr (n + 1) / 2 n); } private static void reverse(int[] arr int start int end) { end--; while (start < end) { int temp = arr[start]; arr[start] = arr[end]; arr[end] = temp; start++; end--; } } // Driver Program public static void main(String[] args) { int[] arr = {1 5 8 9 6 7 3 4 2 0}; bitonicGenerator(arr); for (int num : arr) { System.out.print(num + ' '); } } }
def bitonic_generator(arr): # first odd index i = 1 # last index n = len(arr) j = n - 1 # if last index is odd if j % 2 != 0: # decrement j to even index j -= 1 # swapping till half of array while i < j: arr[i] arr[j] = arr[j] arr[i] i += 2 j -= 2 # Sort first half in increasing arr[:(n + 1) // 2] = sorted(arr[:(n + 1) // 2]) # Sort second half in decreasing arr[(n + 1) // 2:] = sorted(arr[(n + 1) // 2:] reverse=True) # Driver Program arr = [1 5 8 9 6 7 3 4 2 0] bitonic_generator(arr) print(' '.join(map(str arr)))
// Function to generate a bitonic sequence using System; using System.Collections.Generic; using System.Linq; class Program { static void BitonicGenerator(List<int> arr) { // first odd index int i = 1; // last index int n = arr.Count; int j = n - 1; // if last index is odd if (j % 2 != 0) // decrement j to even index j--; // swapping till half of array while (i < j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; i += 2; j -= 2; } // Sort first half in increasing arr.Sort(0 (n + 1) / 2); // Sort second half in decreasing arr.Sort((n + 1) / 2 n - (n + 1) / 2 Comparer<int>.Create((x y) => y.CompareTo(x))); } // Driver Program static void Main() { List<int> arr = new List<int> { 1 5 8 9 6 7 3 4 2 0 }; BitonicGenerator(arr); Console.WriteLine(string.Join(' ' arr)); } }
// Function to generate a bitonic sequence function bitonicGenerator(arr) { // first odd index let i = 1; // last index let n = arr.length; let j = n - 1; // if last index is odd if (j % 2 !== 0) // decrement j to even index j--; // swapping till half of array while (i < j) { [arr[i] arr[j]] = [arr[j] arr[i]]; i += 2; j -= 2; } // Sort first half in increasing arr.sort((a b) => a - b); // Sort second half in decreasing arr.slice((n + 1) / 2).sort((a b) => b - a); } // Driver Program let arr = [1 5 8 9 6 7 3 4 2 0]; bitonicGenerator(arr); console.log(arr.join(' '));
Producción
1 2 3 6 8 9 7 5 4 0
Nota: Los códigos Python y JS anteriores parecen requerir espacio adicional. Háganos saber en los comentarios sobre sus pensamientos y cualquier implementación alternativa.
[Aproximación esperada - 2] - O(n Log n) Tiempo y O(1) Espacio
Otro enfoque eficiente para resolver el problema en el espacio auxiliar O (1) es mediante Usando la multiplicación negativa .
Los pasos involucrados son los siguientes:
- Multiplica todos los elementos en el índice par por -1.
- Ordena toda la matriz. De esta manera podemos obtener todos los índices pares al principio, ya que ahora son números negativos.
- Ahora invierte el signo de estos elementos.
- Después de esto, invierta la primera mitad de la matriz que contiene un número par para hacerlo en orden creciente.
- Y luego invierta la mitad restante de la matriz para formar números impares en orden decreciente.
Nota: Este método solo es aplicable si todos los elementos de la matriz no son negativos.
Un ejemplo ilustrativo del enfoque anterior:
Sea la matriz dada: arreglo[] = {0 1 2 3 4 5 6 7}
Matriz después de multiplicar por -1 para elementos colocados pares: arreglo[] = {0 1 -2 3 -4 5 -6 7}
Matriz después de ordenar: arr[] = {-6 -4 -2 0 1 3 5 7}
Matriz después de revertir valores negativos: arr[] = {6 4 2 0 1 3 5 7}
Después de invertir la primera mitad de la matriz: arr[] = {0 2 4 6 1 3 5 7}
Después de invertir la segunda mitad de la matriz: arr[] = {0 2 4 6 7 5 3 1}
A continuación se muestra el código para el enfoque anterior:
C++#include
import java.util.Arrays; import java.util.List; public class BitonicGenerator { public static void bitonicGenerator(List<Integer> arr) { // Making all even placed index // element negative for (int i = 0; i < arr.size(); i++) { if (i % 2 == 0) arr.set(i -1 * arr.get(i)); } // Sorting the whole array Collections.sort(arr); // Finding the middle value of // the array int mid = (arr.size() - 1) / 2; // Reverting the changed sign for (int i = 0; i <= mid; i++) { arr.set(i -1 * arr.get(i)); } // Reverse first half of array Collections.reverse(arr.subList(0 mid + 1)); // Reverse second half of array Collections.reverse(arr.subList(mid + 1 arr.size())); } // Driver Program public static void main(String[] args) { List<Integer> arr = Arrays.asList(1 5 8 9 6 7 3 4 2 0); bitonicGenerator(arr); for (int i : arr) System.out.print(i + ' '); } }
def bitonic_generator(arr): # Making all even placed index # element negative for i in range(len(arr)): if i % 2 == 0: arr[i] = -1 * arr[i] # Sorting the whole array arr.sort() # Finding the middle value of # the array mid = (len(arr) - 1) // 2 # Reverting the changed sign for i in range(mid + 1): arr[i] = -1 * arr[i] # Reverse first half of array arr[:mid + 1] = reversed(arr[:mid + 1]) # Reverse second half of array arr[mid + 1:] = reversed(arr[mid + 1:]) # Driver Program arr = [1 5 8 9 6 7 3 4 2 0] bitonic_generator(arr) print(' '.join(map(str arr)))
using System; using System.Collections.Generic; using System.Linq; class BitonicGenerator { public static void BitonicGeneratorMethod(List<int> arr) { // Making all even placed index // element negative for (int i = 0; i < arr.Count; i++) { if (i % 2 == 0) arr[i] = -1 * arr[i]; } // Sorting the whole array arr.Sort(); // Finding the middle value of // the array int mid = (arr.Count - 1) / 2; // Reverting the changed sign for (int i = 0; i <= mid; i++) { arr[i] = -1 * arr[i]; } // Reverse first half of array arr.Take(mid + 1).Reverse().ToList().CopyTo(arr); // Reverse second half of array arr.Skip(mid + 1).Reverse().ToList().CopyTo(arr mid + 1); } // Driver Program public static void Main() { List<int> arr = new List<int> { 1 5 8 9 6 7 3 4 2 0 }; BitonicGeneratorMethod(arr); Console.WriteLine(string.Join(' ' arr)); } }
function bitonicGenerator(arr) { // Making all even placed index // element negative for (let i = 0; i < arr.length; i++) { if (i % 2 === 0) arr[i] = -1 * arr[i]; } // Sorting the whole array arr.sort((a b) => a - b); // Finding the middle value of // the array const mid = Math.floor((arr.length - 1) / 2); // Reverting the changed sign for (let i = 0; i <= mid; i++) { arr[i] = -1 * arr[i]; } // Reverse first half of array arr.slice(0 mid + 1).reverse().forEach((val index) => arr[index] = val); // Reverse second half of array arr.slice(mid + 1).reverse().forEach((val index) => arr[mid + 1 + index] = val); } // Driver Program let arr = [1 5 8 9 6 7 3 4 2 0]; bitonicGenerator(arr); console.log(arr.join(' '));
Producción
1 2 3 6 8 9 7 5 4 0
Crear cuestionario