Skip to content
Snippets Groups Projects
Commit b03b11b6 authored by Nicolas M. Thiéry's avatar Nicolas M. Thiéry
Browse files

Préparation

parents
No related branches found
No related tags found
No related merge requests found
Pipeline #51342 failed
Stage: test
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 2410 additions and 0 deletions
.gitignore 0 → 100644
+ 15
− 0
View file @ b03b11b6
feedback
feedback_generated
autograded
attic
.ipynb_checkpoints
*.pyc
__pycache__
*~
core*
*.avi
*.mp4
*.aux
*.log
*.out
\ No newline at end of file
.gitlab-ci.yml 0 → 100644
+ 16
− 0
View file @ b03b11b6
image: gitlab.dsi.universite-paris-saclay.fr:5005/info111/computerlab/image:latest
variables:
ASSIGNMENT: Semaine2
STUDENT: $CI_PROJECT_ROOT_NAMESPACE
autograde:
script:
- STUDENT=`echo $STUDENT | sed -e 's/_travo//;s/_/./'`
- info-111 student_autograde $ASSIGNMENT $STUDENT
artifacts:
paths:
- autograded
- feedback
# reports:
# junit: feedback/scores.xml
.gradebook.db 0 → 100644
+ 0
− 0
View file @ b03b11b6
File added
00-jupyter-mode-edition-vs-commande.md 0 → 100644
+ 147
− 0
View file @ b03b11b6
---
jupytext:
text_representation:
extension: .md
format_name: myst
format_version: 0.13
jupytext_version: 1.15.1
kernelspec:
display_name: Python 3 (ipykernel)
language: python
name: python3
---
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "0d65b1db4ff4d2aefc74ed2c66a51567", "grade": false, "grade_id": "cell-d4e64962efcbc324", "locked": true, "schema_version": 3, "solution": false, "task": false}}
# TP : Jupyter : mode Édition vs mode Commande
<div class="alert alert-info">
Objectif pédagogique : Découvrir les deux modes d'interaction avec un
carnet Jupyter.
</div>
Lorsque l'on travaille sur un carnet Jupyter, on est amené à
alternativement éditer le contenu d'une cellule (par exemple y écrire
du texte) et naviguer entre les cellules et les manipuler
(par exemple supprimer une cellule, ou en insérer une
nouvelle). Jusqu'ici, vous avez probablement utilisé la souris et les
menus pour effectuer ces manipulations de cellules.
Pour travailler plus efficacement, notamment à l'aide de raccourcis clavier,
les carnets Jupyter offrent deux modes d'éditions:
- Le mode ***Édition*** qui permet, comme son nom l'indique, d'éditer le
contenu d'une cellule. C'est celui que vous avez utilisé lorsque
vous avez cliqué ou double cliqué dans une cellule.
- Le mode ***Commande*** qui permet de naviguer d'une cellule à
l'autre et de les manipuler.
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "c9b9cbd959df806a0c76d72bd69931b6", "grade": false, "grade_id": "cell-da8f72cb85b2d1de", "locked": true, "schema_version": 3, "solution": false, "task": false}}
<!--
Vous trouverez tous les raccourcis clavier dans le menu `Aide` ->
`Raccourcis` clavier. Ils sont aussi rappelés dans les menus
eux-même.
!-->
<div class="alert alert-info">
**Les raccourcis clavier essentiels :**
En mode commande :
- Naviguer entre cellules : touches <kbd>↑</kbd> et <kbd>↓</kbd>;
- Basculer en mode Édition sur la cellule courante : touche <kbd>Entrée</kbd>
- Ajouter une cellule Avant : touche <kbd>A</kbd> (comme *above*)
- Ajouter une cellule Après : touche <kbd>B</kbd> (comme *below*)
- Couper une cellule : touche <kbd>X</kbd>
- Copier une cellule : touche <kbd>C</kbd>
- Coller une cellule : touche <kbd>V</kbd>
- Annuler : toucher <kbd>Z</kbd>
- Fusionner avec la cellule du dessous : touches <kbd>Maj</kbd>+<kbd>M</kbd>
<!--
- Obtenir la liste des raccourcis claviers : touche <kbd>H</kbd> (comme *help*);
!-->
En mode édition :
- Basculer en mode Commande : touche <kbd>Esc</kbd>
- Sélectionner au clavier : <kbd>Maj</kbd>-touche de déplacement
- Couper : <kbd>Ctrl</kbd>-<kbd>x</kbd>
- Copier : <kbd>Ctrl</kbd>-<kbd>c</kbd>
- Coller : <kbd>Ctrl</kbd>-<kbd>v</kbd>
</div>
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "4586f168f62b18c016204ff685941479", "grade": false, "grade_id": "cell-1ac7fa2533514788", "locked": true, "schema_version": 3, "solution": false, "task": false}}
## Exercice
Votre défi est d'effectuer l'ensemble de cet exercice, sans toucher
votre souris!
1. Observez la cellule actuellement sélectionnée. Est-elle encadrée
d'un liseré bleu? Si oui vous êtes en mode Édition. Sinon, vous
êtes mode Commande. Utilisez les touches <kbd>Entrée</kbd> et
<kbd>Echap</kbd> pour basculer de l'un à l'autre de ces
modes. Finissez par <kbd>Echap</kbd> pour être en mode commande.
2. Utilisez les flèches <kbd>↑</kbd> et <kbd>↓</kbd> pour vous déplacer rapidement
d'une cellule à l'autre
3. Éditez les cellules ci-dessous en suivant les instructions
qu'elles contiennent.
+++
Je suis la cellule B. Écrivez votre nom ici :
+++
Supprimez-moi!
+++
Je suis la cellule A. Déplacez moi avant la cellule B.
+++
Je souhaiterai qu'on rajoute une cellule avant moi.
+++ {"deletable": false, "editable": true}
Entrez en **mode édition** dans cette cellule, puis suivez les instructions ci-dessous :
Je conserve cette ligne
Je supprime cette ligne
Je supprime cette ligne
Je conserve cette ligne aussi
Je conserve également cette ligne
Je supprime cette ligne
Je garde celle là aussi
Mais je supprime cette ligne
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "5287c2683d7b592a5729b8e5f528cbce", "grade": false, "grade_id": "cell-6144a810d1986571", "locked": true, "schema_version": 3, "solution": false, "task": false}}
## Conclusion
Utiliser alternativement les deux modes Édition et Commande vous
permettra de manipuler efficacement les carnets Jupyter au clavier.
Consultez régulièrement la liste des raccourcis disponibles et
apprenez en un ou deux à chaque séance!
<!-- TODO: liens vers les suites naturelles: réordonner cellules, -->
<!-- jeter sa souris -->
<!--
<div class="btn btn-default btn-xs" role="button">
[<i class="fa fa-home"></i> Revenir à l'accueil du Tutoriel Jupyter](https://jupyter.gitlab.dsi.universite-paris-saclay.fr/tutoriel-jupyter/intro.html)
</div>
## Pour aller plus loin
* Découvrez comment différencier et utiliser les cellules de texte (Markdown) et de code executable avec ce [tuto](https://jupyter.gitlab.dsi.universite-paris-saclay.fr/tutoriel-jupyter/tuto-les-types-de-cellules.html)
*
!-->
01-valeurs-types.md 0 → 100644
+ 588
− 0
View file @ b03b11b6
---
jupytext:
text_representation:
extension: .md
format_name: myst
format_version: 0.13
jupytext_version: 1.15.1
kernelspec:
display_name: C++17
language: C++17
name: xcpp17
---
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "11bc746bb3f36668d563917b04467610", "grade": false, "grade_id": "cell-b78562ee2ff6d72c", "locked": true, "schema_version": 3, "solution": false}}
# TP : valeurs, types et variables
## Introduction à Jupyter et premiers calculs
Lors de ces premières semaines de cours, nous allons travailler dans
l'application web *Jupyter* qui permet d'exécuter du code `C++`
interactivement, un peu comme une super calculatrice. Plus tard, nous
verrons comment créer un programme `C++` indépendant en dehors de
*Jupyter*.
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "31783578f8bde28209b21d60b4afa8df", "grade": false, "grade_id": "cell-33660fa4ef5903e4", "locked": true, "schema_version": 3, "solution": false}}
**Exercice 1 : premiers calculs**
- Cliquez sur la cellule suivante puis exécutez la en appuyant sur les
touches <kbd>Maj</kbd>+<kbd>Entrée</kbd> :
```{code-cell}
1 + 1
```
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "a641bd5ef111d5f779f4d06209dffffb", "grade": false, "grade_id": "cell-291a3535b726abef", "locked": true, "schema_version": 3, "solution": false}}
La première ligne donne le résultat du calcul. La deuxième ligne
indique que ce résultat est de type *entier* (`int`).
Techniquement parlant, le navigateur web a envoyé le contenu `1+1` de
la cellule à un *noyau* (kernel en anglais) qui l'a *compilé* et
*exécuté*, avant de renvoyer le résultat à afficher. Le noyau que nous
utilisons (`C++17`) permet de travailler en `C++`. Il existe des
noyaux pour beaucoup d'autres langages de programmation.
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "23ac875d5810411efd84b5b11ec27071", "grade": false, "grade_id": "cell-c7495bbedb1de8c7", "locked": true, "schema_version": 3, "solution": false}}
- Modifiez l'expression dans la cellule précédente et exécutez la de
nouveau.
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "d687d8f5e69fce473a4c069310d311e9", "grade": false, "grade_id": "cell-12b1679926b1768d", "locked": true, "schema_version": 3, "solution": false}}
- Utilisez la cellule suivante pour calculer la surface d'un rectangle
de largeur 25 et de longueur 37 :
```{code-cell}
---
deletable: false
nbgrader:
cell_type: code
checksum: 6c2954c10ebb31553b07a0019812862e
grade: false
grade_id: cell-b645bc465bd310ae
locked: false
schema_version: 3
solution: true
ordo_failure: "R\xE9ponse incorrecte; essayes encore!"
ordo_solution:
text/plain: '925
type: int'
ordo_success: "Bonne r\xE9ponse!"
---
// REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
```
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "d8e8920ea94e7d6c8db86d6b29e849fe", "grade": false, "grade_id": "cell-1b42d53da30ded82", "locked": true, "schema_version": 3, "solution": false, "task": false}}
**Exercice 2 : types**
Vous avez vu en cours qu'il existe plusieurs types de variables
(`int`, `double`, etc.). Il est très utile de connaître le type des
valeurs que l'on manipule. Exécutez les cellules suivantes et observez
les types obtenus :
```{code-cell}
3*4
```
```{code-cell}
3*4.0
```
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "f91a40fc1958f4b6f1e0681d8df77441", "grade": false, "grade_id": "cell-7c72028bf998c9e5", "locked": true, "schema_version": 3, "solution": false}}
Les lignes suivantes vous présentent des exemples de
calculs. Exécutez-les en observant bien la valeur du résultat et son
type.
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: 593fcfb7063e8d55389842ed36c10a03
grade: false
grade_id: cell-678ae0462813d831
locked: true
schema_version: 3
solution: false
task: false
---
3*(1+3) + (1+4)*(2+4)
```
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: 9f3cc6c0e458e40336da192b6f55aa16
grade: false
grade_id: cell-8c8f01689a82794b
locked: true
schema_version: 3
solution: false
task: false
---
42 / 2
```
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: babcd64046ca10ca7696da6a16825c30
grade: false
grade_id: cell-9678ffe15c270b81
locked: true
schema_version: 3
solution: false
task: false
---
42 / 5
```
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: a1b61504a42f653f72eeb746b99dd23f
grade: false
grade_id: cell-15172444994cbdff
locked: true
schema_version: 3
solution: false
task: false
---
42. / 5
```
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: 7f94e7cc2a78f5f84d00835ab6e3c7fc
grade: false
grade_id: cell-7009aedea5b1e925
locked: true
schema_version: 3
solution: false
task: false
---
42 % 5
```
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: 73faf81ec97e7a196d35eb58d0016ed1
grade: false
grade_id: cell-7c66e2817d57b95c
locked: true
schema_version: 3
solution: false
task: false
---
1 + 1.
```
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: eb7d7730da271c2d1e497aa89c9ad470
grade: false
grade_id: cell-33bc66dde9266641
locked: true
schema_version: 3
solution: false
task: false
---
42 == 6*7
```
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: 88c54f98c8270c287d5ff9cf434e1f2a
grade: false
grade_id: cell-3163364eab44d8d7
locked: true
schema_version: 3
solution: false
task: false
---
41 == 2*21
```
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "b03fd9ec2be270091121833ce867f1cc", "grade": false, "grade_id": "cell-cf97d7e3ffc985a0", "locked": true, "schema_version": 3, "solution": false}}
Remarque: dans les deux cellules précédentes, nous avons utilisé un
**double égal** `==` qui sert à **tester** l'égalité entre deux
valeurs. Nous reverrons bientôt la signification du **simple égal**
`=`.
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: dbabeaac7e3f9d86ef9a32e951cd5df1
grade: false
grade_id: cell-d4b738450011dd37
locked: true
schema_version: 3
solution: false
task: false
---
1 < 2
```
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: 0a8e6b094ad756a7c0ffa364fcc7ee15
grade: false
grade_id: cell-3e5e3a25f145a973
locked: true
schema_version: 3
solution: false
task: false
---
2 > 3
```
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: cb08d8a9c4574e2b2adad48f3464fad8
grade: false
grade_id: cell-606159825dc54bf9
locked: true
schema_version: 3
solution: false
task: false
---
1 < 2 and 2 > 3
```
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: 697a998ec2daa1290313a8fc7797575d
grade: false
grade_id: cell-783a55b0abd2377f
locked: true
schema_version: 3
solution: false
task: false
---
1 < 2 or 2 > 3
```
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "af204e753d48317334d009d9df551827", "grade": false, "grade_id": "cell-05caf97c8306b9b4", "locked": true, "schema_version": 3, "solution": false, "task": false}}
Note: pour éviter de fausses manœuvres, nous configurons de nombreuses
cellules, telles celles ci-dessus, pour qu'elles soient non
modifiables. Pour faire vos propres expérimentations ou pour prendre
des notes personnelles, vous pouvez à tout moment insérer de nouvelles
cellules. Insérez maintenant une cellule ci-dessous en utilisant le
bouton `+` sous les onglets. Dans la barre d'outil de cette feuille,
sélectionnez `Markdown` à la place de `Code` pour en faire une cellule
de texte.
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "f111bfd79786faaa5d38dc0f13967c66", "grade": false, "grade_id": "cell-884721498ad284a1", "locked": true, "schema_version": 3, "solution": false}}
**Exercice 3 :**
Pour chacune des expressions suivantes, déterminez **de tête** le type
et la valeur du résultat, et donnez votre réponse à l'endroit indiqué
sous la forme `type`, `valeur`; puis vérifiez en exécutant les
cellules.
+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "2c2010fc398715fd883ec87dbcf20298", "grade": true, "grade_id": "cell-a8d152d15809265f", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
---
* Type : int, bool, ou double ?
* Valeur : 7, 9, 11, ou 21 ?
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: a72897335f295c7d452b11e914f2fc49
grade: false
grade_id: cell-0f3ff9e9e4c33f41
locked: true
schema_version: 3
solution: false
---
3 * 2 + 5
```
+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "dfe5e7372570d9dea7fd0e5805abc6c1", "grade": true, "grade_id": "cell-b866905e681f44cb", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
---
* Type : int, bool, ou double ?
* Valeur : 12 ou 12.5 ?
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: 962d88d6809f73496c72662e2f1a341d
grade: false
grade_id: cell-127febc577edfc08
locked: true
schema_version: 3
solution: false
---
25 / 2
```
+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "6c2e63ea6633366117382f5c3f127e60", "grade": true, "grade_id": "cell-899fabbcd7ecd371", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
---
* Type : int, bool, ou double ?
* Valeur : 6, 7, 6.0000, ou 7.0000?
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: dfc73c6565beb9718da57a04d56a539a
grade: false
grade_id: cell-286c54ae7e34701d
locked: true
schema_version: 3
solution: false
---
3.5*2
```
+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "71eee2fa3fea6fb3788badde6e41dfc0", "grade": true, "grade_id": "cell-fe0c64ef514d2b0f", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
---
* Type: int, bool, ou double ?
* Valeur : 5, 4, ou 4.66667 ?
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: 20a02b357e2b564128c22de02d6bafff
grade: false
grade_id: cell-b52c330c011b1b89
locked: true
schema_version: 3
solution: false
task: false
---
14. / 3
```
+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "26ca09cd9707728cdd34ca521aed3382", "grade": true, "grade_id": "cell-b1b2d0d4b7baa06e", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
---
* Type : int, bool, ou double ?
* Valeur : 3,7,21, true, ou false ?
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: 5d1d2f1a6a8c2051575b59fe5305d7ab
grade: false
grade_id: cell-67ced375854c7fb3
locked: true
schema_version: 3
solution: false
task: false
---
3*7 == 21
```
+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "ff1acd99636db830d19c4999334bfe63", "grade": true, "grade_id": "cell-59ff90739ae5b7b2", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
---
* Type : int, bool, double ?
* Valeur : 21, 25, true, false ?
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: 1ed41b3835b89e6fcbc70955741fe280
grade: false
grade_id: cell-959d3023456a140e
locked: true
schema_version: 3
solution: false
task: false
---
(3*7 == 21) and (4.2 > 5.3 or 4*4 == 8*2)
```
+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "334e68aa2b0ee056926c9e5d3f54bf12", "grade": true, "grade_id": "cell-2bf659cbac5d597a", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
---
* Type : int, bool, double ?
* Valeur : 1, 0, true, false ?
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: abfc8ff20663be8e6949ec8c6c06ce55
grade: false
grade_id: cell-f47f3ad36d564ee3
locked: true
schema_version: 3
solution: false
task: false
---
true and false
```
+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "4ca4d1bcbd35f830508935fdcf0b1e2a", "grade": true, "grade_id": "cell-e5856c338c095691", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
---
* Type : int, bool, double ?
* Valeur : 1, 0, true, false ?
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: 84b49eb8f761d684f8e79173e910b814
grade: false
grade_id: cell-e0555c4a9b71b38e
locked: true
schema_version: 3
solution: false
task: false
---
true or false
```
+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "ced8c634c6cc49e5a69c156df6e90a91", "grade": true, "grade_id": "cell-89f6e927581416a9", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
---
* Type : int, bool, double ?
* Valeur : 1, 0, true, false ?
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: ab4121e4a092cce93227b3fe2b6c7ca1
grade: false
grade_id: cell-b578732ac62c6681
locked: true
schema_version: 3
solution: false
task: false
---
(false and false) or true
```
+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "d0147601a4bf7a09551fff8080059637", "grade": true, "grade_id": "cell-447af0863372964d", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
---
* Type : int, bool, double ?
* Valeur : 1, 0, true, false ?
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
```{code-cell}
---
deletable: false
editable: false
nbgrader:
cell_type: code
checksum: cb2b8d971ecd3f9ac908ced0e3a2f28b
grade: false
grade_id: cell-64d5df8a0de7fed9
locked: true
schema_version: 3
solution: false
task: false
---
false and (false or true)
```
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "b13d62422ced658b42da7508a80bcb1a", "grade": false, "grade_id": "cell-6e834cd22ecc144b", "locked": true, "schema_version": 3, "solution": false}}
Bravo, vous avez terminé cette première feuille où vous avez exploré
les expressions, valeurs, types en C++. Dans la feuille suivante, vous
aborderez les variables.
Vous pouvez maintenant fermer cette feuille; utilisez pour cela le
raccourci clavier <kbd>Ctrl</kbd>+<kbd>Maj</kbd>+<kbd>Q</kbd>.
02-variables.md 0 → 100644
+ 0
− 0
View file @ b03b11b6
This diff is collapsed.
03-conditions-fonctions.md 0 → 100644
+ 0
− 0
View file @ b03b11b6
This diff is collapsed.
04-td-exercice3.md 0 → 100644
+ 29
− 0
View file @ b03b11b6
---
jupytext:
text_representation:
extension: .md
format_name: myst
format_version: 0.13
jupytext_version: 1.15.1
kernelspec:
display_name: C++17
language: C++17
name: xcpp17
---
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "d7152fc1ff1988cc180a0a234bd70a2e", "grade": false, "grade_id": "cell-ff26d1e4ab285cb4", "locked": true, "schema_version": 3, "solution": false, "task": false}}
# TP : retour sur l'exercice 3 du TD
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "23e6b697bab1e68fe14f70fb2b382003", "grade": false, "grade_id": "cell-1b21180343eef5af", "locked": true, "schema_version": 3, "solution": false}}
Consultez l'énoncé de TD et et implantez en `C++` les algorithmes de
l'exercice 3, autant que possible sans consulter vos notes de TD.
Pensez à faire des tests pour vérifier vos réponses. Vous aurez besoin
d'ajouter de nouvelles cellules (bouton <kbd>+</kbd> dans la barre
d'outil de la feuille).
```{code-cell}
```
05-td-exercice4.md 0 → 100644
+ 19
− 0
View file @ b03b11b6
---
jupytext:
text_representation:
extension: .md
format_name: myst
format_version: 0.13
jupytext_version: 1.15.1
kernelspec:
display_name: C++17
language: C++17
name: xcpp17
---
# TP : retour sur l'exercice 4 du TD
```{code-cell}
```
TD.md 0 → 100644
+ 224
− 0
View file @ b03b11b6
---
exports:
- format: pdf
output: TD.pdf
template: ../../template/TD
- format: tex
output: TDmd.tex
template: ../../template/TD
jupytext:
notebook_metadata_filter: exports, myst
text_representation:
extension: .md
format_name: myst
format_version: 0.13
jupytext_version: 1.15.1
kernelspec:
display_name: C++17
language: C++17
name: xcpp17
---
# TD 2: affectations, instructions conditionnelles
+++
:::{todo}
Mettre à jour la note pour les enseignants selon que les polys ont déjà été imprimés / distribués ou pas.
:::
+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "3646ea08d143a76ae9ab457e4dca2a32", "grade": true, "grade_id": "10", "locked": false, "points": 0, "schema_version": 3, "solution": true}}
::::{admonition} Exercice 1 : affectations
Voici un fragment de programme `Échange`. On suppose que les variables
entières `n1` et `n2` ont été préalablement déclarées et initialisées:
n1 = n2;
n2 = n1;
1. En première lecture, que fait ce fragment de programme?
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
2. Exécutez le fragment de programme pas à pas avec comme valeurs
initiales `5` et `7` pour les variables `n1` et `n2`
respectivement. Obtient-on à la fin les valeurs attendues dans ces
variables ?
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
3. Modifiez le programme pour qu'il réponde à ce qui est
attendu. Seules des déclarations de variables et des affectations
sont nécessaires pour cela.
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
::::
+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "8d908402d296f5bbdca6839ac9c533f7", "grade": true, "grade_id": "30", "locked": false, "points": 0, "schema_version": 3, "solution": true}}
::::{admonition} Exercice 2 : conditionnelles
En relisant votre cours après l'amphi, vous avez appris les opérations
sur les entiers ainsi que les opérations booléennes. Cela vous sera
utile dans cet exercice. On suppose que l'on a déjà déclaré et
initialisé une variable `n` de type entier. On veut diviser $n$ par
$2$ s'il est pair et lui enlever $1$ s'il est impair. Écrivez les
quelques lignes d'instructions correspondantes.
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
::::
+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "e751bbbc92e4e72670429fdf78bd2db2", "grade": true, "grade_id": "50", "locked": false, "points": 0, "schema_version": 3, "solution": true}}
::::{admonition} Exercice 3 : conditionnelles, fonctions
Dans cet exercice (et les suivants), vous préciserez le nom, l'entrée
et la sortie de vos programmes comme dans l'exemple suivant :
// Programme produit
// Entrée: deux entiers a et b de type int
// Sortie: le produit de a et b stocké dans une variable p
int p;
p = a*b;
Si vous vous sentez à l'aise, ou lorsque cela est demandé, mettez
votre programme sous la forme d'une fonction :
int produit(int a, int b) {
return a*b;
}
Lors de la fin d'un semestre dans une Université X, les enseignants
sont amenés à calculer la moyenne générale des notes de physique et de
mathématiques selon une règle précise : la meilleure note des trois
épreuves de mathématiques est comptée coefficient 3, et la meilleure
note des deux épreuves de physique est comptée coefficient 2; les
autres notes ne comptent pas.
Un enseignant est chargé de concevoir un algorithme prenant en entrée
les trois notes de mathématiques et les deux notes de physique, et
donnant la moyenne générale suivant la règle énoncée ci-dessus.
1. Spécifiez et écrivez un algorithme `max2` qui, étant donnés deux
nombres réels `a` et `b` (qu'on suppose déjà déclarés et
initialisés), calcule le plus grand des deux et met le résultat
dans une variable `m`.
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
2. Transformez cet algorithme en une fonction nommée `max2` pour
pouvoir par la suite calculer le maximum de deux nombres avec un
appel à la fonction, par exemple `max2(7,5)`.
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
3. De même, étant donnés trois nombres réels, donnez un algorithme
calculant le plus grand des trois (dans une variable `m`). On
pourra utiliser la fonction `max2(a,b)`.
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
4. $\clubsuit$ Transformer cet algorithme en fonction.
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
5. Spécifiez et donnez un algorithme qui prend en entrée trois
notes de mathématiques, puis deux notes de physique, et calcule la
moyenne selon la règle spécifiée.
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
6. $\clubsuit$ Transformez cet algorithme en fonction.
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
::::
+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "a1dde20aae2304dcd4886ac8cc7af7cd", "grade": true, "grade_id": "70", "locked": false, "points": 0, "schema_version": 3, "solution": true}}
::::{admonition} Exercice 4 : rendu de monnaie
On considère une machine qui distribue des sucreries. Le problème
consiste à écrire le programme qu'elle exécute pour rendre la monnaie
sur une somme, à l'aide de pièces de 50 centimes, 20 centimes, 10
centimes et 5 centimes d'euro, de façon à minimiser le nombre de
pièces rendues sachant que l'on connaît le prix et la somme donnée par
le client. On suppose que les sommes sont données en centimes d'euro,
qu'il n'y a pas de risque de pénurie de pièces de monnaie, et que les
prix sont un multiple de 5 centimes. Par exemple si le prix à payer
est de 110 centimes et que le client a donné 200 centimes, il faut lui
rendre 1 pièce de 50 centimes et 2 pièces de 20 centimes.
1. Quelles sont les entrées / sorties du problème ?
// Entrées : la somme due (prix) et la somme donnée (somme),
// des entiers divisibles par 5
// Sorties : le nombre de pièces de 50, 20, 10 et 5 centimes
// à rendre (npieces50, npieces20, npieces10, npieces5).
2. Écrivez un programme pour résoudre le problème. On pourra supposer
que les variables `prix` et `somme` contiennent respectivement le
prix et la somme donnée par le client. À la fin du programme, la
variable `npieces50` devra contenir le nombre de pièces de
cinquante centimes à rendre, et de même pour les variables
`npieces20`, `npieces10` et `npieces5`.
Note : avec ce que vous avez appris, vous ne pouvez pas encore
écrire une fonction pour ce problème (pourquoi?).
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
3. $\clubsuit$ Comment gérer un nombre limité de pièces en réserve
dans la caisse de la machine?
::::
+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "26a341fc1567103da0dee7eff55ae08f", "grade": true, "grade_id": "80", "locked": false, "points": 0, "schema_version": 3, "solution": true}}
::::{admonition} Exercice 5 : $\clubsuit$ pierre-feuille-ciseaux
Héloïse et Gabriel veulent jouer à pierre-feuille-ciseaux, mais, têtes
en l'air, ils ne se souviennent jamais de qui bat quoi.
1. On numérote les joueurs par $1$ et $2$, et on représente un choix
par un entier: $1$ pour une pierre, $2$ pour une feuille, et $3$
pour les ciseaux. On suppose que les variables `choix1` et
`choix2` ont été déclarées et initialisées respectivement avec les
choix du joueur $1$ et $2$. Écrivez un programme dont la sortie,
stockée dans une variable `gagnant` contienne le numéro du joueur
gagnant (ou zéro si égalité).
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
2. Transformez votre programme sous forme d'une fonction.
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
3. Même chose en représentant un choix par un caractère (type
`char`): 'p' pour pierre, 'f' pour feuille, 'c' pour ciseaux.
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
4. $\clubsuit$ Même chose en utilisant un type `enum`.
% REMPLACER CETTE LIGNE PAR VOTRE RÉPONSE
::::
+++
Vous avez fini la feuille? Regardez les exercices du **Projet
Euler**[^1], une série de défis, de difficulté croissante, mêlant
mathématiques, algorithmique, et programmation. Chaque problème
possède une unique solution qu'il s'agit de découvrir par soi-même. Le
Problème 19 aborde les thématiques de cette semaine.
[^1]: <http://projecteuler.net/>; voir
<http://submoon.freeshell.org/fr/sphinx/euler.html> pour les
énoncés en français.
cours.md 0 → 100644
+ 1000
− 0
View file @ b03b11b6
---
jupytext:
notebook_metadata_filter: rise, semantic
text_representation:
extension: .md
format_name: myst
format_version: 0.13
jupytext_version: 1.15.1
kernelspec:
display_name: C++14
language: C++14
name: xcpp14
rise:
auto_select: first
autolaunch: false
centered: false
controls: false
enable_chalkboard: true
height: 100%
margin: 0
maxScale: 1
minScale: 1
scroll: true
slideNumber: true
start_slideshow_at: selected
transition: none
width: 90%
semantic:
use_module: info-111
---
+++ {"slideshow": {"slide_type": "slide"}}
# Premiers éléments de programmation impérative
+++ {"slideshow": {"slide_type": "slide"}}
## Prélude
+++ {"slideshow": {"slide_type": "slide"}}
### Résumé des épisodes précédents ...
+++ {"slideshow": {"slide_type": "fragment"}}
- Info 111: modalités et infrastructure
+++ {"slideshow": {"slide_type": "fragment"}}
- Informatique: usage, technologie, science
+++ {"slideshow": {"slide_type": "fragment"}}
- Objectif d'Info 111: initier à la science via la technologie
+++ {"slideshow": {"slide_type": "fragment"}}
- Concrètement: bases de la programmation impérative + ...
+++ {"slideshow": {"slide_type": "slide"}}
## Rappel
:::{prf:definition} Programmes
***Programme*** : suite d'instructions exécutées de manière
séquentielle (les unes après les autres)
:::
+++ {"slideshow": {"slide_type": "fragment"}}
<!-- TODO IMG -->
::::::{prf:example}
:::::{grid}
:gutter: 0
:::{grid-item-card}
```
debut()
droite()
avance()
prend()
gauche()
avance()
pose()
droite()
avance()
gauche()
avance()
avance()
droite()
ouvre()
```
:::
::::{grid-item-card}
:::{image} media/laby0.png
:height: 20ex
:align: center
:::
::::
:::::
::::::
+++ {"slideshow": {"slide_type": "slide"}}
## Comment rompre la monotonie?
+++ {"slideshow": {"slide_type": "fragment"}}
- Faire des calculs : *[expressions](expression) et [variables](variable)*
+++ {"slideshow": {"slide_type": "fragment"}}
- Découper en petits programmes : les *[fonctions](fonction_informelle)*
+++ {"slideshow": {"slide_type": "fragment"}}
- S'adapter au contexte : les *[instructions conditionnelles](instruction_conditionnelle)*
+++ {"slideshow": {"slide_type": "fragment"}}
- Répéter : les *[instructions itératives](instruction_iterative)* (boucles)
+++ {"slideshow": {"slide_type": "slide"}}
## Expressions
+++ {"slideshow": {"slide_type": "fragment"}}
(expression)=
:::{prf:definition} Expressions
***Expression*** : combinaison de *valeurs* par
des *opérations* donnant une nouvelle *valeur*
:::
+++ {"slideshow": {"slide_type": "fragment"}}
:::{prf:example}
L'expression `3 * (1 + 3) + (1 + 4) * (2 + 4)` vaut `42`
:::
+++ {"slideshow": {"slide_type": "fragment"}}
(operations_sur_les_entiers)=
:::{admonition} Opérations sur les entiers
| Opération | Exemple | Résultat |
|------------------------------|----------|----------|
| opposé | `-(-5)` | 5 |
| addition | `17 + 5` | 22 |
| soustraction | `17 - 5` | 12 |
| multiplication | `17 * 5` | 85 |
| division entière | `17 / 5` | 3 |
| reste de la division entière | `17 % 5` | 2 |
:::
+++ {"slideshow": {"slide_type": "slide"}}
:::{tip} Aparté : *syntaxe*, *sémantique*, *algorithme*
(syntaxe_informel)=
- ***Syntaxe*** : comment on l'écrit
(semantique_informel)=
- ***Sémantique*** : ce que cela fait
(algorithme_informel)=
- ***Algorithme*** : comment c'est fait
:::
+++ {"slideshow": {"slide_type": "fragment"}}
:::{prf:example}
- Syntaxe : 17 / 5
- Sémantique : calcule la division entière de 17 par 5
- Algorithme : division euclidienne
:::
+++ {"slideshow": {"slide_type": "slide"}}
### Expressions booléennes
+++ {"slideshow": {"slide_type": "fragment"}}
(expression_booleenne)=
:::{prf:definition} Expressions booléennes (conditions)
Une ***expression booléenne*** est une
[expression](expression) dont la valeur est «vrai» ou «faux» (type :
[bool](bool)).
(condition)=
Une [expression booléenne](<expression_booleenne>) est aussi
appelée une ***condition***.
:::
+++ {"slideshow": {"slide_type": "fragment"}}
**Exemples:**
```{code-cell}
---
slideshow:
slide_type: fragment
---
true
```
```{code-cell}
---
slideshow:
slide_type: fragment
---
false
```
+++ {"slideshow": {"slide_type": "fragment"}}
- `regarde() == Vide`
- `x > 3.14`
- `2 <= n and n <= 5`
+++ {"slideshow": {"slide_type": "fragment"}}
(operations_booleennes_usuelles)=
:::{admonition} Opérations booléennes usuelles
| Opération | Exemple | Résultat |
| --------------------- | :-----------------: | ---------- |
| comparaison | `3 <= 5` | `true` |
| comparaison stricte | `3 < 5` | `true` |
| comparaison stricte | `3 > 5` | `false` |
| égalité | `3 == 5` | `false` |
| inégalité | `3 != 5` | `true` |
| négation | `not 3 <= 5` | `false` |
| et | `3 < 5 and 3 > 5` | `false` |
| ou | `3 < 5 or 3 > 5` | `true` |
:::
+++ {"slideshow": {"slide_type": "slide"}}
## Variables
+++ {"slideshow": {"slide_type": "fragment"}}
(exemple:calcul_energie_cinetique)=
:::{prf:example}
:for: expression
:good_to_have: cinetic_energy
:motivates: variable
:name: exemple_variables_énergie_cinétique
Calculer l'[énergie cinétique](<energie_cinetique>) $\frac12 m
v^2$ d'un objet de masse $14,5$ kg selon qu'il aille à $1$, $10$,
$100$, ou $1000$ m/s.
:::
```{code-cell}
---
slideshow:
slide_type: fragment
---
1./2 * 14.5 * 1 * 1
```
```{code-cell}
---
slideshow:
slide_type: fragment
---
1./2 * 14.5 * 10 * 10
```
```{code-cell}
---
slideshow:
slide_type: fragment
---
1./2 * 14.5 * 10 * 10
```
```{code-cell}
---
slideshow:
slide_type: fragment
---
1./2 * 14.5 * 100 * 100
```
+++ {"slideshow": {"slide_type": "fragment"}}
Qu'est-ce qui n'est pas satisfaisant?
```{code-cell}
---
slideshow:
slide_type: fragment
---
double v;
double m;
```
```{code-cell}
---
slideshow:
slide_type: fragment
---
v = 1000;
m = 14.5;
```
```{code-cell}
---
slideshow:
slide_type: fragment
---
1.0/2.0 * m * v * v
```
+++ {"slideshow": {"slide_type": "slide"}}
(variable)=
:::{prf:definition} Variables
Une ***variable*** est un espace de stockage *nommé* où le
programme peut mémoriser une donnée
:::
+++ {"slideshow": {"slide_type": "fragment"}}
Le nom de la variable est choisi par le programmeur
- Objectif : stocker des informations durant l'exécution d'un programme
- Analogie : utiliser un récipient pour stocker des ingrédients en
cuisine :
- Verser le sucre dans un *saladier*
- Ajouter la farine dans le *saladier*
- Laisser reposer
- Verser le contenu du *saladier* dans ...
+++ {"slideshow": {"slide_type": "slide"}}
:::{admonition} À retenir
En C++, une variable possède quatre propriétés :
- un **nom** (ou **identificateur**)
- une **adresse**
à préciser la semaine prochaine
- un **type**
- une **valeur**
La valeur peut changer en cours d'exécution du programme
(d'où le nom de variable)
:::
+++ {"slideshow": {"slide_type": "slide"}}
### Notion de type
Les variables peuvent contenir toutes sortes de données différentes :
- nombres entiers, réels, booléens, ...
- textes
- relevés de notes, images, musiques, ...
+++ {"slideshow": {"slide_type": "fragment"}}
(type_informel)=
:::{prf:definition} Types
- Une variable C++ ne peut contenir qu'une seule sorte de données.
- On appelle cette sorte le ***type*** de la variable.
- On dit que C++ est un langage typé statiquement.
:::
+++ {"slideshow": {"slide_type": "slide"}}
:::{prf:definition} Types de base
Les types de base en C++ sont :
(entier)=
- Les ***entiers*** (mots clés `int`, `long int`)
Exemples : 1, 42, -32765
(reel)=
- les ***réels*** (mots clés `float`, `double`)
Exemples : 10.43, 1.0324432e22
(caractere)=
- les ***caractères*** (mot clé `char`) <a name="char"/>
Exemples : 'a', 'b', ' ', ']'
(chaine_de_caractere)=
- les ***chaînes de caractères*** (mot clé `string`)
Exemples : "bonjour", "Alice aime Bob"
(booleen)=
- les ***booléens*** (mot clé `bool`)
Exemples : `true` (vrai), `false` (faux)
(type_ordinal)=
Les entiers, les caractères et les booléens forment les
***types ordinaux***.
:::
+++ {"slideshow": {"slide_type": "slide"}}
(declaration)=
### La déclaration des variables
Pour chaque variable, il faut donner au programme son nom et son type.
On dit que l'on ***déclare*** la variable.
:::{admonition} Syntaxe : déclaration des variables
``` c++
type nomvariable;
type nomvariable1, nomvariable2, ...;
```
:::
+++ {"slideshow": {"slide_type": "fragment"}}
:::{prf:example}
```
int x, y, monEntier;
double f, g;
bool b;
```
:::
+++ {"slideshow": {"slide_type": "fragment"}}
**Note :** en C++ (compilé) on ne peut pas redéclarer une variable avec le même nom!
+++ {"slideshow": {"slide_type": "slide"}}
(affectation)=
### L'affectation
:::{admonition} Syntaxe
```
identificateur = expression;
```
:::
+++ {"slideshow": {"slide_type": "fragment"}}
:::{prf:example}
```
x = 3 + 5;
```
+++ {"slideshow": {"slide_type": "fragment"}}
:::{admonition} Sémantique
- Calcul (ou évaluation) de la valeur de l'expression
- Stockage de cette valeur dans la case mémoire associée à cette
variable.
- *La variable et l'expression doivent être de même type!*
:::
+++ {"slideshow": {"slide_type": "slide"}}
#### Exemples d'affectations
```{code-cell}
---
slideshow:
slide_type: fragment
---
int x, y;
```
+++ {"slideshow": {"slide_type": "fragment"}}
On affecte la valeur 1 à la variable `x` :
```{code-cell}
x = 1;
```
+++ {"slideshow": {"slide_type": "fragment"}}
On affecte la valeur 3 à la variable `y` :
```{code-cell}
y = 3;
```
+++ {"slideshow": {"slide_type": "fragment"}}
Valeurs des variables après l'affectation :
```{code-cell}
x
```
```{code-cell}
y
```
+++ {"slideshow": {"slide_type": "slide"}}
**Exemple :** affecter la valeur d'une variable à une autre variable
```{code-cell}
x = y;
```
```{code-cell}
---
slideshow:
slide_type: fragment
---
x
```
```{code-cell}
---
slideshow:
slide_type: fragment
---
y
```
+++ {"slideshow": {"slide_type": "fragment"}}
**Note**
- Affectation `x = y` : copie de la valeur
+++ {"slideshow": {"slide_type": "fragment"}}
- `y` garde sa valeur
- L'ancienne valeur de `x` est perdue!
+++ {"slideshow": {"slide_type": "fragment"}}
- Différent de transférer un ingrédient d'un récipient à l'autre
+++ {"slideshow": {"slide_type": "slide"}}
**Exemple : incrémentation**
```{code-cell}
---
slideshow:
slide_type: fragment
---
int x;
x = 1;
```
```{code-cell}
---
slideshow:
slide_type: fragment
---
x = x + 1;
```
```{code-cell}
x
```
+++ {"slideshow": {"slide_type": "fragment"}}
Variantes :
```{code-cell}
---
slideshow:
slide_type: fragment
---
x -= 2
```
```{code-cell}
x--;
```
```{code-cell}
x
```
+++ {"slideshow": {"slide_type": "slide"}}
:::{warning} Affectation et égalité : deux concepts différents
- **L'affectation `x = 5` :**
Une instruction modifiant l'état de la mémoire.
- **Le test d'égalité `x == 5` :**
Une expression booléenne (valeur vrai ou faux) :
« `x` est égal à `5`? »
Autrement dit : est-ce que la valeur contenue dans la variable `x` est `5`?
:::
+++ {"slideshow": {"slide_type": "slide"}}
## Fonctions
+++ {"slideshow": {"slide_type": "fragment"}}
Retour sur notre [exemple](exemple:calcul_energie_cinetique) :
Calculer l'énergie cinétique $\frac12 m v^2$ d'un objet de masse $14,5$
kg selon qu'il aille à $1$, $10$, $100$, ou $1000$ km/h.
Voilà comment nous avions procédé :
```{code-cell}
m = 14.5;
v = 100;
1./2 * m * v * v
```
+++ {"slideshow": {"slide_type": "fragment"}}
Comment éviter de retaper chaque fois la formule?
+++ {"slideshow": {"slide_type": "slide"}}
### Fonctions
(fonction_informelle)=
:::{prf:definition} Fonctions
Informellement, une ***fonction*** est un
petit [programme](programme) :
- Entrées
- Traitement
- Sortie
:::
+++ {"slideshow": {"slide_type": "fragment"}}
**Exemple :**
```{code-cell}
---
slideshow:
slide_type: fragment
---
double energie_cinetique(double m, double v) {
return 0.5 * m * v * v;
}
```
```{code-cell}
---
slideshow:
slide_type: fragment
---
energie_cinetique(14.5, 10)
```
+++ {"slideshow": {"slide_type": "fragment"}}
- Entrées : la masse et la vitesse (des nombres réels)
- Sortie : l'énergie cinétique (un nombre réel)
- Traitement : `0.5 * m * v * v`
+++ {"slideshow": {"slide_type": "slide"}}
#### Autres exemples de fonctions
:::{prf:example}
:for: function, while_loop
Chou-Chèvre-Loup :
``` c++
void transporter(... T) {
charger(T);
traverser();
decharger(T);
}
```
Laby :
``` c++
void avance_tant_que_tu_peux() {
while ( regarde() == Vide ) {
avance();
}
}
```
:::
+++ {"slideshow": {"slide_type": "slide"}}
## Structures de contrôle
+++ {"slideshow": {"slide_type": "slide"}}
### Rôle des structures de contrôle
+++ {"slideshow": {"slide_type": "fragment"}}
#### Rappel
Les instructions sont exécutées de manière séquentielle (les unes après
les autres), dans l'ordre du programme.
**Exemple :**
:::::{grid}
:gutter: 0
:::{grid-item-card}
```
debut()
droite()
avance()
prend()
gauche()
avance()
pose()
droite()
avance()
gauche()
avance()
avance()
droite()
ouvre()
```
:::
::::{grid-item-card}
:::{image} media/laby0.png
:height: 20ex
:align: center
:::
::::
:::::
+++ {"slideshow": {"slide_type": "fragment"}}
#### Le problème
On a souvent besoin de *rompre l'exécution séquentielle* :
+++ {"slideshow": {"slide_type": "fragment"}}
- Des instructions différentes selon le contexte :
:::{image} media/laby3a.png
:height: 5ex
:align: center
:alt: Le labyrinthe 3a avec petite et grande toile
:::
+++ {"slideshow": {"slide_type": "fragment"}}
- Des instructions répétées :
:::{image} media/laby2a.png
:height: 5ex
:align: center
:alt: Un labyrinthe tout en longueur
:::
+++ {"slideshow": {"slide_type": "fragment"}}
Nous avons besoin des **structures de contrôle**.
+++ {"slideshow": {"slide_type": "slide"}}
(instruction_conditionnelle)=
### Instructions conditionnelles
+++ {"slideshow": {"slide_type": "fragment"}}
En fonction d'une **[condition](condition)**, on va exécuter ou non un
**[bloc d'instructions](bloc_d_instruction)**.
```{code-cell}
---
slideshow:
slide_type: fragment
---
#include <laby/global_fr.hpp>
LABY("3a")
```
```{code-cell}
---
slideshow:
slide_type: fragment
---
debut();
droite();
avance();
gauche();
```
+++ {"slideshow": {"slide_type": "fragment"}}
Solution complète :
```{code-cell}
---
slideshow:
slide_type: fragment
---
LABY("3a")
```
```{code-cell}
---
slideshow:
slide_type: fragment
---
debut()
droite();
avance();
gauche();
if ( regarde() == Toile ) {
gauche();
avance();
avance();
droite();
avance();
avance();
droite();
avance();
gauche();
} else {
avance();
avance();
gauche();
avance();
droite();
}
ouvre();
```
+++ {"slideshow": {"slide_type": "slide"}}
(bloc_d_instruction)=
:::{prf:definition} Blocs d'instructions
Un ***bloc d'instructions*** est une suite d'instructions à
exécuter successivement. Il est décrit par la syntaxe suivante :
{
instruction 1;
instruction 2;
...
instruction n;
}
Une instruction toute seule est aussi considérée comme un bloc d'instructions.
:::
+++ {"slideshow": {"slide_type": "slide"}}
#### Instruction conditionnelle simple : «si ... alors ...»
:::{admonition} Syntaxe :
``` c++
if ( condition ) {
bloc d instructions;
}
```
:::
+++ {"slideshow": {"slide_type": "fragment"}}
:::{admonition} Sémantique
1. Évaluation de la condition
2. Si sa valeur est vraie, exécution du bloc d'instructions
:::
+++ {"slideshow": {"slide_type": "fragment"}}
:::{prf:example}
```c++
if ( regarde() == Toile ) { // Au secours, fuyons!
gauche();
gauche();
}
```
```c++
if ( x >= 0 ) gauche();
```
:::
+++ {"slideshow": {"slide_type": "slide"}}
#### Instruction conditionnelle : «si ... alors ... sinon ...»
:::{admonition} Syntaxe
```c++
if ( condition ) {
bloc d instructions 1;
} else {
bloc d instructions 2;
}
```
:::
+++ {"slideshow": {"slide_type": "fragment"}}
:::{admonition} Sémantique
1. Évaluation de la condition
2. Si sa valeur est «Vrai», exécution du bloc d'instructions 1
3. Si sa valeur est «Faux», exécution du bloc d'instructions 2
:::
+++ {"slideshow": {"slide_type": "fragment"}}
#### Exemples d'instruction alternative
:::{prf:example}
```c++
if ( regarde() == Toile ) { // Au secours, fuyons!
gauche();
gauche();
} else { // Tout va bien
avance();
}
```
:::
+++ {"slideshow": {"slide_type": "slide"}}
#### Exemples d'instruction alternative (2)
**Exemple :** Calcul du maximum et du minimum de `x` et `y`
```{code-cell}
---
slideshow:
slide_type: fragment
---
int x = 3, y = 5; // Les entrées
int maximum, minimum; // Les sorties
if ( x > y ) {
maximum = x;
minimum = y;
} else {
maximum = y;
minimum = x;
}
```
```{code-cell}
minimum
```
```{code-cell}
maximum
```
+++ {"slideshow": {"slide_type": "slide"}}
## Résumé
:::{admonition} Un aperçu de premiers éléments de programmation :
- [Expressions](expression), valeurs et [types](type_informel)
- [Variables](variable) (*affectation ≠ égalité!*)
- [Fonctions](fonction_informel)
- [Instructions conditionnelles](instruction_conditionnelle) (`if`)
:::
+++ {"slideshow": {"slide_type": "fragment"}}
On reviendra dessus!
fiche-resume-python.md 0 → 100644
+ 67
− 0
View file @ b03b11b6
jupytext:
notebook_metadata_filter: exports, myst
text_representation:
extension: .md
format_name: myst
format_version: 0.13
jupytext_version: 1.15.1
kernelspec:
display_name: Python 3 (ipykernel)
language: python
name: python3
---
% Fin entête jupytext
# Résumé de la syntaxe de base Python
```
if x == 1 : # Instruction conditionnelle (if)
...
```
```
if x == 1 : # Instruction conditionnelle (if/else)
...
elif x < 2 and not y >= 3:
...
else:
...
```
```
for i in range(10): # Instruction itérative: boucle for
```
```
while i <= 10: # Instruction itérative: boucle while
...
```
```
def factorielle(n): # Exemple de déclaration de fonction
"""La fonction factorielle (documentation au format PEP 484)
Args:
n (int): un entier positif
Returns:
int: n!
"""
resultat = 1
for k in range(n):
resultat = resultat * k
return resultat
```
```
def factorielleTest(): # Les tests de la fonction factorielle
assert factorielle(0) == 1
assert factorielle(1) == 1
assert factorielle(2) == 2
assert factorielle(4) == 24
```
```
import numpy # Import d'une librairie. Utilisation: numpy.pi
import numpy as np # Import d'une librairie avec alias. Utilisation: np.pi
from numpy import pi # Import d'une seule fonction. Utilisation: pi
```
```
n = input() # Lit la variable n au clavier
print(3*x + 1) # Affiche la valeur d'une expression et saute une ligne
```
fiche-resume.md 0 → 100644
+ 89
− 0
View file @ b03b11b6
---
jupytext:
text_representation:
extension: .md
format_name: myst
format_version: 0.13
jupytext_version: 1.15.1
kernelspec:
display_name: C++17
language: C++17
name: xcpp17
---
% Fin entête jupytext
# Résumé de la syntaxe de base C++
Les exemples suivants résument la syntaxe des instructions de base
C++, et précisent les conventions de codage utilisées dans le cadre de
ce module: indentation, espacement, documentation au format javadoc
[^1]
et tests. *Complétez cette feuille à la main au verso comme vous le
souhaitez. Ce sera le seul document autorisé au partiel et à l'examen*.
[^2]: Pour plus de détails sur javadoc, voir par exemple
<http://fr.openclassrooms.com/informatique/cours/presentation-de-la-javadoc/les-tags-javadoc-1>
```
if ( x == 1 ) { // Instruction conditionnelle (if)
...;
}
```
```
if ( x == 1 ) { // Instruction conditionnelle (if/else)
...;
} else if ( x < 2 and not y >= 3 ) {
...;
} else {
...;
}
```
```
for ( int i = 0; i < 10; i++ ) { // Instruction itérative: boucle for
...;
}
```
```
while ( i <= 10 ) { // Instruction itérative: boucle while
...;
}
```
```
do { // Instruction itérative: boucle do ... while
...;
} while ( i <= 10 );
```
```
/** La fonction factorielle // Documentation de la fonction factorielle
* @param n un nombre entier positif
* @return n!
**/
int factorielle(int n) { // Exemple de déclaration de fonction
int resultat = 1;
for ( int k = 1; k <= n; k++ ) {
resultat = resultat * k;
}
return resultat;
}
```
```
void factorielleTest() { // Les tests de la fonction factorielle
CHECK( factorielle(0) == 1 );
CHECK( factorielle(1) == 1 );
CHECK( factorielle(2) == 2 );
CHECK( factorielle(4) == 24 );
}
```
```
#include <iostream> // Squelette de programme
using namespace std;
int main() {
...
}
```
```
cin >> n; // Lit la variable n au clavier
cout << 3*x + 1; // Affiche la valeur d'une expression
cout << endl; // Affiche un saut de ligne
```
index.md 0 → 100644
+ 216
− 0
View file @ b03b11b6
---
jupytext:
text_representation:
extension: .md
format_name: myst
format_version: 0.13
jupytext_version: 1.15.1
kernelspec:
display_name: C++17
language: C++17
name: xcpp17
---
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "ff657c59b200e50d261c063a9775dbc5", "grade": false, "grade_id": "cell-65f24a4fe8c153b9", "locked": true, "schema_version": 3, "solution": false, "task": false}}
# Semaine 2: Programmation impérative: premier aperçu
La semaine dernière, Laby nous a amené à la découverte des premiers
éléments de la programmation impérative: programmes, fonctions,
expressions conditionnelles et itératives. Cette semaine, nous allons
commencer à formaliser ces éléments, en y ajoutant expressions et
variables.
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "2c35c1c7542efe699c052d8014954324", "grade": false, "grade_id": "cell-65f24a4fe8c153c0", "locked": true, "schema_version": 3, "solution": false, "task": false}}
## [Cours](cours.md)
## [TD](TD.md)
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "6b66466b7f04d30b80167a5b5f733e1f", "grade": false, "grade_id": "cell-65f24a4fe8c153c1", "locked": true, "schema_version": 3, "solution": false, "task": false}}
## TP
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "4225cf9a77f610bff1cadee460f19ddd", "grade": false, "grade_id": "cell-65f24a4fe8c153c2", "locked": true, "schema_version": 3, "solution": false, "task": false}}
**Rappel :** Tout exercice non marqué d'un ♣ est à terminer pour la semaine prochaine.**
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "16d262add0837e4334ab87b904b85f8f", "grade": false, "grade_id": "cell-bf0808a9dcb0b572", "locked": true, "schema_version": 3, "solution": false, "task": false}}
### Exercice 0 : Notes de cours
1. Consultez les notes de cours de la semaine 1 sur le site web.
2. Que signifie *syntaxe*? Et *sémantique*? Vérifiez dans les notes
de cours.
3. Quelle est la syntaxe et la sémantique de l'affectation de
variables? Vérifiez dans les notes de cours de la semaine 2 (voir
le site web ou ci-dessus).
<!--
### Exercice: Téléchargement du sujet de TP
1. Ouvrez un terminal (vous pouvez consulter l'exercice 2 du TP 1).
3. Exécutez la commande `info-111` et observez le résultat.
4. Vous venez de lire la documentation de la commande `info-111`.
Téléchargez le sujet de TP «Semaine2» en suivant les instructions
données à ce sujet par cette documentation.
Remarque: Si vous n'avez pas fait le TP1, vous aurez besoin d'activer
votre compte gitlab (voir TP1).
6. Consultez la liste des fichiers de votre nouveau répertoire
`~/ProgImperative/Semaine2/` à l'aide de la commande `ls` (cf. l'UE
Introduction à l'Informatique pour ceux qui la suivent):
ls ~/ProgImperative/Semaine2/
5. Observez ce qui est affiché; notez que `info-111` a fait appel à la
commande `git clone ...`.
!-->
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "e97d0f3d2c198c10d8f8aa4313e2f707", "grade": false, "grade_id": "cell-bf0808a9dcb0b574", "locked": true, "schema_version": 3, "solution": false, "task": false}}
### Exercice 1 : Jupyter
Chaque semaine, nous commencerons par une petite feuille pour vous
familiariser progressivement à l'utilisation de Jupyter. Aujourd'hui,
ce sera:
- [00: Jupyter: mode édition versus mode commande](00-jupyter-mode-edition-vs-commande.md)
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "1974cd8f2b5e472f6c0416829c9031d3", "grade": false, "grade_id": "cell-bf0808a9dcb0b573", "locked": true, "schema_version": 3, "solution": false, "task": false}}
### Exercice 2 : Jupyter, valeurs, types, types, variables, conditionnelles, fonctions
Travaillez successivement sur les feuilles suivantes :
- [01: Expressions, valeurs et types](01-valeurs-types.md);
- [02: Variables](02-variables.md);
- [03: Conditions et fonctions](03-conditions-fonctions.md);
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "d82b17ec12b05990bfd4e9bd1aff611e", "grade": false, "grade_id": "cell-bf0808a9dcb0b575", "locked": true, "schema_version": 3, "solution": false, "task": false}}
### Exercice 3 : Dépôt de votre travail
1. Utilisez le tableau de bord pour déposer votre travail sur GitLab
(consultez au besoin la page
[Case départ](https://nicolas.thiery.name/Enseignement/Info111/ComputerLab/index.html)
du site web).
3. N'oubliez pas de déposer à nouveau votre travail en fin de séance,
afin que tout soit bien sauvegardé.
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "3f7ea34bb4fe2ce23ec7d6a49f3c5ae9", "grade": false, "grade_id": "cell-bf0808a9dcb0b576", "locked": true, "schema_version": 3, "solution": false, "task": false}}
### Exercice 4 : Service JupyterHub@Paris-Saclay
Rappel : l'université a déployé un service `JupyterHub` (expérimental)
vous permettant de travailler en dehors des séances avec simplement
une connexion internet et un navigateur web (firefox, chrome, safari,
...).
**Cet exercice n'est à faire que si vous n'avez pas encore utilisé ce
service ou si vous avez rencontré des difficultés.**
1. Suivez les instructions de la page
[Case départ](https://nicolas.thiery.name/Enseignement/Info111/ComputerLab/index.html)
du site web
pour vous connecter au service JupyterHub; téléchargez-y vos TP 1
et 2 et consultez les; demandez de l'aide au besoin à votre
enseignant.
<!--
2. Fermez votre serveur avec `Control Panel -> Stop My Server`, puis
fermez la page.
!-->
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "3e6182e1ad41cd0c966bafd7c7405f45", "grade": false, "grade_id": "cell-bf0808a9dcb0b577", "locked": true, "schema_version": 3, "solution": false, "task": false}}
### Exercice 5 : Retour sur le TD
Travaillez successivement sur les deux feuilles suivantes :
1. [04-td-exercice3.md](04-td-exercice3.md).
2. [05-td-exercice4.md](05-td-exercice4.md).
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "9e02be34bb97f5a80a6ad0f6e9729ec5", "grade": false, "grade_id": "cell-bf0808a9dcb0b578", "locked": true, "schema_version": 3, "solution": false, "task": false}}
### Exercice 6 : **Pour la semaine prochaine**
1. Vous vérifierez que vous pouvez vous connecter au service
JupyterHub depuis chez vous et que vous pouvez y exécuter vos
feuilles Jupyter (voir exercice « Service JupyterHub » ci dessus).
2. Terminez les fiches Jupyter de ce TP, soit en salle informatique
de l'université, soit depuis chez vous en utilisant le service
JupyterHub.
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "72cd89adbc36aa95e2dcc50f3cd6e55d", "grade": false, "grade_id": "cell-bf0808a9dcb0b57a", "locked": true, "schema_version": 3, "solution": false, "task": false}}
<div class="alert alert-info">
**Note :**
Vous pouvez aborder les exercices ♣ suivants dans l'ordre que vous
souhaitez.
Pour les réaliser, vous créerez au fur et à mesure de nouvelles
feuilles de travail (notebook). Pour cela : utilisez le menu `Fichier
-> Nouveau -> Notebook` et sélectionnez le noyau `Python 3` ou `C++
17`. Vous noterez dans le titre de l'onglet que votre feuille
s'appelle `Untitled.ipynb`; utilisez un clic droit sur le titre de
l'onglet et choisissez `Renomer` dans le menu pour donner un nom
informatif à la feuille.
</div>
<div class="alert alert-info">
**Indication :**
Pour que le dépôt sur GitLab tienne compte de vos nouveaux fichiers,
vous devez au préalable les déclarer au système de gestion de version
sous-jacent `git`. Par exemple, pour déclarer un nouveau fichier
`mon_fichier.md` que vous avez créé dans votre répertoire `Semaine2`,
vous ouvrirez un terminal et ferez :
cd ~/ProgImperative/Semaine2
git add mon_fichier.md
Il sera alors inclus dans tous les dépôts ultérieurs.
</div>
### Exercice ♣ : Euler forever!
Vous trouverez sur le site du projet Euler <https://projecteuler.net>
une série de problèmes mathématiques qui nécessitent chacun une
combinaison de réflexion sur feuille et de programmation (voir
<http://submoon.freeshell.org/fr/sphinx/euler.html> pour avoir les
énoncés en français).
Essayez de résoudre les problèmes 1, 2, 5 et tous ceux qui vous
plairont!
+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "1265a7c7fccab11b7f710a2d6abf74be", "grade": false, "grade_id": "cell-bf0808a9dcb0b579", "locked": true, "schema_version": 3, "solution": false, "task": false}}
### Exercice ♣ : Python
Dans le cours «Introduction à la programmation», vous (re)découvrirez
le langage de programmation Python. Pour prendre un peu d'avance,
refaites le TP en utilisant cette fois `Python`.
Vous pouvez consulter la feuille «Résumé de la syntaxe de base
Python», fournie dans la <a href="TD.pdf">feuille de TD</a> en
parallèle à celle pour C++.
<!--
Vous trouverez un cours complet sur `Python` à cette adresse:
<http://fr.openclassrooms.com/informatique/cours/apprenez-a-programmer-en-python>
Il est intéressant de le lire et de comparer avec ce que vous apprenez
en C++ ce semestre.
!-->
media/laby0.png 0 → 100644
+ 0
− 0
View file @ b03b11b6
media/laby0.png

12.2 KiB

media/laby2a.png 0 → 100644
+ 0
− 0
View file @ b03b11b6
media/laby2a.png

6.07 KiB

media/laby2c.png 0 → 100644
+ 0
− 0
View file @ b03b11b6
media/laby2c.png

14.6 KiB

media/laby3a.png 0 → 100644
+ 0
− 0
View file @ b03b11b6
media/laby3a.png

8.76 KiB

0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment