Instruction répétitive

En programmation le terme boucle fait référence à l’exécution répétitive d’une ou plusieurs instruction. Une boucle répétitive est une structure de contrôle qui permet de répéter l’exécution d’une séquence d’instructions. Elle comporte obligatoirement

  • Un bloc d’instructions qui est exécuté à chaque itération
  • Une instruction d’arrêt, grâce à laquelle la boucle s’arrête
  • Un itérateur qui est le moyen par lequel on réalise la répétition

L’itération, couramment utilisé en programmation, est un processus qui consiste à répéter une séquence d’instructions afin de produire le résultat souhaité. La plupart des langages de programmation impérative implémente l’itération comme une boucle for ou une boucle while

Pour établir une boucle on met en œuvre un itérateur, il défini la manière de parcourir séquentiellement une collection d’éléments.
On dispose de plusieurs techniques pour mettre en œuvre un itérateur :

  • Le compteur: il est placé à l’intérieur de la boucle, il compte le nombre d’itération.
  • Une expression booléenne: la boucle s’arrête quand la valeur de l’expression booléenne qui contrôle la boucle est Faux .
  • Le parcours d’une collection d’éléments: la boucle s’arrête lorsque le dernier élément de la collection est atteint.
  • Un nombre entier: la boucle est répétée autant de fois que la valeur du nombre.
  • Un intervalle: la boucle est répétée autant de fois qu’il ys d’éléménts dans l’intervalle.

Note: Une boucle sans itérateur est par définition une boucle infinie. Le seul moyen de l’arrêter est d’utiliser une instruction de sortie de boucle.

En Schema, un itération est guidée par une condition booléenne, un nombre, un ensemble ou un booléen

L’itération se décline sous quatre formes

  • Itération bornée ,elle permet d’effectuer un traitement un nombre de fois déterminé soit par un entier soit par un intervalle compris entre une borne de départ et de bornes d’arrivée.
  • Itération conditionnelle, elle permet d’effectuer un traitement de zéro à plusieurs fois suivant qu’une expression booléenne est Vrai ou Faux.
  • Itération de parcours, elle consiste à énumérer séquentiellement chaque élément d’une structure de données.
  • Itération booléenne, elle dépend des deux seules valeurs booléenne Vrai ou Faux

Modèle itératif de Schema

Une itération est constituée d’une expression itérable suivie d’une ou plusieurs instructions, terminée par le mot réservé Fin

Expression_Itérable
    séquence d’instructions
Fin

Chaque expression itérable peut être suivie d’un séparateur : suivi d’un identificateur. Cette forme d’itérateur permet d’accéder à chaque élément ou index lors de l’itération.

Expression_Itérable : Element 
    séquence d’instructions
Fin

Les expressions itérables correspondant à chaque forme d’itération sont

  • Conditionnelle, l’expression itérable est une expression booléenne
  • Bornée, l’expression itérable est un nombre ou un intervalle
  • Parcours, l’expression itérable est une collection d’éléments
  • Booléen l’expression itérable est Vrai ou Faux ‘

Itération conditionnelle

Dans la plupart des langages de programmation on implémente une itération conditionnelle avec l’expression while condition. Le langage Schema, ne défini pas de mot réservé équivalent à while à celui de en Python ou Swift.
l’instruction conditionnelle de Schema commence toujours par une expression booléenne. La valeur de l’expression est évaluée avant l’exécution des instructions à répéter. Il est possible la que la séquence d’instruction ne soient jamais exécutées si la condition est initialisée à Faux avant d »entrer dans la boucle.

Pour que la boucle se termine Il faut que dans a liste des instructions une instruction au moins évalue la condition à faux au bout d’un temps fini.

Prenons l’exemple de calcul de la somme des 3 premiers nombres entiers.

SommeDesTroisPremiersNombreEntier -> Entier
   somme <- 0
   index <- 0
   somme <= 3 
      index = index + 1 
      somme <- somme + nombre
      Afficher index #index
      Afficher somme #somme
   Fin 
<- somme 
Fin

Itération bornée par un nombre

l’expression itérable est un nombre entier.
Si l’on veut afficher 3 fois “hello Steve“ on écrira , l’algorithme:

helloSteve 
   3 Afficher hello Steve
Fin

Dans le cas d’un bloc d’instructions

helloSteve 
   3 
      Afficher hello Steve
      Afficher have a nice day
   Fin 
Fin

Pour accéder à la valeur de l’index de boucle que l’on appellera nombre on écrit

helloSteve 
   3 : nombre 
      Afficher hello Steve #nombre fois
      Afficher have a nice day
   Fin 
Fin
SommeDesTroisPremiersNombreEntier -> Entier
   somme <- 0
   3 : nombre
   somme <- somme + nombre
      Afficher somme #somme
   Fin 
   <- somme 
Fin

Itération bornée par un intervalle

l’expression itérable est un intervalle sur l’ensemble des nombres entier
Si l’on veut afficher 3 fois “hello Steve“ on écrira , l’algorithme:
L’intervalle est noté borneInférieure -> borneSupérieure

helloSteve
   3 -> 5 Afficher hello Steve
Fin

Dans le cas d’un bloc d’instructions

helloSteve
   3 -> 5
      Afficher hello Steve
      Afficher have a nice day
   Fin
Fin

Pour accéder à la valeur de l’index de boucle que l’on appellera nombre on écrit:

helloSteve
   3 -> 5 : nombre
     Afficher hello Steve #nombre fois
     Afficher have a nice day
   Fin
Fin
SommeDesTroisPremiersNombreEntier -> Entier
   somme <- 0
   1 -> 3 : nombre 
      somme <- somme + nombre
      Afficher somme #somme
   Fin 
   <- somme 
Fin

Itération de parcours

Prenons l’exemple d’une collection de caractères dans un texte. L’expression itérable est l’identificateur d’un collection d’éléments. Un élément de type Texte est une expression itérable pour Schema. L’algorithme pour énumérer tous les caractères de la chaine s’écrit:

ParcoursTexte 
   texte >- “HelloSteve“ 
   texte : caractère Afficher caractère 
Fin

Ou sur plusieurs ligne

ParcoursTexte -> Entier
   texte >- “HelloSteve“
   longueur <- 0
   texte : caractère
      longueur <- longueur + 1
      Afficher caractère
   Fin
   <- longueur
Fin

Parcours d’un esnemble de nombre s entiers

SommeDesTroisPremiersNombreEntier -> Entier
   ensemble >- [1 2 3]
   somme <- 0
   ensemble : nombre
      somme <- somme + nombre
      Afficher nombre #nombre
      Afficher somme #somme
   Fin 
   <- somme 
Fin

Itération booléenne

L’expression itérable est représentée par les booléens Vrai ou Faux
C’est par définition une boucle infinie si aucune condition d’arrêt n’est spécifiée. Au moins une instruction particulière Sortie permet de provoquer l’arrêt immédiat de l’itération.

Les  particularités de cette boucle: On ne l’utilise pratiquement jamais

  • On peut simuler un boucle TantQue, l’instruction Sortie se trouve en début du bloc d’instructions à itérer
  • On peut simuler une boucle Faire-Jusqua, l’instruction Sortie se trouve en fin de bloc d’instructions
  • On peut exécuter tout ou partie d’un bloc d’instruction, les instructions Sortie sont placées dans le bloc d’instructions.
BoucleInfinie
   Vrai Afficher infinite loop
Fin

La même boucle infinie avec la négation de Faux

BoucleInfinie
   Non Faux : index
      Afficher infinité loop
      Afficher itération #index
   Fin
Fin

la version boucle de helloSteve avec une instruction de Sortie. Elle se termine quand le compteur index est supérieur ou égal à 3

helloSteve
   Vrai : index
      Afficher hello Steve #nombre fois
      Afficher have a nice day
      Sortie index <= 3
   Fin
Fin

Note: l’instruction de Schema Sortie conditionnelle marque la fin de la boucle.

SommeDesTroisPremiersNombreEntier -> Entier
   somme <- 0
   nombre <- 0
   Vrai 
   nombre <- nombre + 1 
      somme <- somme + nombre 
      Afficher nombre #nombre
      Afficher somme #somme
      Sortie somme > 3 
   Fin 
   <- somme 
Fin

Traduction Swift

Itération Conditionnelle

func SommeDesTroisPremiersNombreEntier() -> Int {
   var somme = 0
   var index = 0
   while somme <= 3 { 
      index = index + 1
      somme = somme + index
      print("index \(index)")
      print("somme \(somme)")
   }
   return somme
}

Itération bornée par un nombre

func SommeDesTroisPremiersNombreEntier() -> Int {
   var somme = 0
   for nombre in 1...3 { 
      somme = somme + nombre
      print("somme \(somme)")
   }
   return somme
}

Itération bornée par un intervalle

func SommeDesTroisPremiersNombreEntier() -> Int {
   var somme = 0
   for nombre in 1...3 { 
      somme = somme + nombre
      print("somme \(somme)")
   }
   return somme
}

Itération de parcours

func ParcoursTexte() {
   let texte = “HelloSteve“
   for caractère in texte { print("caractère = \(caractère)") }
}

le même algorithme sur plusieurs lignes

func ParcoursTexte() -> Int {
   let texte = “HelloSteve“
   var longueur = 0
   for caractère in texte { 
      longueur = longueur + 1
      print("caractère = \(caractère)")
   }
   return longueur
}

La somme des 3 premiers nombres entiers peut aussi être calculée en parcourant l’ensemble des nombres entiers. ( File_Elements(1,2,3) déclare un ensemble d’entiers).

func SommeDesTroisPremiersNombreEntier() -> Int {
   let ensemble = File_Elements(1,2,3)
   var somme = 0
   for nombre in ensemble { 
      somme = somme + nombre
      print("nombre \(nombre)")
      print("somme \(somme)")
   }
   return somme
}

Itération booléenne

La condition d’arrêt de cette boucle est implémentée avec l’instruction break

func SommeDesTroisPremiersNombreEntier() -> Int {
   var somme = 0
   var nombre = 0
   while true {
      nombre = nombre + 1
      somme = somme + nombre
      print("nombre \(nombre)")
      print("somme \(somme)")
      if somme > 3 { break}
   }
   return somme
}

Traduction Python

def SommeDesTroisPremiersNombreEntier():
   somme = 0
   index = 0
   while somme <= 3 : 
      index = index + 1
      somme = somme + index
      print("index " + str(index))
      print("somme " + str(somme))
   return somme
def SommeDesTroisPremiersNombreEntier():
   somme = 0
   for nombre in range(3):
      somme = somme + nombre
      print("somme" + str(somme))
   return somme
def SommeDesTroisPremiersNombreEntier():
   somme = 0
   for nombre in range(1,4):
      somme = somme + nombre
      print("somme" + str(somme))
   return somme
def ParcoursTexte():
   texte = "HelloSteve"
   for caractère in texte :
      print("caractère = " + str(caractère))
def SommeDesTroisPremiersNombreEntier():
   ensemble = (1,2,3)
   somme = 0
   for nombre in ensemble:
      somme = somme + nombre
      print("nombre " + str(nombre))
      print("somme " + str(somme))
   return somme
def SommeDesTroisPremiersNombreEntier():
   somme = 0
   nombre = 0
   while True: 
      nombre = nombre + 1
      somme = somme + nombre
      print("nombre " + str(nombre))
      print("somme " + str(somme))
      if somme > 3 : break
   return somme

copyright A rchitectures A pplicatives A vancées A3-Soft

mathAlgo