Open In App

Check if any valid sequence is divisible by M

Given an array of N integers, using ‘+’ and ‘-‘ between the elements check if there is a way to form a sequence of numbers that evaluate to a number divisible by M

Examples: 

Input: arr = {1, 2, 3, 4, 6}
 M = 4
Output: True 
Explanation:
There is a valid sequence i.e., (1 – 2
+ 3 + 4 + 6), which evaluates to 12 that
is divisible by 4 

Input: arr = {1, 3, 9}
 M = 2
Output: False 
Explanation:
There is no sequence which evaluates to
a number divisible by M.

A simple solution is to recursively consider all possible scenarios ie either use a ;+’ or a ‘-‘ operator between the elements and maintain a variable sum which stores the result.If this result is divisible by M then return true else return false.

Recursive implementation is as follows:




bool isPossible(int index, int sum)
{
    // Base case
    if (index == n) {
   
        // check if sum is divisible by M
        if ((sum % M) == 0)
            return true;
        return false;
    }
 
    // recursively call by considering '+'
    // or '-' between index and index+1
 
    // 1.Try placing '+'
    bool placeAdd = isPossible(index + 1,
                        sum + arr[index]);
 
    // 2. Try placing '-'
    bool placeMinus = isPossible(index + 1,
                         sum - arr[index]);
 
    if (placeAdd || placeMinus)
        return true;
     
    return false;
}




static boolean isPossible(int index, int sum)
{
     
    // Base case
    if (index == n)
    {
         
        // Check if sum is divisible by M
        if ((sum % M) == 0)
            return true;
             
        return false;
    }
  
    // Recursively call by considering '+'
    // or '-' between index and index+1
  
    // 1.Try placing '+'
    boolean placeAdd = isPossible(index + 1,
                                 sum + arr[index]);
  
    // 2. Try placing '-'
    boolean placeMinus = isPossible(index + 1,
                                   sum - arr[index]);
  
    if (placeAdd || placeMinus)
        return true;
      
    return false;
}
 
// This code is contributed by rutvik_56.




def isPossible(index, sum):
 
    # Base case
    if (index == n):
   
        # check if sum is divisible by M
        if ((sum % M) == 0):
            return True;
        return False;
 
    # recursively call by considering '+'
    # or '-' between index and index+1
 
    # 1.Try placing '+'
    placeAdd = isPossible(index + 1, sum + arr[index]);
 
    # 2. Try placing '-'
    placeMinus = isPossible(index + 1, sum - arr[index]);
 
    if (placeAdd or placeMinus):
        return True;
     
    return False;
 
# This code is contributed by pratham76.




static bool isPossible(int index, int sum)
{
     
    // Base case
    if (index == n)
    {
         
        // Check if sum is divisible by M
        if ((sum % M) == 0)
            return true;
             
        return false;
    }
  
    // Recursively call by considering '+'
    // or '-' between index and index+1
  
    // 1.Try placing '+'
    bool placeAdd = isPossible(index + 1,
                                 sum + arr[index]);
  
    // 2. Try placing '-'
    bool placeMinus = isPossible(index + 1,
                                   sum - arr[index]);
  
    if (placeAdd || placeMinus)
        return true;
      
    return false;
}
 
// This code is contributed by divyesh072019




<script>
function isPossible(index , sum)
{
     
    // Base case
    if (index == n)
    {
         
        // Check if sum is divisible by M
        if ((sum % M) == 0)
            return true;
             
        return false;
    }
  
    // Recursively call by considering '+'
    // or '-' between index and index+1
  
    // 1.Try placing '+'
    let placeAdd = isPossible(index + 1,
                                 sum + arr[index]);
  
    // 2. Try placing '-'
    let placeMinus = isPossible(index + 1,
                                   sum - arr[index]);
    if (placeAdd || placeMinus)
        return true;
      
    return false;
}
 
// This code is contributed by Amit Katiyar
</script>

There are overlapping subproblems as shown in the image below (Note: the image represents the recursion tree till index = 3)
 

Better Approach: To optimize the above approach use dynamic programming.

Method 1: We apply Dynamic Programming with two states :- 

  1. index, 
  2. sum 

So DP[index][sum] stores the current index we are at and sum stores the result of evaluation of the sequence formed till that index.

Below is the implementation of the above approach:




// C++ program to check if any
// valid sequence is divisible by M
#include <bits/stdc++.h>
using namespace std;
 
const int MAX = 1000;
 
bool isPossible(int n, int index, int sum,
          int M, int arr[], int dp[][MAX])
{
 
    // Base case
    if (index == n) {
 
        // check if sum is divisible by M
        if ((sum % M) == 0)
            return true;
        return false;
    }
 
    // check if the current state
    // is already computed
    if (dp[index][sum] != -1)
        return dp[index][sum];
     
    // 1.Try placing '+'
    bool placeAdd = isPossible(n, index + 1,
               sum + arr[index], M, arr, dp);
 
    // 2. Try placing '-'
    bool placeMinus = isPossible(n, index + 1,
                sum - arr[index], M, arr, dp);
 
    // calculate value of res for recursive case
    bool res = (placeAdd || placeMinus);
 
    // store the value for res for current
    // states and return for parent call
    dp[index][sum] = res;
    return res;
}
int main()
{
    int arr[] = { 1, 2, 3, 4, 6 };
    int n = sizeof(arr)/sizeof(arr[0]);
    int M = 4;
 
    int dp[n + 1][MAX];
    memset(dp, -1, sizeof(dp));
 
    bool res;
    res = isPossible(n, 0, 0, M, arr, dp);
 
    cout << (res ? "True" : "False") << endl;
    return 0;
}




// Java program to check if any
// valid sequence is divisible by M
import java.util.*;
 
class GFG
{
 
    static final int MAX = 1000;
     
    static boolean isPossible(int n, int index, int sum,
                            int M, int arr[], int dp[][])
    {
     
        // Base case
        if (index == n)
        {
     
            // check if sum is divisible by M
            if ((sum % M) == 0)
                return true;
            return false;
        }
        else if(sum < 0 || sum >= MAX)
            return false;
     
        // check if the current state
        // is already computed
        if (dp[index][sum] != -1)
        {
            if(dp[index][sum] == 0)
                return false;
            return true;
        }
         
        // 1.Try placing '+'
        boolean placeAdd = isPossible(n, index + 1,
                sum + arr[index], M, arr, dp);
     
        // 2. Try placing '-'
        boolean placeMinus = isPossible(n, index + 1,
                    sum - arr[index], M, arr, dp);
     
        // calculate value of res for recursive case
        boolean res = (placeAdd || placeMinus);
     
        // store the value for res for current
        // states and return for parent call
        dp[index][sum] = (res) ? 1 : 0;
        return res;
    }
     
    // Driver code
    public static void main(String args[])
    {
        int arr[] = { 1, 2, 3, 4, 6 };
        int n = arr.length;
        int M = 4;
     
        int dp[][] = new int[n + 1][MAX];
        for(int i = 0; i < n + 1; i++)
            Arrays.fill(dp[i], -1);
     
        boolean res;
        res = isPossible(n, 0, 0, M, arr, dp);
     
        System.out.println((res ? "True" : "False"));
    }
}
 
// This code is contributed by ghanshyampandey




# Python3 program to check if any
# valid sequence is divisible by M
 
def isPossible(n, index, Sum, M, arr, dp):
    global MAX
    # Base case
    if index == n:
        # check if sum is divisible by M
        if (Sum % M) == 0:
            return True
        return False
 
    # check if the current state
    # is already computed
    if dp[index][Sum] != -1:
        return dp[index][Sum]
     
    # 1.Try placing '+'
    placeAdd = isPossible(n, index + 1,
                Sum + arr[index], M, arr, dp)
 
    # 2. Try placing '-'
    placeMinus = isPossible(n, index + 1,
                    Sum - arr[index], M, arr, dp)
 
    # calculate value of res for recursive case
    res = placeAdd or placeMinus
 
    # store the value for res for current
    # states and return for parent call
    dp[index][Sum] = res
    return res
 
