# Count possible moves in the given direction in a grid

Given a grid **N x M** size and initial position **(X, Y)** and a series of **K** moves.

Each move contains 2 integers **Dx** and **Dy**.

A single move consists of the following operation that can also be performed as many times as possible:

X = X + DxandY = Y + Dy.

The task is to count the number of moves performed. **Note** that at every point of time, the current position must be inside the grid.**Examples:**

Input:N = 4, M = 5, X = 1, Y = 1, k[] = {{1, 1}, {1, 1}, {0, -2}}Output:4

The values of(X, Y)are as follows:

Steps in Move 1: (1, 1) -> (2, 2) -> (3, 3) -> (4, 4) i.e. 3 moves

Move 2 is not possible as we cannot move to (5, 5) which is out of the bounds of the grid

Steps in Move 3: (4, 4) -> (4, 2) i.e. a single move and (4, 0) will be out of the bound so no further moves possible.

Total moves = 3 + 1 = 4Input:N = 10, M = 10, X = 3, Y = 3, k[] = {{1, 1}, {-1, -1}}Output:16

**Approach:** It can be observed that we can handle **X** and **Y** independently, and merge them as number of steps in current move= minimum of (number of steps with **X**, number of steps with **Y**). To find number of moves with **X**, we can use the sign of **Dx** to know which end we are approaching and find the distance to that end, with speed being **Dx**, we can find out the number of steps it would take.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the above approach` `#include <bits/stdc++.h>` `#define int long long` `using` `namespace` `std;` `// Function to return the count of` `// possible steps in a single direction` `int` `steps(` `int` `cur, ` `int` `x, ` `int` `n)` `{` ` ` `// It can cover infinite steps` ` ` `if` `(x == 0)` ` ` `return` `INT_MAX;` ` ` `// We are approaching towards X = N` ` ` `if` `(x > 0)` ` ` `return` `abs` `((n - cur) / x);` ` ` `// We are approaching towards X = 1` ` ` `else` ` ` `return` `abs` `((cur - 1) / x);` `}` `// Function to return the count of steps` `int` `countSteps(` `int` `curx, ` `int` `cury, ` `int` `n, ` `int` `m,` ` ` `vector<pair<` `int` `, ` `int` `> > moves)` `{` ` ` `int` `count = 0;` ` ` `int` `k = moves.size();` ` ` `for` `(` `int` `i = 0; i < k; i++) {` ` ` `int` `x = moves[i].first;` ` ` `int` `y = moves[i].second;` ` ` `// Take the minimum of both moves independently` ` ` `int` `stepct` ` ` `= min(steps(curx, x, n), steps(cury, y, m));` ` ` `// Update count and current positions` ` ` `count += stepct;` ` ` `curx += stepct * x;` ` ` `cury += stepct * y;` ` ` `}` ` ` `return` `count;` `}` `// Driver code` `main()` `{` ` ` `int` `n = 4, m = 5, x = 1, y = 1;` ` ` `vector<pair<` `int` `, ` `int` `> > moves = { { 1, 1 },` ` ` `{ 1, 1 },` ` ` `{ 0, -2 } };` ` ` `int` `k = moves.size();` ` ` `cout << countSteps(x, y, n, m, moves);` ` ` `return` `0;` `}` |

## Java

`// Java implementation of the above approach` `class` `GFG` `{` ` ` `// Function to return the count of` ` ` `// possible steps in a single direction` ` ` `static` `int` `steps(` `int` `cur, ` `int` `x, ` `int` `n)` ` ` `{` ` ` `// It can cover infinite steps` ` ` `if` `(x == ` `0` `)` ` ` `return` `Integer.MAX_VALUE;` ` ` `// We are approaching towards X = N` ` ` `if` `(x > ` `0` `)` ` ` `return` `Math.abs((n - cur) / x);` ` ` `// We are approaching towards X = 1` ` ` `else` ` ` `return` `Math.abs((cur - ` `1` `) / x);` ` ` `}` ` ` `// Function to return the count of steps` ` ` `static` `int` `countSteps(` `int` `curx, ` `int` `cury,` ` ` `int` `n, ` `int` `m,` ` ` `int` `[][] moves)` ` ` `{` ` ` `int` `count = ` `0` `;` ` ` `int` `k = moves.length;` ` ` `for` `(` `int` `i = ` `0` `; i < k; i++)` ` ` `{` ` ` `int` `x = moves[i][` `0` `];` ` ` `int` `y = moves[i][` `1` `];` ` ` `// Take the minimum of ` ` ` `// both moves independently` ` ` `int` `stepct = Math.min(steps(curx, x, n),` ` ` `steps(cury, y, m));` ` ` `// Update count and current positions` ` ` `count += stepct;` ` ` `curx += stepct * x;` ` ` `cury += stepct * y;` ` ` `}` ` ` `return` `count;` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `int` `n = ` `4` `, m = ` `5` `, x = ` `1` `, y = ` `1` `;` ` ` `int` `[][] moves = { { ` `1` `, ` `1` `}, { ` `1` `, ` `1` `},` ` ` `{ ` `0` `, -` `2` `} };` ` ` `System.out.print(countSteps(x, y, n, m, moves));` ` ` `}` `}` `// This code is contributed by 29AjayKumar` |

## Python3

`# Python3 implementation of the approach` `# Function to return the count of` `# possible steps in a single direction` `def` `steps(cur, x, n):` ` ` `# It can cover infinite steps` ` ` `if` `x ` `=` `=` `0` `:` ` ` `return` `float` `(` `'inf'` `)` ` ` `# We are approaching towards X = N` ` ` `elif` `x > ` `0` `:` ` ` `return` `abs` `((n ` `-` `cur) ` `/` `/` `x)` ` ` `# We are approaching towards X = 1` ` ` `else` `:` ` ` `return` `abs` `(` `int` `((cur ` `-` `1` `) ` `/` `x))` `# Function to return the count of steps` `def` `countSteps(curx, cury, n, m, moves):` ` ` `count ` `=` `0` ` ` `k ` `=` `len` `(moves)` ` ` `for` `i ` `in` `range` `(` `0` `, k):` ` ` `x ` `=` `moves[i][` `0` `]` ` ` `y ` `=` `moves[i][` `1` `]` ` ` `# Take the minimum of both moves` ` ` `# independently` ` ` `stepct ` `=` `min` `(steps(curx, x, n),` ` ` `steps(cury, y, m))` ` ` `# Update count and current positions` ` ` `count ` `+` `=` `stepct` ` ` `curx ` `+` `=` `stepct ` `*` `x` ` ` `cury ` `+` `=` `stepct ` `*` `y` ` ` ` ` `return` `count` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `n, m, x, y ` `=` `4` `, ` `5` `, ` `1` `, ` `1` ` ` `moves ` `=` `[[` `1` `, ` `1` `], [` `1` `, ` `1` `], [` `0` `, ` `-` `2` `]]` ` ` ` ` `print` `(countSteps(x, y, n, m, moves))` `# This code is contributed` `# by Rituraj Jain` |

## C#

`// C# implementation of the above approach` `using` `System;` `class` `GFG` `{` ` ` `// Function to return the count of` ` ` `// possible steps in a single direction` ` ` `static` `int` `steps(` `int` `cur, ` `int` `x, ` `int` `n)` ` ` `{` ` ` `// It can cover infinite steps` ` ` `if` `(x == 0)` ` ` `return` `int` `.MaxValue;` ` ` `// We are approaching towards X = N` ` ` `if` `(x > 0)` ` ` `return` `Math.Abs((n - cur) / x);` ` ` `// We are approaching towards X = 1` ` ` `else` ` ` `return` `Math.Abs((cur - 1) / x);` ` ` `}` ` ` `// Function to return the count of steps` ` ` `static` `int` `countSteps(` `int` `curx, ` `int` `cury,` ` ` `int` `n, ` `int` `m,` ` ` `int` `[,] moves)` ` ` `{` ` ` `int` `count = 0;` ` ` `int` `k = moves.GetLength(0);` ` ` `for` `(` `int` `i = 0; i < k; i++)` ` ` `{` ` ` `int` `x = moves[i, 0];` ` ` `int` `y = moves[i, 1];` ` ` `// Take the minimum of` ` ` `// both moves independently` ` ` `int` `stepct = Math.Min(steps(curx, x, n),` ` ` `steps(cury, y, m));` ` ` `// Update count and current positions` ` ` `count += stepct;` ` ` `curx += stepct * x;` ` ` `cury += stepct * y;` ` ` `}` ` ` `return` `count;` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `Main(String[] args)` ` ` `{` ` ` `int` `n = 4, m = 5, x = 1, y = 1;` ` ` `int` `[,] moves = { { 1, 1 }, { 1, 1 },` ` ` `{ 0, -2 } };` ` ` `Console.Write(countSteps(x, y, n, m, moves));` ` ` `}` `}` `// This code is contributed by Rajput-Ji` |

