Exercice 3: Parlons Javanais...

Exercice 3: Parlons Javanais...#

Dans le dictionnaire on trouve les définitions suivantes:

Javanais: argot codé, attesté depuis 1857, qui consiste à insérer les syllabes «av» ou «va» après chaque consonne («bonjour» se code «bavonvajavour»).
Occurrence: apparition d'une lettre dans un mot.
Consonne: phonème produit par le passage de l'air à travers la gorge, la bouche, formant obstacles. Lettre représentant une consonne.
Voyelle: phonème caractérisé par une résonance de la cavité buccale. Lettre qui sert à noter ce son: a, e, i, o, u, y.

Dans la suite de cet exercice, vous pourrez faire référence aux extraits de code A, B et C ci-dessous sans les recopier. De même pour D et E même si vous ne les avez pas complété.

////////// Extrait de code A
/**
 * fonction nbOccurrences
 * @param c, le caractère à rechercher dans le tableau
 * @param t, tableau de caractères non accentués
 * @return un entier positif donnant le nombre d'occurrences
 * du caractère dans le tableau, et notamment 0 si le caractère
 * n'est pas présent dans le tableau
 */
int nbOccurrences(char lettre, vector<char> tableau);

////////// Extrait de code B
int nbOccurrences(char lettre, vector<char> tableau) {
    return 0;
}

////////// Extrait de code C
CHECK( nbOccurrences('d', vector<char> ({'a', 'b', 'c'}) ) == 0 );

Écrivez deux tests mettant en évidence que la fonction nbOccurrences telle que définie par l'extrait de code B ne répond pas à sa spécification.

////////// Extrait de code D
/// BEGIN SOLUTION
CHECK( nbOccurrences('v', vector<char> ({'c','a','r','a','v','a','n','e'})) == 1 );
CHECK( nbOccurrences('d', vector<char> ({'d','a','d','a'})) == 2 );
/// END SOLUTION

Complétez l'extrait de code E ci-dessous avec une définition alternative de la fonction nbOccurrences qui passe tous les tests précédents.

////////// Extrait de code E
int nbOccurrences(char lettre, vector<char> tableau){
    /// BEGIN SOLUTION
    int compteur = 0;
    /// END SOLUTION
    for (auto c : tableau) {
        /// BEGIN SOLUTION
        if ( c == lettre ) { compteur++; }
        /// END SOLUTION
    }
    return compteur;
}

Lors du test de la fonction epele définie ci-dessous, on obtient le message:

Standard Exception: Test failed: 
  epele("interesse") == vector<char>({'i','n','t','e','r','e','s','s','e'})

Annotez ci-dessous la définition de epele pour indiquer comment la corriger:

using MotEpele = vector<char>;

MotEpele epele(string mot) {
    vector<char> v;
    v = vector<char>( mot.size() );
    for ( int i = 0; i < mot.size(); i++ ){
        v.push_back(mot[i]);
    }
    return v;
}

/// BEGIN SOLUTION
// Solution sans push_back
MotEpele epele(string mot) {
    vector<char> v;
    v = vector<char>(mot.size());
    for ( int i = 0; i < mot.size(); i++ ){
        v[i] = mot[i];
    }
    return v;
}
/// END SOLUTION

/// BEGIN SOLUTION
// Solution avec push_back
MotEpele epele (string mot) {
    vector<char> v;
    v = vector<char>(0);
    for ( int i = 0; i < mot.size(); i++ ){
        v.push_back(mot[i]);
    }
    return v;
}
/// END SOLUTION

On souhaite construire une bibliothèque pour la fonction nbOccurrences. À cet effet, on ébauche un quarto de fichiers nommés respectivement nbOccurrences.cpp, nbOccurrences.hpp, nbOccurrences-test.cpp, nbOccurrences-exemple.cpp. Vous disposez des extraits de code référencés A, B, C, D et E dans le début de l'exercice. Complétez chaque phrase ci-dessous pour préciser les éventuels #include et extraits que doit contenir chaque fichier.

Le fichier nbOccurrences.hpp doit commencer par:

[ ] #include <fstream>
[x] #include <vector>
[x] using namespace std;
[ ] #include "nbOccurrences.hpp"

On y positionnera le ou les extraits de code:

[x] A
[ ] B
[ ] C
[ ] D
[ ] E

Le fichier nbOccurrences.cpp doit commencer par:

[ ] #include <fstream>
[ ] #include <vector>
[ ] using namespace std;
[x] #include "nbOccurrences.hpp"

On y positionnera le ou les extraits de code:

[ ] A
[ ] B
[ ] C
[ ] D
[x] E

Le fichier nbOccurrences-test.cpp doit commencer par:

[ ] #include <fstream>
[ ] #include <vector>
[ ] using namespace std;
[x] #include "nbOccurrences.hpp"

On y positionnera le ou les extraits de code:

[ ] A
[ ] B
[x] C
[x] D
[ ] E

Dans le fichier ascii.cpp on trouve le code suivant:

#include <iostream>
using namespace std;

int main() {
    char lettre; int i;
    do {
        cout << "Saisir une lettre : "; cin >> lettre;
        i = lettre;
        cout << "Le code ASCII de " << lettre << " est " << i << endl;
    } while ( lettre != 'Q' );
    return 0;
}

main()

Donnez les commandes pour compiler puis exécuter le programme ascii:

BEGIN SOLUTION
clang++ ascii.cpp -o ascii
./ascii
END SOLUTION

Que devez vous alors taper pour que le programme affiche:

Le code ASCII de a est 97
Le code ASCII de z est 122

BEGIN SOLUTION
azQ
END SOLUTION

Une bibliothèque estConsonneMinuscule contient la fonction suivante:

bool estConsonneMinuscule(char lettre) {
    int i = lettre; 
    if ((i<=97) or (i>122)) return false;
    return not (lettre == 'e' or lettre == 'i' or lettre == 'o' or
	           	lettre == 'u' or lettre == 'y'); 
}

Testée comme suit:

CHECK(not estConsonneMinuscule('a'));
CHECK(not estConsonneMinuscule(';'));
CHECK(estConsonneMinuscule('t'));

Écrivez le contenu du fichier estConsonneMinuscule.hpp:

//BEGIN SOLUTION
/** 
* fonction 'estConsonneMinuscule'. 
* @param l une lettre
* @return vrai si la lettre est une consonne en minuscule.
*/
bool estConsonneMinuscule( char l);
//END SOLUTION

Annotez la fonction estConsonneMinuscule ci-dessus pour indiquer comment la transformer en fonction estVoyelleMinuscule.

// Solution:
bool estVoyelleMinuscule( char lettre ) {
    int i = lettre; 
    if ( (i<97) or (i>122) ) return false;
    return lettre == 'a' or lettre == 'e' or lettre == 'i' or
	       lettre == 'o' or lettre =='u' or lettre == 'y'; 
}

Définissez un encodeur javanais qui allonge un mot en lettres minuscule en insérant derrière chaque consonne non terminale les lettres «av» si elle est suivie d'une voyelle ou les lettres «va» si elle est suivie d'une autre consonne. Par exemple le mot «exemple» devient «exavemvapvalave» tandis que le mot «eau» est inchangé.

string encodeurJavanais (string mot){
    vector<char> motÉpelé, javanaisÉpelé;
    motÉpelé =  epele(mot);

    for (int i = 0; i < motÉpelé.size() - 1; i++){
	char lettre = motÉpelé[i]; 
	javanaisÉpelé.push_back(lettre);
	// insertion de va ou av derrière une consonne non terminale
	/// BEGIN SOLUTION
	if ( estConsonneMinuscule(lettre) ) {
            if ( estVoyelleMinuscule(motÉpelé[i+1]) ){
		javanaisÉpelé.push_back('a');
		javanaisÉpelé.push_back('v');
            } else{
		javanaisÉpelé.push_back('v');
		javanaisÉpelé.push_back('a');
            }
        }
	//// END SOLUTION
    }
    /// BEGIN SOLUTION
    javanaisÉpelé.push_back(motÉpelé[motÉpelé.size() - 1]);
    //// END SOLUTION

    // construction du mot à renvoyer
    /// BEGIN SOLUTION
    string javanais = "";
    for (auto lettre : javanaisÉpelé)
        javanais += lettre;
    /// END SOLUTION
    return javanais;
}

Quelle est la valeur de l'expression suivante:

nbOccurrences('v', epele(encodeurJavanais("betterave") ) )

BEGIN SOLUTION

6

END SOLUTION