Algorithmes et programmation

Compréhension durable (AAP-1) : Pour trouver des solutions spécifiques à des problèmes généralisables, les programmeurs représentent et organisent les données de multiples façons.

Objectif d'apprentissage AAP-1.A : Représenter une valeur avec une variable. [Compétence 3.A]

• AAP-1.A.1 Une variable est une abstraction à l'intérieur d'un programme qui peut contenir une valeur. Chaque variable possède un espace de stockage associé représentant une seule valeur à la fois, mais cette valeur peut être une liste ou une autre collection contenant elle-même plusieurs valeurs.
• AAP-1.A.2 L'utilisation de noms de variables significatifs facilite la lisibilité du code du programme et la compréhension des valeurs représentées par les variables.
• AAP-1.A.3 Certains langages de programmation fournissent des types pour représenter les données, auxquels on accède via des variables. Ces types incluent les nombres, les booléens, les listes et les chaînes de caractères.
• AAP-1.A.4 Certaines valeurs sont mieux adaptées à la représentation avec un type de donnée particulier plutôt qu'avec un autre.

Objectif d'apprentissage AAP-1.B : Déterminer la valeur d'une variable en résultat d'une affectation. [Compétence 4.B]

• AAP-1.B.1 L'opérateur d'affectation permet à un programme de modifier la valeur représentée par une variable.

• AAP-1.B.2 La feuille de référence de l'examen fournit l'opérateur "$\leftarrow$" à utiliser pour l'affectation. Par exemple,

  Texte :

  a ← expression

  Bloc :

  a ← expression

  évalue expression puis attribue une copie du résultat à la variable a.

• AAP-1.B.3 La valeur stockée dans une variable sera la dernière valeur assignée. Par exemple :

  a ← 1 b ← a a ← 2 display(b)

  affiche toujours 1.

Compréhension durable (AAP-1) : Pour trouver des solutions spécifiques à des problèmes généralisables, les programmeurs représentent et organisent les données de multiples façons.

Objectif d'apprentissage AAP-1.C : Représenter une liste ou une chaîne de caractères à l'aide d'une variable. [Compétence 3.A]

• AAP-1.C.1 Une liste est une séquence ordonnée d'éléments. Par exemple,

  [value1, value2, value3, ...]

  décrit une liste où value1 est le premier élément, value2 est le deuxième élément, value3 est le troisième élément, et ainsi de suite.

• AAP-1.C.2 Un élément est une valeur individuelle dans une liste qui se voit attribuer un index unique.

• AAP-1.C.3 Un index est une méthode courante pour référencer les éléments d'une liste ou d'une chaîne de caractères à l'aide de nombres naturels.

• AAP-1.C.4 Une chaîne de caractères est une séquence ordonnée de caractères.

Objectif d'apprentissage AAP-1.D : Pour l'abstraction de données : a. Développer une abstraction de données en utilisant des listes pour stocker plusieurs éléments. [Compétence 3.B] b. Expliquer comment l'utilisation de l'abstraction de données gère la complexité dans le code du programme. [Compétence 3.C]

• AAP-1.D.1 L'abstraction de données fournit une séparation entre les propriétés abstraites d'un type de données et les détails concrets de sa représentation.

• AAP-1.D.2 Les abstractions de données gèrent la complexité des programmes en donnant un nom à un ensemble de données sans faire référence aux détails spécifiques de la représentation.

• AAP-1.D.3 Les abstractions de données peuvent être créées à l'aide de listes.

• AAP-1.D.4 Le développement d'une abstraction de données à implémenter dans un programme peut entraîner un programme plus facile à développer et à maintenir.

• AAP-1.D.5 Les abstractions de données contiennent souvent différents types d'éléments.

• AAP-1.D.6 L'utilisation de listes permet de traiter plusieurs éléments apparents comme une seule valeur. Les listes sont désignées par différents noms, tels que tableau, selon le langage de programmation.

  • Énoncé d'exclusion (EK AAP-1.D.6) : L'utilisation de listes chaînées est hors du champ de ce cours et de l'examen AP.

• AAP-1.D.7 La feuille de référence de l'examen fournit la notation

  [value1, value2, value3, ...]

  pour créer une liste avec ces valeurs comme premier, deuxième, troisième, etc. éléments. Par exemple,

  • Texte :

    aList ← [value1, value2, value3, ...]

    Bloc :

    aList ← value1, value2, value3

    crée une nouvelle liste contenant les valeurs value1, value2, value3 et ... aux indices 1, 2, 3 et ... respectivement et l'attribue à aList.

  • Texte :

    aList ← []

    Bloc :

    aList ← (vide)

    crée une nouvelle liste vide et l'attribue à aList.

  • Texte :

    aList ← bList

    Bloc :

    aList ← bList

    attribue une copie de la liste bList à la liste aList. Par exemple, si bList contient [20, 40, 60], alors aList contiendra également [20, 40, 60] après l'attribution.