MAX = 1000
arr = [1, 2, 3, 4, 6]
n = len(arr)
M = 4
dp = [[-1]*MAX for i in range(n+1)]
res = isPossible(n, 0, 0, M, arr, dp)
 
if res:
    print(True)
else:
    print(False)
     
# this code is contributed by PranchalK




// C# program to check if any
// valid sequence is divisible by M
using System;
     
class GFG
{
    static int MAX = 1000;
     
    static Boolean isPossible(int n, int index, int sum,
                              int M, int []arr, int [,]dp)
    {
     
        // Base case
        if (index == n)
        {
     
            // check if sum is divisible by M
            if ((sum % M) == 0)
                return true;
            return false;
        }
         
        else if(sum < 0 || sum >= MAX)
            return false;
     
        // check if the current state
        // is already computed
        if (dp[index,sum] != -1)
        {
            if(dp[index,sum] == 0)
                return false;
            return true;
        }
         
        // 1.Try placing '+'
        Boolean placeAdd = isPossible(n, index + 1,
                                      sum + arr[index],
                                      M, arr, dp);
     
        // 2. Try placing '-'
        Boolean placeMinus = isPossible(n, index + 1,
                                        sum - arr[index],
                                        M, arr, dp);
     
        // calculate value of res for recursive case
        Boolean res = (placeAdd || placeMinus);
     
        // store the value for res for current
        // states and return for parent call
        dp[index,sum] = (res) ? 1 : 0;
        return res;
    }
     
    // Driver code
    public static void Main(String []args)
    {
        int []arr = { 1, 2, 3, 4, 6 };
        int n = arr.Length;
        int M = 4;
     
        int [,]dp = new int[n + 1, MAX];
        for(int i = 0; i < n + 1; i++)
            for(int j = 0; j < MAX; j++)
                dp[i, j] = -1;
     
        Boolean res;
        res = isPossible(n, 0, 0, M, arr, dp);
     
        Console.WriteLine((res ? "True" : "False"));
    }
}
 
// This code is contributed by PrinciRaj1992




<script>
 
// javascript program to check if any
// valid sequence is divisible by M
 
var MAX = 1000;
     
function isPossible(n , index , sum,M , arr , dp)
{
 
    // Base case
    if (index == n)
    {
 
        // check if sum is divisible by M
        if ((sum % M) == 0)
            return true;
        return false;
    }
    else if(sum < 0 || sum >= MAX)
        return false;
 
    // check if the current state
    // is already computed
    if (dp[index][sum] != -1)
    {
        if(dp[index][sum] == 0)
            return false;
        return true;
    }
     
    // 1.Try placing '+'
    var placeAdd = isPossible(n, index + 1,
            sum + arr[index], M, arr, dp);
 
    // 2. Try placing '-'
    var placeMinus = isPossible(n, index + 1,
                sum - arr[index], M, arr, dp);
 
    // calculate value of res for recursive case
    var res = (placeAdd || placeMinus);
 
    // store the value for res for current
    // states and return for parent call
    dp[index][sum] = (res) ? 1 : 0;
     
    return res;
}
 
// Driver code
var arr = [ 1, 2, 3, 4, 6 ];
var n = arr.length;
var M = 4;
 
var dp = Array(n+1).fill(-1).map(x => Array(MAX).fill(-1));
 
 
res = isPossible(n, 0, 0, M, arr, dp);
 
document.write((res ? "True" : "False"));
 
// This code contributed by shikhasingrajput
 
</script>

Output: 
True

 

Time Complexity: O(N*sum), where the sum is the maximum possible sum for the sequence of integers and N is the number of elements in the array.
Auxiliary Space: O(N * MAX), here MAX = 1000

Method 2(efficient):  This is more efficient than Method 1. Here also, we apply Dynamic Programming but with two different states:

  1. index, 
  2. modulo 

So DP[index][modulo] stores the modulus of the result of the evaluation of the sequence formed till that index, with M. 

Below is the implementation of the above approach:




#include <bits/stdc++.h>
using namespace std;
 
const int MAX = 100;
 
int isPossible(int n, int index, int modulo,
            int M, int arr[], int dp[][MAX])
{
    // Calculate modulo for this call
    modulo = ((modulo % M) + M) % M;
 
    // Base case
    if (index == n) {
 
        // check if sum is divisible by M
        if (modulo == 0)
            return 1;
        return 0;
    }
 
    // check if the current state is
    // already computed
    if (dp[index][modulo] != -1)
        return dp[index][modulo];
 
    // 1.Try placing '+'
    int placeAdd = isPossible(n, index + 1,
            modulo + arr[index], M, arr, dp);
 
    // 2. Try placing '-'
    int placeMinus = isPossible(n, index + 1,
            modulo - arr[index], M, arr, dp);
 
    // calculate value of res for recursive
    // case
    bool res = (placeAdd || placeMinus);
 
    // store the value for res for current
    // states and return for parent call
    dp[index][modulo] = res;
    return res;
}
 
int main()
{
    int arr[] = { 1, 2, 3, 4, 6 };
    int n = sizeof(arr)/sizeof(arr[0]);
    int M = 4;
 
    // MAX is the Maximum value M can take
    int dp[n + 1][MAX];
    memset(dp, -1, sizeof(dp));
 
    bool res;
    res = isPossible(n, 1, arr[0], M, arr, dp);
 
    cout << (res ? "True" : "False") << endl;
    return 0;
}




// Java implementation of above approach
 
class GFG
{
    static int MAX = 100;
 
    static int isPossible(int n, int index, int modulo,
                         int M, int arr[], int dp[][])
    {
        // Calculate modulo for this call
        modulo = ((modulo % M) + M) % M;
 
        // Base case
        if (index == n)
        {
            // check if sum is divisible by M
            if (modulo == 0)
            {
                return 1;
            }
            return 0;
        }
 
        // check if the current state is
        // already computed
        if (dp[index][modulo] != -1)
        {
            return dp[index][modulo];
        }
 
        // 1.Try placing '+'
        int placeAdd = isPossible(n, index + 1,
                modulo + arr[index], M, arr, dp);
 
        // 2. Try placing '-'
        int placeMinus = isPossible(n, index + 1,
                modulo - arr[index], M, arr, dp);
 
        // calculate value of res for
        // recursive case
        int res = placeAdd;
 
        // store the value for res for current
        // states and return for parent call
        dp[index][modulo] = res;
        return res;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = {1, 2, 3, 4, 6};
        int n = arr.length;
        int M = 4;
 
        // MAX is the Maximum value M can take
        int dp[][] = new int[n + 1][MAX];
        for (int i = 0; i < n + 1; i++)
        {
            for (int j = 0; j < MAX; j++)
            {
                dp[i][j] = -1;
            }
        }
 
        boolean res;
        if (isPossible(n, 1, arr[0], M, arr, dp) == 1)
        {
            res = true;
        }
        else
        {
            res = false;
        }
        System.out.println(res ? "True" : "False");
    }
}
 
// This code is contributed by
// PrinciRaj1992




# Python3 Program to Check if any
# valid sequence is divisible by M
MAX = 100
 
def isPossible(n, index, modulo,
                     M, arr, dp):
 
    # Calculate modulo for this call
    modulo = ((modulo % M) + M) % M
 
    # Base case
    if (index == n):
 
        # check if sum is divisible by M
        if (modulo == 0):
            return 1
        return 0
 
    # check if the current state is
    # already computed
    if (dp[index][modulo] != -1):
        return dp[index][modulo]
 
    # 1.Try placing '+'
    placeAdd = isPossible(n, index + 1, modulo +
                          arr[index], M, arr, dp)
 
    # 2. Try placing '-'
    placeMinus = isPossible(n, index + 1, modulo -
                            arr[index], M, arr, dp)
 
    # calculate value of res
    # for recursive case
    res = bool(placeAdd or placeMinus)
 
    # store the value for res for current
    # states and return for parent call
    dp[index][modulo] = res
    return res
 
# Driver code
arr = [ 1, 2, 3, 4, 6 ]
n = len(arr)
M = 4
 
# MAX is the Maximum value
# M can take
dp = [[-1] * (n + 1)] * MAX
 
res = isPossible(n, 1, arr[0],
                 M, arr, dp)
 
if(res == True):
    print("True")
else:
    print("False")
 
# This code is contributed by ash264




// C# implementation of above approach
using System;
 
class GFG
{
    static int MAX = 100;
 
    static int isPossible(int n, int index, int modulo,
                        int M, int []arr, int [,]dp)
    {
         
        // Calculate modulo for this call
        modulo = ((modulo % M) + M) % M;
 
        // Base case
        if (index == n)
        {
             
            // check if sum is divisible by M
            if (modulo == 0)
            {
                return 1;
            }
            return 0;
        }
 
        // check if the current state is
        // already computed
        if (dp[index, modulo] != -1)
        {
            return dp[index, modulo];
        }
 
        // 1.Try placing '+'
        int placeAdd = isPossible(n, index + 1,
                modulo + arr[index], M, arr, dp);
 
        // 2. Try placing '-'
        int placeMinus = isPossible(n, index + 1,
                modulo - arr[index], M, arr, dp);
 
        // calculate value of res for
        // recursive case
        int res = placeAdd;
 
        // store the value for res for current
        // states and return for parent call
        dp[index, modulo] = res;
        return res;
    }
 
    // Driver code
    public static void Main()
    {
        int []arr = {1, 2, 3, 4, 6};
        int n = arr.Length;
        int M = 4;
 
        // MAX is the Maximum value M can take
        int [,]dp = new int[n + 1,MAX];
        for (int i = 0; i < n + 1; i++)
        {
            for (int j = 0; j < MAX; j++)
            {
                dp[i, j] = -1;
            }
        }
 
        bool res;
        if (isPossible(n, 1, arr[0], M, arr, dp) == 1)
        {
            res = true;
        }
        else
        {
            res = false;
        }
        Console.WriteLine(res ? "True" : "False");
    }
}
 
//This code is contributed by 29AjayKumar




<script>
 
// Javascript implementation of above approach    
const MAX = 100;
 
function isPossible(n, index, modulo, M, arr, dp)
{
     
    // Calculate modulo for this call
    modulo = ((modulo % M) + M) % M;
 
    // Base case
    if (index == n)
    {
         
        // Check if sum is divisible by M
        if (modulo == 0)
        {
            return 1;
        }
        return 0;
    }
 
    // check if the current state is
    // already computed
    if (dp[index][modulo] != -1)
    {
        return dp[index][modulo];
    }
 
    // 1.Try placing '+'
    var placeAdd = isPossible(n, index + 1,
                              modulo + arr[index],
                              M, arr, dp);
 
    // 2. Try placing '-'
    var placeMinus = isPossible(n, index + 1,
                                modulo - arr[index],
                                M, arr, dp);
 
    // Calculate value of res for
    // recursive case
    var res = placeAdd;
 
    // Store the value for res for current
    // states and return for parent call
    dp[index][modulo] = res;
    return res;
}
 
// Driver code
var arr = [ 1, 2, 3, 4, 6 ];
var n = arr.length;
var M = 4;
 
// MAX is the Maximum value M can take
var dp = Array(n + 1);
for(i = 0; i < n + 1; i++)
{
    dp[i] = Array(MAX).fill(-1);
}
 
var res;
if (isPossible(n, 1, arr[0], M, arr, dp) == 1)
{
    res = true;
}
else
{
    res = false;
}
document.write(res ? "True" : "False");
 
// This code is contributed by gauravrajput1
 
</script>

Output
True

Time Complexity: O(N*M).
Auxiliary Space: O(N * MAX), here MAX = 100

Efficient Approach: Follow the steps below in order to solve the problem:

