Given an array **arr[]** consisiting of **N** integers and two integer values **L** and **R**, indicating the starting and ending indices of a subarray, the task is to check if there exists a non-contiguous subsequence which is same as the given subarray or not. If found to be true, print **“Yes”**. Otherwise, print **“No”**.

A

non-contiguous subsequencecontains at least two consecutive characters from non-consecutive indices.

**Examples:**

Input:arr[] = {1, 7, 12, 1, 7, 5, 10, 11, 42}, L = 3, R = 6Output:YesExplanation:The non-contiguous subsequence {arr[0], arr[1], arr[5], arr[6]} is same as the subarray {arr[3], .., arr[6]}.

Input:arr[] = {0, 1, 2, -2, 5, 10}, L = 1, R = 3

**Naive Approach:** The simplest approach is to generate all possible subsequences of the given array and check if any subsequence generated is equal to the given subarray or not. If found to be true, then print **“Yes”**. Otherwise, print **“No”**.

**Time Complexity:** O(N*2^{N})**Auxiliary Space:** O(1)

**Efficient Approach:** To optimize the above approach, the idea is based on the key observation that there will always be a non-contiguous subsequence if there is at least one occurrence of the first element of the given subarray in the range **[0, L – 1]** and at least one occurrence of the last element of a subarray in the range **[R + 1, N]**.

**Proof of Logic:**

If the 1

^{st}element of the subarray{arr[L], … arr[R]}also occurs at any indexK(K < L), then one such non-contiguous subsequence can be{arr[K], arr[L + 1], …., arr[R]}.

If the last element of the subarray{arr[L], … arr[R]}also occurs at any indexK(K > R), then one such non-contiguous subsequence can be strong>{arr[L], arr[L + 1], …., arr[R – 1], arr[K]}.

If none of the above two conditions are satisfied, then no such non-contiguous subsequence exists.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Utility Function to check whether` `// a subsequence same as the given` `// subarray exists or not` `bool` `checkSubsequenceUtil(` ` ` `int` `arr[], ` `int` `L, ` `int` `R, ` `int` `N)` `{` ` ` `// Check if first element of the` ` ` `// subarray is also present before` ` ` `for` `(` `int` `i = 0; i < L; i++)` ` ` `if` `(arr[i] == arr[L])` ` ` `return` `true` `;` ` ` `// Check if last element of the` ` ` `// subarray is also present later` ` ` `for` `(` `int` `i = R + 1; i < N; i++)` ` ` `if` `(arr[i] == arr[R])` ` ` `return` `true` `;` ` ` `// If above two conditions are` ` ` `// not satisfied, then no such` ` ` `// subsequence exists` ` ` `return` `false` `;` `}` `// Function to check and print if a` `// subsequence which is same as the` `// given subarray is present or not` `void` `checkSubsequence(` `int` `arr[], ` `int` `L,` ` ` `int` `R, ` `int` `N)` `{` ` ` `if` `(checkSubsequenceUtil(arr, L,` ` ` `R, N)) {` ` ` `cout << ` `"YES\n"` `;` ` ` `}` ` ` `else` `{` ` ` `cout << ` `"NO\n"` `;` ` ` `}` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `arr[] = { 1, 7, 12, 1, 7,` ` ` `5, 10, 11, 42 };` ` ` `int` `N = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `int` `L = 3, R = 6;` ` ` `// Function Call` ` ` `checkSubsequence(arr, L, R, N);` `}` |

## Java

`// Java program for the above approach` `class` `GFG{` ` ` `// Utility Function to check whether` `// a subsequence same as the given` `// subarray exists or not` `static` `boolean` `checkSubsequenceUtil(` `int` `arr[], ` `int` `L,` ` ` `int` `R, ` `int` `N)` `{` ` ` ` ` `// Check if first element of the` ` ` `// subarray is also present before` ` ` `for` `(` `int` `i = ` `0` `; i < L; i++)` ` ` `if` `(arr[i] == arr[L])` ` ` `return` `true` `;` ` ` ` ` `// Check if last element of the` ` ` `// subarray is also present later` ` ` `for` `(` `int` `i = R + ` `1` `; i < N; i++)` ` ` `if` `(arr[i] == arr[R])` ` ` `return` `true` `;` ` ` ` ` `// If above two conditions are` ` ` `// not satisfied, then no such` ` ` `// subsequence exists` ` ` `return` `false` `;` `}` ` ` `// Function to check and print if a` `// subsequence which is same as the` `// given subarray is present or not` `static` `void` `checkSubsequence(` `int` `arr[], ` `int` `L,` ` ` `int` `R, ` `int` `N)` `{` ` ` `if` `(checkSubsequenceUtil(arr, L,` ` ` `R, N))` ` ` `{` ` ` `System.out.print(` `"YES\n"` `);` ` ` `}` ` ` `else` ` ` `{` ` ` `System.out.print(` `"NO\n"` `);` ` ` `}` `}` ` ` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `arr[] = { ` `1` `, ` `7` `, ` `12` `, ` `1` `, ` `7` `,` ` ` `5` `, ` `10` `, ` `11` `, ` `42` `};` ` ` `int` `N = arr.length;` ` ` `int` `L = ` `3` `, R = ` `6` `;` ` ` ` ` `// Function Call` ` ` `checkSubsequence(arr, L, R, N);` `}` `}` ` ` `// This code is contributed by sanjoy_62` |

