Given an array **arr[]** and an integer **M**, the task is to find the longest subsequence with a given AND value **M**. If there is no such sub-sequence then print **0**. **Examples:**

Input:arr[] = {3, 7, 2, 3}, M = 3Output:3

Longest sub-sequence with AND value 3 is {3, 7, 3}.Input:arr[] = {2, 2}, M = 3Output:0

**Approach:** A simple way to solve this will be to generate all the possible sub-sequences and then find the largest among them with required AND value.

However, for smaller values of **M**, an approach based on dynamic programming can be used.

Let’s look at the recurrence relation first.

dp[i][curr_and] = max(dp[i + 1][curr_and], dp[i + 1][curr_and & arr[i]] + 1)

Let’s understand the states of DP now. Here, **dp[i][curr_and]** stores the longest subsequence of subarray **arr[i…N-1]** such that **curr_and** & the AND of this subsequence is equal to **M**. At each step, either the index **i** can be chosen updating **curr_and** or it can be rejected.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `#define maxN 20` `#define maxM 64` `// To store the states of DP` `int` `dp[maxN][maxM];` `bool` `v[maxN][maxM];` `// Function to return the required length` `int` `findLen(` `int` `* arr, ` `int` `i, ` `int` `curr,` ` ` `int` `n, ` `int` `m)` `{` ` ` `// Base case` ` ` `if` `(i == n) {` ` ` `if` `(curr == m)` ` ` `return` `0;` ` ` `else` ` ` `return` `-1;` ` ` `}` ` ` `// If the state has been solved before` ` ` `// return the value of the state` ` ` `if` `(v[i][curr])` ` ` `return` `dp[i][curr];` ` ` `// Setting the state as solved` ` ` `v[i][curr] = 1;` ` ` `// Recurrence relation` ` ` `int` `l = findLen(arr, i + 1, curr, n, m);` ` ` `int` `r = findLen(arr, i + 1, curr & arr[i],` ` ` `n, m);` ` ` `dp[i][curr] = l;` ` ` `if` `(r != -1)` ` ` `dp[i][curr] = max(dp[i][curr], r + 1);` ` ` `return` `dp[i][curr];` `}` `// Driver code` `int` `main()` `{` ` ` `int` `arr[] = { 3, 7, 2, 3 };` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(` `int` `);` ` ` `int` `m = 3;` ` ` `int` `ans = findLen(arr, 0, ((1 << 8) - 1),` ` ` `n, m);` ` ` `if` `(ans == -1)` ` ` `cout << 0;` ` ` `else` ` ` `cout << ans;` ` ` `return` `0;` `}` |

## Java

`// Java implementation of the approach` `import` `java.util.*;` `class` `GFG` `{` `static` `int` `maxN = ` `300` `;` `static` `int` `maxM = ` `300` `;` `// To store the states of DP` `static` `int` `dp[][] = ` `new` `int` `[maxN][maxM];` `static` `boolean` `v[][] = ` `new` `boolean` `[maxN][maxM];` `// Function to return the required length` `static` `int` `findLen(` `int` `[] arr, ` `int` `i,` ` ` `int` `curr, ` `int` `n, ` `int` `m)` `{` ` ` `// Base case` ` ` `if` `(i == n)` ` ` `{` ` ` `if` `(curr == m)` ` ` `return` `0` `;` ` ` `else` ` ` `return` `-` `1` `;` ` ` `}` ` ` `// If the state has been solved before` ` ` `// return the value of the state` ` ` `if` `(v[i][curr])` ` ` `return` `dp[i][curr];` ` ` `// Setting the state as solved` ` ` `v[i][curr] = ` `true` `;` ` ` `// Recurrence relation` ` ` `int` `l = findLen(arr, i + ` `1` `, curr, n, m);` ` ` `int` `r = findLen(arr, i + ` `1` `, curr & arr[i], n, m);` ` ` `dp[i][curr] = l;` ` ` `if` `(r != -` `1` `)` ` ` `dp[i][curr] = Math.max(dp[i][curr], r + ` `1` `);` ` ` `return` `dp[i][curr];` `}` `// Driver code` `public` `static` `void` `main(String args[])` `{` ` ` `int` `arr[] = { ` `3` `, ` `7` `, ` `2` `, ` `3` `};` ` ` `int` `n = arr.length;` ` ` `int` `m = ` `3` `;` ` ` `int` `ans = findLen(arr, ` `0` `, ((` `1` `<< ` `8` `) - ` `1` `), n, m);` ` ` `if` `(ans == -` `1` `)` ` ` `System.out.print( ` `0` `);` ` ` `else` ` ` `System.out.print( ans);` `}` `}` `// This code is contributed by Arnab Kundu` |

## Python3

`# Python3 implementation of the approach` `import` `numpy as np` `maxN ` `=` `20` `maxM ` `=` `256` `# To store the states of DP` `dp ` `=` `np.zeros((maxN, maxM));` `v ` `=` `np.zeros((maxN, maxM));` `# Function to return the required length` `def` `findLen(arr, i, curr, n, m) :` ` ` `# Base case` ` ` `if` `(i ` `=` `=` `n) :` ` ` `if` `(curr ` `=` `=` `m) :` ` ` `return` `0` `;` ` ` `else` `:` ` ` `return` `-` `1` `;` ` ` `# If the state has been solved before` ` ` `# return the value of the state` ` ` `if` `(v[i][curr]) :` ` ` `return` `dp[i][curr];` ` ` `# Setting the state as solved` ` ` `v[i][curr] ` `=` `1` `;` ` ` `# Recurrence relation` ` ` `l ` `=` `findLen(arr, i ` `+` `1` `, curr, n, m);` ` ` `r ` `=` `findLen(arr, i ` `+` `1` `, curr & arr[i], n, m);` ` ` ` ` `dp[i][curr] ` `=` `l;` ` ` ` ` `if` `(r !` `=` `-` `1` `) :` ` ` `dp[i][curr] ` `=` `max` `(dp[i][curr], r ` `+` `1` `);` ` ` ` ` `return` `dp[i][curr];` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `arr ` `=` `[ ` `3` `, ` `7` `, ` `2` `, ` `3` `];` ` ` `n ` `=` `len` `(arr);` ` ` `m ` `=` `3` `;` ` ` `ans ` `=` `findLen(arr, ` `0` `, ((` `1` `<< ` `8` `) ` `-` `1` `), n, m);` ` ` ` ` `if` `(ans ` `=` `=` `-` `1` `) :` ` ` `print` `(` `0` `);` ` ` `else` `:` ` ` `print` `(ans);` `# This code is contributed by AnkitRai01` |

## C#

`// C# implementation of the approach` `using` `System;` `class` `GFG` `{` `static` `int` `maxN = 300;` `static` `int` `maxM = 300;` `// To store the states of DP` `static` `int` `[,] dp = ` `new` `int` `[maxN, maxM];` `static` `bool` `[,] v = ` `new` `bool` `[maxN, maxM];` `// Function to return the required length` `static` `int` `findLen(` `int` `[] arr, ` `int` `i,` ` ` `int` `curr, ` `int` `n, ` `int` `m)` `{` ` ` `// Base case` ` ` `if` `(i == n)` ` ` `{` ` ` `if` `(curr == m)` ` ` `return` `0;` ` ` `else` ` ` `return` `-1;` ` ` `}` ` ` `// If the state has been solved before` ` ` `// return the value of the state` ` ` `if` `(v[i, curr])` ` ` `return` `dp[i, curr];` ` ` `// Setting the state as solved` ` ` `v[i, curr] = ` `true` `;` ` ` `// Recurrence relation` ` ` `int` `l = findLen(arr, i + 1, curr, n, m);` ` ` `int` `r = findLen(arr, i + 1, curr & arr[i], n, m);` ` ` `dp[i, curr] = l;` ` ` `if` `(r != -1)` ` ` `dp[i, curr] = Math.Max(dp[i, curr], r + 1);` ` ` `return` `dp[i, curr];` `}` `// Driver code` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `[] arr = { 3, 7, 2, 3 };` ` ` `int` `n = arr.Length;` ` ` `int` `m = 3;` ` ` `int` `ans = findLen(arr, 0, ((1 << 8) - 1), n, m);` ` ` `if` `(ans == -1)` ` ` `Console.WriteLine(0);` ` ` `else` ` ` `Console.WriteLine(ans);` `}` `}` `// This code is contributed by` `// sanjeev2552` |

## Javascript

`<script>` `// Javascript implementation of the approach` `var` `maxN = 20` `var` `maxM = 64` `// To store the states of DP` `var` `dp = Array.from(Array(maxN), ()=> Array(maxM));` `var` `v = Array.from(Array(maxN), ()=> Array(maxM));` `// Function to return the required length` `function` `findLen(arr, i, curr, n, m)` `{` ` ` `// Base case` ` ` `if` `(i == n) {` ` ` `if` `(curr == m)` ` ` `return` `0;` ` ` `else` ` ` `return` `-1;` ` ` `}` ` ` `// If the state has been solved before` ` ` `// return the value of the state` ` ` `if` `(v[i][curr])` ` ` `return` `dp[i][curr];` ` ` `// Setting the state as solved` ` ` `v[i][curr] = 1;` ` ` `// Recurrence relation` ` ` `var` `l = findLen(arr, i + 1, curr, n, m);` ` ` `var` `r = findLen(arr, i + 1, curr & arr[i],` ` ` `n, m);` ` ` `dp[i][curr] = l;` ` ` `if` `(r != -1)` ` ` `dp[i][curr] = Math.max(dp[i][curr], r + 1);` ` ` `return` `dp[i][curr];` `}` `// Driver code` `var` `arr = [3, 7, 2, 3];` `var` `n = arr.length;` `var` `m = 3;` `var` `ans = findLen(arr, 0, ((1 << 8) - 1),` ` ` `n, m);` `if` `(ans == -1)` ` ` `document.write( 0);` `else` ` ` `document.write( ans);` `</script>` |

**Output:**

3

**Time Complexity:** O(N * maxVal) where maxVal is the maximum element from the given array.

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 industry experts, please refer **Geeks Classes Live** and **Geeks Classes Live USA**