 Open in App
Not now

# 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)

My Personal Notes arrow_drop_up
Related Articles