Rearrange an array such that product of every two consecutive elements is a multiple of 4

Given an array arr[] of size N, the task is to rearrange the array elements such that for every index i(1 <= i <= N – 1), the product of arr[i] and arr[i – 1] is a multiple of 4.
Example:

Input: arr[] = {1, 10, 100} 
Output: 1, 100, 10 
Explanation:
1 * 100 is divisible by 4 
100 * 10 is divisible by 4

Input: arr[] = {2, 7, 1, 8, 2, 8} 
Output: 7, 8, 1, 8, 2, 2 

Naive Approach:
The simplest approach to solve the problem is to generate all possible permutations of the array and for every permutation, check if the product of every two consecutive elements is a multiple of 4 or not. 

Time complexity: O(N^2 * N!) 
Auxiliary Space: O(N!)

Efficient Approach:
Follow the steps below to optimize the above approach:

• Initialize following three variables:
  • odd = Number of odd elements.
  • four = Number of elements divisible by 4.
  • non_four = Number of even elements not divisible by 4.
• Consider the following two cases:
  • Case 1: non_four = 0
    In this case, no even elements are present which are not divisible by 4.
    • The optimal way is to first place the “odd” elements first in the array in alternate positions.
    • Fill the vacancies with the even elements.

Illustration
arr[] = {1, 1, 1, 4, 4}
Step 0: four = 2, odd = 3
Step 1: {1 _ 1 _ 1}
Step 2: {1 4 1 4 1}

• Hence, for the approach to be mathematically possible, the difference between the count of even and odd elements should not exceed 1.
• Case 2: non_four > 0

In this case, even elements that are not divisible by 4 exist in the array.

• Follow the exact same strategy as depicted above by placing the elements divisible by 4 in alternate positions followed by odd elements in the vacancies.
• Then, place all the remaining even elements at the end of the array. This is because the product of two even numbers is always divisible by 4. Hence, placing the even elements towards the end of the array guarantees that the product of consecutive elements among them is divisible by 4.

Illustration:
arr[] = {2, 7, 1, 8, 2, 8}
Step 1: four = 2, non_four = 2, odd = 2
Step 2: {_ 8 _ 8}
Step 3: {1 8 7 8}
Step 4: {1 8 7 8 2 2}

• For this to be possible mathematically, four >= odd.

Below is the implementation of the above approach:

C++

// C++ Program to rearray array
// elements such that the product
// of every two consecutive
// elements is a multiple of 4

#include <bits/stdc++.h>
using namespace std;

// Function to rearrange array
// elements such that the every
// two consecutive elements is
// a multiple of 4
void Permute(vector<int>& arr,
            int n)
{

    int odd = 0, four = 0;
    int non_four = 0;

    vector<int> ODD, FOUR,
        NON_FOUR;

    for (auto x : arr) {

        // If element is odd
        if (x & 1) {
            odd++;
            // Odd
            ODD.push_back(x);
        }

        // If element is divisible
        // by 4
        else if (x % 4 == 0) {
            four++;
            // Divisible by 4
            FOUR.push_back(x);
        }

        // If element is not
        // divisible by 4
        else {
            non_four++;
            // Even but not divisible
            // by 4
            NON_FOUR.push_back(x);
        }
    }

    // Condition for rearrangement
    // to be possible
    if (non_four == 0
        && four >= odd - 1) {

        int x = ODD.size();
        int y = FOUR.size();
        int i;

        // Print ODD[i] and FOUR[i]
        // consecutively
        for (i = 0; i < x; i++) {
            cout << ODD[i] << " ";
            if (i < y)
                cout << FOUR[i] << " ";
        }

        // Print the remaining
        // FOUR[i], if any
        while (i < y)
            cout << FOUR[i] << " ";
        cout << endl;
    }

    // Condition for rearrangement
    // to be possible
    else if (non_four > 0
            and four >= odd) {

        int x = ODD.size();
        int y = FOUR.size();
        int i;

        // Print ODD[i] and FOUR[i]
        // consecutively
        for (i = 0; i < x; i++) {
            cout << ODD[i] << " ";
            if (i < y)
                cout << FOUR[i] << " ";
        }

        // Print the remaining
        // FOUR[i], if any
        while (i < y)
            cout << FOUR[i] << " ";

        // Print the NON_FOUR[i]
        // elements at the end
        for (int j = 0;
            j < (int)NON_FOUR.size();
            j++)
            cout << NON_FOUR[j] << " ";
        cout << endl;
    }
    else

        // No possible configuration
        cout << "Not Possible" << endl;
}

// Driver Code
signed main()
{

    vector<int> arr = { 2, 7, 1,
                        8, 2, 8 };
    int N = sizeof(arr) / sizeof(arr);
    Permute(arr, N);

    return 0;
}

Java

// Java program to rearray array
// elements such that the product
// of every two consecutive
// elements is a multiple of
import java.io.*;
import java.util.*;

