Minimum elements to be added in a range so that count of elements is divisible by K

Given three integer K, L and R (range [L, R]), the task is to find the minimum number of elements the range must be extended by so that the count of elements in the range is divisible by K.

Examples:

Input: K = 3, L = 10, R = 10 
Output: 2 
Count of elements in L to R is 1. 
So to make it divisible by 3 , increment it by 2.

Input: K = 5, L = 9, R = 12 
Output: 1 

Approach:

• Count the total number of elements in the range and store it in a variable named count = R – L + 1.
• Now, minimum number of elements that need to be added to the range will be K – (count % K).

Below is the implementation of the above approach:  

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

int minimumMoves(int k, int l, int r)
{
    // Total elements in the range
    int count = r - l + 1;

    // If total elements are already divisible by k
    if (count % k == 0)
        return 0;

    // Value that must be added to count
    // in order to make it divisible by k
    return (k - (count % k));
}

// Driver Program to test above function
int main()
{
    int k = 3, l = 10, r = 10;
    cout << minimumMoves(k, l, r);

return 0;
}

Java

// Java implementation of the approach

import java.io.*;

class GFG {

 static int minimumMoves(int k, int l, int r)
{
    // Total elements in the range
    int count = r - l + 1;

    // If total elements are already divisible by k
    if (count % k == 0)
        return 0;

    // Value that must be added to count
    // in order to make it divisible by k
    return (k - (count % k));
}

// Driver Program to test above function
    public static void main (String[] args) {
    int k = 3, l = 10, r = 10;
    System.out.print(minimumMoves(k, l, r));
    }
}
// This code is contributed
// by inder_verma..

Python3

# Python 3 implementation of the approach

def minimumMoves(k, l, r):
    # Total elements in the range
    count = r - l + 1

    # If total elements are already divisible by k
    if (count % k == 0):
        return 0

    # Value that must be added to count
    # in order to make it divisible by k
    return (k - (count % k))

# Driver Program to test above function
if __name__ == '__main__':
    k = 3
    l = 10
    r = 10
    print(minimumMoves(k, l, r))

# This code is contributed by
# Surendra_Gangwar

C#

// C# implementation of the approach
using System;

class GFG {



static int minimumMoves(int k, int l, int r)
{
    // Total elements in the range
    int count = r - l + 1;

    // If total elements are already divisible by k
    if (count % k == 0)
        return 0;

    // Value that must be added to count
    // in order to make it divisible by k
    return (k - (count % k));
}

// Driver Program to test above function
    public static void Main () {
    int k = 3, l = 10, r = 10;
    Console.WriteLine(minimumMoves(k, l, r));
    }
}
// This code is contributed
// by inder_verma..

PHP

<?php
// PHP implementation of the approach

function minimumMoves($k, $l, $r)
{
    // Total elements in the range
    $count = $r - $l + 1;

    // If total elements are already divisible by k
    if ($count % $k == 0)
        return 0;

    // Value that must be added to count
    // in order to make it divisible by k
    return ($k - ($count % $k));
}

// Driver Program to test above function

    $k = 3; $l = 10; $r = 10;
    echo minimumMoves($k, $l, $r);
// This code is contributed
// by inder_verma..


?>

Javascript

<script>

// Javascript implementation of the approach
function minimumMoves(k, l, r)
{

    // Total elements in the range
    let count = r - l + 1;

    // If total elements are already
    // divisible by k
    if (count % k == 0)
        return 0;

    // Value that must be added to count
    // in order to make it divisible by k
    return (k - (count % k));
}

// Driver code
let k = 3, l = 10, r = 10;

document.write(minimumMoves(k, l, r));

// This code is contributed by souravmahato348

</script>

Output:

2

Time Complexity: O(1)

Auxiliary Space: O(1)