## Python3

`# Python3 program for the above approach` ` ` `# Utility Function to check whether` `# a subsequence same as the given` `# subarray exists or not` `def` `checkSubsequenceUtil(arr, L, R, N):` ` ` ` ` `# Check if first element of the` ` ` `# subarray is also present before` ` ` `for` `i ` `in` `range` `(L):` ` ` `if` `(arr[i] ` `=` `=` `arr[L]):` ` ` `return` `True` ` ` ` ` `# Check if last element of the` ` ` `# subarray is also present later` ` ` `for` `i ` `in` `range` `(R ` `+` `1` `, N, ` `1` `):` ` ` `if` `(arr[i] ` `=` `=` `arr[R]):` ` ` `return` `True` ` ` ` ` `# If above two conditions are` ` ` `# not satisfied, then no such` ` ` `# subsequence exists` ` ` `return` `False` `# Function to check and prif a` `# subsequence which is same as the` `# given subarray is present or not` `def` `checkSubsequence(arr, L, R, N):` ` ` ` ` `if` `(checkSubsequenceUtil(arr, L,R, N)):` ` ` `print` `(` `"YES"` `)` ` ` `else` `:` ` ` `print` `(` `"NO"` `)` ` ` `# Driver Code` `arr ` `=` `[ ` `1` `, ` `7` `, ` `12` `, ` `1` `, ` `7` `,` ` ` `5` `, ` `10` `, ` `11` `, ` `42` `]` `N ` `=` `len` `(arr)` `L ` `=` `3` `R ` `=` `6` ` ` `# Function Call` `checkSubsequence(arr, L, R, N)` `# This code is contributed by susmitakundugoaldanga` |

## C#

`// C# program for the above approach` `using` `System;` `class` `GFG{` ` ` `// Utility Function to check whether` `// a subsequence same as the given` `// subarray exists or not` `static` `bool` `checkSubsequenceUtil(` `int` `[] arr, ` `int` `L,` ` ` `int` `R, ` `int` `N)` `{` ` ` ` ` `// Check if first element of the` ` ` `// subarray is also present before` ` ` `for` `(` `int` `i = 0; i < L; i++)` ` ` `if` `(arr[i] == arr[L])` ` ` `return` `true` `;` ` ` ` ` `// Check if last element of the` ` ` `// subarray is also present later` ` ` `for` `(` `int` `i = R + 1; i < N; i++)` ` ` `if` `(arr[i] == arr[R])` ` ` `return` `true` `;` ` ` ` ` `// If above two conditions are` ` ` `// not satisfied, then no such` ` ` `// subsequence exists` ` ` `return` `false` `;` `}` ` ` `// Function to check and print if a` `// subsequence which is same as the` `// given subarray is present or not` `static` `void` `checkSubsequence(` `int` `[] arr, ` `int` `L,` ` ` `int` `R, ` `int` `N)` `{` ` ` `if` `(checkSubsequenceUtil(arr, L,` ` ` `R, N))` ` ` `{` ` ` `Console.Write(` `"YES\n"` `);` ` ` `}` ` ` `else` ` ` `{` ` ` `Console.Write(` `"NO\n"` `);` ` ` `}` `}` ` ` `// Driver code` `public` `static` `void` `Main()` `{` ` ` `int` `[] arr = { 1, 7, 12, 1, 7,` ` ` `5, 10, 11, 42 };` ` ` ` ` `int` `N = arr.Length;` ` ` `int` `L = 3, R = 6;` ` ` ` ` `// Function Call` ` ` `checkSubsequence(arr, L, R, N);` `}` `}` `// This code is contributed by code_hunt` |

## Javascript

`<script>` `// javascript program to implement` `// the above approach` `// Utility Function to check whether` `// a subsequence same as the given` `// subarray exists or not` `function` `checkSubsequenceUtil(arr, L,` ` ` `R, N)` `{` ` ` ` ` `// Check if first element of the` ` ` `// subarray is also present before` ` ` `for` `(let i = 0; i < L; i++)` ` ` `if` `(arr[i] == arr[L])` ` ` `return` `true` `;` ` ` ` ` `// Check if last element of the` ` ` `// subarray is also present later` ` ` `for` `(let i = R + 1; i < N; i++)` ` ` `if` `(arr[i] == arr[R])` ` ` `return` `true` `;` ` ` ` ` `// If above two conditions are` ` ` `// not satisfied, then no such` ` ` `// subsequence exists` ` ` `return` `false` `;` `}` ` ` `// Function to check and prlet if a` `// subsequence which is same as the` `// given subarray is present or not` `function` `checkSubsequence(arr, L,` ` ` `R, N)` `{` ` ` `if` `(checkSubsequenceUtil(arr, L,` ` ` `R, N))` ` ` `{` ` ` `document.write(` `"YES\n"` `);` ` ` `}` ` ` `else` ` ` `{` ` ` `document.write(` `"NO\n"` `);` ` ` `}` `}` `// Driver code` ` ` `let arr = [ 1, 7, 12, 1, 7,` ` ` `5, 10, 11, 42 ];` ` ` `let N = arr.length;` ` ` `let L = 3, R = 6;` ` ` ` ` `// Function Call` ` ` `checkSubsequence(arr, L, R, N);` ` ` ` ` `// This code is contributed by souravghosh0416.` `</script>` |

**Output:**

YES

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