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

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:**

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****.**

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

- 1: Starting point
- 5: 1 -> 5
- 6: 1 -> 6
- 7: 1 -> 7
- 9: 1 -> 5 -> 9
- 10: 1 -> 5 -> 10

Input:X = 3, Y = 12, L = 2, R = 3Output: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)