---
jupytext:
  text_representation:
    extension: .md
    format_name: myst
    format_version: 0.13
kernelspec:
  display_name: C++17
  language: C++17
  name: xcpp17
---
# Exercice 3

:::{exercice}
:points: 12
:::

On appelle « nombres triangulaires » les nombres entiers strictement
positifs qui sont égaux à la somme de plusieurs entiers consécutifs à
partir de $1$. Par exemple:

$21$ est un nombre triangulaire car $21 = 1+2+3+4+5+6$

$7$ n'est pas un nombre triangulaire car $1+2+3 < 7 < 1+2+3+4$

Le premier nombre triangulaire est $1$.

Le deuxième nombre triangulaire est $3$ car $1+2=3$.

Le troisième nombre triangulaire est $6$ car $1+2+3=6$. Etc.

On considère la fonction `nombreTriangulaire` dont la documentation
est donnée ci-dessous:

```{code-cell}
/** Fonction nombreTriangulaire
 *  @param un entier n strictement positif
 *  @return le n-ième nombre triangulaire, somme des entiers de 1 à n
 **/
```

:::{question}
:points: 20
:temps: 4
:::
Écrivez trois tests pour cette fonction:

```{code-cell}
:tags: [remove-cell]

// Comment faire sans cette duplication?

int nombreTriangulaire(int n) {
    int somme = 0;
    for (int k = 1 ; k <= n ; k++) {
    	somme = somme + k;
    }
    return somme;
}
```

```{code-cell}
/// BEGIN SOLUTION
CHECK( nombreTriangulaire(1) == 1 );
CHECK( nombreTriangulaire(2) == 3 );
CHECK( nombreTriangulaire(3) == 6 );
/// END SOLUTION
```

:::{endquestion}
:::

{raw:latex}`\clearpage`

:::{question}
:temps: 2
:::

Écrivez un fragment de programme qui affiche à l'écran les dix
premiers nombres triangulaires, **en utilisant la fonction
`nombreTriangulaire`**:

```{code-cell}
:tags: [remove-cell]

#include <iostream>
using namespace std;
```

```{code-cell}
/// BEGIN SOLUTION
for ( int n = 1 ; n <= 10 ; n++ ) {
	cout << nombreTriangulaire(n) << " ";
}
cout << endl ;
/// END SOLUTION
```

:::{endquestion}
:::


:::{question}
:temps: 3
:::
Complétez la définition de la fonction ci-dessous:

```{code-cell}
int nombreTriangulaire(int n) {
    /// BEGIN SOLUTION
    int somme = 0;
    for (int k = 1 ; k <= n ; k++) {
    	somme = somme + k;
    }
    return somme;
    /// END SOLUTION
}
```

:::{endquestion}
:::

:::{question}
:temps: 3
:::
$\clubsuit$ Définissez une version récursive de cette fonction:

```{code-cell}
int nombreTriangulaireRécursive(int n) {
	/// BEGIN SOLUTION
    if ( n == 1 ){
        return 1;
    } else {
        return n + nombreTriangulaireRécursive(n-1);
    }
    /// END SOLUTION
}
```

:::{endquestion}
:::

```{code-cell}
:tags: [remove-cell]

CHECK( nombreTriangulaireRécursive(1) == 1 );
CHECK( nombreTriangulaireRécursive(2) == 3 );
CHECK( nombreTriangulaireRécursive(3) == 6 );
CHECK( nombreTriangulaireRécursive(5) == 15);
```

:::{question}
:temps: 6
:::
On cherche maintenant à déterminer si un nombre est triangulaire.
Définissez la fonction dont la documentation est donnée ci-dessous.
**Cette fonction devra utiliser (appeler) la fonction
`nombreTriangulaire` écrite précédemment**.

```{code-cell}
/** Fonction estTriangulaire
 *  @param p un nombre entier
 *  @return true si p est un nombre triangulaire, false sinon.
 **/
bool estTriangulaire(int p) {
    /// BEGIN SOLUTION
    int n;
    for ( n=1; nombreTriangulaire(n) < p; n++ ) {
	}
    return nombreTriangulaire(n) == p;
    /// END SOLUTION
}
```

```{code-cell}
:tags: [remove-cell]

CHECK(     estTriangulaire(21) );
CHECK( not estTriangulaire( 7) );
CHECK(     estTriangulaire(10) );
```

:::{endquestion}
:::

:::{endexercice}
:::