Distributing M items in a circle of size N starting from K-th position

31 Jan, 2022
M items are to be delivered in a circle of size N. Find the position where the M-th item will be delivered if we start from a given position K. Note that items are distributed at adjacent positions starting from K.Examples :  
Input : N = 5 // Size of circle
        M = 2 // Number of items
        K = 1 // Starting position
Output : 2
The first item will be given to 1st 
position. Second (or last) item will 
be delivered to 2nd position

Input : N = 5 
        M = 8 
        K = 2
Output : 4
The last item will be delivered to 
4th position
 
We check if the number of items to be distributed is greater than our remaining positions in current cycle of circle or not. If yes, then we simply return m + k – 1 (We distribute items in same cycle starting from k). Else we compute number of remaining items after completing current cycle and return mod of remaining items.Below is the implementation of the above idea  
C++
Java
Python3
C#
PHP
Javascript
// C++ program to find the position where// last item is delivered.#include <bits/stdc++.h>using namespace std; // n ==> Size of circle// m ==> Number of items// k ==> Initial positionint lastPosition(int n, int m, int k){    // n - k + 1 is number of positions    // before we reach beginning of circle    // If m is less than this value, then    // we can simply return (m-1)th position    if (m <= n - k + 1)        return m + k - 1;     // Let us compute remaining items before    // we reach beginning.    m = m - (n - k + 1);     // We compute m % n to skip all complete    // rounds. If we reach end, we return n    // else we return m % n    return (m % n == 0) ? n : (m % n);} // Driver codeint main(){    int n = 5;    int m = 8;    int k = 2;    cout << lastPosition(n, m, k);    return 0;}
// Java program to find the position where// last item is delivered.class GFG {     // n ==> Size of circle    // m ==> Number of items    // k ==> Initial position    static int lastPosition(int n, int m, int k)    {         // n - k + 1 is number of positions        // before we reach beginning of circle        // If m is less than this value, then        // we can simply return (m-1)th position        if (m <= n - k + 1)            return m + k - 1;         // Let us compute remaining items before        // we reach beginning.        m = m - (n - k + 1);         // We compute m % n to skip all complete        // rounds. If we reach end, we return n        // else we return m % n        return (m % n == 0) ? n : (m % n);    }     // Driver Program to test above function    public static void main(String arg[])    {        int n = 5;        int m = 8;        int k = 2;        System.out.print(lastPosition(n, m, k));    }} // This code is contributed by Anant Agarwal.
# Python program to find the position where# last item is delivered. # n ==> Size of circle# m ==> Number of items# k ==> Initial positiondef lastPosition(n, m, k):         # n - k + 1 is number of positions    # before we reach beginning of circle    # If m is less than this value, then    # we can simply return (m-1)th position    if (m <= n - k + 1):       return m + k - 1      # Let us compute remaining items before    # we reach beginning.    m = m - (n - k + 1)      # We compute m % n to skip all complete    # rounds. If we reach end, we return n    # else we return m % n    if(m % n == 0):        return n    else:        return m % n  # Driver coden = 5m = 8k = 2print(lastPosition(n, m, k)) # This code is contributed by Sachin Bisht
// C# program to find the position where// last item is delivered.using System; class GFG {     // n ==> Size of circle    // m ==> Number of items    // k ==> Initial position    static int lastPosition(int n, int m, int k)    {         // n - k + 1 is number of positions        // before we reach beginning of circle        // If m is less than this value, then        // we can simply return (m-1)th position        if (m <= n - k + 1)            return m + k - 1;         // Let us compute remaining items before        // we reach beginning.        m = m - (n - k + 1);         // We compute m % n to skip all complete        // rounds. If we reach end, we return n        // else we return m % n        return (m % n == 0) ? n : (m % n);    }     // Driver Program to test above function    public static void Main()    {        int n = 5;        int m = 8;        int k = 2;         Console.WriteLine(lastPosition(n, m, k));    }} // This code is contributed by vt_m.
<?php// PHP program to find the// position where last item// is delivered. // n ==> Size of circle// m ==> Number of items// k ==> Initial position function lastPosition($n, $m, $k){    // n - k + 1 is number of    // positions before we reach    // beginning of circle.    // If m is less than this value,    // then we can simply return    // (m-1)th position    if ($m <= $n - $k + 1)    return $m + $k - 1;     // Let us compute remaining items    // before we reach beginning.    $m = $m - ($n - $k + 1);     // We compute m % n to skip    // all complete rounds. If we    // reach end, we return n    // else we return m % n    return ($m % $n == 0) ? $n : ($m % $n);} // Driver code$n = 5;$m = 8;$k = 2;echo lastPosition($n, $m, $k); // This code is contributed by ajit?>
<script>// Javascript program to find the// position where last item// is delivered. // n ==> Size of circle// m ==> Number of items// k ==> Initial position function lastPosition(n, m, k){     // n - k + 1 is number of    // positions before we reach    // beginning of circle.    // If m is less than this value,    // then we can simply return    // (m-1)th position    if (m <= n - k + 1)    return m + k - 1;     // Let us compute remaining items    // before we reach beginning.    m = m - (n - k + 1);     // We compute m % n to skip    // all complete rounds. If we    // reach end, we return n    // else we return m % n    return (m % n == 0) ? n : (m % n);} // Driver codelet n = 5;let m = 8;let k = 2;document.write(lastPosition(n, m, k)); // This code is contributed by _saurabh_jaiswal</script>
Output :  
4
Time Complexity : O(1)This article is contributed by Sarthak Kohli. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
vt_m
jit_t
ishitas0301
_saurabh_jaiswal
amartyaghoshgfg
Modular Arithmetic
Mathematical
Mathematical
Modular Arithmetic
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Algorithm to solve Rubik's Cube
Merge two sorted arrays with O(1) extra space
Program to print prime numbers from 1 to N.
Find next greater number with same set of digits
Segment Tree | Set 1 (Sum of given range)
Check if a number is Palindrome
Count ways to reach the n'th stair
Fizz Buzz Implementation
Count all possible paths from top left to bottom right of a mXn matrix
Product of Array except itself