Below is the implementation of the above approach:




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if any valid
// sequence is divisible by M
void func(int n, int m, int A[])
{
    // DEclare mod array
    vector<int> ModArray(n);
    int sum = 0;
 
    // Calculate the mod array
    for (int i = 0; i < n; i++) {
        ModArray[i] = A[i] % m;
        sum += ModArray[i];
    }
 
    sum = sum % m;
 
    // Check if sum is divisible by M
    if (sum % m == 0) {
        cout << "True";
        return;
    }
 
    // Check if sum is not divisible by 2
    if (sum % 2 != 0) {
        cout << "False";
    }
 
    else {
 
        // Remove the first element from
        // the ModArray since it is not
        // possible to place minus
        // on the first element
        ModArray.erase(ModArray.begin());
        int i = 0;
 
        // Decrease the size of array
        int j = ModArray.size() - 1;
 
        // Sort the array
        sort(ModArray.begin(), ModArray.end());
        sum = sum / 2;
        int i1, i2;
 
        // Loop until the pointer
        // cross each other
        while (i <= j) {
            int s = ModArray[i] + ModArray[j];
 
            // Check if sum becomes equal
            if (s == sum) {
                i1 = i;
                i2 = j;
                cout << "True";
                break;
            }
 
            // Increase and decrease
            // the pointer accordingly
            else if (s > sum)
                j--;
 
            else
                i++;
        }
    }
}
 
// Driver code
int main()
{
    int m = 2;
    int a[] = { 1, 3, 9 };
    int n = sizeof a / sizeof a[0];
 
    // Function call
    func(n, m, a);
}




// Java program for the above approach
import java.util.*;
 
class GFG{
     
// Function to check if any valid
// sequence is divisible by M
static void func(int n, int m, int []A)
{
     
    // Declare mod array
    Vector<Integer> ModArray = new Vector<>();
    for(int i = 0; i < n; i++)
        ModArray.add(0);
         
    int sum = 0;
 
    // Calculate the mod array
    for(int i = 0; i < n; i++)
    {
        ModArray.set(i, A[i] % m);
        sum += ((int)ModArray.get(i));
    }
 
    sum = sum % m;
 
    // Check if sum is divisible by M
    if (sum % m == 0)
    {
        System.out.println("True");
        return;
    }
 
    // Check if sum is not divisible by 2
    if (sum % 2 != 0)
    {
        System.out.println("False");
    }
    else
    {
         
        // Remove the first element from
        // the ModArray since it is not
        // possible to place minus
        // on the first element
        ModArray.remove(0);
        int i = 0;
 
        // Decrease the size of array
        int j = ModArray.size() - 1;
 
        // Sort the array
        Collections.sort(ModArray);
        sum = sum / 2;
        int i1, i2;
 
        // Loop until the pointer
        // cross each other
        while (i <= j)
        {
            int s = (int)ModArray.get(i) +
                    (int)ModArray.get(j);
 
            // Check if sum becomes equal
            if (s == sum)
            {
                i1 = i;
                i2 = j;
                System.out.println("True");
                break;
            }
 
            // Increase and decrease
            // the pointer accordingly
            else if (s > sum)
                j--;
            else
                i++;
        }
    }
}
 
// Driver code
public static void main(String args[])
{
    int m = 2;
    int []a = { 1, 3, 9 };
    int n = a.length;
     
    // Function call
    func(n, m, a);
}
}
 
// This code is contributed by Stream_Cipher




# Python3 program for the above approach
 
# Function to check if any valid
# sequence is divisible by M
def func(n, m, A):
 
    # DEclare mod array
    ModArray = [0]*n
    Sum = 0
 
    # Calculate the mod array
    for i in range(n):
        ModArray[i] = A[i] % m
        Sum += ModArray[i]
 
    Sum = Sum % m
 
    # Check if sum is divisible by M
    if (Sum % m == 0) :
        print("True")
        return
 
    # Check if sum is not divisible by 2
    if (Sum % 2 != 0) :
        print("False")
 
    else :
 
        # Remove the first element from
        # the ModArray since it is not
        # possible to place minus
        # on the first element
        ModArray.pop(0)
        i = 0
 
        # Decrease the size of array
        j = len(ModArray) - 1
 
        # Sort the array
        ModArray.sort()
        Sum = Sum // 2
 
        # Loop until the pointer
        # cross each other
        while (i <= j) :
            s = ModArray[i] + ModArray[j]
 
            # Check if sum becomes equal
            if (s == Sum) :
                i1 = i
                i2 = j
                print("True")
                break
 
            # Increase and decrease
            # the pointer accordingly
            elif (s > Sum):
                j -= 1
 
            else:
                i += 1
 