class GFG{

// Function to rearrange array
// elements such that the every
// two consecutive elements is
// a multiple of 4
public static void Permute(Vector<Integer> arr, int n)
{
    int odd = 0, four = 0;
    int non_four = 0;

    Vector<Integer> ODD = new Vector<Integer>();
    Vector<Integer> FOUR = new Vector<Integer>(n);
    Vector<Integer> NON_FOUR = new Vector<Integer>(n);

    for(int x : arr)
    {

        // If element is odd
        if (x % 2 != 0)
        {
            odd++;

            // Odd
            ODD.add(x);
        }

        // If element is divisible
        // by 4
        else if (x % 4 == 0)
        {
            four++;

            // Divisible by 4
            FOUR.add(x);
        }

        // If element is not
        // divisible by 4
        else
        {
            non_four++;

            // Even but not divisible
            // by 4
            NON_FOUR.add(x);
        }
    }

    // Condition for rearrangement
    // to be possible
    if (non_four == 0 && four >= odd - 1)
    {
        int x = ODD.size();
        int y = FOUR.size();
        int i;

        // Print ODD.get(i) and FOUR.get(i)
        // consecutively
        for(i = 0; i < x; i++)
        {
            System.out.print(ODD.get(i) + " ");

            if (i < y)
                System.out.print(FOUR.get(i) + " ");
        }

        // Print the remaining
        // FOUR.get(i), if any
        while (i < y)
            System.out.print(FOUR.get(i) + " ");

        System.out.println();
    }

    // Condition for rearrangement
    // to be possible
    else if (non_four > 0 && four >= odd)
    {
        int x = ODD.size();
        int y = FOUR.size();
        int i;

        // Print ODD.get(i) and FOUR.get(i)
        // consecutively
        for(i = 0; i < x; i++)
        {
            System.out.print(ODD.get(i) + " ");

            if (i < y)
                System.out.print(FOUR.get(i) + " ");
        }

        // Print the remaining
        // FOUR.get(i), if any
        while (i < y)
            System.out.print(FOUR.get(i) + " ");

        // Print the NON_FOUR.get(i)
        // elements at the end
        for(int j = 0; j < (int)NON_FOUR.size(); j++)
            System.out.print(NON_FOUR.get(j) + " ");

        System.out.println();
    }
    else

        // No possible configuration
        System.out.println("Not Possible");
}

// Driver Code
public static void main(String[] args)
{
    Vector<Integer> arr = new Vector<Integer>();
    arr.add(2);
    arr.add(7);
    arr.add(1);
    arr.add(8);
    arr.add(2);
    arr.add(8);

    Permute(arr, arr.size());
}
}

// This code is contributed by grand_master

Python3

# Python3 program to rearray array
# elements such that the product
# of every two consecutive
# elements is a multiple of 4

# Function to rearrange array
# elements such that the every
# two consecutive elements is
# a multiple of 4
def Permute(arr, n):

    odd = 0
    four = 0
    non_four = 0
    ODD, FOUR, NON_FOUR = [], [], []

    for x in arr:

        # If element is odd
        if (x & 1):
            odd += 1

            # Odd
            ODD.append(x)

        # If element is divisible
        # by 4
        elif (x % 4 == 0):
            four += 1

            # Divisible by 4
            FOUR.append(x)

        # If element is not
        # divisible by 4
        else:
            non_four += 1

            # Even but not divisible
            # by 4
            NON_FOUR.append(x)

    # Condition for rearrangement
    # to be possible
    if (non_four == 0 and four >= odd - 1):
        x = len(ODD)
        y = len(FOUR)
        i = 0

        # Print ODD[i] and FOUR[i]
        # consecutively
        while i < x:
            print(ODD[i], end = " ")
            if (i < y):
                print(FOUR[i], end = " ")

        # Print the remaining
        # FOUR[i], if any
        while (i < y):
            print(FOUR[i], end = " ")
            i += 1
        print()

    # Condition for rearrangement
    # to be possible
    elif (non_four > 0 and four >= odd):
        x = len(ODD)
        y = len(FOUR)
        i = 0

        # Print ODD[i] and FOUR[i]
        # consecutively
        while i < x:
            print(ODD[i], end = " ")
            if (i < y):
                print(FOUR[i], end = " ")
            i += 1

        # Print the remaining
        # FOUR[i], if any
        while (i < y):
            print(FOUR[i], end = " ")
            i += 1

        # Print the NON_FOUR[i]
        # elements at the end
        for j in NON_FOUR:
            print(j, end = " ")
    else:

        # No possible configuration
        print("Not Possible")

# Driver Code
if __name__ == '__main__':

    arr = [ 2, 7, 1, 8, 2, 8 ]
    N = len(arr)

    Permute(arr, N)

# This code is contributed by mohit kumar 29

C#

// C# program to rearray array
// elements such that the product
// of every two consecutive
// elements is a multiple of
using System;
using System.Collections.Generic;
class GFG{

// Function to rearrange array
// elements such that the every
// two consecutive elements is
// a multiple of 4
public static void Permute(List<int> arr,
                           int n)
{
  int odd = 0, four = 0;
  int non_four = 0;

  List<int> ODD =
            new List<int>();
  List<int> FOUR =
            new List<int>(n);
  List<int> NON_FOUR =
            new List<int>(n);

  foreach(int x in arr)
  {
    // If element is odd
    if (x % 2 != 0)
    {
      odd++;

      // Odd
      ODD.Add(x);
    }

    // If element is divisible
    // by 4
    else if (x % 4 == 0)
    {
      four++;

      // Divisible by 4
      FOUR.Add(x);
    }

    // If element is not
    // divisible by 4
    else
    {
      non_four++;

      // Even but not divisible
      // by 4
      NON_FOUR.Add(x);
    }
  }

  // Condition for rearrangement
  // to be possible
  if (non_four == 0 &&
      four >= odd - 1)
  {
    int x = ODD.Count;
    int y = FOUR.Count;
    int i;

    // Print ODD[i] and FOUR[i]
    // consecutively
    for(i = 0; i < x; i++)
    {
      Console.Write(ODD[i] + " ");

      if (i < y)
        Console.Write(FOUR[i] + " ");
    }

    // Print the remaining
    // FOUR[i], if any
    while (i < y)
      Console.Write(FOUR[i] + " ");

    Console.WriteLine();
  }

  // Condition for rearrangement
  // to be possible
  else if (non_four > 0 &&
           four >= odd)
  {
    int x = ODD.Count;
    int y = FOUR.Count;
    int i;

    // Print ODD[i] and FOUR[i]
    // consecutively
    for(i = 0; i < x; i++)
    {
      Console.Write(ODD[i] + " ");

      if (i < y)
        Console.Write(FOUR[i] + " ");
    }

    // Print the remaining
    // FOUR[i], if any
    while (i < y)
      Console.Write(FOUR[i] + " ");

    // Print the NON_FOUR[i]
    // elements at the end
    for(int j = 0;
            j < (int)NON_FOUR.Count; j++)
      Console.Write(NON_FOUR[j] + " ");

    Console.WriteLine();
  }
  else

    // No possible configuration
    Console.WriteLine("Not Possible");
}

// Driver Code
public static void Main(String[] args)
{
  List<int> arr = new List<int>();
  arr.Add(2);
  arr.Add(7);
  arr.Add(1);
  arr.Add(8);
  arr.Add(2);
  arr.Add(8);

  Permute(arr, arr.Count);
}
}

// This code is contributed by 29AjayKumar

Javascript

<script>
// Javascript program to rearray array
// elements such that the product
// of every two consecutive
// elements is a multiple of

// Function to rearrange array
// elements such that the every
// two consecutive elements is
// a multiple of 4
function Permute(arr,n)
{
    let odd = 0, four = 0;
    let non_four = 0;

    let ODD = [];
    let FOUR = [];
    let NON_FOUR = [];

    for(let x = 0; x < arr.length; x++)
    {

        // If element is odd
        if (arr[x] % 2 != 0)
        {
            odd++;

            // Odd
            ODD.push(arr[x]);
        }

        // If element is divisible
        // by 4
        else if (arr[x] % 4 == 0)
        {
            four++;

            // Divisible by 4
            FOUR.push(arr[x]);
        }

        // If element is not
        // divisible by 4
        else
        {
            non_four++;

            // Even but not divisible
            // by 4
            NON_FOUR.push(arr[x]);
        }
    }

    // Condition for rearrangement
    // to be possible
    if (non_four == 0 && four >= odd - 1)
    {
        let x = ODD.length;
        let y = FOUR.length;
        let i;

        // Print ODD.get(i) and FOUR.get(i)
        // consecutively
        for(i = 0; i < x; i++)
        {
            document.write(ODD[i] + " ");

            if (i < y)
                document.write(FOUR[i] + " ");
        }

        // Print the remaining
        // FOUR.get(i), if any
        while (i < y)
            document.write(FOUR[i] + " ");

        document.write("<br>");
    }

    // Condition for rearrangement
    // to be possible
    else if (non_four > 0 && four >= odd)
    {
        let x = ODD.length;
        let y = FOUR.length;
        let i;

        // Print ODD.get(i) and FOUR.get(i)
        // consecutively
        for(i = 0; i < x; i++)
        {
            document.write(ODD[i] + " ");

            if (i < y)
                document.write(FOUR[i] + " ");
        }

        // Print the remaining
        // FOUR.get(i), if any
        while (i < y)
            document.write(FOUR[i] + " ");

        // Print the NON_FOUR.get(i)
        // elements at the end
        for(let j = 0; j < NON_FOUR.length; j++)
            document.write(NON_FOUR[j] + " ");

        document.write("<br>");
    }
    else

        // No possible configuration
        document.write("Not Possible<br>");
}


// Driver Code
let arr=[2,7,1,8,2,8]
Permute(arr, arr.length);


// This code is contributed by patel2127
</script>

Output:

7 8 1 8 2 2

Time Complexity: O(N)
Auxiliary Space: O(1)