# 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:7Explanation:

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)

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**.