---
tags: upsud
---

# TD 8 info 111 groupe Eco-Math

* [Sujet du TD8](http://nicolas.thiery.name/Enseignement/Info111/Semaine8/TD.pdf)
* [Cours Semaine8](http://nicolas.thiery.name/Enseignement/Info111/Web/Semaine8/)

## Instructions

Commencez par créer une section à votre nom, en décrivant sur une nouvelle ligne ## suivi de votre nom, puis faites le TD8 par vous-mêmes en rédigeant chaque exercice dans votre section. Pour l'écriture de code, l'écrire entre ```c++ et ```. Si vous avez une question, attirez mon attention grâce au chat Collaborate.

# Correction

### Exercice 1

1. La fonction lit le fichier dont le nom est pris en paramètre. Ce fichier doit contenir une suite de chaînes de caractères (comme des noms par exemple), suivie chacune d'un entier (par exemple une note). Elle affiche chaque chaîne suivie de l'entier multiplié par 2.

On pourrait appeller cette fonction par exemple `afficheNotes` et renommer les variables `t` et `n` en respectivement `nom` et `noteSur10`

2. Il n'y a que la ligne de l'affichage à changer, on remplace

    cout << t << " " << 2 * n << endl;

par

    cout << "Nom: " << t << ", note sur 10 : " << n
                         << ", note sur 20 : " << n * 2 << endl;
                                    

### Exercice 2

1. On reprend la fonction pour lire notre format de fichier, et on remplace les affichages par un calcul de moyenne.

    float moyenne(string nomFichier) {
        // Ouverture du fichier nommé nomFichier
        ifstream fichier;
        fichier.open(nomFichier);
        string osef; // Variable pour stocker les noms inutiles
        int note; // Pour stocker les notes
        float somme = 0.; // Somme des notes au fur et à mesure
        int nb = 0; // Nombre total de notes rencontrées
        while (fichier >> osef and fichier >> note) {
            somme = somme + note; // On ajoute la note à la somme
            nb = nb + 1; // On vient de rencontrer une note de plus
        }
        // Fermeture du fichier
        fichier.close();
        //Il ne reste plus qu'à diviser la somme par le nombre de notes
        return somme / nb;
    }

2. Indice : pour ajouter un élément `e` à la fin d'un tableau `t` existant, on écrit : `t.push_back(e)`. Cela **crée une nouvelle case** à la fin du tableau, contenant la valeur `e`.

Deux manières de procéder :
- soit on parcourt le fichier une première fois, pour compter combien il y a de notes, puis on crée un tableau de la bonne taille, puis on parcourt à nouveau le fichier pour remplir le tableau case par case.
- soit on crée juste un tableau vide, et on utilise `push_back` pour ajouter chaque nouvelle note à la fin du tableau

    vector<int> lit_notes(string nomFichier) {
        // Ouverture du fichier nommé nomFichier
        ifstream fichier;
        fichier.open(nomFichier);
        string osef; // Variable pour stocker les noms inutiles
        int note; // Pour stocker les notes
        vector<int> resultat; // On crée un tableau vide
        while (fichier >> osef and fichier >> note) {
            resultat.push_back(note); // Ajout de la note à la fin du tableau
        }
        // Fermeture du fichier
        fichier.close();
        // On renvoie le tableau final
        return resultat;
    }

### Exercice 3

En représentant les pixels blancs par des espaces et les pixels noirs par des `#`, on obtient :

   ####   
  #    #  
 #      # 
#  #  #  #
#        #
#        #
#  #  #  #
 #  ##  # 
  #    #  
   ####   

# Réponses étudiants

## Vincent
exo1
1)La fonction prend pour paramètre une chaîne de caractère nommée "nomFichiers"
La fonction mystère appelle un fichier sous le format .txt.
elle va ensuite, tant qu'il y a une chaîne de caractère et un entier sur la ligne du fichier, afficher la chaînes de caractères et le double de l'entier de la ligne du fichier.
la fonction va afficher un saut de ligne après avoir afficher toute une ligne.
on peut renommer la variable "t"->"nomjoueur"
et la variable "n"-> "note_sur_10"
et la fonction "mystère" -> "affiche_note_sur10"
2) void mystère....blabla...
cout<<"Nom: "<<nomjoueur<<",note sur 10: "<< n <<", note sur 20: "<< n*2<< endl; .....blabla...
Exo2
1)a)float moyenne(string nomFichier){ifstream fichier;
float i=0; float m=0.0;
fichier.open(nomFichier);
int n;
while(fichier>>n){m=m+n;i++}
fichier.close();
return m/i;}
b)vector<int> lit_notes(string nomFichier){
vector<int> t;
int i=1;
ifstream fichier;
fichier.open(nomFichier);
int n;
while(fichier>>n){t=vector<int>(i);t[i--]=n;i++}
fichier.close();
return t;
}
2)soit le fichier notes.txt:"
mbappette 10
girouette 8 "
ASSERT(moyenne(notes)==9);
ASSERT(lit_notes(notes)=={10,8});
Exo3
affiche un smiley de 10x10 pixels en noir et blanc
Exo4
affiche un rectangle 3x2 tricolore (comme le drapeau francais)
rouge/vert/bleu

## Pierre
**Exercice 1:**
**1)** La fonction *mystere* lit un fichier et affiche les mots qu'il contient et le double du nombre associé à chaque mot. Le format est .txt.
On pourrait nommer cette fonction *buteurs*, la variable *t* s'appellerait *joueur* et le nombre *n* s'appellerait *nb_buts*.
Documentation:
Affiche le nom du joueur et son nombre de buts
Format: chaque ligne est de la forme "<joueur> <nb_buts>"
@param nomFichier le nom du fichier

**2)** void mystere(string nomFichier) {
ifstream fichier;
fichier.open(nomFichier);
string t;
int n;
while ( fichier >> t and fichier >> n ) {
cout << "Nom: " t << ", note sur 10: " << n << ", note sur 20: " << 2 * n << endl;
}
fichier.close();
}

**Exercice 2:**
**1)** Documentation:
* Calcule la moyenne des notes contenues dans un fichier
* Format: chaque ligne est de la forme "<nom> <note>"
* @param nomFichier le nom du fichier
* @return la moyenne des notes

float moyenne(string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
string nom;
float note;
float s(0.0);
int c(0);
while(fichier >> nom and fichier >> note) {
s+=note;
c++;
}
fichier.close();
return (s/c);
}

Documentation:
* Lit les notes contenues dans un fichier et en fait un tableau
* Format: chaque ligne est de la forme "<nom> <note>"
* @param nomFichier le nom du fichier
* @return un tableau contenant les notes

vector<int> lit_notes(string nomFichier){
vector<int> t;
ifstream fichier;
fichier.open(nomFichier);
string nom;
int note;
while(fichier >> nom and fichier >> note) {
t.push_back(note);
}
fichier.close();
return t;
}

**2)** Il faudrait écrire un fichier de test et le passer en argument à notre fonction pour vérifier sa validité.

**Exercice 3: **
Ce format indique d'abord les dimensions de l'image, puis ensuite donne la couleur de chaque pixel de l'image dans l'ordre de lecture (0 pour noir et 1 pour blanc).

**Exercice 4: **
Les trois couleurs primaires usuelles sont: Rouge, Vert, Bleu. L'image est un drapeau (Vert Blanc Rouge)

## Xiaolin
exercice 1
1. La fonction lit un fichier et affiche les mots qu'il contient et double le nombre associe a chaque mot.
Le format "xxx.txt"
nom de fonction: affichebateur
variable: prenom pout t, et nb_buts pour n;
documentation/**affiche le nom et le nombre de but
*@param nomFichier et nom du fichier
*affiche le nom et double de nombre associe a cette nom
**/
2.void mystere (string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
string t;
int n;
while (fichier >> t and fichier >> n){
cout<< "Nom :" << t << " , note sur 10 : " << "" << n << " note sur 20 : " << 2*n << endl;
}
fichier.close();
}
exercice 2
1)
fonction 1
float moyenne(string nomFichier){
ifsteam fichier;
fichier.open (nomFichier);
string nom;
float note;
int n=0;
float nt=0;
while(fichier >> nom and fichier >> note){
n++;
nt=nt+note;

}
fichier close.();
return nt=nt/n;

}
fonction 2
vector<int> lit_notes(string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
string nom;
int nt;
vector<int>t;
while(fichier >> nom and fichier >> note){
t push_back(note);
}
fichier.close();
return t;
}
2.
3.

## Anna

**Exercice 1**:

1) La fonction mystere lit un fichier, puis affiche ce qu'il contient : les mots (chaines de caracteres) et le double du nombre associe a chaque mot.
Le format du fichier est (.txt).
On pourrait appeler plutot cette fonction : *footballeurs*, et ses variables : *prenomFoot*, pour *t*, et *buts*, pour le nombre *n*.

documentation :
/** affiche le nom du joueur et son nombre de buts fois 2
Format: chaque ligne est de la forme "<prenom> <nb_buts>"
@param nomFichier le nom du fichier

2)
void mystere(string nomFichier) {
ifstream fichier;
fichier.open(nomFichier);
string t;
int n;
while ( fichier >> t and fichier >> n ) {
cout << "Nom: " << t << ", note sur 10:" << " " << n << ", note sur 20: " << 2 * n << endl;
}
fichier.close();
}

**Exercice 2:**

1)
float moyenne(string nomFichier) {
ifstream fichier;
fichier.open(nomFichier);
string nom;
float note;
int nb(0);
float m(0.0);
while(fichier >> nom and fichier >> note) {
nb++;
m=m+note;
}
fichier.close();
return m / nb;
}

vector<int> lit_notes(string nomFichier) {
ifstream fichier;
fichier.open(nomFichier);
string nom;
int note;
vector<int> t;
while(fichier >> nom and fichier >> note) {
t.push_back(note);
}
fichier.close();
return t;
}

2)
Il faudrait ecrire un fichier test et ecrire ASSERT a partir de ce fichier.

**Exercice 3:**

Ce format fonctionne de la facon suivante :
- d'abord on a les dimensions de l'image (dans ce cas 10x10)
- puis la couleur de chaque pixel comme liste de nombres (0 pour noir et 1 pour blanc)

**Exercice 4:**
Les toris couleurs primaires usuelles sont :le rouge, le vert et le bleu.
L'image est un drapeau vert, blanc, rouge.

## Lina

ex 1
1) la fonction affiche la chaine de caractere et le nombre associé multiplié par deux
format: texte (.txt)
fonction:
t: nom du footballeur
n: nombre de but

documentation:
/** affiche le double du nombre de but de chaque *joueur
*@param un fichier contenant les joueurs et leur *nombre de but
*@affiche chaque joueur et le double de leur nombre *de but
**/

2) void mystere (string nomFichier) {
ifstream fichier;
fichier.open (nomFichier);
string t;
int n;
while (fichier >> t and fichier >> n) {
cout << "Nom: " << t << ", note sur 10: " << "n"<< ",note sur 20: " << "n*2" << endl;
}
fichier.close();
}

## Théo
**Exercice 1:**
**1)**
La fonction mystere renvoie le double du nombre associé à chaque chiane de caractères contenu dans le fichier.
Format: .txt
Fonction:double_buts
t: nom_joueur
n: nb_buts
Documentation:
/**Fonction double le nombre de buts de chaque joueur.
@param fichier contenant les noms des joueurs et leur nombre de buts.
@return le double du nombre de but marqué par chaque joueur
**/

**2)**
void afficheNotes(string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
string nom;
int note;
while(fichier>>nom and fichier>>note){
cout<<"Nom"<<nom<<", note sur 10:"<<note<<", note sur 20:"<<2*note<<endl;
}
fichier.close();
}

**Exercice 2:**
**1)**
- float moyenne(string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
string nom;
float note;
float total =0.0;
int compteur=0;
while(fichier>>nom and fichier>>note){
total=total+note,
compteur++;
}
fichier.close();
return (total/compteur);
}

- vector<int> lit_notes(string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
vector<int>t;
string nom;
int note;
while (fichier>>nom and fichier>> note){
t.push_back(note);
}
fichier.close();
return t;
}
**2)**
Il faudrait écrire un fichier test et écrire une fonction test du type:
ASSERT( nom de la fonction(fichier)==resultat attendu);
**3)**

**Exercice 3:**
Ce format indique d’abord les dimensions de l’image(ici 10*10), puis il donne la valeur de chaque pixel ligne par ligne. La valeur du pixel correspond à sa couleur: 0 pour blanc et 1 pour noir.
on obtient un smiley

**Exercice 4:**
les trois couleurs usuelles sont rouge, bleu, vert.

## Hovik

Exercice 1:
1)La Fonction renvoie un fichier contenant un nom de footballeur et le double du nombre n associé à ce dernier.
La fonction prend en parametre une chaîne de caractères.

Format : .txt
nom Fonction : affichejoueursetstats
noms variables ;
t: joueur
n: stats

Documentation:
La Fonction affichejoueursetstats affiche un joueur dont le nom est contenu dans un fichier t et le double de ses statistiques n.

2)
void mystere(string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
string t;
int n;
while (fichier>>t and fichier>>n){
cout << "Nom: " << t << ", note sur 10 : " << n
<< ", note sur 20 : " << n * 2 << endl;
} fichier.close();
}

ERERCICE 2:
1)float moyenne (stringnomFichier){
ifstream fichier;
fichier.open(nomFichier);
string nom;
float n;
int c=0;
float note = 0;
while(fichier>>nom and fichier>>n){
note= note+n;
c++;
}
return note/c;
}

vector<int> lit-notes (stringnomFichier){
ifstream fichier;
fichier.open(nomFichier);
string nom;
float n;

EXERCICE 3:
On utilise 0 et 1 pour coder le noir et le blanc.

EXERCICE 4:
Les trois couleurs primaires susuelles sont : rouge, vert et le bleu.

## Inès
exercice 1:
1)La fonction mystere affiche le double de "n", but marqué par un joueur, entier associé au prénom du joueur en question, contenu dans le fichier.
Ce fichier est sous forme de chaines de caractere/ texte.
Noms de la fonction: affiche_double_but
Variables: t => "joueur"
n => b
Documentation:
/** Fonction affiche_double_but affiche le double de but associé au prénom du joueur
@param fichier au format adapté, contenant un entier associé à un nom de joueur
affiche le prénom d'un joeur et le double de son entier associé
**/

2) void note(string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
string t;
int n;
while (fichier >> t and fichier >> n){
cout << "Nom:" << "t" << ", note sur 10:" << n << ", note sur 20:" << 2*n <<endl;
}
fichier.close();}

exercice 2:
1) float moyenne(string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
string nom;
float n = 0,0;
int t = 0;
float note;
while (fichier >> note and fichier >> nom){
note = n + note;
t++;
}
return (note/t);
}

vector<int> lit_notes(string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
string nom;
float note;
t = vector<int>(nomFichier.size() );
while( fichier >>nom and fichier>>note){
for (int i=1; i<t.size(); i++){
t[i]= note;
}
}
return t;
fichier.close();
}

2) ASSERT(moyenne{10, 18} == 14);
ASSER(fichiertest == tab);

exercice 3:
0 = blanc
1 = noir
taille 10x10

exercice 4:
taille 3x2
Couleurs primaires: rouges, vert & bleu

## Hongji

Exercice 1
1.La fonction affiche le double d'un nombre A un nom
2.void mystere(string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
string t;
int n;
while (fichier >> t and fichier >> n){
cout << "Nom: " t << ", note sur 10: " << n << ", note sur 20: " << 2 * n << endl;
}
fichier.close();
}

exercise 2.
1.float moyenne(string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
string t;
int n;
double m;
double i=0;
while(fichier >> t and fichier >> n){
i++;
m=m+n;
}
fichier.close();
double resultat=m/i;
return resultat;
}

2.vector<int>lit_notes(string nomFichier){
vector<int>t;
ifstream fichier;
fichier.open(nomFichier);
string nom;
int note;
while(fichier>>nom and fichier>>note){
t.push_back(note);
}
fichier.close();
return t;
}
ASSERT(lit_notes("truc.txt")=={4,2,3,2,1});

exercise3.
1.0 pour noir et 1 pour blanc

exercise4.les trois couleurs primaires usuelles sont rouge,vert et bleu.

exercise5.

