Área de parcela restante al final

Dados dos enteros N y M que representan el largo y el ancho de una parcela rectangular y otro entero K que representa el número de personas. Cada persona dividirá la parcela en dos partes de tal manera que será el cuadrado más grande posible de la parcela y dejará la segunda parte para los demás, continúa hasta que se termine la parcela o cada persona se quede con la parcela. Ahora, la tarea es determinar el área de la parcela que queda al final.
Ejemplos: 
 

Entrada: N = 5, M = 3, K = 2 
Salida: 2  La
primera persona divide la parcela de 5×3 en 2 partes, es decir, 3×3 y 2×3 
y obtendrá la parcela con una dimensión de 3×3. La otra persona vuelve a dividir la parcela de 2×3 en 
dos partes, es decir, 2×2 y 1×2, y obtendrá una parcela con una dimensión de 2×2. Ahora, la parte restante 
de la parcela tiene una dimensión de 1 × 2 y un área de 2 unidades.
Entrada: N = 4, M = 8, K = 4 
Salida: 0 
 

Acercarse: 
 

1. Si el largo es mayor que el ancho, resta el ancho al largo.
2. Si el ancho es mayor que el largo, resta el largo del ancho.
3. Repita los pasos anteriores para todas las personas mientras el área restante de la parcela sea mayor que 0.
4. Imprime el área de la parcela restante al final, es decir, largo * ancho.

A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the area
// of the remaining plot
int remainingArea(int N, int M, int K)
{
 
    // Continue while plot has positive area
    // and there are persons left
    while (K-- && N && M) {
 
        // If length > breadth
        // then subtract breadth from length
        if (N > M)
            N = N - M;
 
        // Else subtract length from breadth
        else
            M = M - N;
    }
 
    if (N > 0 && M > 0)
        return N * M;
    else
        return 0;
}
 
// Driver code
int main()
{
    int N = 5, M = 3, K = 2;
 
    cout << remainingArea(N, M, K);
 
    return 0;
}

// Java implementation of the approach
class GFG {
 
    // Function to return the area
    // of the remaining plot
    static int remainingArea(int N, int M, int K)
    {
 
        // Continue while plot has positive area
        // and there are persons left
        while (K-- > 0 && N > 0 && M > 0) {
 
            // If length > breadth
            // then subtract breadth from length
            if (N > M)
                N = N - M;
 
            // Else subtract length from breadth
            else
                M = M - N;
        }
 
        if (N > 0 && M > 0)
            return N * M;
        else
            return 0;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int N = 5, M = 3, K = 2;
 
        System.out.println(remainingArea(N, M, K));
    }
}
 
/* This code contributed by PrinciRaj1992 */

# Python3 implementation of the approach
 
# Function to return the area
# of the remaining plot
def remainingArea(N, M, K):
 
    # Continue while plot has positive area
    # and there are persons left
    while (K > 0 and N > 0 and M > 0):
 
        # If length > breadth
        # then subtract breadth from length
        if (N > M):
            N = N - M;
 
        # Else subtract length from breadth
        else:
            M = M - N;
        K = K - 1;
    if (N > 0 and M > 0):
        return N * M;
    else:
        return 0;
 
# Driver code
N = 5;
M = 3;
K = 2;
 
print(remainingArea(N, M, K));
 
# This code contributed by Rajput-Ji

// C# implementation of the approach
using System;
 
class GFG {
 
    // Function to return the area
    // of the remaining plot
    static int remainingArea(int N, int M, int K)
    {
 
        // Continue while plot has positive area
        // and there are persons left
        while (K-- > 0 && N > 0 && M > 0) {
 
            // If length > breadth
            // then subtract breadth from length
            if (N > M)
                N = N - M;
 
            // Else subtract length from breadth
            else
                M = M - N;
        }
 
        if (N > 0 && M > 0)
            return N * M;
        else
            return 0;
    }
 
    // Driver code
    static public void Main()
    {
        int N = 5, M = 3, K = 2;
 
        Console.WriteLine(remainingArea(N, M, K));
    }
}
 
/* This code contributed by ajit */

<?php
// PHP implementation of the approach
 
// Function to return the area
// of the remaining plot
function remainingArea($N, $M, $K)
{
 
    // Continue while plot has positive area
    // and there are persons left
    while ($K-- && $N && $M)
    {
 
        // If length > breadth
        // then subtract breadth from length
        if ($N > $M)
            $N = $N - $M;
 
        // Else subtract length from breadth
        else
            $M = $M - $N;
    }
 
    if ($N > 0 && $M > 0)
        return $N * $M;
    else
        return 0;
}
 
// Driver code
$N = 5;
$M = 3;
$K = 2;
 
echo remainingArea($N, $M, $K);
 
// This code is contributed by AnkitRai01
 
?>

<script>
 
// Javascript implementation of the approach
 
// Function to return the area
// of the remaining plot
function remainingArea(N, M, K)
{
 
    // Continue while plot has positive area
    // and there are persons left
    while (K-- && N && M) {
 
        // If length > breadth
        // then subtract breadth from length
        if (N > M)
            N = N - M;
 
        // Else subtract length from breadth
        else
            M = M - N;
    }
 
    if (N > 0 && M > 0)
        return N * M;
    else
        return 0;
}
 
// Driver code
var N = 5, M = 3, K = 2;
document.write( remainingArea(N, M, K));
 
</script>

2

Complejidad de tiempo: O(K)

Espacio Auxiliar: O(1)