• AAP-1.D.8 La feuille de référence de l'examen décrit une structure de liste dont les valeurs d'index vont de 1 au nombre d'éléments de la liste, inclus. Pour toutes les opérations de liste, si un index de liste est inférieur à 1 ou supérieur à la longueur de la liste, un message d'erreur est produit et le programme se termine.

Compréhension durable (AAP-2) : La manière dont les instructions sont séquencées et combinées dans un programme détermine le résultat calculé. Les programmes intègrent des structures d'itération et de sélection pour représenter la répétition et prendre des décisions afin de gérer des valeurs d'entrée variées.

Objectif d'apprentissage AAP-2.A : Exprimer un algorithme utilisant la séquence sans utiliser un langage de programmation. [Compétence 2.A]

• AAP-2.A.1 Un algorithme est un ensemble fini d'instructions accomplissant une tâche spécifique.
• AAP-2.A.2 Au-delà des langages de programmation visuels et textuels, les algorithmes peuvent être exprimés de diverses manières, telles que le langage naturel, les diagrammes et le pseudocode.
• AAP-2.A.3 Les algorithmes exécutés par des programmes sont implémentés à l'aide de langages de programmation.
• AAP-2.A.4 Tout algorithme peut être construit à l'aide de combinaisons de séquence, de sélection et d'itération.

Objectif d'apprentissage AAP-2.B : Représenter un processus algorithmique étape par étape à l'aide d'instructions de code séquentielles. [Compétence 2.B]

• AAP-2.B.1 La séquence est l'application de chaque étape d'un algorithme dans l'ordre dans lequel les instructions de code sont données.
• AAP-2.B.2 Une instruction de code est une partie du code d'un programme qui exprime une action à effectuer.
• AAP-2.B.3 Une expression peut consister en une valeur, une variable, un opérateur ou un appel de procédure retournant une valeur.
• AAP-2.B.4 Les expressions sont évaluées pour produire une seule valeur.
• AAP-2.B.5 L'évaluation des expressions suit un ordre d'opérations défini par le langage de programmation.
• AAP-2.B.6 Les instructions séquentielles s'exécutent dans l'ordre dans lequel elles apparaissent dans le segment de code.
• AAP-2.B.7 La clarté et la lisibilité sont des considérations importantes lors de l'expression d'un algorithme dans un langage de programmation.

Objectif d'apprentissage AAP-2.C : Évaluer des expressions utilisant des opérateurs arithmétiques. [Compétence 4.B]

• AAP-2.C.1 Les opérateurs arithmétiques font partie de la plupart des langages de programmation et comprennent les opérateurs d'addition, de soustraction, de multiplication, de division et de module.

• AAP-2.C.2 La feuille de référence de l'examen fournit a MOD b, qui évalue au reste de la division de a par b. On suppose que a est un entier supérieur ou égal à 0 et que b est un entier supérieur à 0. Par exemple, 17 MOD 5 évalue à 2.

• AAP-2.C.3 La feuille de référence de l'examen fournit les opérateurs arithmétiques +, -, *, / et MOD.

  Texte et Bloc :

  • a + b
  • a - b
  • a * b
  • a / b
  • a MOD b

  Ceux-ci sont utilisés pour effectuer des opérations arithmétiques sur a et b. Par exemple, 17 / 5 évalue à 3.4.

• AAP-2.C.4 L'ordre des opérations utilisé en mathématiques s'applique lors de l'évaluation des expressions. L'opérateur MOD a la même priorité que les opérateurs * et /.

Compréhension durable (AAP-2) : La manière dont les instructions sont séquencées et combinées dans un programme détermine le résultat calculé. Les programmes intègrent des structures d'itération et de sélection pour représenter la répétition et prendre des décisions afin de gérer des valeurs d'entrée variées.

Objectif d'apprentissage AAP-2.D : Évaluer des expressions manipulant des chaînes de caractères. [Compétence 4.B]

• AAP-2.D.1 La concaténation de chaînes joint deux chaînes ou plus bout à bout pour former une nouvelle chaîne.
• AAP-2.D.2 Un sous-chaine (substring) est une partie d'une chaîne existante.

Compréhension durable (AAP-2) : La manière dont les instructions sont séquencées et combinées dans un programme détermine le résultat calculé. Les programmes intègrent des structures d'itération et de sélection pour représenter la répétition et prendre des décisions afin de gérer des valeurs d'entrée variées.

Objectif d'apprentissage AAP-2.E : Pour les relations entre deux variables, expressions ou valeurs : a. Écrire des expressions utilisant des opérateurs relationnels. [Compétence 2.B] b. Évaluer des expressions utilisant des opérateurs relationnels. [Compétence 4.B]