## Eythan
Exercice 1:
1.
La fonction mystere lit un fichier et renvoie le double d'un nombre associé à une personne
Format du fichier : .txt
Nom de la fonction: Void affiche_double
Documentation :
/** fonction affiche_double qui double les valeurs du fichiers
Format : Chaque ligne est de la forme "<nom><note>"
@param nomFihier le nom du fichier
Return le double de la valeur associé au nom
2.
void affiche_double(string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
string t;
int n;
while (fichier>> t and fichier >>n){
cout << n << t << "/10" << t << "/20" << endl;
}
fichier.close();
}

Exercice 2:
1.
float moyenne (string nomFichier){
ifstreamfichier;
fichier.open(nomFichier);
string t;
string n;
double a;
double compteur = 0;
while (fichier >> n and fichier >>t){
compteur++;
a = a + n;
}
fichier.close();
double resultat = a/compteur;
return resultat;
}

vector<int> lit_note (string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
string nom;
string n;
int a;
vector<int> t;
while (fichier >> nom and fichier >> n){
t.push_back (n)
}
fichier.close();
return t;
}

2.
Assert (moyenne({10,11,12})==(11))
Assert () Ecrire un fichier .txt et vérifier que l'on obtient == tab

3.

Exercice 3:
Le noir ou le blanc est représenté par des 0 et des 1

Exercice 4:
Les trois couleurs primaires usuelles sont le rouge, vert, bleu

Exercice 5:
/** Compte le nombre de mots d'un fichier
int compte_mots(string nomFichier){
ifstream fichier;
fichier.open(nom.Fichier);
int compte = 0
string lit;
while (fichier >> lit)

}

/** Compte le nombre de lignes d'un fichier
int compte_ligne (string nomFichier){
isstream fichier;
fichier.open (nomFichier);
int nombre_de_lignes = 0;
string ligne;
while (istream getline(istream fichier,string ligne)){

nombre_de_lignes ++;
}
fichier.close();
return nombre_de_lignes
}

/** affiche le contenu d'un fichier
void affiche_fichier (string nomFichier){
ifstream fichier;
fichier.open (nomFichier);
int nombre_de_lignes = 0;
string ligne;
while (istream getline(istream fichier,string ligne)){
cout << ligne << endl;
}
fichier.close();

}

## Caroline
exercice1
1.La fonction affiche le double du nom correspondant.
Le format: truc.txt
non de la fonction:afficheDoubleNom
variables:
t = "nom"
n= "but"
documentation: //* afficheDoublePrénom double la valeur du prénom correspondant
@param nom du fichier
@return le double de la valeur du nom

## Axel Sadaoui
Exercice 1
1) Cette fonction affiche les noms contenus dans le fichier et affchiche le double du nombre associé à chaque nom.
2) void mystere(string nomFichier) {
ifstream fichier;
fichier.open(nomFichier);
string nom;
int note;
while ( fichier >> t and fichier >> n ) {
cout << nom << " note /10:" <<note<<"note/20:"<< 2 * note << endl;
}
fichier.close();
}
Exercice 2
1)

## Lorenzo

**Exercice 1**
**1)** la fonction double la valeur associée à chaque nom du fichier format (nom) (note)

Documentation
/**Fonction double_valeur qui double chaque valeur du fichier
/*@param nomFichier : nom du fichier au bon format
/*affiche le double des valeurs du fichier
**/

**2)** On modifie la fonction ainsi

void mystere(string nomFichier){
    ifstream fichier;
    fichier.open(nomFichier);
    string t;
    int n;
    while (fichier >> t and fichier >> n){
        cout<<"Nom: "<< t <<", note sur 10: "<< n <<",note sur 20: "<< 2*n <<endl;
    }
    fichier.close();
}

**Exercice 2**
**1)**
**Fonction qui calcule la moyenne des notes**

double moyenne(string nomFichier){
    ifstream fichier;
    fichier.open(nomFichier);
    string t;
    string n;
    double moy;
    double compteur=0;
    while (fichier >> t and fichier >> n){
        compteur++;
        moy = moy+n
    }
    fichier.close();
    double resultat = moy/compteur;
    return resultat;    
}

**Fonction qui retourne un tableau des notes**

vector<int> lit_notes(string nomFichier){
    ifstream fichier;
    fichier.open(nomFichier);
    int k=0;
    string t;
    int n;
    while (fichier >> t and fichier >> n){
        k++;
    }
    fichier.close();
    fichier.open(nomFichier);
    vector<int> tab = vector<int>(k);
    k=0;
    while (fichier >> t and fichier >> n){
        tab[k]=n;
        k++;
    }
    fichier.close();
    return tab;
}

