Related Articles

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

• Last Updated : 21 Apr, 2021

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:
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 3N.
• 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 2X.
• Finally, print the value of (3N – 2X).

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``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);` `    ``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

 ``
Output:
`5`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up