• AAP-2.E.1 Une valeur booléenne est soit vraie, soit fausse.

• AAP-2.E.2 La feuille de référence de l'examen fournit les opérateurs relationnels suivants : =, ≠, >, <, ≥ et ≤.

  Texte et Bloc :

  • a = b
  • a ≠ b
  • a > b
  • a < b
  • a ≥ b
  • a ≤ b

  Ceux-ci sont utilisés pour tester la relation entre deux variables, expressions ou valeurs. Une comparaison utilisant un opérateur relationnel évalue à une valeur booléenne. Par exemple, a = b évalue à true si a et b sont égaux ; sinon, il évalue à false.

Objectif d'apprentissage AAP-2.F : Pour les relations entre des valeurs booléennes : a. Écrire des expressions utilisant des opérateurs logiques. [Compétence 2.B] b. Évaluer des expressions utilisant des opérateurs logiques. [Compétence 4.B]

• AAP-2.F.1 La feuille de référence de l'examen fournit les opérateurs logiques NOT, AND et OR, qui évaluent à une valeur booléenne.

• AAP-2.F.2 La feuille de référence de l'examen fournit

  Texte :

  NOT condition

  Bloc :

  NOT condition

  qui évalue à true si condition est false ; sinon il évalue à false.

• AAP-2.F.3 La feuille de référence de l'examen fournit

  Texte :

  condition1 AND condition2

  Bloc :

  condition1 AND condition2

  qui évalue à true si tant condition1 que condition2 sont true ; sinon, elle évalue à false.

• AAP-2.F.4 La feuille de référence de l'examen fournit

  Texte :

  condition1 OR condition2

  Bloc :

  condition1 OR condition2

  qui évalue à true si condition1 est true ou si condition2 est true ou si tant condition1 que condition2 sont true ; sinon, elle évalue à false.

• AAP-2.F.5 L'opérande d'un opérateur logique est soit une expression booléenne, soit une valeur booléenne unique.

Compréhension durable (AAP-2) : La manière dont les instructions sont séquencées et combinées dans un programme détermine le résultat calculé. Les programmes intègrent des structures d'itération et de sélection pour représenter la répétition et prendre des décisions afin de gérer des valeurs d'entrée variées.

Objectif d'apprentissage AAP-2.G : Exprimer un algorithme utilisant la sélection sans utiliser de langage de programmation. [Compétence 2.A]

• AAP-2.G.1 La sélection détermine quelles parties d'un algorithme sont exécutées selon qu'une condition est true ou false.

Objectif d'apprentissage AAP-2.H : Pour la sélection : a. Écrire des instructions conditionnelles. [Compétence 2.B] b. Déterminer le résultat des instructions conditionnelles. [Compétence 4.B]

• AAP-2.H.1 Les instructions conditionnelles, ou « instructions if », modifient le flux séquentiel du contrôle en exécutant différentes instructions selon la valeur d'une expression booléenne.

• AAP-2.H.2 La feuille de référence de l'examen fournit

  Texte :

  IF(condition) { <block of statements> }

  Bloc :

  IF condition block of statements

  dans lequel le code dans block of statements est exécuté si l'expression booléenne condition évalue à true ; aucune action n'est prise si condition évalue à false.

• AAP-2.H.3 La feuille de référence de l'examen fournit

  Texte :

  IF(condition) { <first block of statements> } ELSE { <second block of statements> }

  Bloc :

  IF condition first block of statements ELSE second block of statements

  dans lequel le code dans first block of statements est exécuté si l'expression booléenne condition évalue à true ; sinon, le code dans second block of statements est exécuté.

Compréhension durable (AAP-2) : La manière dont les instructions sont séquencées et combinées dans un programme détermine le résultat calculé. Les programmes intègrent des structures d'itération et de sélection pour représenter la répétition et prendre des décisions afin de gérer des valeurs d'entrée variées.

Objectif d'apprentissage AAP-2.I : Pour la sélection imbriquée : a. Écrire des instructions conditionnelles imbriquées. [Compétence 2.B] b. Déterminer le résultat des instructions conditionnelles imbriquées. [Compétence 4.B]

• AAP-2.I.1 Les instructions conditionnelles imbriquées consistent en des instructions conditionnelles situées à l'intérieur d'autres instructions conditionnelles.

Compréhension durable (AAP-2) : La manière dont les instructions sont séquencées et combinées dans un programme détermine le résultat calculé. Les programmes intègrent des structures d'itération et de sélection pour représenter la répétition et prendre des décisions afin de gérer des valeurs d'entrée variées.

Objectif d'apprentissage AAP-2.J : Exprimer un algorithme utilisant l'itération sans utiliser de langage de programmation. [Compétence 2.A]

• AAP-2.J.1 L'itération est une portion répétitive d'un algorithme. L'itération répète un nombre spécifié de fois ou jusqu'à ce qu'une condition donnée soit remplie.

Objectif d'apprentissage AAP-2.K : Pour l'itération : a. Écrire des instructions d'itération. [Compétence 2.B] b. Déterminer le résultat ou l'effet secondaire des instructions d'itération. [Compétence 4.B]

• AAP-2.K.1 Les instructions d'itération modifient le flux séquentiel du contrôle en répétant un ensemble d'instructions zéro ou plusieurs fois, jusqu'à ce qu'une condition d'arrêt soit rencontrée.

• AAP-2.K.2 La feuille de référence de l'examen fournit

  Texte :

  REPEAT n TIMES { <block of statements> }

  Bloc :

  REPEAT n TIMES block of statements

  dans lequel la block of statements est exécutée n fois.

• AAP-2.K.3 La feuille de référence de l'examen fournit

  Texte :

  REPEAT UNTIL(condition) { <block of statements> }

  Bloc :

  REPEAT UNTIL condition block of statements

  dans lequel le code dans block of statements est répété jusqu'à ce que l'expression booléenne condition évalue à true.

• AAP-2.K.4 Dans l'itération REPEAT UNTIL(condition), une boucle infinie se produit lorsque la condition de fin n'évaluera jamais à true.

• AAP-2.K.5 Dans l'itération REPEAT UNTIL(condition), si la condition évalue initialement à true, le corps de la boucle n'est pas exécuté du tout, car la condition est vérifiée avant la boucle.

Compréhension durable (AAP-2) : La manière dont les instructions sont séquencées et combinées dans un programme détermine le résultat calculé. Les programmes intègrent des structures d'itération et de sélection pour représenter la répétition et prendre des décisions afin de gérer des valeurs d'entrée variées.

Objectif d'apprentissage AAP-2.L : Comparer plusieurs algorithmes pour déterminer s'ils produisent le même effet secondaire ou le même résultat. [Compétence 1.D]

• AAP-2.L.1 Les algorithmes peuvent être écrits de différentes manières tout en accomplissant les mêmes tâches.
• AAP-2.L.2 Des algorithmes qui semblent similaires peuvent produire des effets secondaires ou des résultats différents.
• AAP-2.L.3 Certaines instructions conditionnelles peuvent être écrites sous forme d'expressions booléennes équivalentes.
• AAP-2.L.4 Certaines expressions booléennes peuvent être écrites sous forme d'instructions conditionnelles équivalentes.
• AAP-2.L.5 Différents algorithmes peuvent être développés ou utilisés pour résoudre le même problème.

Objectif d'apprentissage AAP-2.M : Pour les algorithmes : a. Créer des algorithmes. [Compétence 2.A] b. Combiner et modifier des algorithmes existants. [Compétence 2.B]

• AAP-2.M.1 Les algorithmes peuvent être créés à partir d'une idée, en combinant des algorithmes existants, ou en modifiant des algorithmes existants.
• AAP-2.M.2 La connaissance d'algorithmes existants peut aider à en construire de nouveaux. Certains algorithmes existants incluent :
  • déterminer la valeur maximale ou minimale de deux nombres ou plus
  • calculer la somme ou la moyenne de deux nombres ou plus
  • identifier si un entier est ou n'est pas divisible par un autre entier
  • déterminer le parcours d'un robot à travers un labyrinthe
• AAP-2.M.3 L'utilisation d'algorithmes existants corrects comme briques de construction pour en créer un autre présente des avantages tels que la réduction du temps de développement, la réduction des tests et la simplification de l'identification des erreurs.

Compréhension durable (AAP-2) : La manière dont les instructions sont séquencées et combinées dans un programme détermine le résultat calculé. Les programmes intègrent des structures d'itération et de sélection pour représenter la répétition et prendre des décisions afin de gérer des valeurs d'entrée variées.

Objectif d'apprentissage AAP-2.N : Pour les opérations sur les listes : a. Écrire des expressions utilisant l'indexation de liste et les procédures de liste. [Compétence 2.B] b. Évaluer des expressions utilisant l'indexation de liste et les procédures de liste. [Compétence 4.B]