**2)**
**Effectuer tests**

void test(){
    ASSERT( moyenne("truc.txt") == 2.4 );
    vector<int> tab = {4,2,3,2,1};
    ASSERT( lit_notes("truc.txt") == tab);
}

**3)**
On peut changer la fonction type void en type string, et en retournant une chaine de caractères on peut effectuer un test comme ceux ci-dessus

**Exercice 3**
On utilise les valeurs 0 et 1 pour coder le blanc et le noir

**Exercice 4**
On utilise les valeurs de 0 à 255 pour coder un dégradé de couleurs. Les trois couleurs primaires usuelles sont le rouge, le vert et le bleu

**Exercice 5**

**Fonction qui détermine le nombre de mots d'un fichier ne contenant que des mots ou nombres**

int word_count(string nomFichier){
    ifstream fichier;
    fichier.open(nomFichier);
    int count=0;
    string lecture;
    while (fichier >> lecture){
        istringstream flux = istringstream(lecture);
        double typeNombre;
        if ( not (flux >> typeNombre)){
            count++;
        }
    }
    fichier.close();
    return count;
}

**Fonction qui retourne le nombre de lignes d'un fichier**

int line_count(string nomFichier){
    int nbLignes=0;
    ifstream fichier;
    fichier.open(nomFichier);
    string ligne;
    while (getline(fichier,ligne)){
        nbLignes++;
    }
    fichier.close();
    return nbLignes;
}

**Fonction qui affiche le fichier en sortie**

void cat(string nomFichier){
    ifstream fichier;
    fichier.open(nomFichier);
    string ligne;
    while (getline(fichier,ligne)){
        cout << ligne << endl;
    }
    fichier.close();
}

**Fonction qui copie le contenu d'un fichier dans un autre**

void copy(string source, string destination){
    ifstream fichierSource;
    fichierSource.open(source);
    string ligne;
    string copie;
    while (getline(fichierSource,ligne)){
        copie = copie + ligne + "\n";
    }
    fichierSource.close();
    ofstream fichierDest;
    fichierDest.open(destination);
    fichierDest << copie << endl;
    fichierDest.close();
}

**Exercice 6**
La fonction mystereEpais retourne le nombre de caractères du fichier

void test(){
    ASSERT( mystereEpais("truc.txt") == 32)
}

**Exercice 7**

**1)**

void synthese(){
    if(not(line_count("etud1.txt")==line_count("etud2.txt") and line_count("etud1.txt")==line_count("etud3.txt"))){
        throw runtime_error ("Erreur : pas le même nombre d'élèves")
    }
    ifstream f1;
    f1.open("etud1.txt");
    ifstream f2;
    f2.open("etud2.txt");
    ifstream f3;
    f3.open("etud3.txt");
    string lecture;
    string nom1, nom2, nom3;
    string groupe1, groupe2, groupe3;
    string note1, note2, note3;
    for (int k=1; k<=line_count("etud1.txt");k++){
        f1 >> nom1 >> groupe1 >> note1;
        f2 >> nom2 >> groupe2 >> note2;
        f3 >> nom3 >> groupe3 >> note3;
        if ( not ((nom1 == nom2) and (nom1 == nom3))){
            throw runtime_error("Erreur : verifier ordre");
        }
        lecture = lecture+nom1+" "+groupe1+" "+note1+" "+note2+" "+note3+"\n";
    }
    f1.close();
    f2.close();
    f3.close();
    ofstream fichier;
    fichier.open("synthese.txt");
    fichier << lecture << endl;
    fichier.close();
    }
}

**2)**

