Skip to content
Related Articles

Related Articles

Improve Article

Count numbers from a given range that can be visited moving any number of steps from the range [L, R]

  • Last Updated : 05 Aug, 2021

Given two integers X, Y and a range [L, R], the task is to count the number of integers from the range X and Y (inclusive) that can be visited in any number of steps, starting from X. In each step, it is possible to increase by L to R.

Examples:

Input: X = 1, Y = 10, L = 4, R = 6
Output: 6
Explanation: A total of six points can be visited between [1, 10]: 
 

  1. 1: Starting point
  2. 5: 1 -> 5
  3. 6: 1 -> 6
  4. 7: 1 -> 7
  5. 9: 1 -> 5 -> 9
  6. 10: 1 -> 5 -> 10

Input: X = 3, Y = 12, L = 2, R = 3
Output: 9

Approach: From index i, one can reach anywhere between [i+L, i+R] also similarly for each point j in [i+L, i+R] one can move to [j+L, j+R]. For each index i these reachable ranges can be marked using the difference array. Follow the steps below for the approach.



  • Construct an array say diff_arr[] of large size, to mark the ranges.
  • Initialize a variable say count = 0, to count the reachable points.
  • Initially, make diff_arr[x] = 1 and diff_arr[x+1] = -1 to mark starting point X as visited.
  • Iterate from X to Y and for each i update diff_arr[i] += diff_arr[i-1]  and if diff_arr[i] >= 1 then update diff_arr[i+L] = 1 and diff_arr[i + R + 1] = -1 and count = count + 1.
  • Finally, return the count.

Below is the implementation of the above approach:

C++




// C++ code for above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to count points from the range [X, Y]
// that can be reached by moving by L or R steps
int countReachablePoints(int X, int Y,
                         int L, int R)
{
 
    // Initialize difference array
    int diff_arr[100000] = { 0 };
 
    // Initialize Count
    int count = 0;
 
    // Marking starting point
    diff_arr[X] = 1;
    diff_arr[X + 1] = -1;
 
    // Iterating from X to Y
    for (int i = X; i <= Y; i++) {
 
        // Accumulate difference array
        diff_arr[i] += diff_arr[i - 1];
 
        // If diff_arr[i] is greater
        // than 1
        if (diff_arr[i] >= 1) {
            // Updating difference array
            diff_arr[i + L] += 1;
            diff_arr[i + R + 1] -= 1;
 
            // Visited point found
            count++;
        }
    }
    return count;
}
 
// Driver Code
int main()
 
{
    // Given Input
    int X = 3, Y = 12, L = 2, R = 3;
 
    // Function Call
    cout << countReachablePoints(X, Y, L, R);
 
    return 0;
}

Java




// Java code for above approach
 
import java.util.*;
 
class GFG{
 
// Function to count points from the range [X, Y]
// that can be reached by moving by L or R steps
static int countReachablePoints(int X, int Y,
                         int L, int R)
{
 
    // Initialize difference array
    int diff_arr[] = new int[100000];
 
    // Initialize Count
    int count = 0;
 
    // Marking starting point
    diff_arr[X] = 1;
    diff_arr[X + 1] = -1;
 
    // Iterating from X to Y
    for (int i = X; i <= Y; i++) {
 
        // Accumulate difference array
        diff_arr[i] += diff_arr[i - 1];
 
        // If diff_arr[i] is greater
        // than 1
        if (diff_arr[i] >= 1) {
            // Updating difference array
            diff_arr[i + L] += 1;
            diff_arr[i + R + 1] -= 1;
 
            // Visited point found
            count++;
        }
    }
    return count;
}
 
// Driver Code
public static void main(String[] args)
 
{
    // Given Input
    int X = 3, Y = 12, L = 2, R = 3;
 
    // Function Call
    System.out.print(countReachablePoints(X, Y, L, R));
 
}
}
 
// This code contributed by shikhasingrajput

Python3




# Python3 code for above approach
 
# Function to count points from the range [X, Y]
# that can be reached by moving by L or R steps
def countReachablePoints(X, Y, L, R):
     
    # Initialize difference array
    diff_arr = [0 for i in range(100000)]
 
    # Initialize Count
    count = 0
 
    # Marking starting point
    diff_arr[X] = 1
    diff_arr[X + 1] = -1
 
    # Iterating from X to Y
    for i in range(X, Y + 1, 1):
         
        # Accumulate difference array
        diff_arr[i] += diff_arr[i - 1]
 
        # If diff_arr[i] is greater
        # than 1
        if (diff_arr[i] >= 1):
             
            # Updating difference array
            diff_arr[i + L] += 1
            diff_arr[i + R + 1] -= 1
 
            # Visited point found
            count += 1
 
    return count
 
# Driver Code
if __name__ == '__main__':
     
    # Given Input
    X = 3
    Y = 12
    L = 2
    R = 3
 
    # Function Call
    print(countReachablePoints(X, Y, L, R))
     
# This code is contributed by ipg2016107

C#




// C# program for the above approach
using System;
 
class GFG{
 
// Function to count points from the range [X, Y]
// that can be reached by moving by L or R steps
static int countReachablePoints(int X, int Y,
                         int L, int R)
{
 
    // Initialize difference array
    int[] diff_arr= new int[100000];
 
    // Initialize Count
    int count = 0;
 
    // Marking starting point
    diff_arr[X] = 1;
    diff_arr[X + 1] = -1;
 
    // Iterating from X to Y
    for (int i = X; i <= Y; i++) {
 
        // Accumulate difference array
        diff_arr[i] += diff_arr[i - 1];
 
        // If diff_arr[i] is greater
        // than 1
        if (diff_arr[i] >= 1)
        {
           
            // Updating difference array
            diff_arr[i + L] += 1;
            diff_arr[i + R + 1] -= 1;
 
            // Visited point found
            count++;
        }
    }
    return count;
}
// Driver Code
public static void Main()
{
        // Given Input
    int X = 3, Y = 12, L = 2, R = 3;
 
    // Function Call
    Console.Write(countReachablePoints(X, Y, L, R));
}
}
 
// This code is contributed by splevel62.

Javascript




<script>
 
// JavaScript code for above approach
 
// Function to count points from the range [X, Y]
// that can be reached by moving by L or R steps
function countReachablePoints(X, Y, L, R) {
  // Initialize difference array
  let diff_arr = new Array(100000).fill(0);
 
  // Initialize Count
  let count = 0;
 
  // Marking starting point
  diff_arr[X] = 1;
  diff_arr[X + 1] = -1;
 
  // Iterating from X to Y
  for (let i = X; i <= Y; i++) {
    // Accumulate difference array
    diff_arr[i] += diff_arr[i - 1];
 
    // If diff_arr[i] is greater
    // than 1
    if (diff_arr[i] >= 1) {
      // Updating difference array
      diff_arr[i + L] += 1;
      diff_arr[i + R + 1] -= 1;
 
      // Visited point found
      count++;
    }
  }
  return count;
}
 
// Driver Code
 
// Given Input
let X = 3,
  Y = 12,
  L = 2,
  R = 3;
 
// Function Call
document.write(countReachablePoints(X, Y, L, R));
 
</script>
Output: 
9

 

Time Complexity: O(Y – X) 
Auxiliary Space: O(Y)
 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :