# Count of pairs in an array such that the highest power of 2 that divides their product is 1

Given an array **arr[]** of **N** positive integers. The task is to find the count of pairs **(arr[i], arr[j])** such that the maximum power of **2** that divides **arr[i] * arr[j]** is **1**.**Examples:**

Input:arr[] = {3, 5, 2, 8}Output:3

(3, 2), (5, 2) and (3, 5) are the only valid pairs.

Since the power of 2 that divides 3 * 2 = 6 is 1,

5 * 2 = 10 is 1 and 3 * 5 = 15 is 0.Input:arr[] = {4, 2, 7, 11, 14, 15, 18}Output:12

**Approach:** As the maximum power of **2** that divides **arr[i] * arr[j]** is at max **1**, it means that if **P** is the product then it must either be **odd** or **2** is the only even factor of **P**.

It implies that both **arr[i]** and **arr[j]** must be **odd** or exactly one of them is **even** and **2** is the only even factor of this number.

If **odd** is the count of odd numbers and **even** is the count of even numbers such that **2** is the only even factor of that number then the answer will be **odd * even + odd * (odd – 1) / 2**.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to return the count of valid pairs` `int` `cntPairs(` `int` `a[], ` `int` `n)` `{` ` ` `// To store the count of odd numbers and` ` ` `// the count of even numbers such that 2` ` ` `// is the only even factor of that number` ` ` `int` `odd = 0, even = 0;` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `// If current number is odd` ` ` `if` `(a[i] % 2 == 1)` ` ` `odd++;` ` ` `// If current number is even and 2` ` ` `// is the only even factor of it` ` ` `else` `if` `((a[i] / 2) % 2 == 1)` ` ` `even++;` ` ` `}` ` ` `// Calculate total number of valid pairs` ` ` `int` `ans = odd * even + (odd * (odd - 1)) / 2;` ` ` `return` `ans;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `a[] = { 4, 2, 7, 11, 14, 15, 18 };` ` ` `int` `n = ` `sizeof` `(a) / ` `sizeof` `(a[0]);` ` ` `cout << cntPairs(a, n);` ` ` `return` `0;` `}` |

## Java

`// Java implementation of the approach` `class` `GFG` `{` `// Function to return the count of valid pairs` `static` `int` `cntPairs(` `int` `a[], ` `int` `n)` `{` ` ` `// To store the count of odd numbers and` ` ` `// the count of even numbers such that 2` ` ` `// is the only even factor of that number` ` ` `int` `odd = ` `0` `, even = ` `0` `;` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `{` ` ` `// If current number is odd` ` ` `if` `(a[i] % ` `2` `== ` `1` `)` ` ` `odd++;` ` ` `// If current number is even and 2` ` ` `// is the only even factor of it` ` ` `else` `if` `((a[i] / ` `2` `) % ` `2` `== ` `1` `)` ` ` `even++;` ` ` `}` ` ` `// Calculate total number of valid pairs` ` ` `int` `ans = odd * even + (odd * (odd - ` `1` `)) / ` `2` `;` ` ` `return` `ans;` `}` `// Driver code` `public` `static` `void` `main(String []args)` `{` ` ` `int` `a[] = { ` `4` `, ` `2` `, ` `7` `, ` `11` `, ` `14` `, ` `15` `, ` `18` `};` ` ` `int` `n = a.length;` ` ` `System.out.println(cntPairs(a, n));` `}` `}` `// This code is contributed by 29AjayKumar` |

## Python3

`# Python3 implementation of the approach` `# Function to return the count of valid pairs` `def` `cntPairs(a, n) :` ` ` `# To store the count of odd numbers and` ` ` `# the count of even numbers such that 2` ` ` `# is the only even factor of that number` ` ` `odd ` `=` `0` `; even ` `=` `0` `;` ` ` `for` `i ` `in` `range` `(n) :` ` ` `# If current number is odd` ` ` `if` `(a[i] ` `%` `2` `=` `=` `1` `) :` ` ` `odd ` `+` `=` `1` `;` ` ` `# If current number is even and 2` ` ` `# is the only even factor of it` ` ` `elif` `((a[i] ` `/` `2` `) ` `%` `2` `=` `=` `1` `) :` ` ` `even ` `+` `=` `1` `;` ` ` ` ` `# Calculate total number of valid pairs` ` ` `ans ` `=` `odd ` `*` `even ` `+` `(odd ` `*` `(odd ` `-` `1` `)) ` `/` `/` `2` `;` ` ` `return` `ans;` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `a ` `=` `[ ` `4` `, ` `2` `, ` `7` `, ` `11` `, ` `14` `, ` `15` `, ` `18` `];` ` ` `n ` `=` `len` `(a);` ` ` `print` `(cntPairs(a, n));` ` ` `# This code is contributed by AnkitRai01` |

## C#

`// C# implementation of the approach` `using` `System;` ` ` `class` `GFG` `{` `// Function to return the count of valid pairs` `static` `int` `cntPairs(` `int` `[]a, ` `int` `n)` `{` ` ` `// To store the count of odd numbers and` ` ` `// the count of even numbers such that 2` ` ` `// is the only even factor of that number` ` ` `int` `odd = 0, even = 0;` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` `// If current number is odd` ` ` `if` `(a[i] % 2 == 1)` ` ` `odd++;` ` ` `// If current number is even and 2` ` ` `// is the only even factor of it` ` ` `else` `if` `((a[i] / 2) % 2 == 1)` ` ` `even++;` ` ` `}` ` ` `// Calculate total number of valid pairs` ` ` `int` `ans = odd * even + (odd * (odd - 1)) / 2;` ` ` `return` `ans;` `}` `// Driver code` `public` `static` `void` `Main(String []args)` `{` ` ` `int` `[]a = { 4, 2, 7, 11, 14, 15, 18 };` ` ` `int` `n = a.Length;` ` ` `Console.WriteLine(cntPairs(a, n));` `}` `}` `// This code is contributed by Ajay KUmar` |

## Javascript

`<script>` `// Javascript implementation of the approach` `// Function to return the count of valid pairs` `function` `cntPairs(a, n)` `{` ` ` `// To store the count of odd numbers and` ` ` `// the count of even numbers such that 2` ` ` `// is the only even factor of that number` ` ` `var` `odd = 0, even = 0;` ` ` `for` `(` `var` `i = 0; i < n; i++) {` ` ` `// If current number is odd` ` ` `if` `(a[i] % 2 == 1)` ` ` `odd++;` ` ` `// If current number is even and 2` ` ` `// is the only even factor of it` ` ` `else` `if` `((a[i] / 2) % 2 == 1)` ` ` `even++;` ` ` `}` ` ` `// Calculate total number of valid pairs` ` ` `var` `ans = odd * even + (odd * (odd - 1)) / 2;` ` ` `return` `ans;` `}` `// Driver code` `var` `a = [4, 2, 7, 11, 14, 15, 18];` `var` `n = a.length;` `document.write( cntPairs(a, n));` `// This code is contributed by rrrtnx.` `</script>` |

**Output:**

12

**Time Complexity: **O(n) where n is number of elements in given array. As, we are using a loop to traverse N times so it will cost us O(N) time **Auxiliary Space: **O(1), as we are not using any extra space.