• AAP-2.N.1 La feuille de référence de l'examen fournit les opérations de base sur les listes, y compris :

  • accéder à un élément par son index

    Texte :

    aList[i]

    Bloc :

    aList i

    accède à l'élément de aList à l'index i. Le premier élément de aList est à l'index 1 et est accèsé à l'aide de la notation aList[1].

  • attribuer la valeur d'un élément de liste à une variable

    Texte :

    x ← aList[i]

    Bloc :

    x ← aList i

    attribue la valeur de aList[i] à la variable x.

  • attribuer une valeur à un élément de liste

    Texte :

    aList[i] ← x

    Bloc :

    aList i ← x

    attribue la valeur de x à aList[i].

    Texte :

    aList[i] ← aList[j]

    Bloc :

    aList i ← aList j

    attribue la valeur de aList[j] à aList[i].

  • insérer des éléments à un index donné

    Texte :

    INSERT(aList, i, value)

    Bloc :

    INSERT aList, i, value

    décale vers la droite toutes les valeurs dans aList aux indices supérieurs ou égaux à i. La longueur de la liste augmente de 1, et value est placé à l'index i dans aList.

  • ajouter des éléments à la fin de la liste

    Texte :

    APPEND(aList, value)

    Bloc :

    APPEND aList, value

    augmente la longueur de aList de 1, et value est placé à la fin de aList.

  • supprimer des éléments

    Texte :

    REMOVE(aList, i)

    Bloc :

    REMOVE aList, i

    supprime l'élément à l'index i dans aList et décale vers la gauche toute valeur aux indices supérieurs à i. La longueur de aList diminue de 1.

  • déterminer la longueur d'une liste

    Texte :

    LENGTH(aList)

    Bloc :

    LENGTH aList

    évalue au nombre d'éléments actuellement présents dans aList.

• AAP-2.N.2 Les procédures de liste sont implémentées conformément aux règles de syntaxe du langage de programmation.

Objectif d'apprentissage AAP-2.O : Pour les algorithmes impliquant des éléments d'une liste : a. Écrire des instructions d'itération pour parcourir une liste. [Compétence 2.B] b. Déterminer le résultat d'un algorithme incluant des traversées de liste. [Compétence 4.B]

• AAP-2.O.1 Parcourir une liste peut être une traversée complète, où tous les éléments de la liste sont accédés, ou une traversée partielle, où seule une portion des éléments est accédée.

  • Énoncé d'exclusion (EK AAP-2.O.1) : Parcourir plusieurs listes simultanément en utilisant le même index pour les deux (traversées parallèles) est hors du champ de ce cours et de l'examen AP.

• AAP-2.O.2 Les instructions d'itération peuvent être utilisées pour parcourir une liste.

• AAP-2.O.3 La feuille de référence de l'examen fournit

  Texte :

  FOR EACH item IN aList { <block of statements> }

  Bloc :

  FOR EACH item IN aList block of statements

  La variable item se voit attribuer la valeur de chaque élément de aList séquentiellement, dans l'ordre, du premier élément au dernier. Le code dans block of statements s'exécute une fois pour chaque attribution de item.

• AAP-2.O.4 La connaissance d'algorithmes existants utilisant l'itération peut aider à construire de nouveaux algorithmes. Certains exemples d'algorithmes existants souvent utilisés avec les listes incluent :

  • déterminer une valeur minimale ou maximale dans une liste
  • calculer une somme ou une moyenne d'une liste de nombres

• AAP-2.O.5 Les algorithmes de recherche linéaire ou séquentielle vérifient chaque élément d'une liste, dans l'ordre, jusqu'à ce que la valeur souhaitée soit trouvée ou que tous les éléments aient été vérifiés.

Compréhension durable (AAP-2) : La manière dont les instructions sont séquencées et combinées dans un programme détermine le résultat calculé. Les programmes intègrent des structures d'itération et de sélection pour représenter la répétition et prendre des décisions afin de gérer des valeurs d'entrée variées.

Objectif d'apprentissage AAP-2.P : Pour les algorithmes de recherche binaire : a. Déterminer le nombre d'itérations nécessaires pour trouver une valeur dans un jeu de données. [Compétence 1.D] b. Expliquer les conditions nécessaires pour effectuer une recherche binaire. [Compétence 1.A]

• AAP-2.P.1 L'algorithme de recherche binaire commence au milieu d'un ensemble de données numérotées trié et élimine la moitié des données ; ce processus se répète jusqu'à ce que la valeur souhaitée soit trouvée ou que tous les éléments aient été éliminés.
  • Énoncé d'exclusion (EK AAP-2.P.1) : Des implémentations spécifiques de la recherche binaire sont hors du champ du cours et de l'examen AP.
• AAP-2.P.2 Les données doivent être triées pour utiliser l'algorithme de recherche binaire.
• AAP-2.P.3 La recherche binaire est souvent plus efficace que la recherche séquentielle/linéaire lorsqu'elle est appliquée à des données triées.

Compréhension durable (AAP-3) : Les programmeurs décomposent les problèmes en pièces plus petites et plus gérables. En créant des procédures et en exploitant les paramètres, les programmeurs généralisent des processus réutilisables. Les procédures permettent aux programmeurs de s'appuyer sur du code existant déjà testé, leur permettant d'écrire des programmes plus rapidement et avec plus de confiance.

Objectif d'apprentissage AAP-3.A : Pour les appels de procédures : a. Écrire des instructions pour appeler des procédures. [Compétence 3.B] b. Déterminer le résultat ou l'effet d'un appel de procédure. [Compétence 4.B]

• AAP-3.A.1 Une procédure est un groupe nommé d'instructions de programmation pouvant avoir des paramètres et des valeurs de retour.

• AAP-3.A.2 Les procédures sont désignées par différents noms, comme méthode ou fonction, selon le langage de programmation.

• AAP-3.A.3 Les paramètres sont les variables d'entrée d'une procédure. Les arguments spécifient les valeurs des paramètres lors de l'appel d'une procédure.

• AAP-3.A.4 Un appel de procédure interrompt l'exécution séquentielle des instructions, amenant le programme à exécuter les instructions contenues dans la procédure avant de continuer. Une fois la dernière instruction de la procédure (ou une instruction de retour) exécutée, le flux de contrôle revient au point immédiatement après celui où la procédure a été appelée.

• AAP-3.A.5 La feuille de référence de l'examen fournit

  procName(arg1, arg2, ...)

  comme moyen d'appeler

  Texte :

  PROCEDURE procName(parameter1, parameter2, ...) { <block of statements> }

  Bloc :

  PROCEDURE procName parameter1, parameter2,... block of statements

  qui prend zéro ou plus d'arguments ; arg1 est attribué à parameter1, arg2 est attribué à parameter2, et ainsi de suite.

• AAP-3.A.6 La feuille de référence de l'examen fournit la procédure

  Texte :

  DISPLAY(expression)

  Bloc :

  DISPLAY expression

  pour afficher la valeur de expression, suivie d'un espace.

• AAP-3.A.7 La feuille de référence de l'examen fournit la

  Texte :

  RETURN(expression)

  Bloc :

  RETURN expression

  instruction, utilisée pour retourner le flux de contrôle au point où la procédure a été appelée et pour retourner la valeur de expression.

• AAP-3.A.8 La feuille de référence de l'examen fournit

  result ← procName(arg1, arg2, ...)

  pour attribuer à result la "valeur de la procédure" retournée en appelant

  Texte :

  PROCEDURE procName(parameter1, parameter2, ...) { <block of statements> RETURN(expression) }

  Bloc :

  PROCEDURE procName parameter1, parameter2,... block of statements RETURN expression

• AAP-3.A.9 La feuille de référence de l'examen fournit la procédure

  Texte :

  INPUT()

  Bloc :

  INPUT

  qui accepte une valeur de l'utilisateur et retourne la valeur saisie.

Compréhension durable (AAP-3) : Les programmeurs décomposent les problèmes en pièces plus petites et plus gérables. En créant des procédures et en exploitant les paramètres, les programmeurs généralisent des processus réutilisables. Les procédures permettent aux programmeurs de s'appuyer sur du code existant déjà testé, leur permettant d'écrire des programmes plus rapidement et avec plus de confiance.

Objectif d'apprentissage AAP-3.B : Expliquer comment l'utilisation de l'abstraction procédurale gère la complexité dans un programme. [Compétence 3.C]

• AAP-3.B.1 Un type courant d'abstraction est l'abstraction procédurale, qui fournit un nom à un processus et permet d'utiliser une procédure sans connaître que ce qu'elle fait, pas comment elle le fait.
• AAP-3.B.2 L'abstraction procédurale permet de baser la solution d'un grand problème sur les solutions de sous-problèmes plus petits. Cela s'accomplit en créant des procédures pour résoudre chacun des sous-problèmes.
• AAP-3.B.3 La subdivision d'un programme informatique en sous-programmes distincts est appelée modularité.
• AAP-3.B.4 Une abstraction procédurale peut extraire des fonctionnalités partagées pour généraliser la fonctionnalité au lieu de dupliquer le code. Cela permet la réutilisation du code du programme, ce qui aide à gérer la complexité.
• AAP-3.B.5 L'utilisation de paramètres permet de généraliser les procédures, rendant les procédures réutilisables avec une gamme de valeurs d'entrée ou d'arguments.
• AAP-3.B.6 L'utilisation de l'abstraction procédurale aide à améliorer la lisibilité du code.
• AAP-3.B.7 L'utilisation de l'abstraction procédurale dans un programme permet aux programmeurs de modifier les détails internes de la procédure (pour la rendre plus rapide, plus efficace, utilisant moins de mémoire, etc.) sans avoir besoin d'avertir les utilisateurs du changement tant que ce que la procédure fait est préservé.

