Russian algorithmic language. Algorithmic languages ​​and programming. Basic branching structure

postfix operation increments the operand after it has been used

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

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

decrease by one:

prefix operation - decrements the operand before it is used

postfix operation decrements the operand after it is used

calculating the size (in bytes) for an object of the type that

has an operand

has two forms

sizeof expression

sizeof (float) // 4

sizeof (1.0) // 8, since real constants by default

Algorithmic language - it is a system of notation and rules for the uniform and accurate recording of algorithms and their execution. An algorithmic language is a means for recording algorithms in an analytical form, intermediate between the recording of an algorithm in a natural (human) language and a recording in a computer language (programming language).

There is a difference between the concepts of "algorithmic language" and "programming languages". First of all, a program written in an algorithmic language is not necessarily intended for a computer. The practical implementation of an algorithmic language is a separate issue in each specific case.

Like every language, an algorithmic language has its own vocabulary. The basis of this dictionary is formed by the words used to write commands included in the command system of the executor of one or another algorithm. Such commands are called simple commands. In an algorithmic language, words are used, the meaning and way of using which is set once and for all. These words are called service. The use of function words makes the recording of the algorithm more descriptive, and the form of presentation of various algorithms is uniform.

An algorithm written in an algorithmic language must have a name. It is advisable to choose the name so that it is clear which solution to which problem the given algorithm describes. To highlight the name of the algorithm, the service word ALG (ALGoritm) is written in front of it. Algorithm name (usually with new line) write down his commands. To indicate the beginning and end of the algorithm, its commands are enclosed in a pair of service words START (START) and KON (END). The commands are written sequentially.

ALG - the name of the algorithm

series of algorithm commands

For example, an algorithm that determines the movement of a robot performer can be as follows:

ALG - in_warehouse

When constructing new algorithms, the algorithms compiled earlier can be used. Algorithms used entirely as part of other algorithms are called auxiliary algorithms. Any algorithm from the ones previously compiled can be auxiliary. It is also possible that an algorithm that itself contains a link to auxiliary algorithms may turn out to be auxiliary in a certain situation.

Very often, when compiling algorithms, it becomes necessary to use the same algorithm as an auxiliary one, which, moreover, can be very complex and cumbersome. It would be irrational, starting work, each time to re-compose and memorize such an algorithm for its subsequent use. Therefore, in practice, the so-called built-in (or standard) auxiliary algorithms are widely used, i.e. such algorithms that are constantly at the disposal of the performer. The reference to such algorithms is carried out in the same way as to the "usual" auxiliary algorithms. The robot executor has a built-in auxiliary algorithm that can move to the warehouse from any point in the working field; for the performer-programming language BASIC - this is, for example, the built-in algorithm "SIN".

The algorithm may contain an appeal to itself as an auxiliary, and in this case it is called recursive. If the command for addressing the algorithm to itself is in the algorithm itself, then such a recursion is called straight. There are cases when the recursive call of this algorithm comes from an auxiliary algorithm, to which in this algorithm there is an appeal. This recursion is called indirect. An example of direct recursion:

ALG - movement

traffic

Algorithms, during the execution of which the order of commands is determined depending on the results of checking certain conditions, are called branching. To describe them in an algorithmic language, a special compound command is used - the command branching. As applied to the robot performer, the condition may be to check whether the robot is at the edge of the working field (edge ​​/ not_ edge); checking for the presence of an object in the current cell (yes / no) and some others:

IF condition IF condition IF edge

TO series 1 TO series TO right

ELSE series2 EVERYTHING ELSE forward

The following is an algorithmic notation of the selection command, which is a development of the branching command:

WHEN condition 1: series 1

WHEN condition 2: series 2

WHEN condition N: series N

ELSE series N + 1

Algorithms, in the execution of which individual commands or series of commands are executed repeatedly, are called cyclical. To organize cyclic algorithms in an algorithmic language, a special compound loop instruction is used. It corresponds to block diagrams of the "iteration" type and can take the following form:

WHILE condition NC

series up to condition

Algorithm - an accurate and understandable instruction to the performer to perform a sequence of actions aimed at solving the task.

The name "algorithm" comes from the Latin form of the name of the Central Asian mathematician al-Khwarizmi - Algorithmi. Algorithm is one of the basic concepts of computer science and mathematics.

An algorithm executor is some abstract or real (technical, biological or biotechnical) system capable of performing the actions prescribed by the algorithm.

The performer is characterized by:

elementary actions;

command system;

The environment (or setting) is the "habitat" of the performer. For example, for a performer Robot from a school textbook, Wednesday is an endless cellular field. Walls and shaded cells are also part of the environment. And their location and the position of the Robot itself determine the specific state of the environment.

Each executor can execute commands only from some strictly specified list - the executor's command system. For each command, applicability conditions (in what states of the environment the command can be executed) must be specified and the results of command execution must be described. For example, the "up" command of the Robot can be executed if there is no wall above the Robot. Its result is a displacement of the Robot one cell up.

After calling the command, the executor performs the corresponding elementary action.

Executor failures occur when a command is invoked with an invalid state of the environment.

Usually the executor knows nothing about the purpose of the algorithm. He follows all the commands he receives, without asking the "why" or "why" questions.

In computer science, the computer is the universal executor of algorithms.

The main properties of the algorithms are as follows:

Comprehensibility for the performer - i.e. the executor of the algorithm must know how to execute it.

Discreteness (discontinuity, separation) - i.e. the algorithm should represent the process of solving the problem as a sequential execution of simple (or previously defined) steps (stages).

Definition - i.e. each rule of the algorithm should be clear, unambiguous and leave no room for arbitrariness. Due to this property, the execution of the algorithm is mechanical in nature and does not require any additional instructions or information about the problem being solved.

Performance (or limb). This property consists in the fact that the algorithm must lead to the solution of the problem in a finite number of steps.

Mass character. This means that the algorithm for solving the problem is developed in general view, i.e. it should be applicable for a certain class of problems that differ only in the initial data. In this case, the initial data can be selected from a certain area, which is called the area of ​​applicability of the algorithm.

In practice, the following forms of presentation of algorithms are most common:

verbal (natural language recordings);

graphic (images from graphic symbols);

pseudocodes (semi-formalized descriptions of algorithms in a conditional algorithmic language, including both programming language elements and natural language phrases, generally accepted mathematical notation, etc.);

software (texts in programming languages).

The verbal way of writing algorithms is a description of the sequential stages of data processing. The algorithm is set in free form in natural language.

For example. Write down the algorithm for finding the greatest common divisor (GCD) of two natural numbers.

The algorithm can be as follows:

set two numbers;

if the numbers are equal, then take any of them as an answer and stop, otherwise continue the algorithm;

determine the larger of the numbers;

replace the larger of the numbers with the difference between the larger and smaller of the numbers;

repeat the algorithm from step 2.

The described algorithm is applicable to any natural numbers and should lead to the solution of the problem. See for yourself by determining the greatest common divisor of 125 and 75 using this algorithm.

The verbal way has no widespread the following reasons:

such descriptions are not strictly formalized;

suffer from verbosity of records;

allow for ambiguity in the interpretation of individual prescriptions.

The graphical way of presenting algorithms is more compact and clear in comparison with the verbal one.

In a graphical presentation, the algorithm is depicted as a sequence of interconnected functional blocks, each of which corresponds to the execution of one or more actions.

Such graphical representation called a flowchart or flowchart.

In the flowchart, each type of action (input of initial data, calculation of expression values, checking conditions, control of repetition of actions, completion of processing, etc.) corresponds to a geometric figure represented in the form of a block symbol. Block symbols are connected by transition lines that determine the order in which actions are performed.

Table 1 lists the most commonly used symbols.

The "process" block is used to designate an action or a sequence of actions that change the value, form of presentation or placement of data. To improve the clarity of the diagram, several separate processing blocks can be combined into one block. Representation of individual operations is fairly free.

The "decision" block is used to indicate conditional control transitions. Each "solution" block must indicate the question, condition, or comparison that it defines.

The "modification" block is used to organize cyclic structures. (The word modification means modification, transformation). The loop parameter is written inside the block, for which its initial value, boundary condition and step of changing the parameter value are specified for each repetition.

The "predefined process" block is used to indicate calls to auxiliary algorithms that exist autonomously in the form of some independent modules, and for calls to library routines.

Pseudocode is a notation and rule system designed to consistently record algorithms.

It occupies an intermediate place between natural and formal languages.

On the one hand, it is close to ordinary natural language, so algorithms can be written and read in it like ordinary text. On the other hand, some formal constructions and mathematical notation are used in pseudocode, which brings the notation of the algorithm closer to the generally accepted mathematical notation.

The pseudocode does not accept the strict syntactic rules for writing commands inherent in formal languages, which makes it easier to write an algorithm at the design stage and makes it possible to use a wider set of commands designed for an abstract executor. However, pseudocode usually contains some constructs that are inherent in formal languages, which facilitates the transition from writing in pseudocode to writing an algorithm in a formal language. In particular, in pseudocode, just as in formal languages, there are function words, the meaning of which is determined once and for all. They are highlighted in bold in printed text and underlined in handwritten text. There is no single or formal definition of pseudocode, therefore, various pseudocodes are possible, differing in the set of service words and basic (basic) constructions.

An example of pseudocode is a school algorithmic language in Russian notation (school AY), described in the textbook by A.G. Kushnirenko et al. "Fundamentals of Informatics and computing technology", 1991. Hereinafter we will call this language simply" algorithmic language ".

