给定由N个正整数组成的数组arr [] ，任务是沿逆时针方向旋转数组元素的数字，以使数组元素的元素呈交替的奇偶或奇偶形式。如果存在多个解决方案，则打印其中任何一种。否则，打印-1 。
例子：
Input: arr[] = { 143, 251, 534, 232, 854 }
Output: 143 512 345 232 485
Explanation:
Rotating arr[1] by 1 in anticlockwise direction modifies arr[1] to 512.
Rotating arr[2] by 1 in anticlockwise direction modifies arr[2] to 345.
Rotating arr[4] by 2 in anticlockwise direction modifies arr[4] to 485.
Input: arr[] = { 44, 23, 21, 33, 14 }
Output: 44 23 12 33 14
方法：可以通过将第一个数组元素修改为奇数或偶数来解决上述问题。该阵列元件可以通过将数字转换成一个字符串进行修改，然后旋转根据需要留下的字符串的字符。请按照以下步骤解决问题：
- 将第一个数组元素重新排列为偶数，并检查是否可以将其余的数组元素交替排列为奇偶数。如果发现是真的，则将数组元素交替重新排列为奇偶数，然后打印数组元素。
- 否则，将第一个数组元素重新排列为奇数，然后检查是否可以交替将其余的数组元素重新排列为偶数奇数。如果发现是真的，则将剩余的数组元素交替重新排列为偶数，然后打印该数组元素。
- 否则，打印-1 。
下面是上述方法的实现：
C++
// c++ program of the above approach
#include
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& arr, bool check)
{
// Checks if array can be converted
// into even-odd or odd-even form
bool exists = true;
// Store array elements
vector 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& 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 arr = { 143, 251, 534, 232, 854 };
convert_arr(arr);
}
// This code is contributed by grand_master. Java
// java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
class GFG {
// Utility function to rotate the digits of
// array elements such that array elements are
// in placed even-odd or odd-even alternately
static boolean is_possible(int arr[], int check)
{
// Checks if array can be converted
// into even-odd or odd-even form
boolean exists = true;
// Store array elements
int cpy[] = arr.clone();
boolean flag;
// Traverse the array
for (int i = 0; i < arr.length; i++) {
// Check if arr[i] is already
// at correct position
if (arr[i] % 2 == check) {
// Changes the
// parity of check
check = (check == 0 ? 1 : 0);
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 = Integer.toString(arr[i]);
// Traverse over the digits of
// the current element
for (int j = 0; j < strEle.length(); j++) {
// Checks if parity of check and
// current digit is same or not
if ((strEle.charAt(j) - '0') % 2 == check) {
// Rotates the string by j + 1 times
// in anticlockwise
arr[i] = Integer.parseInt(
strEle.substring(j + 1)
+ strEle.substring(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 == 0 ? 1 : 0);
}
// 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
static void convert_arr(int arr[])
{
// If array elements can be arranged
// in even-odd manner alternately
if (is_possible(arr, 0)) {
for (int v : arr) {
System.out.print(v + " ");
}
}
// If array elements can be arranged
// in odd-even manner alternately
else if (is_possible(arr, 1)) {
for (int v : arr) {
System.out.print(v + " ");
}
}
// Otherwise, prints -1
else
System.out.println(-1);
}
// Driver code
public static void main(String[] args)
{
// Given array
int arr[] = { 143, 251, 534, 232, 854 };
// FUnction call
convert_arr(arr);
}
}
// This code is contributed by Kingash.Python3
# Python program of the above approach
# Utility function to rotate the digits of
# array elements such that array elements are
# in placed even-odd or odd-even alternately
def is_possible(arr, check):
# Checks if array can be converted
# into even-odd or odd-even form
exists = True
# Store array elements
cpy = arr
# Traverse the array
for i in range(len(arr)):
# Check if arr[i] is already
# at correct position
if (arr[i] % 2 == check):
check = not(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
strEle = str(arr[i])
# Traverse over the digits of
# the current element
for j in range(len(strEle)):
# 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] = int(strEle[j + 1:] + strEle[: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 = not(check)
# Checks if arr[] cannot be
# modified, then returns false
if not 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
def convert_arr(arr):
# If array elements can be arranged
# in even-odd manner alternately
if(is_possible(arr, 0)):
print(*arr)
# If array elements can be arranged
# in odd-even manner alternately
elif(is_possible(arr, 1)):
print(*arr)
# Otherwise, prints -1
else:
print(-1)
# Driver Code
if __name__ == '__main__':
arr = [143, 251, 534, 232, 854]
convert_arr(arr)
# This code is contributed by ipg2016107.C#
// C# program of the above approach
using System;
using System.Collections.Generic;
class GFG{
// Utility function to rotate the digits of
// array elements such that array elements are
// in placed even-odd or odd-even alternately
static bool ispossible(List arr, bool check)
{
// Checks if array can be converted
// into even-odd or odd-even form
bool exists = true;
// Store array elements
List cpy = arr;
bool flag;
// Traverse the array
for (int i=0;i arr)
{
// If array elements can be arranged
// in even-odd manner alternately
if (ispossible(arr, false)) {
foreach (int i in arr)
Console.Write(i +" ");
}
// If array elements can be arranged
// in odd-even manner alternately
else if (ispossible(arr, true)) {
foreach (int i in arr)
Console.Write(i + " ");
}
// Otherwise, prints -1
else
Console.Write("-1");
}
// Driver Code
public static void Main()
{
List arr = new List(){143, 251, 534, 232, 854};
convert_arr(arr);
}
} 输出：
314 251 534 223 854时间复杂度： O(N)
辅助空间： O(N)