Programa C++ para reorganizar los elementos de la array en una secuencia alternativa par-impar mediante la rotación de dígitos en sentido contrario a las agujas del reloj

Dada una array arr[] que consta de N enteros positivos, la tarea es rotar los dígitos de los elementos de la array en sentido contrario a las agujas del reloj, de modo que los elementos de la array estén en forma alternativa par-impar o impar-par . Si existen varias soluciones, imprima cualquiera de ellas. De lo contrario, imprima -1 .

Ejemplos:

Entrada: arr[] = { 143, 251, 534, 232, 854 }
Salida: 143 512 345 232 485
Explicación: 
Al girar arr[1] en 1 en sentido contrario a las agujas del reloj, se modifica arr[1] a 512. 
Al girar arr[2] en 1 en sentido antihorario modifica arr[2] a 345. 
Girando arr[4] 2 en sentido antihorario modifica arr[4] a 485.

Entrada: arr[] = { 44, 23, 21, 33, 14 }
Salida: 44 23 12 33 14

Enfoque: el problema anterior se puede resolver modificando el primer elemento de la array a un número impar o un número par. El elemento de la array se puede modificar convirtiendo el número en una string y luego girando los caracteres de la string hacia la izquierda según sea necesario. Siga los pasos a continuación para resolver el problema:

  • Reorganice el primer elemento de la array como un número par y verifique si los elementos restantes de la array se pueden reorganizar en pares e impares alternativamente o no. Si se encuentra que es cierto, entonces reorganice los elementos de la array en pares e impares alternativamente e imprima los elementos de la array .
  • De lo contrario, reorganice el primer elemento de la array como un número impar y verifique si los elementos restantes de la array se pueden reorganizar en par-impar alternativamente o no. Si se determina que es cierto, entonces reorganice los elementos restantes de la array en pares e impares alternativamente e imprima los elementos de la array.
  • De lo contrario, imprima -1 .

A continuación se muestra la implementación del enfoque anterior:

C++

// c++ program of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Utility function to rotate the digits of
// array elements such that array elements are
// in placed even-odd or odd-even alternately
bool is_possible(vector<int>& arr, bool check)
{
 
    // Checks if array can be converted
    // into even-odd or odd-even form
    bool exists = true;
 
    // Store array elements
    vector<int> cpy = arr;
    bool flag;
    // Traverse the array
    for (int i = 0; i < arr.size(); i++) {
 
        // Check if arr[i] is already
        // at correct position
        if (arr[i] % 2 == check) {
            check = !(check);
            continue;
        }
 
        // Checks if it is possible
        // to modify the number arr[i]
        // by rotating the digits of
        // the number anticlockwise
        flag = false;
 
        // Stores the number arr[i] as
        // string
        string strEle = to_string(arr[i]);
 
        // Traverse over the digits of
        // the current element
        for (int j = 0; j < strEle.size(); j++) {
 
            // Checks if parity of check and
            // current digit is same or not
            if (int(strEle[j]) % 2 == check) {
 
                // Rotates the string by j + 1 times
                // in anticlockwise
                arr[i] = stoi(strEle.substr(j + 1)
                              + strEle.substr(0, j + 1));
 
                // Marks the flag
                // as true and break
                flag = true;
                break;
            }
        }
 
        // If flag is false
        if (flag == false) {
            // Update exists
            exists = false;
            break;
        }
 
        // Changes the
        // parity of check
        check = !(check);
    }
 
    // Checks if arr[] cannot be
    // modified, then returns false
    if (!exists) {
        arr = cpy;
        return false;
    }
 
    // Otherwise, return true
    else
        return true;
}
 
// Function to rotate the digits of array
// elements such that array elements are
// in the form of even-odd or odd-even form
void convert_arr(vector<int>& arr)
{
 
    // If array elements can be arranged
    // in even-odd manner alternately
    if (is_possible(arr, 0)) {
        for (auto& i : arr)
            cout << i << " ";
    }
 
    // If array elements can be arranged
    // in odd-even manner alternately
    else if (is_possible(arr, 1)) {
        for (auto& i : arr)
            cout << i << " ";
    }
 
    // Otherwise, prints -1
    else
        cout << "-1" << endl;
}
 
// Driver Code
int main()
{
 
    vector<int> arr = { 143, 251, 534, 232, 854 };
    convert_arr(arr);
}
 
// This code is contributed by grand_master.
Producción: 

314 251 534 223 854

 

Complejidad de tiempo : O (N), ya que estamos usando un bucle para atravesar N veces.

Espacio auxiliar : O (N), ya que estamos usando espacio adicional para copiar.

¡ Consulte el artículo completo sobre Reorganizar los elementos de la array en secuencias pares e impares alternas mediante la rotación de dígitos en sentido contrario a las agujas del reloj para obtener más detalles!

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *