Contacts

Langue algorithmique russe. Langages algorithmiques et programmation. Structure de branchement de base

Ministère de l'Éducation Fédération Russe Université technique d'État de Perm

département technologies de l'information et systèmes automatisés

Vikentieva O. L.

Notes de cours pour le cours " Langages algorithmiques et programmation "(Fondamentaux du langage C++, 1 semestre)

introduction

Au premier semestre, les constructions de base du langage C et la technologie de programmation de base (programmation structurée) sont considérées.

La programmation structurée est une technologie de création de programmes qui permet, en respectant certaines règles, de réduire le temps de développement et le nombre d'erreurs, ainsi que de faciliter la possibilité de modifier un programme.

1.1. Algorithme et programme

L'algorithme est une prescription précise qui détermine processus de calcul passer de données initiales variables au résultat final, c'est-à-dire une recette pour atteindre un objectif.

L'ensemble d'outils et de règles permettant de représenter un algorithme sous une forme adaptée à son exécution par un ordinateur est appelé langage de programmation, un algorithme écrit dans ce langage est appelé programme.

Tout d'abord, un algorithme d'actions est toujours développé, puis il est écrit dans l'un des langages de programmation. Le texte du programme est traité par des programmes utilitaires spéciaux - des traducteurs. Les langages de programmation sont des langages artificiels. Ils se distinguent des langages naturels par un nombre limité de « mots » et des règles très strictes d'écriture des commandes (opérateurs). La totalité de ces exigences forme la syntaxe du langage de programmation, et le sens de chaque construction est sa sémantique.

1.2 Propriétés de l'algorithme

1. Massivité : l'algorithme doit être appliqué non pas à un problème, mais à toute une classe de problèmes similaires (un algorithme pour résoudre une équation quadratique ne doit pas résoudre une équation, mais toutes les équations quadratiques).

2. Efficacité : l'algorithme doit conduire à un résultat en un nombre d'étapes déterminé (en divisant 1 par 3, on obtient une fraction périodique de 0,3333 (3) ; pour parvenir au résultat final, il est nécessaire de préciser la précision d'obtention de cette fraction , par exemple, jusqu'à 4 décimales).

3. Certitude (déterminisme) - chaque action de l'algorithme doit être claire pour son exécuteur (instructions pour un appareil électroménager en japonais pour une personne qui ne parle pas japonais n'est pas un algorithme, car il n'a pas la propriété de déterminisme).

4. Discret - le processus doit être décrit en utilisant indivisible

opérations effectuées à chaque étape (c'est-à-dire que les étapes ne peuvent pas être divisées en étapes plus petites).

Les algorithmes peuvent être présentés sous les formes suivantes :

1) une description verbale de l'algorithme.

2) description graphique de l'algorithme.

3) utiliser un langage de programmation algorithmique

1.2. Compilateurs et interprètes

AVEC à l'aide d'un langage de programmation, un texte est créé qui décrit un algorithme préalablement compilé. Pour obtenir un programme fonctionnel, vous devez traduire ce texte en une séquence d'instructions du processeur, qui est exécutée en utilisant programmes spéciaux qu'on appelle traducteurs. Il existe deux types de traducteurs : les compilateurs et les interprètes. Le compilateur traduit le texte du module source en code machine, appelé module objet, en un processus continu. Parallèlement, il parcourt d'abord le code source du programme à la recherche de erreurs de syntaxe... L'interpréteur exécute le module source du programme en mode opérateur par opérateur, en

l'avancement des travaux, en traduisant chaque opérateur en langage machine.

1.3 langages de programmation

Différents types de processeurs ont des jeux d'instructions différents. Si un langage de programmation se concentre sur un type spécifique de processeur et prend en compte ses particularités, il est alors appelé langage de programmation de bas niveau. Le langage de niveau le plus bas est le langage assembleur, qui représente simplement chaque instruction de code machine sous la forme de symboles spéciaux appelés mnémoniques. À l'aide de langages de bas niveau, des programmes très efficaces et compacts sont créés, car le développeur a accès à toutes les capacités du processeur. Parce que jeux d'instructions pour différents modèles les processeurs sont également différents, alors chaque modèle de processeur correspond à son propre langage d'assemblage, et le programme qui y est écrit ne peut être utilisé que dans cet environnement. Des langues similaires sont utilisées pour écrire en petit applications système, pilotes de périphériques, etc.

Langages de programmation haut niveau ne prennent pas en compte les particularités des architectures informatiques spécifiques, donc programmes créés au niveau de la source, ils sont facilement portés sur d'autres plateformes si les traducteurs correspondants ont été créés pour eux. Développer des programmes dans des langages de haut niveau est beaucoup plus facile que dans des langages machine.

Les langages de haut niveau sont :

1. Fortran est le premier langage compilé créé en années 50 du 20e siècle. Il a mis en œuvre un certain nombre de concepts de programmation essentiels. Pour cette langue a été créé grande quantité bibliothèques allant des complexes statistiques à la gestion des satellites, il continue donc d'être utilisé dans de nombreuses organisations.

2. Cobol - Langage compilé pour les calculs et décisions économiques problèmes commerciaux se sont développés au début des années 60. Des outils très puissants pour travailler avec de grandes quantités de données stockées sur des supports externes ont été implémentés dans Cobol.

3. Pascal - créé à la fin Le mathématicien suisse des années 70 Niklaus Wirth spécialement pour l'enseignement de la programmation. Il vous permet de développer une pensée algorithmique, de construire un court, bien programme lisible, démontrer les techniques de base de l'algorithmique, il est également bien adapté à la mise en œuvre de grands projets.

4. BASIC - créé en 60s aussi pour l'enseignement de la programmation. Il existe des compilateurs et des interprètes pour cela, c'est l'un des langages de programmation les plus populaires.

5. C - a été créé dans les années 70 et n'était pas à l'origine considéré comme un langage de programmation grand public. Il était destiné à remplacer l'assembleur afin qu'il puisse créer des programmes aussi efficaces et courts que possible sans être dépendant du processeur. Il est à bien des égards semblable à Pascal et a caractéristiques supplémentaires travailler avec la mémoire. Il contient de nombreuses applications et programmes système, et système opérateur Unix.

6. C++ est une extension orientée objet du langage C, créée par Bjarne Stroustrup en 1980.

7. Java est un langage qui a été créé par Sun au début années 90 basé sur C++. Il est conçu pour simplifier le développement d'applications C++ en éliminant les fonctionnalités de bas niveau. caractéristique principale langage est qu'il n'est pas compilé en code machine, mais en bytecode indépendant de la plate-forme (chaque instruction prend un octet). Ce code peut être exécuté à l'aide d'un interpréteur - la machine virtuelle Java (JVM).

2.La structure d'un programme C++

Un programme C a la structure suivante : # directives du préprocesseur

. . . . . . . . .

# directives du préprocesseur fonction a ()

opérateurs de fonction dans ()

les opérateurs

void main () // fonction, qui démarre les instructions d'exécution du programme

descriptif

affectations

opérateur vide de fonction

composite

transition

Directives du préprocesseur - contrôlent la transformation du texte du programme avant sa compilation. Programme original préparé en SI sous la forme fichier texte, passe par 3 étapes de traitement :

1) transformation de texte par préprocesseur ;

2) compilation ;

3) mise en page (édition de liens ou assemblage).

Après ces trois étapes, le code exécutable du programme est formé. La tâche de prépro-

cessor - transformation du texte du programme avant sa compilation. Les règles de prétraitement sont définies par le programmeur à l'aide de directives de préprocesseur. La directive commence par #. Par exemple,

1) #define - indique les règles de remplacement dans le texte. #définir ZÉRO 0.0

Signifie que chaque utilisation du nom ZERO dans le programme sera remplacée

2) #inclure< имя заголовочного файла>- destiné à l'inclusion dans le texte du programme du texte du catalogue "Fichiers d'en-tête" fourni avec bibliothèques standards... Chaque fonction de la bibliothèque C a une description correspondante dans l'un des fichiers d'en-tête. La liste des fichiers d'en-tête est définie par la norme de langue. L'utilisation de la directive include n'inclut pas la bibliothèque standard correspondante

bibliothèque, mais vous permet uniquement d'insérer des descriptions du fichier d'en-tête spécifié dans le texte du programme. Les codes de la bibliothèque sont connectés au stade de l'enchaînement, c'est-à-dire après compilation. Bien que les fichiers d'en-tête contiennent toutes les descriptions des fonctions standard, seules les fonctions utilisées dans le programme sont incluses dans le code du programme.

Après le traitement de prétraitement, aucune directive de prétraitement ne reste dans le texte du programme.

Un programme est un ensemble de descriptions et de définitions, et se compose d'un ensemble de fonctions. Ces fonctions doivent toujours inclure une fonction nommée main. Sans cela, le programme ne peut pas être exécuté. Le nom de la fonction est précédé d'informations sur le type de la valeur renvoyée par la fonction (le type du résultat). Si la fonction ne renvoie rien, alors le type void est indiqué : void main(). Chaque fonction, y compris main, doit avoir un jeu de paramètres, il peut être vide, alors (void) est indiqué entre parenthèses.

Le corps de la fonction est placé derrière l'en-tête de la fonction. Un corps de fonction est une séquence de définitions, de descriptions et d'instructions exécutables entourées d'accolades. Chaque définition, description ou instruction se termine par un point-virgule.

Définitions - introduire des objets (un objet est une zone de mémoire nommée, un cas particulier d'un objet est une variable) nécessaires pour représenter les données traitées dans le programme. Un exemple est

entier y = 10; // nommé constant float x; //variable

Descriptions - informe le compilateur des propriétés et des noms des objets et des fonctions décrits ailleurs dans le programme.

Opérateurs - déterminent les actions du programme à chaque étape de son exécution

Un exemple de programme C :

#comprendre // directive du préprocesseur

Questions de contrôle

1. Quelles sont les parties d'un programme C++ ?

2. En quoi une définition est-elle différente d'une annonce ?

3. Répertoriez les étapes de création d'un programme exécutable en C++.

4. Qu'est-ce qu'un préprocesseur ?

5. Qu'est-ce qu'une directive de préprocesseur ? Donnez des exemples de directives de préprocesseur.

6. Ecrivez un programme qui imprime le texte "Mon premier programme C++"

2. Moyens de base du langage C++ 2.1.La composition du langage

Dans un texte de n'importe quelle langue naturelle, quatre éléments principaux peuvent être distingués : des symboles, des mots, des expressions et des phrases. Le langage algorithmique contient également de tels éléments, seuls les mots sont appelés lexèmes (constructions élémentaires), phrases - expressions, phrases - opérateurs. Les lexèmes sont formés de symboles, d'expressions de jetons et de symboles, d'opérateurs de symboles d'expressions et de jetons (Fig. 1.1)

Riz. 1.1. Composition du langage algorithmique Ainsi, les éléments du langage algorithmique sont :

Les identificateurs sont les noms d'objets pour les programmes SI. L'identifiant peut contenir des lettres latines, des chiffres et un trait de soulignement. On distingue les majuscules et les minuscules, par exemple PROG1, prog1 et Prog1 sont trois identifiants différents. Le premier caractère doit être une lettre ou un trait de soulignement (mais pas un chiffre). Les espaces dans les identifiants ne sont pas autorisés.

Les mots clés (réservés) sont des mots qui ont une signification particulière pour le compilateur. Ils ne peuvent pas être utilisés comme identifiants.

- Les caractères d'opération sont un ou plusieurs caractères qui définissent une action sur un opérande. Les opérations sont divisées en unaire, binaire et ternaire selon le nombre d'opérandes impliqués dans cette opération.

Les constantes sont des valeurs immuables. Il existe des constantes entières, réelles, de caractère et de chaîne. Le compilateur sélectionne une constante comme jeton (construction élémentaire) et l'affecte à l'un des types par son apparence.

Les séparateurs sont des crochets, des points, des virgules et des espaces.

2.1.1. Constantes en C++

Une constante est un jeton qui représente une image d'une valeur numérique, d'une chaîne ou d'un caractère fixe.

Les constantes sont divisées en 5 groupes :

Entiers ;

- réel (virgule flottante);

Énumérable ;

Symbolique;

Chaîne de caractères.

Le compilateur extrait un jeton et l'affecte à un groupe ou à un autre, puis en interne

trois groupes à un certain type selon sa forme d'enregistrement dans le texte du programme et selon sa valeur numérique.

Les constantes entières peuvent être décimales, octales et hexadécimales. Une constante décimale est définie comme une séquence de chiffres décimaux commençant par un non-0, si le nombre n'est pas 0 (exemples : 8, 0, 192345). Une constante octale est une constante qui commence toujours à 0. 0 est suivi de chiffres octaux (exemples : 016 - valeur décimale 14, 01). Les constantes hexadécimales sont une séquence de chiffres hexadécimaux précédés de caractères 0x ou 0X (exemples : 0xA, 0X00F).

V selon la valeur de la constante entière le compilateur la présentera différemment

v mémoire de l'ordinateur (c'est-à-dire que le compilateur affectera le type de données correspondant à la constante).

Les constantes réelles ont une forme différente de représentation interne dans la mémoire de l'ordinateur. Le compilateur reconnaît ces constantes par leur apparence. Les constantes réelles peuvent avoir deux formes de représentation : virgule fixe et virgule flottante. Type de constante à virgule fixe : [chiffres]. [Chiffres] (exemples : 5.7,. 0001, 41.). Type de constante à virgule flottante : [chiffres] [.] [Chiffres] E | e [+ | -] [chiffres ] (exemples : 0.5e5, .11e-5, 5E3). Dans la notation des constantes réelles, soit la partie entière ou fractionnaire, soit la virgule décimale, soit le signe de l'exposant avec l'exposant peut être omis.

Les constantes énumérées sont entrées à l'aide du mot-clé enum. Ce sont des constantes entières ordinaires auxquelles des désignations uniques et faciles à utiliser sont attribuées. Exemples : enum (un = 1, deux = 2, trois = 3, quatre = 4);

enum (zéro, un, deux, trois) - si vous omettez les signes = et dans la définition des constantes énumérées valeurs numériques, alors les valeurs seront attribuées par défaut. Dans ce cas, l'identifiant le plus à gauche recevra la valeur 0, et chaque identifiant suivant augmentera de 1.

enum (dix = 10, trois = 3, quatre, cinq, six);

enum (dimanche, lundi, mardi, mercredi, jeudi, vendredi, samedi

Les constantes de caractères sont un ou deux caractères entourés d'apostrophes. Les constantes de caractères constituées d'un caractère sont de type char et occupent un octet en mémoire, les constantes de caractères constituées de deux caractères sont de type int et occupent deux octets. Les séquences commençant par un \ sont appelées séquences de contrôle, elles sont utilisées :

- Pour représenter des symboles qui n'ont pas d'affichage graphique, par exemple :

\ a - signal sonore,

\ b - revenir en arrière, \ n - saut de ligne,

\ t - tabulation horizontale.

- Pour représenter les caractères : \, ',? , "(\\, \', \?, \").

- Pour représenter des caractères à l'aide de codes hexadécimaux ou octaux (\ 073, \ 0xF5).

Une constante chaîne est une séquence de caractères entre guillemets.

Les caractères de contrôle peuvent également être utilisés dans les chaînes. Par exemple : "\ nNouvelle ligne",

"\ N \" Langages de programmation algorithmique de haut niveau \ "".

2.2. Types de données en C++

Les données sont affichées dans le programme dans le monde entier. Le but du programme est de traiter des données. Données différents types stockées et traitées de différentes manières. Le type de données définit :

1) représentation interne des données dans la mémoire de l'ordinateur ;

2) un ensemble de valeurs pouvant prendre des valeurs de ce type ;

3) opérations et fonctions applicables aux données de ce type.

V En fonction des exigences de la tâche, le programmeur choisit le type des objets du programme. Les types C++ peuvent être divisés en types simples et composites. Les types simples sont des types caractérisés par une valeur unique. C++ définit 6 types de données simples :

entier (entier)

caractère (caractère)

wchar_t (caractère large) bool (booléen) float (réel)

double (double précision réel)

Il existe 4 spécificateurs de type pour spécifier la représentation interne et la gamme des types standard.

court long signé

non signé

2.2.1. Type d'entier

Les valeurs de ce type sont des entiers.

La taille du type int n'est pas définie par la norme, mais dépend de l'ordinateur et du compilateur. Pour un processeur 16 bits, 2 octets lui sont alloués, pour un processeur 32 bits - 4 octets.

Si int est précédé du spécificateur court, alors 2 octets sont alloués pour le nombre, et si le spécificateur long, alors 4 octets. La quantité de mémoire allouée à l'objet dépend de l'ensemble de valeurs valides que l'objet peut prendre :

short int - prend 2 octets, a donc une plage de –32768 .. + 32767 ;

long int - occupe 4 octets, a donc une plage de –2 147 483 648 .. + 2 147 483 647

Le type int est le même que l'int court sur les PC 16 bits et l'int long sur les PC 32 bits.

Les modificateurs signés et non signés affectent également l'ensemble des valeurs valides qu'un objet peut prendre :

unsigned short int - occupe 2 octets, a donc une plage de 0 ..65536 ; unsigned long int - occupe 4 octets, a donc une plage de 0 .. + 4 294 967

2.2.2. Type de caractère

Les valeurs de ce type sont membres d'un ensemble fini et ordonné de caractères. Chaque caractère se voit attribuer un numéro appelé code de caractère. 1 octet est alloué pour la valeur du type de caractère. Le type char peut être utilisé avec les spécificateurs signés et non signés. Le type de données char signé peut stocker des valeurs comprises entre -128 et 127. Lorsque vous utilisez le type de données char non signé, les valeurs peuvent aller de 0 à 255. ASCII (American Standard Code foe International Interchange) est utilisé pour codage. Les caractères avec des codes de 0 à 31 se réfèrent à ceux de service et ont sens indépendant uniquement dans les déclarations d'E/S.

Les valeurs de type char sont également utilisées pour stocker les nombres des plages spécifiées.

2.2.3. Type Wchar_t

Conçu pour fonctionner avec un jeu de caractères pour lequel 1 octet n'est pas suffisant, par exemple Unicode. Ce type est généralement de la même taille que court. Les constantes chaîne de ce type sont écrites avec le préfixe L : L « String #1 ».

2.2.4. Type booléen

Le type booléen est appelé booléen. Ses valeurs peuvent être vraies et fausses. La forme interne est false - 0, toute autre valeur est interprétée comme true.

2.2.5. Types à virgule flottante.

La représentation interne d'un nombre réel se compose de 2 parties : la mantisse et l'ordre. Dans les PC compatibles IBM, les valeurs flottantes occupent 4 octets, dont un bit est réservé au signe de la mantisse, 8 à l'ordre et 24 à la mantisse.

Les valeurs de types doubles occupent 8 octets, 11 et 52 bits sont alloués pour l'ordre et la mantisse, respectivement. La longueur de la mantisse détermine la précision du nombre, et la longueur est de l'ordre de sa portée.

S'il y a un spécificateur long avant le nom du type double, des octets sont alloués pour la valeur.

2.2.6. Type de vide

À les principaux types incluent également le type void.L'ensemble des valeurs de ce type est

2.3. Variables

Une variable en C++ est une zone de mémoire nommée qui stocke des données d'un certain type. Une variable a un nom et une valeur. Le nom est utilisé pour faire référence à la zone de mémoire dans laquelle la valeur est stockée. Toute variable doit être déclarée avant utilisation. Exemples:

Vue générale de l'opérateur de description :

[classe de mémoire] nom de type [initialiseur] ;

La classe mémoire peut prendre les valeurs suivantes : auto, extern, static, register. La classe de mémoire définit la durée de vie et la portée de la variable. Si la classe de mémoire n'est pas spécifiée explicitement, le compilateur la détermine en fonction du contexte de la déclaration. La durée de vie peut être constante - pendant l'exécution du programme ou temporaire - pendant le bloc. La portée est une partie du texte du programme à partir de laquelle l'accès normal à une variable est autorisé. Habituellement, la portée est la même que la portée. Sauf dans le cas où une variable du même nom existe dans le bloc interne.

Const - indique que cette variable ne peut pas être modifiée (nommée constante). Lors de la description, vous pouvez affecter une valeur initiale à la variable (initialisation). Cours de mémoire :

auto est une variable locale automatique. Le spécificateur automatique ne peut être spécifié que lors de la définition d'objets de bloc, par exemple, dans le corps d'une fonction. Pour ces variables, de la mémoire est allouée à l'entrée dans le bloc et libérée à la sortie. De telles variables n'existent pas en dehors du bloc.

extern est une variable globale, elle est située à un autre endroit du programme (dans un autre fichier ou plus loin dans le texte). Utilisé pour créer des variables qui sont disponibles dans tous les fichiers de programme.

static est une variable statique, elle n'existe que dans le fichier où la variable est définie.

register - sont similaires à auto, mais la mémoire pour eux est allouée dans les registres du processeur. Si cela n'est pas possible, les variables sont traitées comme auto.

int un; // variable globale void main() (

int b; // variable locale

extern int x; // la variable x est définie ailleurs static int c; // variable statique locale a = 1; // affectation à une variable globale

int a; // variable locale a

a = 2; // affectation à une variable locale :: a = 3; // affectation à une variable globale

int x = 4; // définition et initialisation de x

Dans l'exemple, la variable a est définie en dehors de tous les blocs. La portée de la variable a est l'ensemble du programme, à l'exception des lignes où la variable locale a est utilisée. Les variables b et c sont locales, leur portée est bloc. La durée de vie est différente : la mémoire sous b est allouée lors de la saisie du bloc (puisque par défaut la classe mémoire est auto), et elle est libérée lors de la sortie du bloc. La variable avec (statique) existe pendant l'exécution du programme.

Si la valeur initiale des variables n'est pas spécifiée explicitement lors de la définition, le compilateur mettra les variables globales et statiques à zéro. Les variables automatiques ne sont pas initialisées.

Le nom de la variable doit être unique dans sa portée.

Une déclaration de variable peut être effectuée soit en tant que déclaration, soit en tant que définition. La déclaration contient des informations sur la classe de mémoire et le type de la variable, la définition avec ces informations donne une instruction pour allouer de la mémoire. Dans l'exemple extern int x; - déclaration, et le reste sont des définitions.

2.4. Signes d'opération en C++

Les signes d'opération fournissent la formation d'expressions. Les expressions se composent d'opérandes, de signes d'opérateur et de parenthèses. Chaque opérande est, à son tour, une expression ou un cas particulier d'expression - une constante ou une variable.

Opérations unaires

& obtenir l'adresse de l'opérande

* Adressage de l'adresse (déréférencement)

- moins unaire, change le signe de l'opérande arithmétique

++ Augmenter de un :

opération de préfixe - incrémente l'opérande avant qu'il ne soit utilisé

L'opération postfix incrémente l'opérande après son utilisation

int a = (m ++) + n; // a = 4, m = 2, n = 2

int b = m + (++ n); // a = 3, m = 1, n = 3

diminuer de un :

opération de préfixe - décrémente l'opérande avant qu'il ne soit utilisé

L'opération postfix décrémente l'opérande après son utilisation

calculer la taille (en octets) d'un objet du type qui

a un opérande

a deux formes

taille de l'expression

sizeof (float) // 4

sizeof (1.0) // 8, puisque les vraies constantes par défaut

Langage algorithmique - c'est un système de notation et de règles pour l'enregistrement uniforme et précis des algorithmes et de leur exécution. Un langage algorithmique est un moyen d'enregistrement d'algorithmes sous une forme analytique, intermédiaire entre l'enregistrement d'un algorithme dans un langage naturel (humain) et un enregistrement dans un langage informatique (langage de programmation).

Il existe une différence entre les concepts de « langage algorithmique » et de « langages de programmation ». Tout d'abord, un programme écrit dans un langage algorithmique n'est pas forcément destiné à un ordinateur. La mise en œuvre pratique d'un langage algorithmique est une question distincte dans chaque cas spécifique.

Comme tout langage, un langage algorithmique a son propre vocabulaire. La base de ce dictionnaire est formée par les mots utilisés pour écrire les commandes incluses dans le système de commandes de l'exécuteur de l'un ou l'autre algorithme. De telles commandes sont appelées commandes simples. Dans un langage algorithmique, on utilise des mots dont le sens et le mode d'emploi sont fixés une fois pour toutes. Ces mots s'appellent service. L'utilisation de mots de fonction rend l'enregistrement de l'algorithme plus descriptif et la forme de présentation des différents algorithmes est uniforme.

Un algorithme écrit dans un langage algorithmique doit avoir un nom. Il est conseillé de choisir le nom de sorte qu'il soit clair quelle solution de problème l'algorithme décrit décrit. Pour mettre en évidence le nom de l'algorithme, le mot de service ALG (ALGoritm) est écrit devant celui-ci. Nom de l'algorithme (généralement avec nouvelle ligne) notez ses commandes. Pour indiquer le début et la fin de l'algorithme, ses commandes sont enfermées dans une paire de mots de service START (START) et KON (END). Les commandes sont écrites séquentiellement.

ALG - le nom de l'algorithme

série de commandes d'algorithme

Par exemple, un algorithme qui détermine le mouvement d'un robot interprète peut être le suivant :

ALG - w_entrepôt

Lors de la construction de nouveaux algorithmes, les algorithmes compilés précédemment peuvent être utilisés. Les algorithmes utilisés entièrement dans le cadre d'autres algorithmes sont appelés algorithmes auxiliaires. Tout algorithme parmi ceux compilés précédemment peut être auxiliaire. Il est également possible qu'un algorithme qui contient lui-même un lien vers des algorithmes auxiliaires se révèle être auxiliaire dans une certaine situation.

Très souvent, lors de la compilation d'algorithmes, il devient nécessaire d'utiliser le même algorithme qu'un auxiliaire, ce qui, de plus, peut être très complexe et encombrant. Il serait irrationnel de commencer un travail à chaque fois de recomposer et de mémoriser un tel algorithme pour son utilisation ultérieure. Par conséquent, dans la pratique, les algorithmes auxiliaires dits intégrés (ou standard) sont largement utilisés, c'est-à-dire de tels algorithmes qui sont constamment à la disposition de l'interprète. La référence à de tels algorithmes s'effectue de la même manière qu'aux algorithmes auxiliaires "habituels". L'exécuteur du robot dispose d'un algorithme auxiliaire intégré qui peut se déplacer vers l'entrepôt depuis n'importe quel point du champ de travail ; pour l'exécuteur, le langage de programmation BASIC, il s'agit par exemple de l'algorithme SIN intégré.

L'algorithme peut contenir un appel à lui-même en tant qu'auxiliaire, et dans ce cas il est appelé récursif. Si la commande pour adresser l'algorithme à lui-même est dans l'algorithme lui-même, alors une telle récursivité est appelée droit. Il existe des cas où un appel récursif d'un algorithme donné provient d'un algorithme auxiliaire, auquel dans cet algorithme il y a un recours. Cette récursivité est appelée indirect. Un exemple de récursivité avant :

ALG - mouvement

circulation

Les algorithmes, dans l'exécution desquels l'ordre des commandes est déterminé en fonction des résultats de la vérification de certaines conditions, sont appelés ramification. Pour les décrire dans un langage algorithmique, une commande composée spéciale est utilisée - la commande ramification. Appliquée au robot performeur, la condition peut être de vérifier si le robot est au bord du champ de travail (edge ​​/ not_ edge) ; vérifier la présence d'un objet dans la cellule courante (oui/non) et quelques autres :

SI condition SI condition SI front

À la série 1 À la série À droite

ELSE series2 TOUT D'AUTRE en avant

Ce qui suit est une notation algorithmique de la commande de sélection, qui est un développement de la commande de branchement :

QUAND condition 1 : série 1

QUAND condition 2 : série 2

QUAND condition N : série N

AUTRE série N + 1

Les algorithmes, dans l'exécution desquels des commandes individuelles ou des séries de commandes sont exécutées à plusieurs reprises, sont appelés cycliques. Pour organiser les algorithmes cycliques dans un langage algorithmique, une instruction de boucle composée spéciale est utilisée. Il correspond à des schémas blocs de type « itération » et peut prendre la forme suivante :

TANT QUE NTS

série jusqu'à l'état

Algorithme - une instruction précise et compréhensible à l'interprète pour effectuer une séquence d'actions visant à résoudre la tâche assignée.

Le nom "algorithme" vient de la forme latine du nom du mathématicien d'Asie centrale al-Khwarizmi - Algorithmi. L'algorithme est l'un des concepts de base de l'informatique et des mathématiques.

Un exécuteur d'algorithme est un système abstrait ou réel (technique, biologique ou biotechnique) capable d'effectuer les actions prescrites par l'algorithme.

L'interprète se caractérise par :

actions élémentaires;

système de commandement ;

L'environnement (ou décor) est « l'habitat » de l'interprète. Par exemple, pour un robot interprète d'un manuel scolaire, le mercredi est un champ cellulaire sans fin. Les murs et les cellules ombragées font également partie de l'environnement. Et leur emplacement et la position du robot lui-même déterminent l'état spécifique de l'environnement.

Chaque exécuteur peut exécuter des commandes uniquement à partir d'une certaine liste strictement spécifiée - le système de commandes de l'exécuteur. Pour chaque commande, les conditions d'applicabilité (dans quels états de l'environnement la commande peut être exécutée) doivent être spécifiées et les résultats de l'exécution de la commande doivent être décrits. Par exemple, la commande "haut" du Robot peut être exécutée s'il n'y a pas de mur au-dessus du Robot. Son résultat est un déplacement du Robot d'une cellule vers le haut.

Après avoir appelé la commande, l'exécuteur effectue l'action élémentaire correspondante.

Les échecs de l'exécuteur se produisent lorsqu'une commande est invoquée avec un état invalide de l'environnement.

Habituellement, l'exécuteur ne sait rien du but de l'algorithme. Il exécute toutes les commandes qu'il reçoit sans se poser les questions « pourquoi » ou « pourquoi ».

En informatique, l'ordinateur est l'exécuteur universel des algorithmes.

Les principales propriétés des algorithmes sont les suivantes :

Compréhensibilité pour l'interprète - c'est-à-dire l'exécuteur de l'algorithme doit savoir comment l'exécuter.

Discrétion (discontinuité, séparation) - c'est-à-dire l'algorithme doit représenter le processus de résolution du problème comme une exécution séquentielle d'étapes (étapes) simples (ou préalablement définies).

Définition - c'est-à-dire chaque règle de l'algorithme doit être claire, sans ambiguïté et ne laisser aucune place à l'arbitraire. En raison de cette propriété, l'exécution de l'algorithme est mécanique et ne nécessite aucune instruction ou information supplémentaire sur le problème à résoudre.

Performance (ou membre). Cette propriété consiste dans le fait que l'algorithme doit conduire à la résolution du problème en un nombre fini d'étapes.

Caractère de masse. Cela signifie que l'algorithme pour résoudre le problème est développé en vue générale, c'est à dire. il devrait être applicable à une certaine classe de problèmes qui ne diffèrent que par les données initiales. Dans ce cas, les données initiales peuvent être sélectionnées dans une certaine zone, appelée zone d'applicabilité de l'algorithme.

En pratique, les formes suivantes de présentation des algorithmes sont les plus courantes :

verbal (enregistrements en langage naturel);

graphique (images de symboles graphiques);

pseudocodes (descriptions semi-formalisées d'algorithmes dans un langage algorithmique conditionnel, comprenant à la fois des éléments de langage de programmation et des phrases en langage naturel, notation mathématique généralement acceptée, etc.);

logiciels (textes en langages de programmation).

La manière verbale d'écrire des algorithmes est une description des étapes séquentielles du traitement des données. L'algorithme est défini sous forme libre en langage naturel.

Par exemple. Écrivez l'algorithme pour trouver le plus grand diviseur commun (GCD) de deux nombres naturels.

L'algorithme peut être le suivant :

définir deux nombres ;

si les nombres sont égaux, prenez l'un d'eux comme réponse et arrêtez, sinon continuez l'algorithme ;

déterminer le plus grand des nombres ;

remplacer le plus grand des nombres par la différence entre le plus grand et le plus petit des nombres ;

répéter l'algorithme de l'étape 2.

L'algorithme décrit est applicable à tous les nombres naturels et devrait conduire à la solution du problème. Voyez par vous-même en utilisant cet algorithme pour déterminer le plus grand diviseur commun de 125 et 75.

La voie verbale n'a pas répandu les raisons suivantes :

ces descriptions ne sont pas strictement formalisées ;

souffrez de la verbosité des enregistrements ;

permettre l'ambiguïté dans l'interprétation des prescriptions individuelles.

La manière graphique de présenter les algorithmes est plus compacte et claire par rapport à la verbale.

Dans une présentation graphique, l'algorithme est représenté comme une séquence de blocs fonctionnels interconnectés, dont chacun correspond à l'exécution d'une ou plusieurs actions.

Tel représentation graphique appelé organigramme ou organigramme.

Dans l'organigramme, chaque type d'action (saisie de données initiales, calcul de valeurs d'expression, conditions de contrôle, contrôle de répétition d'actions, fin de traitement, etc.) correspond à une figure géométrique présentée sous la forme d'un bloc symbole. Les symboles de bloc sont connectés par des lignes de transition qui déterminent l'ordre dans lequel les actions sont effectuées.

Le tableau 1 répertorie les symboles les plus couramment utilisés.

Le bloc "process" est utilisé pour désigner une action ou une séquence d'actions qui modifient la valeur, la forme de présentation ou le placement des données. Pour améliorer la clarté du schéma, plusieurs blocs de traitement distincts peuvent être combinés en un seul bloc. La représentation des opérations individuelles est assez libre.

Le bloc "décision" est utilisé pour indiquer les transitions de contrôle conditionnelles. Chaque bloc "solution" doit indiquer la question, la condition ou la comparaison qu'il définit.

Le bloc "modification" permet d'organiser des structures cycliques. (Le mot modification signifie modification, transformation). Le paramètre de boucle est écrit à l'intérieur du bloc, pour lequel sa valeur initiale, sa condition aux limites et l'étape de modification de la valeur du paramètre sont spécifiées pour chaque répétition.

Le bloc "processus prédéfini" est utilisé pour indiquer les appels à des algorithmes auxiliaires qui existent de manière autonome sous la forme de certains modules indépendants, et pour les appels à des routines de bibliothèque.

Le pseudocode est un système de notation et de règles conçu pour enregistrer de manière cohérente les algorithmes.

Il occupe une place intermédiaire entre les langues naturelles et formelles.

D'une part, il est proche du langage naturel ordinaire, de sorte que les algorithmes peuvent y être écrits et lus comme du texte ordinaire. D'autre part, le pseudocode utilise des constructions formelles et une notation mathématique, ce qui rapproche la notation de l'algorithme de la notation mathématique généralement acceptée.

Le pseudocode n'accepte pas les règles syntaxiques strictes d'écriture de commandes inhérentes aux langages formels, ce qui facilite l'écriture d'un algorithme au stade de la conception et permet d'utiliser un ensemble plus large de commandes conçues pour un exécuteur abstrait. Cependant, le pseudocode contient généralement des constructions inhérentes aux langages formels, ce qui facilite le passage de l'écriture en pseudocode à l'écriture d'un algorithme dans un langage formel. En particulier, dans le pseudocode, comme dans les langages formels, il existe des mots fonctions dont le sens est déterminé une fois pour toutes. Ils sont surlignés en gras dans le texte imprimé et soulignés dans le texte manuscrit. Il n'y a pas de définition unique ou formelle de pseudocode, par conséquent, divers pseudocodes sont possibles, différant par l'ensemble des mots de service et des constructions de base (de base).

Un exemple de pseudocode est un langage algorithmique scolaire en notation russe (école AY), décrit dans le manuel d'A.G. Kushnirenko et al. "Les fondamentaux de l'informatique et technologie informatique», 1991. Ci-après nous appellerons ce langage simplement « langage algorithmique ».

Mots de service de base

Vue générale de l'algorithme :

alg nom de l'algorithme (arguments et résultats)

les conditions d'applicabilité de l'algorithme sont données

il te faut le but de l'algorithme

démarrer la description des valeurs intermédiaires

| séquence de commandes (corps de l'algorithme)

La partie de l'algorithme allant du mot alg au mot start est appelée le titre, et la partie comprise entre les mots start et end est appelée le corps de l'algorithme.

Dans la phrase al, après le nom de l'algorithme, les caractéristiques (arg, res) et le type de la valeur (integer, thing, sim, lit ou log) de toutes les variables d'entrée (arguments) et de sortie (résultats) sont indiqués entre parenthèses. Lors de la description des tableaux (tables), l'onglet mot de service est utilisé, complété par des paires de limites pour chaque index d'éléments de tableau.

Exemples de phrases alg :

alg Volume et aire d'un cylindre (arg élément R, H, res élément V, S)

alg Roots KvUr (arg chose a, b, c, rez chose x1, x2, rez allumé t)

alg Exclure l'élément (arg entier N, arg rez chose onglet A)

alg diagonal (arg cel N, arg cel tab A, res allumé Otvet)

Des suggestions sont données et devraient être facultatives. Il est recommandé d'y écrire des déclarations décrivant l'état de l'environnement de l'exécuteur de l'algorithme, par exemple :

alg Remplacement (arg allumé Str1, Str2, arg res allumé Text)

donné | les longueurs des sous-chaînes Str1 et Str2 sont les mêmes

il faut | partout dans la chaîne de texte la sous-chaîne Str1 est remplacée par Str2

alg Nombre de maxima (arg int N, arg real tab A, res entier K)

donné | N> 0

il faut | K - le nombre d'éléments maximum dans le tableau A

alg Résistance (arg chose R1, R2, arg int N, res chose R)

donné | N> 5, R1> 0, R2> 0

il faut | R - résistance de circuit

Ici dans les phrases, il est donné et nécessaire après le " | " les commentaires sont enregistrés. Les commentaires peuvent être placés à la fin de n'importe quelle ligne. Ils ne sont pas traités par le traducteur, mais ils rendent l'algorithme beaucoup plus facile à comprendre.

Les algorithmes peuvent être considérés comme des structures, constituées d'éléments de base séparés (c'est-à-dire de base).

Naturellement, avec une telle approche des algorithmes, l'étude des principes de base de leur conception devrait commencer par l'étude de ces éléments de base.

Pour les décrire, nous utiliserons le langage des schémas algorithmiques et le langage algorithmique scolaire.

La structure logique de tout algorithme peut être représentée par une combinaison de trois structures de base :

suivre,

ramification,

Les structures de base se caractérisent par la présence d'une entrée et d'une sortie.

Langage de programmation algorithmique- un langage formel utilisé pour l'écriture, la mise en œuvre et l'apprentissage d'algorithmes. Contrairement à la plupart des langages de programmation, le langage algorithmique n'est pas lié à l'architecture de l'ordinateur, ne contient pas de détails liés à la structure de la machine.

Pour étudier les bases de l'algorithmique, ce qu'on appelle langage algorithmique russe(langue algorithmique scolaire), en utilisant des mots en russe compréhensibles par l'élève.

Un langage algorithmique de type algorithme avec une syntaxe russe a été introduit par l'académicien A. P. Ershov au milieu des années 1980, comme base d'un cours d'informatique « sans machine ».

Les principaux mots fonctions du langage algorithmique

Description de l'algorithme

  • alg(algorithme)
  • argument(argument)
  • couper(résultat)
  • de bonne heure(début) - le début de l'algorithme
  • inconvénient(fin) - fin de l'algorithme
  • étant donné- données initiales sous n'importe quelle forme
  • nécessaire- le but de l'algorithme

Types de données:

  • intact(entier)
  • des choses(réel)
  • Sim(personnage)
  • litas(littéral) - chaîne
  • Journal(logique)
  • languette(table) - pour désigner un tableau
  • longueurs(longueur) - nombre d'éléments du tableau

Désignation de l'état

  • si
  • autrement
  • choix
  • sens

Notation de cycle

  • nts(début de cycle)
  • nœuds(fin de cycle)
  • tandis que

Fonctions et valeurs booléennes pour la construction d'expressions

Entrée sortie

  • saisir
  • sortir

Vue générale de l'algorithme

1
2
3
4
5
6

alg nom de l'algorithme (arguments et résultats)
| étant donné conditions d'applicabilité de l'algorithme
| nécessaire le but de l'algorithme
de bonne heure description des valeurs intermédiaires
| séquence de commandes (corps de l'algorithme)
inconvénient

Une partie de l'algorithme du mot alg au mot de bonne heure appelé le titre, et la partie entre les mots de bonne heure et inconvénient- le corps de l'algorithme.

Dans une phrase alg après le nom de l'algorithme entre parenthèses se trouvent les caractéristiques ( argument, couper) et le type de valeur ( intact, des choses, Sim, litas ou Journal) de toutes les variables d'entrée (arguments) et de sortie (résultats). Lors de la description des tableaux (tableaux), un mot spécial est utilisé languette, complété par des paires de limites pour chaque index des éléments du tableau.

Enregistrement de l'algorithme mots clés généralement souligné ou en gras. Pour mettre en évidence les blocs logiques, une indentation est appliquée et les mots appariés du début et de la fin du bloc sont connectés par une ligne verticale.

Structures algorithmiques de base

Une description détaillée des principales structures algorithmiques est donnée dans cet article. Vous trouverez ci-dessous les modèles pour composer ces structures dans un langage algorithmique.
Fourche incomplète

| siétat
| | alors Actions
| tous

Fourche pleine

1
2
3
4
5

| siétat
| | alors action 1
| | autrement action 2
| tous

Branchement

1
2
3
4
5
6
7
8

| choix paramètre
| | au sens valeur 1
| | | action 1
| | au sens valeur 2
| | | action 2
| | autrement
| | | actions par défaut
| tous

Boucle avec précondition

| au revoirétat
| | Actions
| nœuds

Boucle avec postcondition

Le plus souvent, les instructions sont écrites dans un langage algorithmique. Elle est nécessaire à la prescription précise de toutes les étapes et à leur exécution. Il existe de nettes différences entre le langage algorithmique de l'école et les langages de programmation. En règle générale, non seulement un ordinateur agit comme un interprète dans la première version, mais également un autre appareil capable d'effectuer un travail. Tout programme écrit dans un langage algorithmique n'a pas à être fait par la technologie. La mise en œuvre de toutes les instructions dans la pratique est une question purement distincte. Ci-dessous sera également considérée une description de l'algorithme en langage algorithmique. Cela vous aidera à comprendre la structure de ce système.

Étudier à l'école

Le langage algorithmique est souvent enseigné dans les écoles, mieux connu sous le nom d'enseignement du langage. Il s'est répandu en raison du fait qu'il utilise des mots qui sont les plus compréhensibles pour tout étudiant. Une langue similaire avec une syntaxe en russe a été introduite il y a longtemps, à savoir au milieu des années 1980. Il a été utilisé pour donner une base aux écoliers et leur enseigner un cours d'informatique sans ordinateur. Publié langue donnéeétait en 1985 dans l'un des manuels. Il a également été réimprimé plusieurs fois pour des livres spéciaux destinés à l'enseignement en 9e et 10e années. Le tirage total de la publication était de 7 millions d'exemplaires.

Séquence d'enregistrement d'algorithme

Tout d'abord, vous devez écrire la combinaison de lettres ALG. Le nom de l'algorithme suit. Ensuite, après le NACH, vous devez décrire une série de commandes. L'opérateur KOH signifie la fin du programme.

Description de l'algorithme en langage algorithmique :

Société ALG

DÉBUT

tourner à 90 degrés vers la gauche

KOH

Lors de la rédaction, les mots-clés doivent être soulignés ou en gras. Pour indiquer les blocs logiques, vous devez utiliser l'indentation, et s'il y a des mots appariés du début et de la fin, vous devez utiliser la barre verticale, qui indique la connexion.

Compilation d'algorithmes

Les anciennes notes peuvent être utilisées pour composer de nouvelles instructions. Ces instructions sont appelées instructions auxiliaires. Un algorithme similaire peut être n'importe lequel de tous ceux décrits précédemment. Il est également possible que dans ce système un algorithme supplémentaire soit appliqué, qui a lui-même reçu une référence aux systèmes auxiliaires.

Souvent, lors de la création d'une instruction, il est nécessaire d'utiliser un seul algorithme en plus. C'est pourquoi les enregistrements peuvent souvent être complexes et encombrants. Mais il est à noter que la possibilité de faire une référence est plus facile que de réécrire plusieurs fois les mêmes enregistrements.

C'est pourquoi, en pratique, un algorithme auxiliaire standard est souvent utilisé, qui est constamment subordonné à l'utilisateur. L'instruction peut être référencée, à la fois pour elle-même et pour toute autre personne. Les commandes de langage algorithmique sont conçues pour de telles actions. Ces instructions sont dites récursives.

La commande self-bind se trouve dans le système lui-même. Cette récursivité est simple. Un indirect est celui où l'algorithme est appelé dans toute autre instruction auxiliaire.

Les algorithmes, qui ont un certain ordre d'instructions, peuvent changer constamment en fonction des résultats de l'exécution de parties spéciales du programme. De tels systèmes sont appelés systèmes de branchement. Pour les créer, vous devez utiliser une commande de branche spéciale. Il a un schéma orthographique abrégé et complet. Il n'est pas rare de voir des algorithmes cycliques qui exécutent plusieurs fois des commandes spécifiques.

E-atelier

Afin d'améliorer l'étude de la théorie dans le langage grammatical, les professionnels de la Faculté de mécanique et de mathématiques de l'Université d'État de Moscou ont créé en 1985 un compilateur spécial. Il a été nommé "E-atelier". Avec son aide, il était possible d'entrer, de modifier et d'exécuter des programmes. L'année suivante, un ensemble spécifique d'interprètes est sorti. Il est sur "Robot", "Dessinateur", "Deux pattes", "Véhicule tout-terrain". Cela a permis d'implémenter les algorithmes simplement et facilement. Ce compilateur est devenu très populaire et a été utilisé sur certains ordinateurs. Assez Longtemps ce langage de programmation a été affiné et modifié. En 1990, une version ultérieure de celui-ci est apparue dans un manuel.

Idole

Aujourd'hui, le langage algorithmique de l'école connaît sa renaissance, après qu'un package spécial "Idol" a été développé pour Windows et Linux. Le système fonctionne avec plusieurs interprètes. Les classiques parmi eux sont "Robot", "Draftsman". Le même forfait est inclus dans fichier d'installation"École" Linux. Ce système a été spécialement développé sur ordre de l'Académie des sciences de Russie. Il est distribué gratuitement et gratuitement. Ces dernières années, le langage décrit a été activement proposé pour être utilisé dans l'examen comme l'un des

Affectation de la langue

Le langage algorithmique est utilisé pour résoudre une gamme assez large de problèmes. Il convient à la maîtrise des mathématiques et des exercices dans d'autres matières. Il convient de noter qu'il est également utilisé pour permettre aux écoliers d'étudier plus facilement des sujets similaires.

Différences entre les langages machine et algorithmique

Le représentant le plus célèbre des langages dépendants de la machine est "Assembler". Lors de la programmation sur celui-ci, une personne doit clairement indiquer au traducteur, grâce à des opérateurs spéciaux, quelles cellules mémoire doivent être remplies ou transférées. La syntaxe d'"assembleur" étant aussi proche que possible de la forme informatique de l'écriture, il est assez difficile de l'étudier. C'est pourquoi le langage algorithmique est enseigné à l'école, ainsi qu'au début de l'enseignement de la programmation en première année de l'enseignement supérieur.

Fonctions standards

Le langage algorithmique a une particularité fonctions standards, qui ont reçu le statut de « intégré ». C'est grâce à eux que vous pouvez facilement écrire de nombreuses opérations avec des nombres et des expressions sans effectuer d'entrées de routine. Le programme de langage algorithmique est assez simple. Les fonctions standard peuvent vous permettre de calculer la racine carrée, les logarithmes, le module, etc. Les méthodes intégrées les plus courantes sont les suivantes :

  • abs module absolu (X);
  • racine carrée sqrt (X);
  • naturel et ln (X), lg (X);
  • minimum et maximum min (X, Y), max (X, Y);
  • fonctions trigonométriques sin (X), cos (X), tg (X), ctg (X).

Grâce à cela, tout programmeur ou simplement une personne qui apprend à travailler avec un langage algorithmique peut facilement écrire un problème mathématique sans recourir à l'invention du vélo. Ainsi, il convient de noter que ce langage est assez convivial. Il est simple à comprendre et aussi facile à comprendre que possible. Ce n'est pas pour rien qu'il a été inclus dans le programme scolaire. Les écoliers sont heureux de l'étudier.



Vous avez aimé l'article ? Partagez-le