Basic service words

General view of the algorithm:

alg algorithm name (arguments and results)

the conditions of applicability of the algorithm are given

you need the purpose of the algorithm

start description of intermediate values

| sequence of commands (algorithm body)

The part of the algorithm from the word alg to the word start is called the heading, and the part between the words beginning and the end is called the body of the algorithm.

In the al sentence, after the name of the algorithm, in parentheses, the characteristics (arg, res) and the type of the value (integer, thing, sym, lit or log) of all input (arguments) and output (results) variables are indicated. When describing arrays (tables), the service word tab is used, supplemented by boundary pairs for each index of array elements.

Examples of alg sentences:

alg Volume and area of ​​a cylinder (arg item R, H, res item V, S)

alg Roots QvUr (arg thing a, b, c, rez thing x1, x2, rez lit t)

alg Exclude element (arg integer N, arg rez thing tab A)

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

Suggestions are given and should be optional. It is recommended to write in them statements describing the state of the environment of the executor of the algorithm, for example:

alg Replacement (arg lit Str1, Str2, arg rez lit Text)

given | the lengths of the substrings Str1 and Str2 are the same

it is necessary | everywhere in the Text string substring Str1 is replaced by Str2

alg Number of maxima (arg integer N, arg real tab A, res integer K)

given | N> 0

it is necessary | K - the number of maximum elements in table A

alg Resistance (arg thing R1, R2, arg int N, res thing R)

given | N> 5, R1> 0, R2> 0

it is necessary | R - circuit resistance

Here in sentences it is given and necessary after the "|" comments are recorded. Comments can be placed at the end of any line. They are not processed by the translator, but they make the algorithm much easier to understand.

Algorithms can be thought of as some structures, consisting of separate basic (i.e. basic) elements.

Naturally, with such an approach to algorithms, the study of the basic principles of their design should begin with the study of these basic elements.

To describe them, we will use the language of algorithmic schemes and the school algorithmic language.

The logical structure of any algorithm can be represented by a combination of three basic structures:

following,

branching,

A characteristic feature of basic structures is that they have one entrance and one exit.

Algorithmic programming language- a formal language used to write, implement and learn algorithms. Unlike most programming languages, the algorithmic language is not tied to the architecture of the computer, does not contain details related to the structure of the machine.

To study the basics of algorithmization, the so-called Russian algorithmic language(school algorithmic language), using words in Russian that are understandable to the student.

An algorithm-like algorithmic language with Russian syntax was introduced into use by Academician A. P. Ershov in the mid-1980s, as the basis for a "machine-less" computer science course.

The main function words of the algorithmic language

Algorithm description

• alg(algorithm)
• arg(argument)
• cut(result)
• early(start) - the beginning of the algorithm
• con(end) - end of the algorithm
• given- initial data in any form
• necessary- the goal of the algorithm

Data types:

• intact(whole)
• things(real)
• Sim(character)
• litas(literal) - string
• log(logical)
• tab(table) - to denote an array
• lengths(length) - number of array elements

Condition designation

• if
• otherwise
• choice
• meaning

Cycle notation

• nts(start of cycle)
• kts(end of cycle)
• while

Logical functions and values ​​for constructing expressions

Input Output

• input
• output

General view of the algorithm

1
2
3
4
5
6

alg algorithm name (arguments and results)
| given algorithm applicability conditions
| necessary the purpose of the algorithm
early description of intermediate values
| sequence of commands (algorithm body)
con

Part of the algorithm from the word alg to the word early called the title, and the part between the words early and con- the body of the algorithm.

In a sentence alg after the name of the algorithm in parentheses are the characteristics ( arg, cut) and value type ( intact, things, Sim, litas or log) of all input (arguments) and output (results) variables. When describing arrays (tables), a special word is used tab, supplemented with boundary pairs for each index of the array elements.

Algorithm record keywords usually underlined or in bold. To highlight logical blocks, indentation is applied, and paired words of the beginning and end of the block are connected with a vertical line.

Basic algorithmic structures

A detailed description of the main algorithmic structures is given in this article. Below are the templates for composing these structures in an algorithmic language.
Incomplete fork

| if condition
| | then actions
| all

Full fork

1
2
3
4
5

| if condition
| | then action 1
| | otherwise action 2
| all

Branching

1
2
3
4
5
6
7
8

| choice parameter
| | at meaning value 1
| | | action 1
| | at meaning value 2
| | | action 2
| | otherwise
| | | default actions
| all

Loop with precondition

| nc bye condition
| | actions
| kts

Loop with postcondition

Most often, instructions are written in an algorithmic language. It is necessary for the precise prescription of all steps and their execution. There are clear differences between the school algorithmic language and programming languages. As a rule, not only a computer acts as a performer in the first version, but also another device that is capable of performing work. Any program written in an algorithmic language does not have to be done by technology. Implementation of all instructions in practice is a purely separate issue. Below will also be considered a description of the algorithm in algorithmic language. It will help you understand the structure of this system.