## PHP

`<?php` `// Php implementation of the above approach` `// Function to return the count of` `// possible steps in a single direction` `function` `steps(` `$cur` `, ` `$x` `, ` `$n` `)` `{` ` ` `// It can cover infinite steps` ` ` `if` `(` `$x` `== 0)` ` ` `return` `PHP_INT_MAX;` ` ` `// We are approaching towards X = N` ` ` `if` `(` `$x` `> 0)` ` ` `return` `floor` `(` `abs` `((` `$n` `- ` `$cur` `) / ` `$x` `));` ` ` `// We are approaching towards X = 1` ` ` `else` ` ` `return` `floor` `(` `abs` `((` `$cur` `- 1) / ` `$x` `));` `}` `// Function to return the count of steps` `function` `countSteps(` `$curx` `, ` `$cury` `, ` `$n` `, ` `$m` `, ` `$moves` `)` `{` ` ` `$count` `= 0;` ` ` `$k` `= sizeof(` `$moves` `);` ` ` `for` `(` `$i` `= 0; ` `$i` `< ` `$k` `; ` `$i` `++)` ` ` `{` ` ` `$x` `= ` `$moves` `[` `$i` `][0];` ` ` `$y` `= ` `$moves` `[` `$i` `][1];` ` ` `// Take the minimum of both moves independently` ` ` `$stepct` `= min(steps(` `$curx` `, ` `$x` `, ` `$n` `), steps(` `$cury` `, ` `$y` `, ` `$m` `));` ` ` `// Update count and current positions` ` ` `$count` `+= ` `$stepct` `;` ` ` `$curx` `+= ` `$stepct` `* ` `$x` `;` ` ` `$cury` `+= ` `$stepct` `* ` `$y` `;` ` ` `}` ` ` `return` `$count` `;` `}` ` ` `// Driver code` ` ` `$n` `= 4 ;` ` ` `$m` `= 5 ;` ` ` `$x` `= 1 ;` ` ` `$y` `= 1 ;` ` ` `$moves` `= ` `array` `( ` `array` `( 1, 1 ),` ` ` `array` `( 1, 1 ),` ` ` `array` `( 0, -2 ) );` ` ` `$k` `= sizeof(` `$moves` `);` ` ` ` ` `echo` `countSteps(` `$x` `, ` `$y` `, ` `$n` `, ` `$m` `, ` `$moves` `);` ` ` `// This code is contributed by Ryuga` `?>` |

## Javascript

`<script>` `// Javascript implementation of the above approach` ` ` ` ` `// Function to return the count of` ` ` `// possible steps in a single direction` ` ` `function` `steps(cur, x, n)` ` ` `{` ` ` `// It can cover infinite steps` ` ` `if` `(x == 0)` ` ` `return` `Number.MAX_VALUE;` ` ` `// We are approaching towards X = N` ` ` `if` `(x > 0)` ` ` `return` `Math.abs((n - cur) / x);` ` ` `// We are approaching towards X = 1` ` ` `else` ` ` `return` `Math.abs((cur - 1) / x);` ` ` `}` ` ` `// Function to return the count of steps` ` ` `function` `countSteps(curx, cury, n, m, moves)` ` ` `{` ` ` `let count = 0;` ` ` `let k = moves.length;` ` ` `for` `(let i = 0; i < k; i++)` ` ` `{` ` ` `let x = moves[i][0];` ` ` `let y = moves[i][1];` ` ` `// Take the minimum of ` ` ` `// both moves independently` ` ` `let stepct = Math.min(steps(curx, x, n),` ` ` `steps(cury, y, m));` ` ` `// Update count and current positions` ` ` `count += stepct;` ` ` `curx += stepct * x;` ` ` `cury += stepct * y;` ` ` `}` ` ` `return` `Math.floor(count);` ` ` `}` `// driver program` ` ` ` ` `let n = 4, m = 5, x = 1, y = 1;` ` ` `let moves = [[ 1, 1 ], [ 1, 1 ],` ` ` `[ 0, -2 ]];` ` ` `document.write(countSteps(x, y, n, m, moves));` ` ` `</script>` |

**Output:**

4

**Time Complexity:** O(N)