Count ways to construct array with even product from given array such that absolute difference of same indexed elements is at most 1

Given an array A[] of size N, the task is to count the numbers of ways to construct an array B[] of size N, such that the absolute difference at the same indexed elements must be less than or equal to 1, i.e. abs(A[i] – B[i]) ? 1, and the product of elements of the array B[] must be an even number.

Examples:

Input: A[] = { 2, 3 } 
Output: 7 
Explanation:
Possible values of the array B[] are { { 1, 2 }, { 1, 4 }, { 2, 2 }, { 2, 4 }, { 3, 2 }, { 3, 4 } } 
Therefore, the required output is 7.

Input: A[] = { 90, 52, 56, 71, 44, 8, 13, 30, 57, 84 } 
Output: 58921 

Approach: The idea is to first count the number of ways to construct an array, B[] such that abs(A[i] – B[i]) <= 1 and then remove those arrays whose product of elements is not an even number. Follow the below steps to solve the problem:

• Possible values of B[i] such that abs(A[i] – B[i]) <= 1 are { A[i], A[i] + 1, A[i] – 1 }. Therefore, the total count of ways to construct an array, B[] such that abs(A[i] – B[i]) less than or equal to 1 is 3^N.
• Traverse the array and store the count of even numbers in the array A[] say, X.
• If A[i] is an even number then (A[i] – 1) and (A[i] + 1) must be an odd number. Therefore, the total count of ways to the construct array, B[] whose product is not an even number is 2^X.
• Finally, print the value of (3^N – 2^X).

Below is the implementation of the above approach:

C++

// C++ program to implement
// the above approach

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

// Function to find count the ways to construct
// an array, B[] such that abs(A[i] - B[i]) <=1
// and product of elements of B[] is even
void cntWaysConsArray(int A[], int N)
{

    // Stores count of arrays B[] such
    // that abs(A[i] - B[i]) <=1
    int total = 1;

    // Stores count of arrays B[] whose
    // product of elements is not even
    int oddArray = 1;

    // Traverse the array
    for (int i = 0; i < N; i++) {

        // Update total
        total = total * 3;

        // If A[i] is an even number
        if (A[i] % 2 == 0) {

            // Update oddArray
            oddArray *= 2;
        }
    }

    // Print 3^N - 2^X
    cout << total - oddArray << "\n";
}

// Driver Code
int main()
{
    int A[] = { 2, 4 };
    int N = sizeof(A) / sizeof(A[0]);

    cntWaysConsArray(A, N);

    return 0;
}

Java

// Java Program to implement the
// above approach
import java.util.*;
class GFG
{

// Function to find count the ways to construct
// an array, B[] such that abs(A[i] - B[i]) <=1
// and product of elements of B[] is even
static void cntWaysConsArray(int A[], int N)
{

    // Stores count of arrays B[] such
    // that abs(A[i] - B[i]) <=1
    int total = 1;

    // Stores count of arrays B[] whose
    // product of elements is not even
    int oddArray = 1;

    // Traverse the array
    for (int i = 0; i < N; i++)
    {

        // Update total
        total = total * 3;

        // If A[i] is an even number
        if (A[i] % 2 == 0)
        {

            // Update oddArray
            oddArray *= 2;
        }
    }

    // Print 3^N - 2^X
    System.out.println( total - oddArray);
}

// Driver Code
public static void main(String[] args)
{
    int A[] = { 2, 4 };
    int N = A.length;
    cntWaysConsArray(A, N);
}
}

// This code is contributed by code_hunt.

Python3

# Python3 program to implement
# the above approach

# Function to find count the ways to construct
# an array, B[] such that abs(A[i] - B[i]) <=1
# and product of elements of B[] is even
def cntWaysConsArray(A, N) :

    # Stores count of arrays B[] such
    # that abs(A[i] - B[i]) <=1
    total = 1;

    # Stores count of arrays B[] whose
    # product of elements is not even
    oddArray = 1;

    # Traverse the array
    for i in range(N) :

        # Update total
        total = total * 3;

        # If A[i] is an even number
        if (A[i] % 2 == 0) :

            # Update oddArray
            oddArray *= 2;

    # Print 3^N - 2^X
    print(total - oddArray);

# Driver Code
if __name__ == "__main__" :
    A = [ 2, 4 ];
    N = len(A);
    cntWaysConsArray(A, N);

    # This code is contributed by AnkThon

C#

// C# program to implement the
// above approach
using System;

class GFG{

// Function to find count the ways to construct
// an array, []B such that abs(A[i] - B[i]) <=1
// and product of elements of []B is even
static void cntWaysConsArray(int []A, int N)
{

    // Stores count of arrays []B such
    // that abs(A[i] - B[i]) <=1
    int total = 1;

    // Stores count of arrays []B whose
    // product of elements is not even
    int oddArray = 1;

    // Traverse the array
    for(int i = 0; i < N; i++)
    {

        // Update total
        total = total * 3;

        // If A[i] is an even number
        if (A[i] % 2 == 0)
        {

            // Update oddArray
            oddArray *= 2;
        }
    }

    // Print 3^N - 2^X
    Console.WriteLine(total - oddArray);
}

// Driver Code
public static void Main(String[] args)
{
    int []A = { 2, 4 };
    int N = A.Length;

    cntWaysConsArray(A, N);
}
}

// This code is contributed by shikhasingrajput

Javascript

<script>

// Javascript Program to implement the
// above approach

// Function to find count the ways to construct
// an array, B such that abs(A[i] - B[i]) <=1
// and product of elements of B is even
function cntWaysConsArray(A, N)
{

    // Stores count of arrays B such
    // that abs(A[i] - B[i]) <=1
    var total = 1;

    // Stores count of arrays B whose
    // product of elements is not even
    var oddArray = 1;

    // Traverse the array
    for(i = 0; i < N; i++)
    {

        // Update total
        total = total * 3;

        // If A[i] is an even number
        if (A[i] % 2 == 0)
        {

            // Update oddArray
            oddArray *= 2;
        }
    }

    // Print var 3^N - 2^X
    document.write(total - oddArray);
}

// Driver Code
var A = [ 2, 4 ];
var N = A.length;

cntWaysConsArray(A, N);

// This code is contributed by umadevi9616

</script>

Output:

5

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