# Driver code               
m = 2
a = [ 1, 3, 9 ]
n = len(a)
 
# Function call
func(n, m, a)
 
# This code is contributed by divyeshrabadiya07




// C# program for the above approach
using System.Collections.Generic;
using System; 
 
class GFG{
     
// Function to check if any valid
// sequence is divisible by M
static void func(int n, int m, int []A)
{
     
    // Declare mod array
    List<int> ModArray = new List<int>();
    for(int i = 0; i < n; i++)
        ModArray.Add(0);
         
    int sum = 0;
 
    // Calculate the mod array
    for(int i = 0; i < n; i++)
    {
        ModArray[i] = (A[i] % m);
        sum += ((int)ModArray[i]);
    }
 
    sum = sum % m;
 
    // Check if sum is divisible by M
    if (sum % m == 0)
    {
        Console.WriteLine("True");
        return;
    }
 
    // Check if sum is not divisible by 2
    if (sum % 2 != 0)
    {
        Console.WriteLine("False");
    }
 
    else
    {
         
        // Remove the first element from
        // the ModArray since it is not
        // possible to place minus
        // on the first element
        ModArray.Remove(0);
        int i = 0;
 
        // Decrease the size of array
        int j = ModArray.Count - 1;
 
        // Sort the array
        ModArray.Sort();
        sum = sum / 2;
        int i1, i2;
 
        // Loop until the pointer
        // cross each other
        while (i <= j)
        {
            int s = (int)ModArray[i] +
                    (int)ModArray[j];
 
            // Check if sum becomes equal
            if (s == sum)
            {
                i1 = i;
                i2 = j;
                Console.WriteLine("True");
                break;
            }
 
            // Increase and decrease
            // the pointer accordingly
            else if (s > sum)
                j--;
            else
                i++;
        }
    }
}
 
// Driver code
public static void Main()
{
    int m = 2;
    int []a = { 1, 3, 9 };
    int n = a.Length;
     
    // Function call
    func(n, m, a);
}
}
 
// This code is contributed by Stream_Cipher




<script>
    // Javascript program for the above approach
     
    // Function to check if any valid
    // sequence is divisible by M
    function func(n, m, A)
    {
 
        // Declare mod array
        let ModArray = [];
        for(let i = 0; i < n; i++)
            ModArray.push(0);
 
        let sum = 0;
 
        // Calculate the mod array
        for(let i = 0; i < n; i++)
        {
            ModArray[i] = A[i] % m;
            sum += ModArray[i];
        }
 
        sum = sum % m;
 
        // Check if sum is divisible by M
        if (sum % m == 0)
        {
            document.write("True");
            return;
        }
 
        // Check if sum is not divisible by 2
        if (sum % 2 != 0)
        {
            document.write("False");
        }
        else
        {
 
            // Remove the first element from
            // the ModArray since it is not
            // possible to place minus
            // on the first element
            ModArray.shift();
            let i = 0;
 
            // Decrease the size of array
            let j = ModArray.length - 1;
 
            // Sort the array
            ModArray.sort(function(a, b){return a - b});
            sum = parseInt(sum / 2, 10);
            let i1, i2;
 
            // Loop until the pointer
            // cross each other
            while (i <= j)
            {
                let s = ModArray[i] + ModArray[j];
 
                // Check if sum becomes equal
                if (s == sum)
                {
                    i1 = i;
                    i2 = j;
                    document.write("True");
                    break;
                }
 
                // Increase and decrease
                // the pointer accordingly
                else if (s > sum)
                    j--;
                else
                    i++;
            }
        }
    }
     
    let m = 2;
    let a = [ 1, 3, 9 ];
    let n = a.length;
      
    // Function call
    func(n, m, a);
     
</script>

Output
False

Time Complexity: O(n * log n) 
Auxiliary Space: O(n)


Article Tags :