Problème d'installation des étagères

#include <stdio.h>

void probEtageres(int L, int m, int n) {
    int nb_m = L / m;        // Nombre optimal d'étagères de type m
    int nb_n = 0;            // Nombre optimal d'étagères de type n
    int reste = L % m;       // Espace vide minimal
    int L_original = L;      // Sauvegarder la valeur originale
    
    // Variable pour la solution courante
    int p, q = 0, r;
    
    while (L >= n) {
        q++;                 // Ajouter une étagère de type n
        L -= n;              // Réduire la longueur disponible
        
        p = L / m;           // Nombre d'étagères de type m possibles
        r = L % m;           // Espace vide avec cette configuration
        
        // Si on trouve un espace vide plus petit
        if (r < reste) {
            nb_m = p;
            nb_n = q;
            reste = r;
        }
        // Si espace vide égal, préférer plus d'étagères de type n (moins chères)
        else if (r == reste && q > nb_n) {
            nb_m = p;
            nb_n = q;
            reste = r;
        }
    }
    
    printf("%d %d %d\n", nb_m, nb_n, reste);
    printf("(Solution : %d × %d + %d × %d = %d ; reste = %d)\n", 
           nb_m, m, nb_n, n, nb_m * m + nb_n * n, reste);
}

int main() {
    // Test des exemples
    printf("Exemple 1 : L=7, m=3, n=5\n");
    probEtageres(7, 3, 5);
    
    printf("\nExemple 2 : L=29, m=3, n=9\n");
    probEtageres(29, 3, 9);
    
    printf("\nExemple 3 : L=24, m=4, n=7\n");
    probEtageres(24, 4, 7);
    
    return 0;
}

def probEtageres(L, m, n):
    """
    Résout le problème d'étagères murales.
    
    Paramètres:
    L (int): Longueur du mur
    m (int): Longueur du premier type d'étagère (plus petite)
    n (int): Longueur du second type d'étagère (plus grande, moins chère)
    
    Retourne:
    tuple: (nb_m, nb_n, reste) où nb_m est le nombre d'étagères de type m,
           nb_n le nombre d'étagères de type n, et reste l'espace vide.
    """
    # Initialisation avec uniquement des étagères de type m
    nb_m = L // m
    nb_n = 0
    reste = L % m
    
    # q compte le nombre d'étagères de type n
    q = 0
    L_temp = L
    
    while L_temp >= n:
        q += 1
        L_temp -= n
        
        # Avec q étagères de type n, combien peut-on mettre de type m ?
        p = L_temp // m
        r = L_temp % m
        
        # Si on trouve un espace vide plus petit
        if r < reste:
            nb_m = p
            nb_n = q
            reste = r
        # Si espace vide égal, préférer plus d'étagères de type n (moins chères)
        elif r == reste and q > nb_n:
            nb_m = p
            nb_n = q
            reste = r
    
    return nb_m, nb_n, reste

def afficher_solution(L, m, n):
    """Affiche la solution de façon détaillée"""
    nb_m, nb_n, reste = probEtageres(L, m, n)
    total = nb_m * m + nb_n * n
    
    print(f"Entrée : L={L}, m={m}, n={n}")
    print(f"Sortie : {nb_m} {nb_n} {reste}")
    print(f"Solution : {nb_m} × {m} + {nb_n} × {n} = {total} ; reste = {L - total}")
    print()

# Tester la fonction avec les exemples
print("Exemple 1 :")
afficher_solution(7, 3, 5)

print("Exemple 2 :")
afficher_solution(29, 3, 9)

print("Exemple 3 :")
afficher_solution(24, 4, 7)

# Test interactif
print("--- Test personnalisé ---")
L = int(input("Longueur du mur L : "))
m = int(input("Longueur petite étagère m : "))
n = int(input("Longueur grande étagère n : "))
nb_m, nb_n, reste = probEtageres(L, m, n)
print(f"Résultat : {nb_m} {nb_n} {reste}")