# Count arrays having at least K elements exceeding XOR of all given array elements by X given operations

Given an array arr[] of size N, the task is to count the number of arrays having at least K elements greater than the XOR of all array elements, generated by performing the following operations X times.

• Select either first or last element from the given array.
• Either increment the selected element by 1 or delete the selected element.

Examples:

Input: arr[] = {10, 2, 10, 5}, X = 3, K = 3
Output: 1
Explanation:
XOR of the given array = 7. The only possible array satisfying the condition is {10, 2, 10, 8}, obtained by incrementing the last array element thrice.

Input: arr[] = {3, 3, 4}, X = 3, K = 2
Output:

Approach: The idea is to use the backtracking approach to recursively try out all the possible moves and increment the count when the required array is obtained. Possible moves are:

• Initialize a variable, say xorValue, to calculate the XOR of the original array.
• Initialize a variable, say count, to store the final count of the required arrays.
• Recursively try all the following four possibilities and increment the count when the required array is obtained:
• Delete the first element of the array.
• Delete the last element of the array.
• Increment the first array element by one.
• Increment last array element by one.
• Print the final count as the answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Stores the final answer``int` `ans = 0;` `// Utility function to count arrays``// having at least K elements exceeding``// XOR of all given array elements``void` `countArraysUtil(vector<``int``>& arr,``                     ``int` `X, ``int` `K,``                     ``int` `xorVal)``{``    ``// If no operations are left``    ``if` `(X == 0) {` `        ``// Stores the count of``        ``// possible arrays``        ``int` `cnt = 0;` `        ``// Count array elements are``        ``// greater than XOR``        ``for` `(``int` `i = 0; i < arr.size(); i++) {` `            ``if` `(arr[i] > xorVal)``                ``cnt++;``        ``}``        ``if` `(cnt >= K)``            ``ans++;``        ``return``;``    ``}``    ` `    ``// Stores first element``    ``int` `temp = arr[0];` `    ``// Delete first element``    ``arr.erase(arr.begin());` `    ``// Recursive call``    ``countArraysUtil(arr, X - 1, ``                    ``K, xorVal);` `    ``// Insert first element into vector``    ``arr.insert(arr.begin(), temp);` `    ``// Stores the last element``    ``temp = arr.back();` `    ``// Remove last element from vector``    ``arr.pop_back();` `    ``// Recursive call``    ``countArraysUtil(arr, X - 1, ``                    ``K, xorVal);` `    ``// Push last element into vector``    ``arr.push_back(temp);` `    ``// Increment first element``    ``arr[0]++;``  ` `    ``// Recursive call``    ``countArraysUtil(arr, X - 1,``                    ``K, xorVal);``  ` `    ``// Decrement first element``    ``arr[0]--;` `    ``// Increment last element``    ``arr[arr.size() - 1]++;``  ` `    ``// Recursive call``    ``countArraysUtil(arr, X - 1,``                    ``K, xorVal);``  ` `    ``// Decrement last element``    ``arr[arr.size() - 1]--;``}` `// Function to find the count of ``// arrays having atleast K elements ``// greater than XOR of array``void` `countArrays(vector<``int``>& arr, ``                 ``int` `X, ``int` `K)``{``    ``// Stores the XOR value``// of original array``    ``int` `xorVal = 0;` `    ``// Traverse the vector``    ``for` `(``int` `i = 0; i < arr.size(); i++)``        ``xorVal = xorVal ^ arr[i];` `    ``countArraysUtil(arr, X, K, xorVal);` `    ``// Print the answer``    ``cout << ans;``}` `// Driver Code``int` `main()``{``    ``// Given vector``    ``vector<``int``> arr = { 10, 2, 10, 5 };` `    ``// Given value of X & K``    ``int` `X = 3, K = 3;` `    ``countArrays(arr, X, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.ArrayList;``class` `GFG{` `// Stores the final answer``static` `int` `ans = ``0``;` `// Utility function to count arrays``// having at least K elements exceeding``// XOR of all given array elements``public` `static` `void` `countArraysUtil(ArrayList arr,``                     ``int` `X, ``int` `K,``                     ``int` `xorVal)``{``    ``// If no operations are left``    ``if` `(X == ``0``) {` `        ``// Stores the count of``        ``// possible arrays``        ``int` `cnt = ``0``;` `        ``// Count array elements are``        ``// greater than XOR``        ``for` `(``int` `i = ``0``; i < arr.size(); i++) {` `            ``if` `(arr.get(i) > xorVal)``                ``cnt++;``        ``}``        ``if` `(cnt >= K)``            ``ans++;``        ``return``;``    ``}``    ` `    ``// Stores first element``    ``int` `temp = arr.get(``0``);` `    ``// Delete first element``    ``arr.remove(``0``);` `    ``// Recursive call``    ``countArraysUtil(arr, X - ``1``, ``                    ``K, xorVal);` `    ``// Insert first element into vector``    ``arr.add(``0``, temp);` `    ``// Stores the last element``    ``temp = arr.get(arr.size() - ``1``);` `    ``// Remove last element from vector``    ``arr.remove(arr.size() - ``1``);` `    ``// Recursive call``    ``countArraysUtil(arr, X - ``1``, ``                    ``K, xorVal);` `    ``// Push last element into vector``    ``arr.add(temp);` `    ``// Increment first element``    ``arr.set(``0``, arr.get(``0``) + ``1``);``  ` `    ``// Recursive call``    ``countArraysUtil(arr, X - ``1``,``                    ``K, xorVal);``  ` `    ``// Decrement first element``    ``arr.set(``0``, arr.get(``0``) - ``1``);`  `    ``// Increment last element``    ``arr.set(arr.size() - ``1``, arr.get(arr.size() - ``1``) + ``1``);``  ` `    ``// Recursive call``    ``countArraysUtil(arr, X - ``1``,``                    ``K, xorVal);``  ` `    ``// Decrement last element``    ``arr.set(arr.size() - ``1``, arr.get(arr.size() - ``1``) - ``1``);` `}` `// Function to find the count of ``// arrays having atleast K elements ``// greater than XOR of array``public` `static` `void` `countArrays(ArrayList arr, ``                 ``int` `X, ``int` `K)``{``    ``// Stores the XOR value``// of original array``    ``int` `xorVal = ``0``;` `    ``// Traverse the vector``    ``for` `(``int` `i = ``0``; i < arr.size(); i++)``        ``xorVal = xorVal ^ arr.get(i);` `    ``countArraysUtil(arr, X, K, xorVal);` `    ``// Print the answer``    ``System.out.println(ans);``}` `// Driver Code``public` `static` `void` `main(String arg[])``{``  ` `    ``// Given vector``    ``int``[] input = {``10``, ``2``, ``10``, ``5``};``    ` `    ``// Convert the input as ArrayList``    ``ArrayList arr = ``new` `ArrayList();` `    ``for``(``int` `i : input){``        ``arr.add(i);``    ``}``     `  `    ``// Given value of X & K``    ``int` `X = ``3``, K = ``3``;` `    ``countArrays(arr, X, K);``}``}` `// This code is contributed by gfgking.`

