Skip to content
Related Articles

Related Articles

Check if maximum difference between indices of Non-Zero Elements is greater than X
  • Last Updated : 14 Sep, 2020

Given an array arr[] and an integer X, the task is to check that maximum difference between indices of the non-zero elements is greater than or equal to X
Examples:

Input: arr[] = {1, 0, 1}, X = 3 
Output: No 
Explanation: 
Maximum Difference between the indices of non-zero elements is 2.

Input: arr[] = {1, 0, 0, 0, 0, 0, 1}, X = 6 
Output: Yes 
Explanation: 
Maximum Difference between the indices of non-zero elemente is 6.

Approach: The idea is to maintain the occurrence of last non-zero element in the array and As soon as there is a new element which is non-zero then compare the distance between the last occurrence index to the current index. If the difference between them is greater than or equal to X. Then, update the last occurrence of the non-zero element and continue checking. Otherwise, return False.

Below is the implementation of the above approach:



C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation to check that
// maximum difference of indices between
// non-zero elements if greater than X
#include<bits/stdc++.h>
using namespace std;
  
// Function to check that maximum 
// difference of indices between
// non-zero elements if greater than X
void findRuleFollowed(int arr[], int n, int x)
{
    int last_occur = -1;
    bool flag = true;
      
    // Loop to iterate over the elements 
    // of the array 
    for(int i = 0; i < n; i++)
    {
          
        // Condition if there is a last occured
        // non-zero element in the array
        if (arr[i] != 0 && last_occur != -1)
        {
            int diff = i - last_occur;
            if (diff >= x)
            {
                continue;
            }
            else
            {
                flag = false;
                break;
            }
        }
        else if (arr[i] != 0 && last_occur == -1)
        {
            last_occur = i;
        }
    }
      
    // Condition to check if the 
    // maximum difference is maintained
    if (flag)
        cout << "YES";
    else
        cout << "NO";
}
  
// Driver code
int main()
{
    int arr[] = { 0, 1, 0, 0, 1 };
    int n = sizeof(arr) / sizeof(0);
    int x = 3;
      
    // Function call
    findRuleFollowed(arr, n, x);
}
  
// This code is contributed by ankitkumar34

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation to check that
// maximum difference of indices between
// non-zero elements if greater than X
import java.util.*;
  
class GFG{
      
// Function to check that maximum
// difference of indices between
// non-zero elements if greater than X
static void findRuleFollowed(int arr[], int n, int x)
{
    int last_occur = -1;
    boolean flag = true;
      
    // Loop to iterate over the elements 
    // of the array 
    for(int i = 0; i < n; i++)
    {
          
        // Condition if there is a last occured
        // non-zero element in the array
        if (arr[i] != 0 && last_occur != -1)
        {
            int diff = i - last_occur;
            if (diff >= x)
            {
                continue;
            }
            else
            {
                flag = false;
                break;
            }
        }
        else if (arr[i] != 0 && last_occur == -1)
        {
            last_occur = i;
        }
    }
      
    // Condition to check if the 
    // maximum difference is maintained
    if (flag)
        System.out.println("YES");
    else
        System.out.println("NO");
}
  
// Driver Code
public static void main(String args[])
{
    int arr[] = { 0, 1, 0, 0, 1 };
    int n = arr.length;
    int x = 3;
      
    // Function call
    findRuleFollowed(arr, n, x);
}
}
  
// This code is contributed by ankitkumar34

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation to check that
# maximum difference of indices between
# non-zero elements if greater than X
  
# Function to check that
# maximum difference of indices between
# non-zero elements if greater than X
def findRuleFollowed(arr, x):
    last_occur = -1
    flag = True
      
    # Loop to iterate over the elements 
    # of the array 
    for i in range(len(arr)):
          
        # Condition if there is a last occured
        # non-zero element in the array
        if arr[i] != 0 and last_occur != -1:
            diff = i - last_occur
            if diff >= x:
                continue
            else:
                flag = False
                break
        elif arr[i] != 0 and last_occur == -1:
            last_occur = i
      
    # Condition to check if the 
    # maximum difference is maintained
    if flag:
        print("YES")
    else:
        print("NO")
  
# Driver Code
if __name__ == "__main__":
    arr = [0, 1, 0, 0, 1]
    x = 3
      
    # Function Call
    findRuleFollowed(arr, x)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation to check that
// maximum difference of indices between
// non-zero elements if greater than X
using System;
  
class GFG{
      
// Function to check that maximum
// difference of indices between
// non-zero elements if greater than X
static void findRuleFollowed(int []arr, 
                             int n, int x)
{
    int last_occur = -1;
    bool flag = true;
      
    // Loop to iterate over the elements 
    // of the array 
    for(int i = 0; i < n; i++)
    {
          
        // Condition if there is a last occured
        // non-zero element in the array
        if (arr[i] != 0 && last_occur != -1)
        {
            int diff = i - last_occur;
              
            if (diff >= x)
            {
                continue;
            }
            else
            {
                flag = false;
                break;
            }
        }
        else if (arr[i] != 0 && last_occur == -1)
        {
            last_occur = i;
        }
    }
      
    // Condition to check if the 
    // maximum difference is maintained
    if (flag)
        Console.WriteLine("YES");
    else
        Console.WriteLine("NO");
}
  
// Driver Code
public static void Main(String []args)
{
    int []arr = { 0, 1, 0, 0, 1 };
    int n = arr.Length;
    int x = 3;
      
    // Function call
    findRuleFollowed(arr, n, x);
}
}
  
// This code is contributed by Amit Katiyar

chevron_right


Output: 

YES

Time Complexity: O(N)
 

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :