Ce dernier temps je découvre la notion de récursivité. consigne exercice : pour un nombre de joueurs, quel est le nombre de matches total si chaque joueur joue contre tous les autres joueurs qu’une seule fois
En réalité, la consigne de l’exerce était bcp plus complexe que ça, je me suis permis de le simplifier en le rendant plus facile a faire. En tout cas j’appris bcp de choses et j’ai constaté que le nombre de matche a augmente au début de 1 puis 2, puis 3, puis 4 et ainsi de suite :
Avec j : nombre de joueurs et m : nombre de matches
pour j = 1 , m = 0 car il n’y a qu’un seul joueur
pour j = 2 , m = 1 : 1 VS 2
pour j = 3 , m = 3 : 1 vs 2 , 1 vs 3 , 2 vs 3
pour j = 4 , m = 6 : 1 vs 2 , 1 vs 3 , 1 vs 4 , 2 vs 3 , 2 vs 4 , 3 vs 4
Au premier essaye, j’avais implémenté une fonction récursive non terminal or j’avais lu et compris qu’elle était plus longue et faisait une double exécution (ascendante puis descendante).
Après une qui est récursive terminal. Il était fastidieux de tester le résultat de la fonction pour des nombres de joueurs trop élevé, j’ai utilisé la formule pour calculer la somme des entiers naturels en la modifiant un peu : m = (j * (j - 1) )/2
Bref, j’aimerai avoir des retours sur ce code et ce qu’il faut que j’évite. Merci pour vos temps en avance.
code :
#include <iostream>
#include <limits>
#include <cassert>
void securisee_entree (int & entier);
int nombre_matches_term (int j, int m);
void test_nombre_matches_term_return_value ();
// -----------------------------------------------------------------------------------------------------------------------------------------
int main ()
{
int j { 0 };
std::cout << "Donnez le nombre de joueur : ";
securisee_entree (j);
int const m { 0 };
int resultat { nombre_matches_term (j, m) };
std::cout << "pour j = " << j << ", m = " << resultat << std::endl;
return 0;
}
// -----------------------------------------------------------------------------------------------------------------------------------------
void securisee_entree (int & entier)
{
while (not (std::cin >> entier) or entier < 0)
{
if (std::cin.eof () )
{
std::cout << "Fin du flux." << std::endl;
break;
}
else if (std::cin.fail () )
{
std::cout << "entre invalide, recommencez : ";
std::cin.clear ();
std::cin.ignore (std::numeric_limits<std::streamsize>::max (), '\n');
}
else
{
std::cout << "nombre negatif, recommencez : ";
}
}
}
// -----------------------------------------------------------------------------------------------------------------------------------------
/***
+ ROLE :
> permet de calculer le nombre de matche pour un jeu a 2 joueurs.
+ PARAMETRE :
> prend en argument le nombre de joueurs et le nombre de match qui
vaut au depart 0.
+ RETURN-VALUE :
> retourne une valeur de type integer.
+ AJOUT ULTERIEUR :
> aucune idee
***/
int nombre_matches_term (int j, int m)
{
assert (j >= 0 and "le nombre de joueur ne peut pas etre negatif.");
assert (m >= 0 and "le nombre de matches ne peut pas etre negatif.");
if (j == 0)
{
return m;
}
else
{
return nombre_matches_term (j - 1, (j - 1) + m);
}
}
// test-unitaire de la fonction nombre_matches
void test_nombre_matches_term_return_value ()
{
int j { 1 };
int const m { 0 };
int resultat { nombre_matches_term (j, m) };
assert (resultat == 0 and "pour j = 1, m doit-etre egal a 0.");
j = 2;
resultat = nombre_matches_term (j, m);
assert (resultat == 1 and "pour j = 2, m doit-etre egal a 1.");
j = 3;
resultat = nombre_matches_term (j, m);
assert (resultat == 3 and "pour j = 3, m doit-etre egal a 3.");
j = 4;
resultat = nombre_matches_term (j, m);
assert (resultat == 6 and "pour j = 4, m doit-etre egal a 6.");
}
Désolé, j’avais poster le sujet sur le mauvais forum au départ.