Studying at school

Algorithmic language is often taught in schools, best known as teaching language. It has become widespread due to the fact that it uses words that are most understandable to any student. A similar language with syntax in Russian was introduced a long time ago, namely in the mid-1980s. It was used to provide a foundation for schoolchildren and teach them a computer science course without a computer. Published given language was in 1985 in one of the textbooks. It was also reprinted several times for special books that were intended for teaching in grades 9 and 10. The total circulation of the publication was 7 million copies.

Algorithm recording sequence

First of all, you need to write down the ALG combination of letters. The name of the algorithm follows. Then, after the NACH, you need to describe a series of commands. The KOH operator means the end of the program.

Description of the algorithm in algorithmic language:

ALG Company

START

turn 90 degrees to the left

KOH

When writing, keywords must be underlined or in bold. To indicate logical blocks, you should use indentation, and if there are paired words of the beginning and end, you must use the vertical bar, which denotes the connection.

Compilation of algorithms

Old notes can be used to compose new instructions. Such instructions are called auxiliary instructions. A similar algorithm can be any of all those described previously. It is also possible that in this system an additional algorithm will be applied, which itself received a reference to auxiliary systems.

Often, when creating an instruction, there is a need to use only one algorithm as an additional one. This is why recordings can often be complex and cumbersome. But it is worth noting that the ability to make a reference is easier than rewriting the same records several times.

That is why, in practice, a standard auxiliary algorithm is often used, which is constantly subordinate to the user. The instruction can have a reference, both to itself and to anyone else. Algorithmic language commands are designed for such actions. Such instructions are called recursive.

The self-bind command is within the system itself. This recursion is straight forward. An indirect one is one where the algorithm is called in any other auxiliary instruction.

Algorithms that have a certain order of instructions can constantly change depending on the results of the execution of special parts of the program. Such systems are called branching systems. In order to create them, you need to use a special branching command. It has an abbreviated and complete spelling scheme. Cyclic algorithms are not uncommon that execute specific commands multiple times.

E-workshop

In order to improve the study of theory in the grammatical language, the professionals of the Faculty of Mechanics and Mathematics of Moscow State University in 1985 created a special compiler. It was named "E-workshop". With its help it was possible to enter, modify and execute programs. The following year, a specific set of performers was released. It is about "Robot", "Draftsman", "Two-legged", "All-terrain vehicle". This made it possible to implement the algorithms simply and easily. This compiler has become very popular and has been used on some computers. Enough long time this programming language has been refined and changed. In 1990, a later version of it appeared in a textbook.

Idol

Now the school algorithmic language is experiencing its rebirth, after a special package "Idol" was developed for Windows and Linux. The system works with several performers. Classic among them are "Robot", "Draftsman". The same package is included in setup file Linux "School". This system was developed specially by order of the Russian Academy of Sciences. It is distributed free of charge and freely. Over the past few years, the described language has been actively proposed to be used in the Unified State Exam as one of the

Language assignment

Algorithmic language is used to solve a fairly wide range of problems. It is suitable for mastering both math and exercises in other subjects. It should be noted that it is also used to make it easier for schoolchildren to study similar topics.

Differences between machine and algorithmic languages

The most famous representative of machine-dependent languages ​​is "Assembler". During programming on it, a person must clearly indicate to the translator, thanks to special operators, which memory cells should be filled or transferred. Since the syntax of "Assembler" is as close as possible to the computer form of writing, it is quite difficult to study it. That is why algorithmic language is taught at school, as well as at the beginning of teaching programming in the first year of higher education.

Standard functions

Algorithmic language has special standard functions which have received the status of "built-in". It is thanks to them that you can easily write many operations with numbers and expressions without performing routine entries. The algorithmic language program is quite simple. Standard functions can allow you to calculate square root, logarithms, modulus, and so on. The most popular built-in methods are as follows:

• absolute module abs (X);
• square root sqrt (X);
• natural and ln (X), lg (X);
• minimum and maximum min (X, Y), max (X, Y);
• trigonometric functions sin (X), cos (X), tg (X), ctg (X).

Thanks to this, any programmer or just a person who learns to work with an algorithmic language can easily write a mathematical problem without resorting to the invention of the bicycle. Thus, it should be noted that this language is quite user-friendly. It is simple to understand and also as easy to understand as possible. No wonder he was included in the school curriculum. Schoolchildren are happy to study it.

Recommended related articles

Why the computer does not see the new hard drive

Minecraft crashes, what should I do?

Excel - paint cells by condition

Visitors are now discussing

Email forgot password TP-Link

How to completely uninstall Avast! D-link

Updating iPhone without problems Useful

How do I clear the cache on my computer? iPhone / iPad