Distribuir M elementos en un círculo de tamaño N a partir de la K-ésima posición

Se deben entregar M artículos en un círculo de tamaño N. Encuentre la posición en la que se entregará el M-ésimo artículo si comenzamos desde una posición determinada K. Tenga en cuenta que los artículos se distribuyen en posiciones adyacentes a partir de K.
Ejemplos: 
 

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

Comprobamos si el número de artículos a distribuir es mayor que nuestras posiciones restantes en el ciclo actual del círculo o no. En caso afirmativo, simplemente devolvemos m + k – 1 (Distribuimos artículos en el mismo ciclo a partir de k). De lo contrario, calculamos el número de elementos restantes después de completar el ciclo actual y devolvemos la modalidad de los elementos restantes.
A continuación se muestra la implementación de la idea anterior. 
 

// 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 position
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 code
int 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 position
def 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 code
n = 5
m = 8
k = 2
print(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 code
let n = 5;
let m = 8;
let k = 2;
document.write(lastPosition(n, m, k));
 
// This code is contributed by _saurabh_jaiswal
</script>

Producción : 
 

4

Complejidad del tiempo : O(1)
Este artículo es una contribución de Sarthak Kohli . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.