Java程序通过逆时针旋转数字将数组元素重新排列为交替的奇偶序列

给定一个由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 。

下面是上述方法的实现：

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.

输出：

314 251 534 223 854

时间复杂度： O(N)
辅助空间： O(N)

有关详细信息，请参阅有关通过逆时针旋转数字将数组元素重新排列为交替奇偶序列的完整文章！