## Python3

 `# Python program for the above approach` `# Stores the final answer``ans ``=` `0` `# Utility function to count arrays``# having at least K elements exceeding``# XOR of all given array elements``def` `countArraysUtil( arr, X, K, xorVal):``    ``global` `ans``    ` `    ``# If no operations are left``    ``if` `(X ``=``=` `0``):``      ` `        ``# Stores the count of``        ``# possible arrays``        ``cnt ``=` `0` `        ``# Count array elements are``        ``# greater than XOR``        ``for` `i ``in` `range``(``len``(arr)):``            ``if` `(arr[i] > xorVal):``                ``cnt ``+``=` `1``        ``if` `(cnt >``=` `K):``            ``ans ``+``=` `1``        ``return``    ` `    ``# Stores first element``    ``temp ``=` `arr[``0``]` `    ``# Delete first element``    ``arr.pop(``0``)` `    ``# Recursive call``    ``countArraysUtil(arr, X ``-` `1``, K, xorVal)` `    ``# Insert first element into vector``    ``arr.insert(``0``, temp)` `    ``# Stores the last element``    ``temp ``=` `arr[``-``1``]` `    ``# Remove last element from vector``    ``arr.pop()` `    ``# Recursive call``    ``countArraysUtil(arr, X ``-` `1``, K, xorVal)` `    ``# Push last element into vector``    ``arr.append(temp)` `    ``# Increment first element``    ``arr[``0``] ``+``=` `1``  ` `    ``# Recursive call``    ``countArraysUtil(arr, X ``-` `1``,K, xorVal)``  ` `    ``# Decrement first element``    ``arr[``0``] ``-``=` `1` `    ``# Increment last element``    ``arr[``len``(arr) ``-` `1``] ``+``=` `1``  ` `    ``# Recursive call``    ``countArraysUtil(arr, X ``-` `1``, K, xorVal)``  ` `    ``# Decrement last element``    ``arr[``len``(arr) ``-` `1``] ``-``=` `1` `# Function to find the count of ``# arrays having atleast K elements ``# greater than XOR of array``def` `countArrays(arr, X, K):``  ` `    ``# Stores the XOR value``    ``# of original array``    ``xorVal ``=` `0` `    ``# Traverse the vector``    ``for` `i ``in` `range``(``len``(arr)):``        ``xorVal ``=` `xorVal ^ arr[i]``    ``countArraysUtil(arr, X, K, xorVal)` `    ``# Print the answer``    ``print``(ans)``    ` `# Driver Code``# Given vector``arr ``=` `[ ``10``, ``2``, ``10``, ``5` `]` `# Given value of X & K``X ``=` `3``K ``=` `3``countArrays(arr, X, K)` `# This code is contributed by rohitsingh07052.`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``  ` `    ``// Stores the final answer``    ``static` `int` `ans = 0;` `    ``// Utility function to count arrays``    ``// having at least K elements exceeding``    ``// XOR of all given array elements``    ``static` `void` `countArraysUtil(List<``int``> arr, ``int` `X, ``int` `K,``                                ``int` `xorVal)``    ``{``        ``// If no operations are left``        ``if` `(X == 0) {` `            ``// Stores the count of``            ``// possible arrays``            ``int` `cnt = 0;` `            ``// Count array elements are``            ``// greater than XOR``            ``for` `(``int` `i = 0; i < arr.Count; i++) {` `                ``if` `(arr[i] > xorVal)``                    ``cnt++;``            ``}``            ``if` `(cnt >= K)``                ``ans++;``            ``return``;``        ``}` `        ``// Stores first element``        ``int` `temp = arr[0];` `        ``// Delete first element``        ``arr.RemoveAt(0);` `        ``// Recursive call``        ``countArraysUtil(arr, X - 1, K, xorVal);` `        ``// Insert first element into vector``        ``arr.Insert(0, temp);` `        ``// Stores the last element``        ``temp = arr[arr.Count - 1];` `        ``// Remove last element from vector``        ``arr.RemoveAt(arr.Count - 1);` `        ``// Recursive call``        ``countArraysUtil(arr, X - 1, K, xorVal);` `        ``// Push last element into vector``        ``arr.Add(temp);` `        ``// Increment first element``        ``arr[0]++;` `        ``// Recursive call``        ``countArraysUtil(arr, X - 1, K, xorVal);` `        ``// Decrement first element``        ``arr[0]--;` `        ``// Increment last element``        ``arr[arr.Count - 1]++;` `        ``// Recursive call``        ``countArraysUtil(arr, X - 1, K, xorVal);` `        ``// Decrement last element``        ``arr[arr.Count - 1]--;``    ``}` `    ``// Function to find the count of``    ``// arrays having atleast K elements``    ``// greater than XOR of array``    ``static` `void` `countArrays(List<``int``> arr, ``int` `X, ``int` `K)``    ``{``        ``// Stores the XOR value``        ``// of original array``        ``int` `xorVal = 0;` `        ``// Traverse the vector``        ``for` `(``int` `i = 0; i < arr.Count; i++)``            ``xorVal = xorVal ^ arr[i];` `        ``countArraysUtil(arr, X, K, xorVal);` `        ``// Print the answer``        ``Console.Write(ans);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``      ` `        ``// Given vector``        ``List<``int``> arr = ``new` `List<``int``>() { 10, 2, 10, 5 };` `        ``// Given value of X & K``        ``int` `X = 3, K = 3;``        ``countArrays(arr, X, K);``    ``}``}` `// This code is contributed by chitranayal.`

## Javascript

 ``

Output:
`1`

Time Complexity: O(4K * N)
Auxiliary Space: O(1)

Previous
Next
Share your thoughts in the comments
Similar Reads