Objectif d'apprentissage AAP-3.C : Développer des abstractions procédurales pour gérer la complexité dans un programme en écrivant des procédures. [Compétence 3.B]

• AAP-3.C.1 La feuille de référence de l'examen fournit

  Texte :

  PROCEDURE procName(parameter1, parameter2, ...) { <block of statements> }

  Bloc :

  PROCEDURE procName parameter1, parameter2,... block of statements

  qui est utilisé pour définir une procédure prenant zéro ou plus d'arguments. La procédure contient block of statements.

• AAP-3.C.2 La feuille de référence de l'examen fournit

  Texte :

  PROCEDURE procName(parameter1, parameter2, ...) { <block of statements> RETURN(expression) }

  Bloc :

  PROCEDURE procName parameter1, parameter2,... block of statements RETURN expression

  qui est utilisé pour définir une procédure prenant zéro ou plus d'arguments. La procédure contient block of statements et retourne la valeur de expression. L'instruction RETURN peut apparaître à n'importe quel endroit à l'intérieur de la procédure et provoque un retour immédiat de la procédure vers l'instruction qui l'a appelée.

Compréhension durable (AAP-3) : Les programmeurs décomposent les problèmes en pièces plus petites et plus gérables. En créant des procédures et en exploitant les paramètres, les programmeurs généralisent des processus réutilisables. Les procédures permettent aux programmeurs de s'appuyer sur du code existant déjà testé, leur permettant d'écrire des programmes plus rapidement et avec plus de confiance.

Objectif d'apprentissage AAP-3.D : Sélectionner des bibliothèques appropriées ou des segments de code existants à utiliser dans la création de nouveaux programmes. [Compétence 2.B]

• AAP-3.D.1 Une bibliothèque logicielle contient des procédures qui peuvent être utilisées dans la création de nouveaux programmes.
• AAP-3.D.2 Les segments de code existants peuvent provenir de sources internes ou externes, telles que des bibliothèques ou du code écrit précédemment.
• AAP-3.D.3 L'utilisation de bibliothèques simplifie la tâche de création de programmes complexes.
• AAP-3.D.4 Les interfaces de programmation d'application (API) sont des spécifications définissant le comportement et l'utilisation des procédures dans une bibliothèque.
• AAP-3.D.5 La documentation d'une API/bibliothèque est nécessaire pour comprendre les comportements qu'elle fournit et la manière de les utiliser.

Compréhension durable (AAP-3) : Les programmeurs décomposent les problèmes en pièces plus petites et plus gérables. En créant des procédures et en exploitant les paramètres, les programmeurs généralisent des processus réutilisables. Les procédures permettent aux programmeurs de s'appuyer sur du code existant déjà testé, leur permettant d'écrire des programmes plus rapidement et avec plus de confiance.

Objectif d'apprentissage AAP-3.E : Pour la génération de valeurs aléatoires : a. Écrire des expressions pour générer des valeurs possibles. [Compétence 2.B] b. Évaluer des expressions pour déterminer les résultats possibles. [Compétence 4.B]

• AAP-3.E.1 La feuille de référence de l'examen fournit

  Texte :

  RANDOM(a, b)

  Bloc :

  RANDOM a, b

  qui génère et retourne un entier aléatoire compris entre a et b, inclus. Chaque résultat a une probabilité égale de survenir. Par exemple, RANDOM(1, 3) pourrait retourner 1, 2 ou 3.

• AAP-3.E.2 L'utilisation de la génération de nombres aléatoires dans un programme signifie que chaque exécution peut produire un résultat différent.

Compréhension durable (AAP-3) : Les programmeurs décomposent les problèmes en pièces plus petites et plus gérables. En créant des procédures et en exploitant les paramètres, les programmeurs généralisent des processus réutilisables. Les procédures permettent aux programmeurs de s'appuyer sur du code existant déjà testé, leur permettant d'écrire des programmes plus rapidement et avec plus de confiance.

Objectif d'apprentissage AAP-3.F : Pour les simulations : a. Expliquer comment les ordinateurs peuvent être utilisés pour représenter des phénomènes ou des événements du monde réel. [Compétence 1.A] b. Comparer les simulations avec des contextes du monde réel. [Compétence 1.D]

• AAP-3.F.1 Les simulations sont des abstractions d'objets ou de phénomènes plus complexes à des fins spécifiques.
• AAP-3.F.2 Une simulation est une représentation qui utilise des ensembles de valeurs variables pour refléter l'état changeant d'un phénomène.
• AAP-3.F.3 Les simulations imitent souvent des événements du monde réel afin de tirer des conclusions, permettant d'investiguer un phénomène sans les contraintes du monde réel.
• AAP-3.F.4 Le processus de développement d'une simulation abstraite implique la suppression de détails spécifiques ou la simplification de fonctionnalités.
• AAP-3.F.5 Les simulations peuvent contenir un biais découlant des choix d'éléments du monde réel inclus ou exclus.
• AAP-3.F.6 Les simulations sont les plus utiles lorsque les événements du monde réel sont irréalisables pour des expériences (trop grands, trop petits, trop rapides, trop lents, trop coûteux ou trop dangereux).
• AAP-3.F.7 Les simulations facilitent la formulation et l'affinement d'hypothèses relatives aux objets ou phénomènes considérés.
• AAP-3.F.8 Les générateurs de nombres aléatoires peuvent être utilisés pour simuler la variabilité existant dans le monde réel.

Compréhension durable (AAP-4) : Il existe des problèmes que les ordinateurs ne peuvent pas résoudre, et même lorsqu'un ordinateur peut résoudre un problème, il peut ne pas pouvoir le faire en un temps raisonnable.

Objectif d'apprentissage AAP-4.A : Pour déterminer l'efficacité d'un algorithme : a. Expliquer la différence entre les algorithmes s'exécutant en un temps raisonnable et ceux qui ne le font pas. [Compétence 1.D] b. Identifier les situations où une solution heuristique peut être plus appropriée. [Compétence 1.D]

• AAP-4.A.1 Un problème est une description générale d'une tâche qui peut (ou ne peut pas) être résolue algorithmiquement. Une instance d'un problème inclut également une entrée spécifique. Par exemple, le tri est un problème ; trier la liste (2,3,1,7) est une instance du problème.
• AAP-4.A.2 Un problème de décision est un problème ayant une réponse oui/non (par ex., y a-t-il un chemin de A vers B ?). Un problème d'optimisation est un problème dont l'objectif est de trouver la solution "meilleure" parmi plusieurs (par ex., quel est le chemin le plus court de A vers B ?).
• AAP-4.A.3 L'efficacité est une estimation de la quantité de ressources informatiques utilisées par un algorithme. L'efficacité est généralement exprimée sous forme de fonction de la taille de l'entrée.
  • Énoncé d'exclusion (EK AAP-4.A.3) : L'analyse formelle des algorithmes (Big-O) et le raisonnement formel utilisant des formules mathématiques sont hors du champ de ce cours et de l'examen AP.
• AAP-4.A.4 L'efficacité d'un algorithme est déterminée par un raisonnement formel ou mathématique.
• AAP-4.A.5 L'efficacité d'un algorithme peut être mesurée informellement en déterminant le nombre de fois qu'une instruction ou un groupe d'instructions s'exécute.
• AAP-4.A.6 Différents algorithmes corrects pour le même problème peuvent avoir des efficacités différentes.
• AAP-4.A.7 Les algorithmes ayant une efficacité polynomiale ou plus lente (constante, linéaire, quadratique, cubique, etc.) sont dits s'exécuter en un temps raisonnable. Les algorithmes ayant des efficacités exponentielles ou factorielles sont des exemples d'algorithmes s'exécutant en un temps irraisonnable.
• AAP-4.A.8 Certains problèmes ne peuvent pas être résolus en un temps raisonnable car il n'existe aucun algorithme efficace pour les résoudre. Dans ces cas, des solutions approximatives sont recherchées.
• AAP-4.A.9 Une heuristique est une approche à un problème qui produit une solution qui n'est pas garantie comme étant optimale, mais qui peut être utilisée lorsque les techniques garantissant toujours de trouver une solution optimale sont irréalisables.
  • Énoncé d'exclusion (AAP-4.A.9) : Les solutions heuristiques spécifiques sont hors du champ de ce cours et de l'examen AP.

Compréhension durable (AAP-4) : Il existe des problèmes que les ordinateurs ne peuvent pas résoudre, et même lorsqu'un ordinateur peut résoudre un problème, il peut ne pas pouvoir le faire en un temps raisonnable.

Objectif d'apprentissage AAP-4.B : Expliquer l'existence de problèmes indécidables en informatique. [Compétence 1.A]

• AAP-4.B.1 Un problème décidable est un problème de décision pour lequel un algorithme peut être écrit pour produire une sortie correcte pour toutes les entrées (par ex., "Le nombre est-il pair ?").
• AAP-4.B.2 Un problème indécidable est un problème pour lequel aucun algorithme ne peut être construit capable de fournir toujours une réponse correcte oui ou non.
  • Énoncé d'exclusion (EK AAP-4.B.2) : Déterminer si un problème donné est indécidable est hors du champ de ce cours et de l'examen AP.
• AAP-4.B.3 Un problème indécidable peut avoir certaines instances avec une solution algorithmique, mais il n'existe pas de solution algorithmique pouvant résoudre toutes les instances du problème.