# Check if Array can be split into subarrays such that XOR of length of Longest Decreasing Subsequences of those subarrays is 0

• Last Updated : 17 Dec, 2021

Given an array of integers arr[] of size N, the task is to check whether arr[] can be split into different subarrays such that on taking the XOR of lengths of LDS (Longest decreasing subsequences) of all the subarrays is equal to 0. Print ‘YES‘ if it is possible to split else print ‘NO‘.

Examples:

Input: arr[] = {1, 0, 3, 4, 5}
Output: YES
Explanation: {1}, {0}, {3}, {4, 5} length of LDS of subarrays: 1, 1, 1, 1, XOR of lengths = 0. So answer is Yes.

Input: arr[] = {5, 4, 3}
Output: NO

Approach: The XOR operation of even number of 1’s is 0. So if the array length is even then each element can be considered as LDS of size 1 which makes XOR of even 1’s equal to 0 and for odd length arrays to have even LDS’s with 1’s any subarray of size 2 can be considered with LDS i.e. the subarray should be strictly increasing so the LDS will be 1. Follow the steps below to solve the problem:

• Initialize a variable found as false.
• If N is even print ‘YES’ and return.
• Else, Iterate over the range (0, N – 1] using the variable i and perform the following tasks:
• Check if there is consecutive increasing elements by arr[i]>arr[i-1]
• If arr[i]>arr[i-1] make found as true and come out of the loop
• If found is true print “YES”, else print “NO”

Below is the implementation of the above approach.

## C++

 `// C++ code for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find XOR of LDS's` `// of subarrays` `void` `xor_of_lds(``int` `arr[], ``int` `n)` `{`   `    ``// If length is even each element` `    ``// can be considered as lds of length` `    ``// 1 which makes even 1's and xor is 0` `    ``if` `(n % 2 == 0) {` `        ``cout << ``"YES"` `<< endl;` `        ``return``;` `    ``}` `    ``else` `{`   `        ``// For odd length we need to find` `        ``// even subarray of length 2 which` `        ``// is strictly increasing so that it` `        ``// makes a subarray with lds=1`   `        ``bool` `found = 0;` `        ``for` `(``int` `i = 1; i < n; i++) {`   `            ``// Check if there are 2` `            ``// consecutive increasing elements` `            ``if` `(arr[i] > arr[i - 1]) {` `                ``found = 1;` `                ``break``;` `            ``}` `        ``}` `        ``if` `(found == 1)` `            ``cout << ``"YES"` `<< endl;` `        ``else` `            ``cout << ``"NO"` `<< endl;` `    ``}` `}`   `// Driver Code` `int` `main()` `{`   `    ``// Initializing array of arr` `    ``int` `arr[] = { 1, 0, 3, 4, 5 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);`   `    ``// Call the function` `    ``xor_of_lds(arr, N);`   `    ``return` `0;` `}`

## Java

 `// Java code for the above approach` `import` `java.util.*;` `class` `GFG{`   `// Function to find XOR of LDS's` `// of subarrays` `static` `void` `xor_of_lds(``int` `arr[], ``int` `n)` `{`   `    ``// If length is even each element` `    ``// can be considered as lds of length` `    ``// 1 which makes even 1's and xor is 0` `    ``if` `(n % ``2` `== ``0``) {` `        ``System.out.print(``"YES"` `+``"\n"``);` `        ``return``;` `    ``}` `    ``else` `{`   `        ``// For odd length we need to find` `        ``// even subarray of length 2 which` `        ``// is strictly increasing so that it` `        ``// makes a subarray with lds=1`   `        ``boolean` `found = ``false``;` `        ``for` `(``int` `i = ``1``; i < n; i++) {`   `            ``// Check if there are 2` `            ``// consecutive increasing elements` `            ``if` `(arr[i] > arr[i - ``1``]) {` `                ``found = ``true``;` `                ``break``;` `            ``}` `        ``}` `        ``if` `(found == ``true``)` `            ``System.out.print(``"YES"` `+``"\n"``);` `        ``else` `            ``System.out.print(``"NO"` `+``"\n"``);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{`   `    ``// Initializing array of arr` `    ``int` `arr[] = { ``1``, ``0``, ``3``, ``4``, ``5` `};` `    ``int` `N = arr.length;`   `    ``// Call the function` `    ``xor_of_lds(arr, N);`   `}` `}`   `// This code is contributed by shikhasingrajput`

## Python3

 `# Python code for the above approach`   `# Function to find XOR of LDS's` `# of subarrays` `def` `xor_of_lds  (arr, n) :`   `    ``# If length is even each element` `    ``# can be considered as lds of length` `    ``# 1 which makes even 1's and xor is 0` `    ``if` `(n ``%` `2` `=``=` `0``):` `        ``print``(``"YES"``)` `        ``return` `    ``else``:`   `        ``# For odd length we need to find` `        ``# even subarray of length 2 which` `        ``# is strictly increasing so that it` `        ``# makes a subarray with lds=1`   `        ``found ``=` `0` `        ``for` `i ``in` `range``(``1``, n):` `            ``# Check if there are 2` `            ``# consecutive increasing elements` `            ``if` `(arr[i] > arr[i ``-` `1``]):` `                ``found ``=` `1` `                ``break` `        ``if` `(found ``=``=` `1``):` `            ``print``(``"YES"``)` `        ``else``:` `            ``print``(``"NO"``)`   `# Driver Code` `# Initializing array of arr` `arr ``=` `[``1``, ``0``, ``3``, ``4``, ``5``]` `N ``=` `len``(arr)`   `# Call the function` `xor_of_lds(arr, N)`   `# This code is contributed by Saurabh Jaiswal`

## C#

 `// C# code for the above approach` `using` `System;`   `class` `GFG` `{` `  `  `// Function to find XOR of LDS's` `// of subarrays` `static` `void` `xor_of_lds(``int` `[]arr, ``int` `n)` `{`   `    ``// If length is even each element` `    ``// can be considered as lds of length` `    ``// 1 which makes even 1's and xor is 0` `    ``if` `(n % 2 == 0) {` `        ``Console.Write(``"YES"` `+ ``"\n"``);` `        ``return``;` `    ``}` `    ``else` `{`   `        ``// For odd length we need to find` `        ``// even subarray of length 2 which` `        ``// is strictly increasing so that it` `        ``// makes a subarray with lds=1`   `        ``bool` `found = ``false``;` `        ``for` `(``int` `i = 1; i < n; i++) {`   `            ``// Check if there are 2` `            ``// consecutive increasing elements` `            ``if` `(arr[i] > arr[i - 1]) {` `                ``found = ``true``;` `                ``break``;` `            ``}` `        ``}` `        ``if` `(found == ``true``)` `            ``Console.Write(``"YES"` `+``"\n"``);` `        ``else` `            ``Console.Write(``"NO"` `+``"\n"``);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `  `  `    ``// Initializing array of arr` `    ``int` `[]arr = { 1, 0, 3, 4, 5 };` `    ``int` `N = arr.Length;`   `    ``// Call the function` `    ``xor_of_lds(arr, N);` `}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`YES`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :