Accueil site Tableur Programmation Outils XML Téléchargement Informations



Algorithmique

Initiation

Première activité 
 
Introduction
Initiation
  Généralités
  Première activité
  Calcul d'une racine carrée
  Exemple en géométrie
  Exemple avec Logo
Prolongement
  Symétrie centrale
  Parallélogramme
  Procédures avec Logo
  Récursivité avec Logo
Avec Algobox
  Fraction irréductible
  Fonction monotone
  Résolution d'équation 1
  Résolution d'équation 2
Avec Python
  Environnement
  Autres environnements
  L'essentiel
  Premier exemple
  Addition de fractions
  Cryptographie
  Statistiques / Probabilité
Avec Java
  Environnement
  L'essentiel
  Premier exemple
  Avec des classes
 
Algorithme renversant
Première partie
Après avoir présenté les trois grandes parties d'un algorithme (Entrée, traitement, sortie), on peut donner un exemple d'algorithme sans dire pour quoi il est fait mais pour lequel on expliquera le rôle des variables pour mémoriser les valeurs qui seront utilisées dans le traitement. Une variable est associée à un endroit de la mémoire de la machine où est stockée une valeur ; il est commode de représenter une variable par un nom ou identificateur (suite de caractères sans espace ni signe de ponctuation).

On donne aux élèves l’algorithme suivant :

Variables utilisées
mot (un mot)
motbis (un autre mot)
car (une lettre)
n (longueur d’un mot)
p (pour compter)
Entrée
Saisir mot
Traitement
n prend la valeur du nombre de lettres de mot
Début de boucle
Pour p variant de 1 à n faire
car prend comme valeur la dernière lettre de mot
mot prend comme valeur les n-p premières lettres de mot
motbis prend comme valeur sa valeur actuelle suivie de la valeur de car
p suivant
Fin de boucle
Sortie
Afficher motbis

Pour le mot « copain » quel sera à chaque étape de la boucle le contenu des variables car, mot et motbis ?
Les élèves peuvent remplir un tableau comme ci-dessous :


En sortie de boucle quel sera le résultat affiché pour motbis ?
Quel sera le résultat pour le mot bonjour? Pour n’importe quel mot ?
Deuxième partie
Avec un tableur, en utilisant l’opérateur & et les fonctions GAUCHE, DROITE, NBCAR, traduire l’algorithme précédent en sachant que la boucle est traduite par la recopie des formules sur le nombre de ligne correspondant au nombre de passages dans la boucle.
On peut disposer la feuille de calcul comme ci-dessous :




On peut également adapter ce tableau à tout mot du français en recopiant les formules vers le bas 25 fois (le mot usuel le plus long étant le mot « anticonstitutionnellement ») et en ajoutant des fonctions SI pour stopper les affichages à l’étape correspondant aux nombres de lettre du mot. On peut également faire afficher le mot résultant (en dessous du mot tapé) par la fonction RECHERCHV dans le tableau (télécharger le fichier complété Excel ou Calc).
Troisième partie
Amélioration de l’algorithmique.
1) En réalité, la variable intermédiaire car est inutile, écrire le nouvel algorithme correspondant à cette suppression.
2) Traduire cet algorithme en modifiant la feuille de calcul précédente (télécharger le fichier complété Excel ou Calc).
3) On remarque, grâce au tableau précédent que la dernière lettre du mot doit toujours être insérée à la position dans le mot donné par le numéro d’étape. Il suffit donc de couper le mot en deux parties et d’introduire entre les deux la dernière lettre. Soit à l’étape p (1 p n) :
mot prend comme valeur les p-1 lettres de mot suivies de la dernière lettre de mot puis des lettres de p à n-1 de mot.
4) Traduire ce dernier algorithme avec un tableur (utiliser la fonction STXT pour obtenir une partie d'un mot (télécharger le fichier complété Excel ou Calc)
Quatrième partie
On peut alors traduire l'algorithme précédent dans un logiciel d'initiation à l'algorithmique, par exemple avec Algobox :



Dans Algobox, l'instruction permettant d'extraire des caractères d'une chaîne est SUBSTR. La syntaxe est : SUBSTR(rang, nb caractères) avec rang qui commence à 0 (télécharger le fichier complété Algobox).

On peut également le traduire avec le langage Visual Basic intégré à Excel après avoir créé un bouton de commande dans la feuille de calcul et en écrivant le code dans la procédure événementielle Click de ce bouton (voir les documents ressouces ci-dessous) :


Private Sub CommandButton1_Click()
'Variables
Dim mot As String
Dim n As Byte
Dim p As Byte
'Entrée (le mot à traiter doit être tapé dans la cellule B3)
mot = Cells(3, 2).Value
'Traitement
n = Len(mot)
For p = 1 To n
mot = Left$(mot, p - 1) & Right$(mot, 1) & Mid$(mot, p, n - p)
Next p
'Sortie (le résultat est affiché dans la cellule D3)
Cells(3, 4).Value = mot
End Sub

Remarque : avant de cliquer sur le bouton Exécuter, il faut avoir saisi le mot et validé le contenu de la cellule sinon la saisie est toujours en cours et le programme ne peut s'exécuter.

On peut également légèrement modifier ce programme pour saisir le mot par une boîte de dialogue puis écrire le mot tapé dans la cellule B3. Pour cela il suffit de remplacer les lignes :
'Entrée (le mot à traiter doit être tapé dans la cellule B3)
mot = Cells(3, 2).Value
par :
'Entrée (le mot saisi est affiché dans la cellule B3)
mot = InputBox("Taper un mot", "Saisie", "Copain")
Cells(3, 2).Value = mot
Ressources
- Environnement de développement
- Dessiner l'interface
- Compléments sur l'éditeur VB
- Régler le niveau de sécurité
- Télécharger le fichier complété de cet exemple

Avec le tableur Calc d'OpenOffice, c'est un tout petit peu plus compliqué qu'avec Excel car il n'y a pas d'objet par défaut, il faut atteindre les cellules d'une feuille à partir de l'objet Feuille, cet objet étant lui-même obtenu avec la collection de feuilles du Classeur. En dehors de cette contrainte, le code est semblable à celui d'Excel avec toutefois une différences pour les références de cellules (numéro de colonne, numéro de ligne) avec les index commençant à 0. De plus pour lire ou écrire le contenu d'une cellule, Calc fait une différence entre un contenu de type chaîne et un contenu de type nombre :
Ecriture/lecture d'une chaîne : Cells(x, y).String
Ecrituire/lecture d'un nombre : Cells(x, y).Value
Pour réaliser l'interface et la lier au code voir les documents ressources ci-dessous.

REM ***** BASIC *****
Sub InversionMot
'Variables
Dim LesFeuilles as Object
Dim PremiereFeuille as Object
Dim Cellule as Object
Dim mot as string
Dim n as integer
Dim p as integer
'Initialisation
LesFeuilles = ThisComponent.Sheets
PremiereFeuille = LesFeuilles.GetbyName("Feuil1")
'Entrée (le mot à traiter est tapé dans la cellule B3)
Cellule = PremiereFeuille.GetCellByPosition(1,2)
mot = Cellule.String
'Traitement
n = Len(mot)
For p = 1 To n
mot = Left$(mot, p - 1) & Right$(mot, 1) & Mid$(mot, p, n - p)
Next p
'Sortie (le résultat est affiché dans la cellule D3)
Cellule = PremiereFeuille.GetCellByPosition(3,2)
Cellule.String = mot
End Sub

Même remarque que pour Excel : il faut valider le contenu de la cellule recevant le mot avant d'exécuter le programme. On peut ausi saisir le mot par une boîte de dialogue :
mot = inputbox("Taper un mot","Saisie","Copain")
Cellule.String = mot

© Matabu mars 2020 - Tous droits réservés. Limitation à l'usage non commercial, privé ou scolaire.