Boucles en langage C

Version imprimable

Bonjour,

Cela fait plusieurs jours que je persévère sur un exercice en C !

J'ai réalisé le début mais je n'arrive pas a résoudre le problème en entier. Je sais faire afficher que les classes seules, c'est a dire des passagers uniquement en économique, première ou classe affaire séparément. Quand il s'agit de les répartir sur les 3 classes en même temps je n'arrive pas à trouver une boucle adéquate. J'ai vraiment tout essayé et ça fait plus d'une semaine que j'essaie de trouver une solution !

Voila l'énoncé de l'exercice

Prix1, 2 et 3 sont les prix des billets d'avion des 3 classes et Nb1, 2, 3 le nombres de personnes dans chaque classe.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 int main() { int prix1=2000,prix2=1500,prix3=700,prix=132000,Nb1=0,Nb2=0,Nb3=0; for(Nb3=0;Nb1*prix1+Nb2*prix2+Nb3*prix3<=264000;Nb3=Nb3+50) { if(Nb1*prix1+Nb2*prix2+Nb3*prix3>=prix) { printf("Classe1 : %d Classe2 : %d Classe3 : %d \n",Nb1,Nb2,Nb3); } } for(Nb1=0;Nb1*prix1+Nb2*prix2+Nb3*prix3<=264000;Nb1=Nb1+50) { for(Nb2=0;Nb1*prix1+Nb2*prix2+Nb3*prix3<=264000;Nb2=Nb2+50) { for(Nb3=0;Nb1*prix1+Nb2*prix2+Nb3*prix3<=264000;Nb3=Nb3+50) { if(Nb1*prix1+Nb2*prix2+Nb3*prix3>=prix) { printf("Classe1 : %d Classe2 : %d Classe3 : %d \n",Nb1,Nb2,Nb3); } } } } }
Merci d'avance pour votre aide.

Je pense que ce n'est pas la bonne section :whistle: ce sont des mathématiques.

Il faut résoudre une inégalité :mrgreen:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 Soit en entrée prix_eco, le prix classe économique Soit nb_passagers_eco, le nombre de passagers classe économique Soit en entrée prix_premiere, le prix première classe Soit nb_passagers_premiere, le nombre de passagers première classe Soit en entrée prix_affaire, le prix classe affaire Soit nb_passagers__affaire, le nombre de passagers classe affaire Soit en entrée prix_voyage Il faut résoudre prix_voyage <= (prix_eco * nb_passagers_eco) + (prix_premiere * nb_passagers_premiere) + (prix_affaire * nb_passagers__affaire) <= (prix_voyage * 2) nb_passagers_eco % 50 = 0 nb_passagers_premiere % 50 = 0 nb_passagers__affaire% 50 = 0
Et je n'ai pas d'idées comment faire :whistle:

Édit 01 : Ou alors un algo en kit du style

On fait varier 1 paramètre par palier de 50 et les 2 autres à 0 (3 fois) *
On fait varier 2 paramètres par palier de 50 et 1 seul à 0 (3 fois)
On fait varier les 3 paramètres par palier de 50

Et pour le cas 2 et 3, on va de 0 au maximum trouvé dans le cas 1.
Dans ton exemple, on s'aperçoit que nb_passagers_eco <= 200, nb_passagers_premiere <= 100 et nb_passagers__affaire <= 150

* Simplification : (si je ne trompe pas :whistle: )
prix_voyage <= (prix_XXX * nb_passagers_XXX * 50) <= (prix_voyage * 2)
Donc
(prix_voyage / (prix_XXX * 50)) <= nb_passagers_XXX <= ((prix_voyage * 2) / (prix_XXX * 50))

Édit 02 : Mon algo en kit a un problème :wow: : le cas 3 va regénérer le cas 1 et le cas 2
Donc soit on limite le cas 03 en ne commençant pas par 0 soit, et je me demande :koi: si le cas 1 ne permet pas de calculer des maximums pour le cas 2 qui, ce dernier, ne permet pas d'affiner ces limites pour le cas 3 (pour des valeurs différentes de 0) :koi:

Édit 03 : Sve@r a donné un algo, que je n'ai pas testé :wow:, mais à vue de nez il explique mieux ma pensée de mon édit 2 :kiss:

La solution la plus simple est souvent (toujours?) la meilleure.

Pourquoi ne pas tester les trois variables indépendemment? C'est à dire faire quelque chose du genre
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 fonction fini(...) retourne prixvol < (n1 * p1 + n2 * p2 + n3 * p3) < 2*prixvol fonction valide(...) retourne (n1 * p1 + n2 * p2 + n3 * p3) < 2*prixvol entier n1=n2=n3=0 boucle infinie si(fini) ->break si(valide) -> ajoutesolution() boucle infinie si(fini) ->break si(valide) -> ajoutesolution() boucle infinie si(fini) ->break si(valide) -> ajoutesolution() n3 += 50 n2 += 50 n1 += 50
Je reste volontairement en pseudo code pour que tu aie de quoi réfléchir, mais une approche comme ça devrait fonctionner (ce n'est pas optimal en terme de performances mais tu t'en fous probablement)

21/03/2018, 20h19
xmaestro

Merci pour vos réponses, je vais m'y mettre pour trouver un algorithme qui fonctionne grace a vos elements

Bonjour
Citation:
Envoyé par xmaestro
Merci pour vos réponses, je vais m'y mettre pour trouver un algorithme qui fonctionne grace a vos elements
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 int main() { int prix1=2000,prix2=1500,prix3=700,prix=132000,Nb1=0,Nb2=0,Nb3=0; for(Nb1=0;Nb1*prix1+Nb2*prix2+Nb3*prix3<=264000;Nb1=Nb1+50) { for(Nb2=0;Nb1*prix1+Nb2*prix2+Nb3*prix3<=264000;Nb2=Nb2+50) { for(Nb3=0;Nb1*prix1+Nb2*prix2+Nb3*prix3<=264000;Nb3=Nb3+50) { if(Nb1*prix1+Nb2*prix2+Nb3*prix3>=prix) { printf("Classe1 : %d Classe2 : %d Classe3 : %d \n",Nb1,Nb2,Nb3); } } } } }
C'est con, tu l'avais déjà l'algorithme.
Ta seule erreur a été d'inclure Nb3 dans l'évaluation de la boucle Nb2 ; et d'inclure Nb2 et Nb3 dans l'évaluation de la boucle Nb1.
Quand la 3° boucle se termine, Nb3 est à sa valeur max. L'évaluation Nb1*prix1+Nb2*prix2+Nb3*prix3<=26400 de la seconde boucle devient alors fausse et la seconde boucle se termine immédiatement. Et pareil pour la première boucle. Et donc en fait tu n'as que la boucle 3 qui tourne.

Alors qu'en réalité, quand chaque boucle itère son indice, les indices des sous-boucles sont considérés à 0 (quand Nb1 itère, Nb2 et Nb3 sont considérés à 0 donc ils n'ont rien à faire dans l'évaluation de continuation de la boucle Nb1 ; et pareil quand Nb2 itère, Nb3 est sensé être à 0)
Code:

1 2 3 4 5 6 7 8 9 for (Nb1=0; Nb1*prix1 <= 264000; Nb1+=50) { for (Nb2=0; Nb1*prix1+Nb2*prix2 <= 264000; Nb2+=50) { for (Nb3=0; Nb1*prix1+Nb2*prix2+Nb3*prix3 <= 264000; Nb3+=50) { if (Nb1*prix1+Nb2*prix2+Nb3*prix3 >= prix) { printf("Classe1 : %d Classe2 : %d Classe3 : %d\n", Nb1, Nb2, Nb3); } } } }
Citation:

Envoyé par xmaestro

et ça fait plus d'une semaine que j'essaie de trouver une solution !

Hum... tu aurais mis printf("nb1=%d\n", Nb1) dans le corps de la première boucle; et pareil avec Nb2 et Nb3, tu aurais trouvé en 10mn...:weird: