Exercices S04 – Tests possibles

Ce qui suit propose quelques solutions possibles pour les exercices proposés à la séance S04. Vous aurez peut-être même trouvé mieux, qui sait?

Problème de trouver_consecutifs(debut,fin,n)

Consigne :

Écrivez l'algorithme trouver_consecutifs(debut,fin,n) qui retournera un itérateur sur le début de la première séquence de n éléments consécutifs de même valeur dans la séquence .
- Cet algorithme retournerasi aucune telle séquence n'existe, ou encore si $n \le 0$

Programme de test possible : il serait possible de tester votre solution avec un programme comme celui-ci.

//
// Votre code va ici, ou dans un .h que vous inclurez
//
#include <cassert>
using namespace std;
int main() {
   int tab[] { 2, 3, 3, 3, 5, 7, 7, 7, 7, 11, 11 };
   auto pos = trouver_consecutifs(begin(tab), end(tab), 1);
   assert(pos == begin(tab));
   pos = trouver_consecutifs(begin(tab), end(tab), 2);
   assert(pos == begin(tab) + 1);
   pos = trouver_consecutifs(begin(tab), end(tab), 3);
   assert(pos == begin(tab) + 1);
   pos = trouver_consecutifs(begin(tab), end(tab), 4);
   assert(pos == begin(tab) + 5);
   pos = trouver_consecutifs(begin(tab), end(tab), 5);
   assert(pos == end(tab));
   pos = trouver_consecutifs(begin(tab), end(tab), -2);
   assert(pos == end(tab));
}

Remarquez que :

Je n'ai pas produit de code complexe. Une simple série de tests pour les cas qui semblaient pertinents se succèdent, et les résultats attendus sont vérifiés par des assertions. Ainsi, si le code ne fait pas ce qu'il doit faire selon nos spécifications, l'assertion non-vérifiée fera planter le programme et la ligne posant problème sera affichée à l'écran
J'ai testé le cas où l'on trouverait immédiatement ce que l'on cherche, des séquences de différentes longueurs, le cas où l'on ne trouverait aucune séquence de la longueur souhaitée, et le cas où n serait inférieur ou égal à zéro
Notez que la première séquence de longueur 2 est celle débutant par 3 3 (le troisième 3 en fait une séquence de longueur 3, mais son préfixe est bel et bien une séquence de longueur 2)

Problème de plus_longue_sequence(debut,fin)

Consigne :

Écrivez l'algorithme plus_longue_sequence(debut,fin), qui retournera une paire (voir std::pair et std::make_pair()) dont le premier élément sera un itérateur sur le début de la plus longue séquence de valeurs consécutives trouvée dans la séquence , et le second élément sera un itérateur sur la fin de cette « sous-séquence ».
- Veillez à ce que la paire d'itérateurs retournée forme une séquence à demi-ouverte.
- Si la séquence $[debut,fin)$ est vide, alors retournez une paire fin,fin. Si plusieurs séquences distinctes ont la même (plus longue) longueur, alors retournez une paire d'itérateurs sur la première d'entre elles.
- Vous pouvez vous aider en écrivant des algorithmes auxiliaires.
- Vous avez le droit d'utiliser std::distance()

Programme de test possible : il serait possible de tester votre solution avec un programme comme celui-ci.

//
// Votre code va ici, ou dans un .h que vous inclurez
//
#include <vector>
#include <algorithm>
#include <utility>
#include <cassert>
using namespace std;
int main() {
   vector<int> v;
   auto resultat = plus_longue_sequence(begin(v), end(v));
   assert(resultat.first == end(v) && resultat.second == end(v));
   v = { 2, 2, 3, 4, 5, 5, 5, 6 };
   resultat = plus_longue_sequence(begin(v), end(v));
   assert(resultat.first == begin(v) + 4 && resultat.second == begin(v) + 7);
   v = { 2 };
   resultat = plus_longue_sequence(begin(v), end(v));
   assert(resultat.first == begin(v) && resultat.second == end(v));
   v = { 2, 2, 3, 3 };
   resultat = plus_longue_sequence(begin(v), end(v));
   assert(resultat.first == begin(v) && resultat.second == begin(v) + 2);
}

Remarquez que :

Je n'ai pas produit de code complexe. Une simple série de tests pour les cas qui semblaient pertinents se succèdent, et les résultats attendus sont vérifiés par des assertions. Ainsi, si le code ne fait pas ce qu'il doit faire selon nos spécifications, l'assertion non-vérifiée fera planter le programme et la ligne posant problème sera affichée à l'écran
J'ai testé le cas où la séquence est vide, de même que quelques cas qui me semblaient permettre de vérifier que l'algorithme fonctionne convenablement. C'est parce que je comptais tester la séquence vide que j'ai préféré un vecteur à un tableau dans ce cas-ci

Problème de plus_longue_sequence(debut,fin,pred)

Consigne :

Écrivez l'algorithme plus_longue_sequence(debut,fin,pred), qui retournera une paire (voir std::pair et std::make_pair()) dont le premier élément sera un itérateur sur le début de la plus longue séquence de valeurs consécutives respectant le prédicat pred trouvée dans la séquence , et le second élément sera un itérateur sur la fin de cette « sous-séquence ».
- Veillez à ce que la paire d'itérateurs retournée forme une séquence à demi-ouverte.
- Si la séquence $[debut,fin)$ est vide, alors retournez une paire fin,fin.
- Si plusieurs séquences distinctes ont la même (plus longue) longueur, alors retournez une paire d'itérateurs sur la première d'entre elles.
- Vous pouvez vous aider en écrivant des algorithmes auxiliaires.
- Vous avez le droit d'utiliser std::distance()

Programme de test possible : il serait possible de tester votre solution avec un programme comme celui-ci.

//
// Votre code va ici, ou dans un .h que vous inclurez
//
#include <vector>
#include <cassert>
using namespace std;
int main() {
   auto est_pair = [](int n) { return n % 2 == 0; };
   auto est_impair = [=](int n) { return !est_pair(n); };
   vector<int> v;
   auto resultat = plus_longue_sequence(begin(v), end(v), est_pair);
   assert(resultat.first == end(v) && resultat.second == end(v));
   v = { 2, 2, 3, 4, 5, 5, 5, 6 };
   resultat = plus_longue_sequence(begin(v), end(v), est_pair);
   assert(resultat.first == begin(v) && resultat.second == begin(v) + 2);
   resultat = plus_longue_sequence(begin(v), end(v), est_impair);
   assert(resultat.first == begin(v) + 4 && resultat.second == begin(v) + 7);
   v = { 2 };
   resultat = plus_longue_sequence(begin(v), end(v), est_pair);
   assert(resultat.first == begin(v) && resultat.second == end(v));
   resultat = plus_longue_sequence(begin(v), end(v), est_impair);
   assert(resultat.first == end(v) && resultat.second == end(v));
   v = { 2, 2, 4, 4 };
   resultat = plus_longue_sequence(begin(v), end(v), est_pair);
   assert(resultat.first == begin(v) && resultat.second == end(v));
}

Les tests sont semblables à ceux réalisés pour plus_longue_sequence(debut,fin), à ceci près que nous utilisons ici des prédicats pour déterminer les caractéristiques d'une séquence. Par exemple, le dernier test trouvera le contenu de v tout entier puisque tous les nombres qui y sont sont pairs.

Pour les exercices suivants, vous aurez besoin de déterminer si un caractère c est un blanc ou non. Utilisez pour ce faire la fonction std::isspace(char,std::locale) que vous trouverez dans <locale>, en utilisant locale{""} à titre de paramètre pour le locale.

Notez qu'il existe aussi un std::isspace(char), fonction du langage C, dans <cctype>, version C++ de <ctype.h>, mais cette version (plus rapide, car moins puissante) ne tient pas compte de la culture et ne correspond pas à nos attentes pour cet exercice.

Problème de inverser_mots(s)

Consigne :

Écrivez l'algorithme inverser_mots(s) qui retourne une chaîne de la même taille que s, mais dont le contenu est l'inverse de l'ordre des mots dans la chaîne s sans toutefois modifier l'ordre et la taille des séquences de blancs dans s.
- Par exemple :
  - si s est " j'aime mon prof ", alors la fonction retournera " prof mon j'aime "
  - si s est "yo", alors la fonction retournera "yo"
  - si s est " yo man", alors la fonction retournera " man yo"
  - si s est "yo man", alors la fonction retournera "man yo"

Programme de test possible : il serait possible de tester votre solution avec un programme comme celui-ci.

//
// Votre code va ici, ou dans un .h que vous inclurez
//
#include <cassert>
int main() {
   assert(inverser_mots("") == "");
   assert(inverser_mots(" j'aime   mon prof  ") == " prof   mon j'aime  ");
   assert(inverser_mots("yo") == "yo");
   assert(inverser_mots("     yo man") == "     man yo");
   assert(inverser_mots("yo  man") == "man  yo");
}

Ceci correspond aux cas de tests proposés dans l'énoncé du travail. Le cas d'une chaîne vide n'avait pas été imposé, mais quelle excellent cas de test, n'est-ce pas?

Problème de inverser_lettres(s)

Consigne :

Écrivez l'algorithme inverser_lettres(s) qui retourne une chaîne de la même taille que s, mais dont le contenu est tel que seul l'ordre des symboles dans chacun des mots est inversé.
- Par exemple :
  - si s est " j'aime mon prof ", alors la fonction retournera " emia'j nom forp "
  - si s est "yo", alors la fonction retournera "oy"
  - si s est " yo man", alors la fonction retournera " oy nam"
  - si s est "yo man", alors la fonction retournera "oy nam"

Programme de test possible : il serait possible de tester votre solution avec un programme comme celui-ci.

//
// Votre code va ici, ou dans un .h que vous inclurez
//
#include <cassert>
int main() {
   assert(inverser_lettres("") == "");
   assert(inverser_lettres(" j'aime   mon prof  ") == " emia'j   nom forp  ");
   assert(inverser_lettres("yo") == "oy");
   assert(inverser_lettres("     yo man") == "     oy nam");
   assert(inverser_lettres("yo  man") == "oy  nam");
}

Ceci correspond aux cas de tests proposés dans l'énoncé du travail. Le cas d'une chaîne vide n'avait pas été imposé, mais quelle excellent cas de test, n'est-ce pas?

Problème de ltrim(s)

Consigne :

Écrivez l'algorithme ltrim(s) (pour Left Trim) qui retourne une chaîne de caractères équivalente à s, mais dont toutes les séquences de blancs au début auront été supprimées.
- Par exemple :
  - si s est " j'aime mon prof ", alors la fonction retournera "j'aime mon prof "
  - si s est "j'aime mon prof ", alors la fonction retournera "j'aime mon prof "
  - si s est " x ", alors la fonction retournera "x "
  - si s est " ", alors la fonction retournera ""
  - si s est "", alors la fonction retournera ""

Programme de test possible : il serait possible de tester votre solution avec un programme comme celui-ci.

//
// Votre code va ici, ou dans un .h que vous inclurez
//
#include <cassert>
int main() {
   assert(ltrim(" j'aime   mon prof  ") == "j'aime   mon prof  ");
   assert(ltrim("j'aime   mon prof  ") == "j'aime   mon prof  ");
   assert(ltrim(" x ") == "x ");
   assert(ltrim("   ") == "");
   assert(ltrim("") == "");
}

Ceci correspond aux cas de tests proposés dans l'énoncé du travail.

Problème de rtrim(s)

Consigne :

Écrivez l'algorithme rtrim(s) (pour Right Trim) qui retourne une chaîne de caractères équivalente à s, mais dont toutes les séquences de blancs à la fin auront été supprimées.
- Par exemple :
  - si s est " j'aime mon prof ", alors la fonction retournera " j'aime mon prof"
  - si s est " j'aime mon prof", alors la fonction retournera "j'aime mon prof "
  - si s est " x ", alors la fonction retournera " x"
  - si s est " ", alors la fonction retournera ""
  - si s est "", alors la fonction retournera ""

Programme de test possible : il serait possible de tester votre solution avec un programme comme celui-ci.

//
// Votre code va ici, ou dans un .h que vous inclurez
//
#include <cassert>
int main() {
   assert(rtrim(" j'aime   mon prof  ") == " j'aime   mon prof");
   assert(rtrim(" j'aime   mon prof") == " j'aime   mon prof");
   assert(rtrim(" x ") == " x");
   assert(rtrim("   ") == "");
   assert(rtrim("") == "");
}

Ceci correspond aux cas de tests proposés dans l'énoncé du travail.

Problème de trim(s)

Consigne :

Écrivez l'algorithme trim(s) qui retourne une chaîne de caractères équivalente à s, mais dont toutes les séquences de blancs au début et à la fin auront été supprimées.
- Par exemple :
  - si s est " j'aime mon prof ", alors la fonction retournera "j'aime mon prof"
  - si s est " j'aime mon prof", alors la fonction retournera "j'aime mon prof"
  - si s est " x ", alors la fonction retournera "x"
  - si s est " ", alors la fonction retournera ""
  - si s est "", alors la fonction retournera ""

Programme de test possible : il serait possible de tester votre solution avec un programme comme celui-ci.

//
// Votre code va ici, ou dans un .h que vous inclurez
//
#include <cassert>
int main() {
   assert(trim(" j'aime   mon prof  ") == "j'aime   mon prof");
   assert(trim("j'aime   mon prof") == "j'aime   mon prof");
   assert(trim("x") == "x");
   assert(trim("   ") == "");
   assert(trim("") == "");
}

Ceci correspond aux cas de tests proposés dans l'énoncé du travail.

Problème de elaguer_blancs(s)

Consigne :

Écrivez l'algorithme elaguer_blancs(s) qui retourne une chaîne de caractères équivalente à s, mais dont toutes les séquences de blancs seront remplacées par un seul caractère d'espacement.
- Par exemple :
  - si s est " j'aime mon prof ", alors la fonction retournera " j'aime mon prof "
  - si s est "j'aime mon prof", alors la fonction retournera "j'aime mon prof"
  - si s est " ", alors la fonction retournera " "
  - si s est " ", alors la fonction retournera " "
  - si s est "", alors la fonction retournera ""

Programme de test possible : il serait possible de tester votre solution avec un programme comme celui-ci.

//
// Votre code va ici, ou dans un .h que vous inclurez
//
#include <cassert>
int main() {
   assert(elaguer_blancs(" j'aime   mon prof  ") == " j'aime mon prof ");
   assert(elaguer_blancs("j'aime   mon prof") == "j'aime mon prof");
   assert(elaguer_blancs("   ") == " ");
   assert(elaguer_blancs(" ") == " ");
   assert(elaguer_blancs("") == "");
}

Ceci correspond aux cas de tests proposés dans l'énoncé du travail.