Les Boucles en Dart

• Boucle for
• Boucle for..in
• Boucle while
• Boucle do..while

1. Syntaxe et interprétation du boucle for.

• La syntaxe de la partie déclaration de contrôle est composé de 3 grandes parties : une initialisation, une condition et une incrémentation ou un décrémentation.

for (initialisation; condition; itération ){
    expression
}

• initialisation :
• Spécifie l’initialisation de la boucle. Il permet d’initialiser un compteur qui sera ensuite utilisé dans la boucle.
• Dans la boucle for, l’initialisation se produit d’abord et une seule fois, ce qui signifie que la partie d’initialisation de la boucle for ne s’exécute qu’une seule fois.
• condition :
• Si l’expression est vraie true, l’ expression est exécutée puis l’itération est évaluée (s’il en existe une). Si la condition est omise elle est considérée comme vrai true. Si la condition est fausse false , l’instruction for se termine et le contrôle passe à l’instruction suivante du programme.
• La condition dans la boucle for est évaluée à chaque itération, si la condition est vraie, les instructions à l’intérieur du corps de la boucle for sont exécutées.
• Une fois que la condition renvoie false, les instructions de la boucle for ne s’exécutent pas et le contrôle est transféré à l’instruction suivante du programme après la boucle for.
• itération :
• est une expression qui s’ exécute à chaque itération de la boucle après l’ exécution de la portion de code de la boucle. L’ itération est généralement une incrémention ou une décrémentation.
• Après chaque exécution du corps de la boucle for, la partie incrémentation/décrémentation de la boucle for s’exécute et met à jour le compteur de boucle.

2. Exemple

for (var compteur = 1; compteur <= 3 ; compteur++){
    print("la valeur du compteur est $compteur");
}

/* Output
la valeur du compteur est 1
la valeur du compteur est 2
la valeur du compteur est 3*/

3. Application

• Afficher les nombres de 1 à 10 à l'aide de la boucle for

void main() {
  for (int i = 1; i <= 10; i++) {
    print(i);
  }
}

• Afficher les nombres de 10 à 1 à l'aide de la boucle for

void main() {
  for (int i = 10; i >= 1; i--) {
    print(i);
  }
}

Cette boucle permet de faire parcourir les éléments d'une collection telle qu'une liste (List), une carte (Map), un ensemble (Set), ou d'autres types de données itérables. la boucle for .. in est une boucle de parcours . C'est à dire que la boucle est exécutée sur chacun des éléments d'une collection.

Cette boucle est utilisée pour exécuter un bloc de code tant qu'une condition est vraie. Ce qui revient à dire qu'on n'a pas une idée fixe de combien de fois l'itération sera exécutée, d'où son classement parmi les boucles dit "indéterminée".

Cette boucle est semblable à celle de while mais la différence est qu'elle exécute un bloc de code au moins une fois avant la condition d’arrêt, puis de manière répétée tant qu’une condition est vraie.

1. L'instruction break

• Déjà rencontré précédemment dans la structure conditionnelle switch , ici aussi il joue le même rôle, celui de nous faire quitter de l’itération (les instructions) d’une boucle, autrement dit faire arrêter la boucle (comme veut dire ses sens “casser, rompre, arrêter, …”), et de passer à la suite du programme.

1. Exemple d'une boucle for avec l'instruction break

//Ce code s'arrête ou on quitte l'itération dès que i sera égal à 5
for (int i = 0; i < 10; i++) {
  if (i == 5) {
    break;
  }
  print("i est égal à $i");
}

• L’instruction continue

• L’instruction continue, quant à elle, est utilisée pour passer à l’itération suivante d’une boucle ou de sauter le reste du code dans l’itération en cours et de continuer avec l’itération suivante.

1. Exemple : Un programme qui affiche seulement les nombres impairs inférieurs à 10.

//Exemple d'une itération avec l'instruction continue
for (int i = 0; i < 10; i++) {
  if (i % 2 == 0) {
    continue;
  }
  print("$i est impair.");
}

• Notons ici que le signe % est dit modulo, c’est une opération qui calcul la division et retient le reste de cette division.
• C’est ainsi que notre condition dit que si le reste de la division entre l’index i et 2 est égale à 0 passer (continuer), parce que c’est un nombre pair, sinon afficher “$i est impair.”

• Les "label"

• Les labels sont des instructions appelé identifiants suivies par deux points (:), qui s’appliquent à une déclaration ou à un bloc de code, permettant de pointer à un endroit particulier une instruction ou un bloc d’instructions du programme.
• Elles peuvent être utilisées avec break ou continue pour une grande précision sur le bloc d’instruction à quitter ou à continuer.

1. Exemple d'un bloc de code contrôler par un label avec un break

maBoucleExterne:
  for (int i = 0; i < 3; i++) {
    //maBoucleInterne:
    for (int j = 0; j < 3; j++){
      print("$i $j");
      if (i == 2 && j == 2) {
        //Ce break permettrant d'arrêter directement la boucle externe
        //Mais si il n'est pas là seule, la boucle interne sera arrêter
        break maBoucleExterne;
      }      
    }
  }

2. Exemple d'un bloc de code contrôler par un label avec un continue

maBoucleExterne:
  for (int i = 0; i < 3; i++) {
    //maBoucleInterne:
    for (int j = 0; j < 3; j++){
      print("$i $j");
      if (i == 2 && j == 2) {
        continue maBoucleExterne;
      }      
    }
  }
/*Vous pouvez joueur avec le label de la boucle externe
  et interne pour voir le changement*/

• Écrire un programme Dart qui vérifie si un nombre saisie par l'utilisateur est premier ou non
• Le programme doit afficher un message pour les deux cas.
Solution

import 'dart:io';
import 'dart:math';

void main() {
  print('Veuillez saisir un nombre pour vérifier s\'il est premier ou non');
  int? nbr = int.parse(stdin.readLineSync()!);
  print('$nbr');
  if (verifierPremier(nbr)) {
    print('$nbr est un nombre premier');
  } else {
    print('$nbr n\'est pas premier');
  }
}

bool verifierPremier(int nbr) {
  if (nbr <= 1) {
    return false;
  }
  for (int i = 2; i <= sqrt(nbr); i++) {
    if (nbr % i == 0) {
      return false;
    }
  }
  return true;
}

• Écrire un programme Dart qui permet d'afficher la liste de tous les nombres premiers inférieurs 100.
Un nombre premier est un entier naturel qui admet exactement deux diviseurs distincts entiers et positifs. Ces deux diviseurs sont 1 et le nombre considéré, puisque tout nombre a pour diviseurs 1 et lui-même comme le montre l’égalité les nombres premiers étant ceux qui n’en possèdent aucun autre.
Solution

void main() {
  print("Liste des nombres premiers inférieurs 100:");
  print('----------------------------');
  for (int i = 2; i <= 100; i++) {
    verifierPremier(i);
  }
}

void verifierPremier(int nbrPremiers) {
  int i, j = 0;
  bool nbrTrouve = false;
  j = nbrPremiers ~/ 2;
  //print("La valeur de j est :$j");
  for (i = 2; i <= j; i++) {
    if (nbrPremiers % i == 0) {
      nbrTrouve = true;
      break;
    }
  }
  if (nbrTrouve == false) {
    print('$nbrPremiers');
  }
}

• Écrire un programme Dart qui permet de rechercher la liste de tous les nombres premiers inférieurs à un nombre donné (saisie par l'utilisateur)
Solution

import 'dart:io';

void main() {
  print(
      "Les nombres premiers inférieurs à un nombre saisie par l'utilisateur:");
  print('Veuillez saisir un nombre entier positif');
  int? nbr = int.parse(stdin.readLineSync()!);
  print("Liste des nombres premiers inférures à $nbr");
  print('----------------------------');
  for (int i = 2; i <= nbr; i++) {
    verifierPremier(i);
  }
}

void verifierPremier(int nbrPremiers) {
  int i, j = 0;
  bool nbrTrouve = false;
  j = nbrPremiers ~/ 2;
  //print("La valeur de j est :$j");
  for (i = 2; i <= j; i++) {
    if (nbrPremiers % i == 0) {
      nbrTrouve = true;
      break;
    }
  }
  if (nbrTrouve == false) {
    print('$nbrPremiers');
  }
}

• Écrire un programme en langage Dart qui affiche les 100 premiers nombres entiers sur la même ligne.
• Le résultat doit correspondre au schéma suivant:



• Afficher la somme des nombres pairs, impairs et premiers
Solution

import 'dart:io';

void main() {
  int sommePair = 0, sommeImpair = 0, sommePremiers = 0;
  for (int i = 2; i <= 100; i++) {
    if (i % 2 == 0) {
      sommePair += i;
    } else {
      sommeImpair += i;
    }
    if (verifierPremier(i)) {
      sommePremiers += i;
    }
    if (i != 100) {
      stdout.write("$i, ");
    } else {
      stdout.write(i);
    }
  }
  print("\nLa somme des nombres pairs est: $sommePair");
  print("La somme des nombres impairs est: $sommeImpair");
  print("La somme des nombres premiers est: $sommePremiers");
}

bool verifierPremier(int num) {
  int j = 0;
  if (num <= 1) {
    return false;
  }
  j = num ~/ 2;
  for (int i = 2; i <= j; i++) {
    if (num % i == 0) {
      return false;
    }
  }
  return true;
}

• Écrire un programme Dart qui demande à l'utilisateur un nombre compris entre 1 et 3 jusqu’à ce que la réponse convienne.
Solution

import 'dart:convert';
import 'dart:io';

void main() {
  int nbr = 0;
  int i = 1;
  print("Veuillez saisir un nombre entre 1 et 3");
  do {
    print(
        'Essaie de saisie numéro: $i est: ${nbr = int.parse(stdin.readLineSync()!)}');
    i += 1;
  } while (nbr < 1 || nbr > 3);
  print("--------------------Fin du programme-------------------------------");
}

• Écrire un programme Dart qui demande un nombre compris entre 10 et 20, jusqu’à ce que la réponse convienne.
• En cas de réponse supérieure à 20, on fera apparaître un message : "Plus petit ! ", et inversement, " Plus grand !" si le nombre est inférieur à 10.
• En cas de réponse juste le programme affiche le nombre des essaies total et les essaies "Plus petit ! " et " Plus grand !
Solution

import 'dart:io';

void main() {
  int nbr = 0;
  int i = 1;
  int nbrPlusPetit = 0, nbrPlusGrand = 0;
  print("Veuillez saisir un nombre entre 10 et 20");
  do {
    print(
        'Essaie de saisie numéro: $i est: ${nbr = int.parse(stdin.readLineSync()!)}');
    if (nbr < 10) {
      print("Plus petit !");
      nbrPlusPetit += 1;
    } else if (nbr > 20) {
      print("Plus grand !");
      nbrPlusGrand += 1;
    }
    i += 1;
  } while (nbr < 10 || nbr > 20);
  print("Nombre des essaies 'Plus grand !' est: $nbrPlusGrand");
  print("Nombre des essaies 'Plus petit !' est : $nbrPlusPetit");
  print("Nombre total des essaies est : ${i - 1}");

  print("--------------------Fin du programme-------------------------------");
}

• Écrire un programme Dart avec une boucle do..while qui compte de 3 à 22 selon le modèle suivant :3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
Solution

import 'dart:io';

void main() {
  int i = 3;
  do {
    stdout.write("$i ");
    i += 1;
  } while (i < 23);
}

• Écrire un programme Dart qui affiche "apcpedagogie est cool." 5 fois avec toutes les boucles.
Solution

void main() {
  // Boucle for
  for (var m = 0; m < 5; m++) {
    print("apcpedagogie est cool.");
  }
  // Boucle While
  var i = 0;
  while (i != 5) {
    print("apcpedagogie est cool.");
    i++;
  }
  // Boucle DoWhile
  var x = 0;
  do {
    print("apcpedagogie est cool.");
    x++;
  } while (x != 5);
}

• Écrire un programme Dart qui affiche une liste incrémenté des nombres inférieurs à nbr à l'aide de la boucle for
• Le nombre nbr est donnée par l'utilisateur
• Afficher la somme des nombres affichés.
Solution

import 'dart:io';

void main() {
  print('Veuillez saisir un nombre');
  int? nbr = int.parse(stdin.readLineSync()!);
  int somme = 0;
  for (int i = nbr; i >= 1; i--) {
    somme += i;
    stdout.write("$i ");
  }
  print("\nLa somme des nombres est: $somme");
}