void groupes_moyennes(){
    vector<string> repertoire;
    repertoire = vector<string>(line_count("synthese.txt")*2);
    ifstream fichier;
    fichier.open("synthese.txt");
    string ligne;
    int nbre_groupes = 0;
    while (getline(fichier,ligne)){
        istringstream flux;
        flux = istringstream(ligne);
        string nom, groupe;
        double note1, note2, note3;
        flux >> nom >> groupe >> note1 >> note2 >> note3;
        int i=0;
        double moy = (note1 + note2 + note3)/3.;
        while (repertoire[i]!= groupe){
            if (repertoire[i] == ""){
                repertoire[i] = groupe;
                nbre_groupes++;
            } else {
                i=i+2;
            }
        }
        ostringstream flux2;
        flux2 << nom << " " << moy << endl;
        string ajout = flux2.str();
        repertoire[i+1] = repertoire[i+1] + ajout;
    }
    fichier.close();
    for (int k=0; k < nbre_groupes; k++){
        string nomFichier = "groupe" + repertoire[k*2] + ".txt";
        ofstream nouveau;
        nouveau.open(nomFichier);
        nouveau << repertoire[(k*2)+1] << endl;
        nouveau.close();
    }
}

## Marie
Exercice 1: 1)la fonction affiche le double d'un nombre n associé à une personne
format : chaine de caractere ou un texte (string)
nom de la fonction : AfficheDouble
t => noms du joueur (ex:Messi)
n => nombre de but
Documentation
**// Fonction AfficheDouble affiche le double de chaque but associé aux personnes incrites dans le fichier truc.txt
@param truc.txt fichier au contenant le nom des inscrits/ des joueurs
@return nombre de but

## Rémi
Exercice 1
1) La fonction mystere affiche les noms des personnes inscrites dans le fichier truc.txt et le double du nombre qui leur est associé. On remplace la variable t par nom et n par nombredebuts. Le format du fichier est txt (texte).
Documentation
**/La fonction mystere affiche les noms des personnes inscrites dans le fichier et le double du nombre de buts de chacun.
@param truc.txt une chaine de caracteres qui contient les noms des joeurs et leur nombre de buts
@return rien du tout car on affiche
2)
void question2(string nomFichier) {
ifstream fichier;
fichier.open(nomFichier);
string nom;
int notesur10;
while(fichier>>nom and fichier>>notesur10) {
cout<<"Nom: "<<nom<<", note sur 10: "<<notesur10<<", note sur 20: "<<notesur10*2<<endl;
}
fichier.close();
}

Exercice 2

1)
float moyenne(string nomFichier);
ifstream fichier;
fichier.open(nomFichier);
string nom;
int note;
int sommedesnotes=0;
int nombredenotes=0;
float moyenne;
while(fichier>>nom and fichier>>sommedesnotes) {
sommedesnotes=sommedesnotes+note;
nombredenotes=nombredenotes+1;
}
return moyenne=sommedesnotes/nombredenotes;

vector<int>lit_notes(string nomFichier) {
int nbrdelignes=0;
ifstream fichier;
fichier.open(nomFichier);
string nom1;
int note1;
while(fichier>>nom and fichier>>note) {
nbrdelignes=nbrdelignes+1;
}
fichier.close();
vector<int>tableaudesnotes(nbrdelignes);
fichier.open(nomFichier);
int note2;
string nom2;
for(int j=0;fichier<<nom2 and fichier>>note2;j++) {
tableaudesnotes[j]=note2;
}
fichier.close();
return tableaudesnotes;
}
Je fais la suite sur un autre document

## Laura
**Exercice 1**
1. Cette fonction affiche le double de chaque chiffre associé à une personne avec son prénom correspondant.

nom de la fonction : double_goalsFoot
t : joueur
n : goals

Documentation:
**/ Fonction double_goalsFoot qui associe les goals
@param fichier avec les joueurs et leur goals
ouverture du fichier
afficher "joueur 2*goals"

2. void notes_10_20(string notes){
ifstream fichier;
fichier.open(notes);
string prenom;
int note;
while(fichier>>prenom and fichier>>note){
cout<<prenom<<", note sur 10:"<<note<<", note sur 20:"<<2*note<<endl;
}
fichier.close();
}

**Exercice 2**

1. float moyenne(string nomFichier){
int m=0;
ifstream fichier;
fichier.open(nomFichier);
string nom;
int note;
for(int i=1;i<.....)
return m/i;
}

Exercice 3:
Quand il y a un 1: noire
0: blanc

Exercice 4:

Bleu, rouge, jaune
Donc pour chaque pixel on y associe une couleur formée d'une des trois couleurs primaires.

Exercice 5:

## Nolwenn
Exercice 1
1. La fonction affiche le double n de but de chaque joueurs d'un chiffre qui leur a été attribués
format txt
t joueur
n nombre but
documentation: la fonction affiche le noms des joeurs et le double de leur nombre de but
2. void nom_note10_note20
ifstream fichier

## Romane
Exercice 1
1. La fonction mystère renvoie le double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre qui estle double du chiffre

## Juliette
Ex 1:
1)cette fonction prend en compte des noms et des chiffres associés à ces noms.A la fin celle ci affiche les nom avec leurs chiffre qui ont été doublé.
2)void mystere (string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
string t;
int n;
int s=0;
while (fichier>>t and fichier>>n){
s=2*n;
cout<<"Nom:"<<t<<" note sur 10:"<<n<<"" note sur 20:"<<s<<endl;
}
}
Ex 2
float moyenne(string nomFichier){
ifstream fichier ;
fichier.open(nomFichier) ;
string nom ;
int note ;
int s=0 ;
int g=0 ;
while (fichier >>nom and fichier>>g){
s=s+note ;
g=g+1 ;
}fichier close ;
return s/g;
}

vector<int>lit_notes(string nomFichier){
vector<int>t ;
ifstream fichier ;
fichier.open(nomFichier) ;
int n ;
for(int i = 0 ; fichier>>nom;i++){
t[i]=n;}
return t;}

2)nomfichier =truc.txt
paolo 7 ;
paola 9 ;
ASSERT(moyenne(truc)==9) ;
ASSERT(lit_note(truc)=={7,9}) ;

Ex3:

## Axel Geertsen
Exercice 1
1. Les prénoms ont eu un chiffre qui leur à été attribué.Celui ci est doublé.
format: Texte
Nouveau nom de la fonction: note_enfant
Variables: String: enfant
Int n: note
void age_enfant(string nomFichier){
ifstream fichier;
fichier.open (nomFichier);
string enfant;
int note;
while (fichier>> age and fichier>> enfant){
cout<<enfant<<" "<< "note sur 10"<<note<< "note sur 20"<< 2*n<<endl;
} fichier.close();
}

Exercice 2.
float moyenne(string nomFichier);
ifstream fichier;
fichier.open(nomFichier);
int nombredenote = 0 ;
int sommedenote = 0 ;
string t;
double n;
double moyenne ;
while (fichier>> t and fichier>>n) {
nombredenote = nombredenote +1 ;
sommedenote = sommedenote + n ;
} fichier.close() ;
moyenne = sommedenote / nombredenote ;
Return moyenne ;
}

vector<int> lit_notes(string nomFichier);
ifstream fichier;
fichier.open(nomFichier);
int p =0;
while (fichier>> t and fichier>>n) {
p=p+1;
} fichier.close() ;
lit_notes = vector<int> (p) ;
p=0 ;
while (fichier>>t and fichier>>n){
lit_notes[p]=n;
p= p +1 ;
}fichier.close() ;

Exercice 3
Le 10, 10 est une indication du nombre de pixel dans le carré, c'est à dire dans ce cas ci 100. Le binaire qui suit est pour indiquer quel pixel à quelle couleur entre le noir et le blanc. dans ce cas il y a 100 valeurs qui sont partagés entre les 2 valeurs.

Exercice 4
En peinture, les 3 couleurs primaires usuelles sont le jaune, le magenta et le cyan. En physique (lumière), les 3 couleurs primaires sont le rouge, le jaune et le vert. ces couleurs sont numériquements définie sur 256 (de 0 à 255). ces 256 valeurs désignent à quel point la couleur est prononcé. DAns ce document on remarque qu'il y a 18 chiffres, des 0 ou des 255. Il faut donc regrouper ces paquets par groupe de 3. Lorsque l'on fait cela, on a la proportion de chaque couleur primaire pour chaque pixel.

Exercice 5
/** compte le nombre de mots**/
int word_count(string nomFichier) {
ifstream fichier;
fichier.open(nomFichier);
string t;
int n=0;
while ( fichier >> t ) {
n=n+1;
}
fichier.close();
return n;
}

/**compte le nombre de lignes**/
int line_count(string nomFichier){
ifstream fichier;
fichier.open(nomFichier);
string t;
int n=0;
while ( comment qu'on compte les lignes? ) {
n=n+1;
}
fichier.close();
return n;
}
}