Given two **positive integers A and B** where A is greater than B. In one move one can decrease A by 1 which implies that after one move A is equal to A – 1. The task is to find the minimum number of moves required to make A divisible by B in constant time.

**Examples:**

Input :A = 10, B = 3Output :1Explanation:Only one move is required A = A - 1 = 9, which is divisible by 3.Input :A = 10, B = 10Output :0Explanation:Since A is equal to B therefore zero move required.

**Approach:**

To solve the problem mentioned above we take the modulus of the numbers that are A % B and the result is stored in a variable which is the required answer.

Below is the implementation of the above approach:

## C++

`// C++ implementation to count ` `// Total numbers moves to make ` `// integer A divisible by integer B ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function that print number ` `// of moves required ` `void` `movesRequired(` `int` `a, ` `int` `b) ` `{ ` ` ` `// calculate modulo ` ` ` `int` `total_moves = a % b; ` ` ` ` ` `// print the required answer ` ` ` `cout << total_moves << ` `"\n"` `; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` ` ` `// initialise A and B ` ` ` `int` `A = 10, B = 3; ` ` ` ` ` `movesRequired(A, B); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java implementation to count ` `// total numbers moves to make ` `// integer A divisible by integer B ` `import` `java.util.*; ` ` ` `class` `GFG{ ` ` ` `// Function that print number ` `// of moves required ` `static` `void` `movesRequired(` `int` `a, ` `int` `b) ` `{ ` ` ` ` ` `// Calculate modulo ` ` ` `int` `total_moves = a % b; ` ` ` ` ` `// Print the required answer ` ` ` `System.out.println(total_moves); ` `} ` ` ` `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` ` ` ` ` `// Initialise A and B ` ` ` `int` `A = ` `10` `, B = ` `3` `; ` ` ` ` ` `movesRequired(A, B); ` `} ` `} ` ` ` `// This code is contributed by offbeat ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation to count ` `# total numbers moves to make ` `# integer A divisible by integer B ` ` ` `# Function that print number ` `# of moves required ` `def` `movesRequired(a, b): ` ` ` ` ` `# Calculate modulo ` ` ` `total_moves ` `=` `a ` `%` `b ` ` ` ` ` `# Print the required answer ` ` ` `print` `(total_moves) ` ` ` `# Driver Code ` `if` `__name__ ` `=` `=` `'__main__'` `: ` ` ` ` ` `# Initialise A and B ` ` ` `A ` `=` `10` ` ` `B ` `=` `3` ` ` ` ` `movesRequired(A, B) ` ` ` `# This code is contributed by Samarth ` |

*chevron_right*

*filter_none*

## C#

`// C# implementation to count ` `// total numbers moves to make ` `// integer A divisible by integer B ` `using` `System; ` `class` `GFG ` `{ ` ` ` `// Function that print number ` `// of moves required ` `static` `void` `movesRequired(` `int` `a, ` `int` `b) ` `{ ` ` ` ` ` `// Calculate modulo ` ` ` `int` `total_moves = a % b; ` ` ` ` ` `// Print the required answer ` ` ` `Console.Write(total_moves); ` `} ` ` ` `// Driver code ` `public` `static` `void` `Main(String []args) ` `{ ` ` ` ` ` `// Initialise A and B ` ` ` `int` `A = 10, B = 3; ` ` ` ` ` `movesRequired(A, B); ` `} ` `} ` ` ` `// This code is contributed by shivanisinghss2110 ` |

*chevron_right*

*filter_none*

**Output:**

1

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.

## Recommended Posts:

- Minimum Decrements on Subarrays required to reduce all Array elements to zero
- Minimum decrements required such that sum of all adjacent pairs in an Array does not exceed K
- Minimize subarray increments/decrements required to reduce all array elements to 0
- Minimum operations required to make all Array elements divisible by K
- Minimum number of given moves required to make N divisible by 25
- Minimum swaps required to make a binary string divisible by 2^k
- Minimum number of swaps required to make a number divisible by 60
- Minimum positive integer divisible by C and is not in range [A, B]
- Find permutation of n which is divisible by 3 but not divisible by 6
- Count the number of pairs (i, j) such that either arr[i] is divisible by arr[j] or arr[j] is divisible by arr[i]
- Print digit's position to be removed to make a number divisible by 6
- Number of digits to be removed to make a number divisible by 3
- Possible to make a divisible by 3 number using all digits in an array
- Count of m digit integers that are divisible by an integer n
- Maximum positive integer divisible by C and is in the range [A, B]
- Length of longest subarray whose sum is not divisible by integer K
- Minimum and Maximum element of an array which is divisible by a given number k
- Minimum elements to be added in a range so that count of elements is divisible by K
- Minimum removals in a number to be divisible by 10 power raised to K
- Minimum value that divides one number and divisible by other

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.