Compruebe si la diferencia máxima entre los índices de elementos distintos de cero es mayor que X

Dada una array arr[] y un entero X , la tarea es verificar que la diferencia máxima entre los índices de los elementos distintos de cero sea mayor o igual a X.
Ejemplos:

Entrada: arr[] = {1, 0, 1}, X = 3 
Salida: No 
Explicación: 
La diferencia máxima entre los índices de elementos distintos de cero es 2.
Entrada: arr[] = {1, 0, 0, 0, 0, 0, 1}, X = 6 
Salida: Sí 
Explicación: 
La diferencia máxima entre los índices de los elementos distintos de cero es 6.

Enfoque: la idea es mantener la ocurrencia del último elemento distinto de cero en la array y tan pronto como haya un nuevo elemento que no sea cero, compare la distancia entre el último índice de ocurrencia con el índice actual. Si la diferencia entre ellos es mayor o igual a X. Luego, actualice la última aparición del elemento distinto de cero y continúe verificando. De lo contrario, devuelve Falso.
A continuación se muestra la implementación del enfoque anterior:

// 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 occurred
        // 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

// 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 occurred
        // 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

# 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 occurred
        # 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)

// 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 occurred
        // 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

YES

Complejidad de tiempo: O(N)