Turbo Pascal. Structured statements

The conditional jump operator in Turbo Pascal has the form:

If condition then operator 1 else operator 2;

condition is a logical expression, depending on which one of two alternative branches of the algorithm is selected. If the condition value is TRUE, then the operator 1, written after the then keyword. Otherwise it will be executed operator 2, following the word else, while operator 1 skipped. After executing the specified statements, the program proceeds to executing the command immediately after the if statement.

It is important to remember that a semicolon is never placed before the else keyword!

else - part in the if statement may be missing:

If condition then operator 1;

Then, if the logical condition is not met, control is immediately transferred to the operator located in the program after the if construct.

Basic operations and mathematical procedures and functions

Mathematical expressions in algorithmic notation consist of operations and operands. Most operations are binary, i.e. contain two operands (unary operations contain one operand, for example: -a, take address @B).

Arithmetic operations:

+, -, /, *, div (integer division), mod (division remainder),

Logical: not, and, or, xor,

Relational operations: >,<, >=, <=, <>, =.

Logical calculations and relational operations

The presence of the Boolean type and operations with it allows you to program logical calculations, which are based on Boolean algebra. Four logical operations are introduced, the result of which is always of type Boolean and can only have one of two values ​​(Trueº1 (true) or Falseº0 (false)).

To avoid errors, it is better to place parentheses yourself during logical calculations. So, for example, the notation Not A And B will be interpreted by the compiler as (Not A)And B, but perhaps it would be necessary as follows: Not (A And B).

Mathematical procedures and functions

The Turbo Pascal system library is shown in the table:

Mathematical functions are very sensitive to the range of their arguments. In addition, return values ​​of integer types must fit within them, otherwise fatal consequences are possible

Most of the functions are standard and do not need comments. Separately, I would like to dwell on specific ones.

The PI function generates the number “Pi” with an accuracy depending on the presence of a coprocessor and contains from 10 to 14 significant digits after the decimal point; it can be used in calculations as a constant, but cannot be placed in the computable constants of the Const block.

The set of trigonometric functions is limited, but makes it possible to expand the mathematical library by introducing your own functions that define standard mathematical

Data types

Laboratory work No. 2(2 hours)

Option 5

An operator is an indivisible element of a program that makes it possible to perform certain algorithmic actions. The difference between an operator and other elements is that it always implies some kind of action. In Pascal, operators consist of function words. Operators used in a program are separated from each other and from other program elements by the symbol (;). All Pascal operators can be roughly divided into two groups:

1. simple;
2. structured.

Simple Operators are operators that do not contain other operators. These include:

• assignment operator (:=);
• procedure statement;
• unconditional jump operator (GOTO).

Structured statements are operators that contain other operators. These include:

• compound operator;
• conditional operators (IF, CASE);
• loop operators (FOR, WHILE, REPEAT);
• join operator (WITH).

Simple Operators

Procedure operator

Procedure operator serves to call a procedure.

Format: [procedure_name] (list of call parameters);

A procedure statement consists of a procedure identifier, immediately followed by a list of call parameters in parentheses. Pascal has procedures without parameters. In this case, when called, there is no list of parameters. Execution of a procedure statement leads to the activation of the actions described in its body. There are two types of procedures in Pascal:

• Standard ones, which are described in the language itself and are part of the language;
• User procedures that are created by the user.

To call standard procedures, you must connect in the USES section of the module (library) name, where this procedure is described. A number of procedures located in the SYSTEM module are always connected to the program automatically and their connection in the USES section is not necessary. Standard Pascal procedures are READ, WRITE, REWRITE, CLOSE, RESET.

READ ([file_variable], [input_list])

READ(x,y)

User procedures (non-standard) must be created before they can be used in the program and are located either in the description section of the program itself or in separate program units of the module. If the procedure is in a module, then the name of that module must be mentioned in the USES application.

Unconditional GOTO operator

Format: GOTO [label];

GOTO is a reserved word in Pascal. [label] is an arbitrary identifier that allows you to mark a certain program statement and later refer to it. In Pascal, it is possible to use unsigned integers as labels. The label is placed before and separated from the marked operator (:). One statement can be marked with several labels. They are also separated from each other (:). Before using a label in the statement section, it must be described in the LABEL section (description section).

The GOTO action transfers control to the appropriate marked statement. When using tags, you must follow the following rules:

• the label must be described in the descriptions section and all labels must be used;
• if integers are used as labels, they are not declared.

Contradicts the principles of structured programming technology. Modern programming languages ​​do not include such an operator, and there is no need to use it. In addition, modern computers use the so-called conveyor method. If an unconditional jump operator is encountered in a program, then such an operator breaks the entire pipeline, forcing it to be created anew, which significantly slows down the computational process.

Structured statements

IF condition statements

The conditional operator is used in the program to implement the algorithmic structure - branching. In this structure, the computational process can continue in one of the possible directions. The choice of direction is usually carried out by checking some condition. There are two types of branching structures: fork and bypass structures.

In the Pascal language, the conditional IF operator is a means of organizing a branching computational process.

Format: IF [boolean_expression] Then [operator_1]; Else [operator_2];

IF, Then, Else are function words. [operator_1], [operator_2] - ordinary operations of the Pascal language. The Else part is optional (may be missing).

The IF statement works like this: It first checks the result of a Boolean expression. If the result is TRUE, then [statement_1] following the Then function word is executed, and [statement_2] is skipped. If the result is FALSE, then [statement_1] is skipped and [statement_2] is executed.

If the Else part is missing, then the IF statement is not in full form:

IF [boolean expression] Then [operator];

In this case, if the result is True (TRUE), then the [statement] is executed; if False (FALSE), then control is transferred to the statement following the IF statement.

There are 2 numbers A and B. Find the maximum number.

Compound operator

A compound statement is a sequence of arbitrary operations in a program, enclosed in so-called operator brackets (Begin-End).

Format: Begin [operators]; End;

Compound statements allow a group of statements to be represented as a single statement.

CASE selection statement

Designed to implement multiple branches, since the IF operator can implement only two directions of the computational process, it is not always convenient to use it to implement multiple branches. Multiple branching is implemented by the CASE statement.

Format: CASE [select_key] OF

[selection_constant_1]:[operator_1];

[selection_constant_2]:[operator_2];

[selection_constant_N]:[operator_N];

ELSE [operator];

CASE, OF, ELSE, END - function words. [select_key] is a parameter of one of the ordinal types. [selection_constants] - constants of the same type as the selection key that implement selection. [operator_1(N)] is an ordinary operator. ELSE may be missing.

The selection operator works as follows: before the operator operates, the value of the selection key parameter is determined. This parameter can either be expressed as a variable in the program or in some other way. Then the selection key parameter is sequentially compared with the selection constant. If the value of the selection key matches one of the selection constants, the operator following this constant is executed, and all other operators are ignored. If the selection key does not match any of the constants, the statement following Else is executed. Often Else is optional and if the selection key does not match any of the selection constants and in the absence of Else, control is transferred to the statement following the CASE statement.

The CASE statement does not have the explicit conditional checking that is typical for the IF statement. At the same time, the comparison operation is performed implicitly. CASE introduces dissonance into a Pascal program, since this statement ends with the service word End, which does not have a paired Begin.

Create an algorithm and program for a problem simulating the operation of a traffic light. When you enter the symbol of the first letter of the traffic light colors, the program should display a message about the corresponding color and actions.

The program works as follows: using the Read procedure, the letter symbol of the traffic light color is entered from the keyboard. If the letter ‘z’ corresponding to the green color is entered, then in the CASE statement the value entered in the selection list will find the selection constant ‘z’ and the message “Green color, movement is allowed” will be displayed. When you enter the symbol of the letters 'k' and 'zh', similar messages will be displayed. If you enter any other character, the message “Traffic light does not work” will be displayed, because in this case the Else part of the CASE statement works.

Loop statements

A cyclic algorithmic structure is a structure in which some actions are performed several times. There are two types of loop structures in programming: the loop with a parameter and the iterative loop.

In a cycle with a parameter there are always so-called cycle parameters: X, X n, X k, ∆X. Sometimes a loop with a parameter is called a regular loop. A characteristic feature is that the number of loops and repetitions can be determined before the loop is executed.

In an iterative loop, it is impossible to determine the number of loops before executing it. It is executed as long as the loop continuation condition is satisfied.

The Pascal language has three operators that implement cyclic computational structures:

• counting operator FOR. It is intended to implement a loop with a parameter and cannot be used to implement an iterative loop;
• loop operator with WHILE precondition;
• loop operator with REPEAT postcondition.

The last two are focused on implementing an iterative loop, but they can also be used to implement a loop with a parameter.

FOR operator

Format: FOR [loop_parameter] := [n_z_p_ts] To [k_z_p_ts] Do [operator];

FOR, To, Do are function words. [cycle_parameter] - cycle parameter. [n_z_p_ts] - the initial value of the cycle parameter. [k_z_p_ts] - final value of the cycle parameter. [operator] - arbitrary operator.

The loop parameter must be an ordinal variable. The start and end values ​​of the loop parameter must be of the same type as the loop parameter.

Let's look at the operator's work using its algorithm:

At the first step, the value of the cycle parameter takes [n_z_p_ts], then the cycle parameter is checked to be less than or equal to [k_z_p_ts]. This condition is the condition for continuing the loop. If executed, the loop continues its operation and the [statement] is executed, after which the loop parameter is increased (decreased) by one. Then, with the new value of the loop parameter, the condition for continuing the loop is checked. If it is fulfilled, then the actions are repeated. If the condition is not met, then the loop stops running.

The For operator is significantly different from similar operators in other programming languages. The differences are as follows:

• body of the For operator. The statement may never be executed because the loop continuation condition is checked before the loop body;
• the cycle parameter change step is constant and equal to 1;
• The body of the loop in the For statement is represented by one statement. If the action of the loop body requires more than one simple statement, then these statements must be converted into one compound statement using operator brackets (BEGIN-END);
• A loop parameter can only be an ordinal variable.

Example of using the FOR operator: create a table for converting rubles to dollars.

WHILE statement (loop statement with precondition)

Format: WHILE [condition] Do [operator];

WHILE, Do - function words. [condition] - expression of logical type. [operator] - ordinary operator.

;

The While statement works as follows: first, the result of the logical condition is checked. If the result is true, then the statement is executed, after which it returns to checking the condition with the new value of the parameters in the logical expression of the condition. If the result is false, then the loop is terminated.

When working with While, you need to pay attention to its properties:

• The conditions used in While are the loop continuation condition;
• in the body of the loop, the value of the parameter included in the condition expression always changes;
• The While loop may not execute even once, since the condition check in the loop continuation is performed before the loop body.

REPEAT statement (loop statement with postcondition)

Format: REPEAT [cycle_body]; UNTIL [condition];

The REPEAT statement works as follows: first, the statements of the loop body are executed, after which the result is checked for the logical condition. If the result is false, then it returns to executing the statements of the next loop body. If the result is true, then the operator exits.

The Repeat operator has the following features:

• in Repeat, the loop termination condition is checked and if the condition is met, the loop stops working;
• The body of the loop is always executed at least once;
• the parameter for checking the condition is changed in the body of the loop;
• The loop body statements do not need to be enclosed in operator brackets (BEGIN-END), while the role of operator brackets is performed by Repeat and Until.

Calculate y=sin(x), where xn=10, xk=100, step is 10.

It happens that programs need to organize branching. In this case, the process of solving a problem occurs on the basis of the fulfillment or non-fulfillment of some condition.

In the Pascal language, the selection of an action, depending on some condition, can be implemented using the construction

if... then... else...if... then...

2. What is the full form of the conditional jump operator if in Pascal?

Full form of the conditional jump operator if :

ifconditionthenoperator1elseoperator2;

The action of the operator is as follows: first, the value of the expression is calculated condition . If it is true (equal to TRUE ), then the statement that follows the word is executed then (operator1). If the value is false (FALSE), then the statement that follows the word is executed else(operator2 ).

Operators operator1 And operator2 can be compound, that is, contain several lines of code. Such operators are placed in operator brackets begin...end. This need arises if after reserved words then or else you need to specify several operators.

In this case, the general form of the conditional jump operator may have, for example, the following form:

ifconditionthenbegin// several operators ... endelsebegin// several operators ... end ;

3. What is the abbreviated form of the conditional jump operator?

The short form of the conditional jump operator does not contain a block else and has the form:

ifconditionthenoperator;

In this case, the operator works as follows. First, the value of the logical (Boolean) expression is calculated condition . If the result of a logical expression condition true (equal TRUE), then the operator that follows the word is executed then. If the result is FALSE , then the statement that follows the statement is executed if(in the statement if...then nothing is done).

If, when a condition is met, several operators need to be executed, then the general form of the conditional jump operator can be as follows:

ifconditionthenbegin// two or more operators ... end ;

4. Examples of using the conditional jump operator, which has a full representation form.

Example 1. Fragment of a program for finding the maximum value between two real numbers.

var a,b:real; // a, b - variables for which the maximum is sought max:real; // maximum ... begin ... // a, b - are specified if a>b then max:=a else max:=b; end ;

...

Example 2.

... var A fragment of program code that solves this problem: begin ... // x,f:real; if -5 then x - specified else f:= x*x+8 // f:= -x*x*x+2 ; ... end ;

in the variable f - the result

Example 1. 5. Examples of using the conditional jump operator, which has a shortened form of representation. Code snippet that finds the minimum value between two real numbers And x .

... var y begin ... // min:real; ... x, y - given if min:= x; then min end ;

... min:= y;

var... begin ... // Calculate the value of a function according to a condition. Suppose you need to find the value of a function: if x, f:real;<-6 then x - specified if (-6 <=x) x f:=3 *x*x-x;<=5 ) then and if(x then f:=sqrt(7 -x); end ;

This lesson looks at the conditional operator in Pascal ( if). Explains how to use multiple conditions in one construct ( AND And OR). Examples of working with an operator are considered We remind you that this site does not pretend to provide a complete presentation of information on the topic. The purpose of the portal is to provide the opportunity to learn material based on ready-made solved examples on the topic “Pascal Programming Language” with practical tasks to reinforce the material. The Pascal tasks presented on the site are arranged sequentially as their complexity increases. The website can be used by teachers and lecturers as an auxiliary visual aid. Before considering this topic, linear algorithms in Pascal were mainly used, which are typical for very simple problems when actions (operators) are performed sequentially, one after another. More complex algorithms involve the use of a branching construct. Conditional operator block diagram: The conditional statement in Pascal has the following syntax: Abridged version: if condition then statement; Full version: if condition then statement else statement; The conditional operator in Pascal - if - serves to organize the progress of a task in such a way that the sequence of execution of operators changes depending on some logical condition. A logical condition can take one of two values: either true or false, respectively, it can be either true or false. Compound operator If, under a true condition, it is necessary to execute several statements, then According to the rules of the Pascal language, they must be enclosed in a block, starting with the function word begin and ending with the function word end . Such a block is usually called operator brackets, and this construction - compound operator: Operator brackets and compound operator in Pascal: if logical expression then begin statement1; operator2; end else begin statement1; operator2; end; Translation from English of the condition operator will make it easier to understand its use: IF THEN ELSE IF THAT OTHERWISE The condition (in a logical expression) uses relational operators. Consider Pascal's list of relational operators: more > less greater than or equal to in Pascal >= less than or equal to in Pascal comparison in Pascal = not equal in Pascal Example: find the largest of two numbers Option 1 Option 2 comparison in Pascal = Understand the work in detail you can use the conditional operator in Pascal by watching the video tutorial: calculate the value of the variable y using one of two branches Show solution: var x,y:real; begin writeln("enter x"); read(x); if x>0 then y:=ln(x) else y:=exp(x); writeln ("y=", y:6:2) (the resulting number will occupy 6 positions and will have 2 decimal places) end. Notice how y is output in this example. When deducing type variables in pascal, you can use the so-called formatted output , or notation with two colons: y:6:2 - the number after the first colon (6) indicates how many characters the number will occupy when displayed on the screen - the number after the second colon (2) indicates how many decimal places of the real number will be displayed Thus, using such notation in pascal practically allows you to round to hundredths, thousandths, etc. Task 0. Calculate the value of the variable y using one of two branches: Task 1. Two numbers are entered into the computer. If the first is greater than the second, then calculate their sum, otherwise - the product. After this, the computer should print the result and the text PROBLEM SOLVED Task 2. The dragon grows three heads every year, but after it turns 100 years old, only two. How many heads and eyes does a dragon have? N years? Logical operations in Pascal (in logical expression) AND When you need to use a double condition in Pascal, you will need logical operations. Logical operation OR (And), placed between two conditions, says that both of these conditions must be met at once (must be true). The logical meaning of the operation is “conjunction”. Placed between two conditions, the sign (OR) says that it is sufficient if at least one of them is satisfied (one of the two conditions is true). The logical meaning of the operation is “disjunction”. - a sign of a logical operation that has the meaning of “strict disjunction” and indicates that it is necessary that one of the two conditions be fulfilled (true), and the other not satisfied (false). Logical operations in Pascal (in logical expression) NOT before a logical expression or variable it means “negation” or “inversion” and indicates that if a given variable or expression is true, then its negation is false and vice versa. Important: Each simple condition must be enclosed in parentheses. Example: Let's look at examples of logical operations in logical expressions in Pascal 1 2 3 4 5 6 7 8 var n: integer ;<10 ) then writeln ("истина" ) ; if (n>begin n: = 6 ;<10 ) then writeln ("истина" ) ; if (n>if (n>5 ) and (n<10 ) then writeln ("истина" ) ; if not (n>7 ) or (n 7 )xor (n<10) then writeln("истина"); if (n>7) then writeln("true");<10) then writeln("истина"); if (n>end.<10) then writeln("истина"); if not(n>var n:integer; begin n:=6; if (n>5) and (n comparison in Pascal = 7) or (n 7)xor(n 7) then writeln("true"); end. The company recruits employees from 25 to 40 years of age inclusive. Enter the person’s age and determine whether he is suitable for this company (display the answer “suitable” or “not suitable”). Peculiarity: we need to check whether two conditions are met simultaneously. Transition operator 1..9999 This time I will continue to consider the topic “Operators”. (Unconditional) jump statements are designed to transfer control to a statement marked with a label (preceded by the label). The author's version of the language assumes that the label is formatted as an integer decimal number in the range . Turbo Pascal allows the use of identifiers as labels. When using jump operators, the following rules must be observed: 1) All marks in the block must be described. In this case, each label can be described no more than once. Those. There cannot be two labels with the same name within a block. 1) if it seems impossible to do without transition operators, you should strive to use them to transfer control only down the program text (forward); if there is a need to transfer control “back”, it is better to use loop operators (see below); 2) for clarity, the distance between the label and the operator to jump to it should not exceed one page of text (or the height of the display screen), otherwise the meaning of such an unconditional transition will be difficult to grasp. Labels are defined by descriptions that begin with a function word label and contain a sequence of label names separated by commas. To transfer control to the operator marked with a label, an unconditional transition operator is provided goto. A label is separated from the following statement by a ‘:’ (colon). Example: var j:integer; (we announce two labels) label Start, Finish; Start: writeln(‘Start of program’); goto Finish; Finish: writeln('End of program'); Compound operator The simplest structure operator is the compound operator. This statement specifies the sequence of execution of the operators contained in it. A compound operator is formatted as a list of operators separated from each other by the symbol ‘;’ (semicolon) and enclosed between auxiliary words begin And end. The need for a compound operator may arise in cases where the syntax of the Pascal language allows the use of only one operator in a place in the program where a number of actions (operators) are needed, see examples below. Here's a simple example of a compound operator: Conditional operator The meaning of a conditional operator is to analyze a certain logical condition, and in accordance with whether this condition is satisfied or not, transfer control to the corresponding operator. The condition can be an expression that returns a Boolean value. The result of condition analysis can be the value true, i.e. the condition is satisfied and false, i.e. the condition is not met. The conditional statement is executed as follows. The expression specified after the service word is pre-calculated operator2; end;. If the condition is met, then control is transferred to the operator specified after the service word then, if not, then the operator specified after the else service word is executed. In this case, part of the conditional operator, starting with the word else, may be missing. Here are examples of conditional statements: If Keypressed then writeln('Key pressed'); If A>B then Min:= B else Min:= A; if X1 > X2 then begin The last example is exactly the case when it is necessary for a number of operators to be executed according to the condition, but due to the fact that behind the service word then or else only one statement can follow, that is, it is possible to resolve the situation by using a compound statement containing just a number of those necessary statements. When composing nested conditional statements, keep in mind that the else branch always belongs to the previous branch operator2; end;, which does not yet have an else branch. Those. the following construction if Condition1 then if Condition2 then Operator1 else Operator2; for clarity, it can be interpreted as follows if Condition1 then begin if Condition2 then Operator1 else Operator2; It is necessary to be careful when using nested conditional statements, so that in the heat of the moment when composing the next conditional statement of the program, you do not lose sight of such a seemingly small detail that can lead to a completely different execution of conditional branching. Variant operator Quite often a situation arises when a chain of conditional statements grows to enormous proportions, for example, the following example illustrates a branching that is modest in size, but already contains the complexity of perceiving the meaning inherent in it: type TWay = (Up, Right, Down, Left); var Way: TWay; MapX, MapY: word; if Way = Up then MapY:= MapY - 1 else if Way = Right then MapX:= MapX + 1 elseif Way = Down then MapY:= MapY + 1 else MapX:= MapX - 1; The last else branch does not have a statement If, since if all three conditions are not met, it would be logical for the operator corresponding to the fourth and last option of possible values ​​of the type to come into effect TWay. In this case, we are lucky that the type TWay has only four possible values. Would composing such branches become a chore if there were ten or more options? But in the presented branching a simple pattern is visible. So is there any way to simplify it and make it more efficient and readable? It is possible, and for this purpose the language provides a variant operator, the construction of which can contain an arbitrary number of alternatives for a certain expression. Then the last example can be rewritten in a new way: case Way of Up: MapY:= MapY - 1; Right: MapX:= MapX + 1; Down: MapY:= MapY + 1; Left: MapX:= MapX - 1; Well, that's a completely different matter. Now let's look at the execution order of this statement. The value of the expression following the function word is pre-calculated case, but since in this case the variable name is Way, then the value of this variable is read. The resulting value is compared in turn with each alternative (constant, immediate value) specified after the service word of. If the value of an expression is equal to the next constant, the alternative operator following this constant, separated from it by a colon, is executed. After the alternative statement completes execution, action moves to the statement following the variant statement. If the value does not match Way With no constant, this variant operator does not perform any actions. But what if it is necessary to provide a certain branch of operators that would be executed if the value of the expression does not match any constant? You can use an else alternative for this, for example: case Way of Up: MapY:= MapY - 1; Right: MapX:= MapX + 1; Down: MapY:= MapY + 1; else MapX:= MapX - 1; Consequently, the construction built using the case operator is completely equivalent to the construction built earlier using the operator operator2; end;. In addition, it is clearer and there is no risk of getting confused in numerous else. Once again, I want to draw your attention to the fact that the constants in the variant operator can be both direct integers and the names of untyped constants described earlier. The use of typed constants in alternatives to the variant operator is not allowed. Moreover, in each option you can specify a whole list of constants separated by commas or a range of values, for example: case Way of Up, Down: writeln(‘Moving vertically’); Right, Left: writeln(‘Moving horizontally’); case X of 10,20,30: writeln('tens'); 1..9: writeln('units'); In the last construction the operator writeln('units') will be executed if the variable X has one of the values 1,2,3,..,8,9 . As you may have noticed, I aligned the lines with constants by colons, since it seems to me that this type is more visual, although this is a matter of taste, and as you know, there is no friend for taste;O) The variant operator should be used in accordance with the following rules: 1) Acceptable values ​​of the expression - “switch”, written after the function word case, must satisfy the discrete type: for an integer type they must lie in the range -32768..32767 . 2) All specified alternative constants must be of a type compatible with the type of the expression. 3) Constants in alternatives must not be repeated within a variant statement, and ranges must not overlap and must not contain constants specified in this or other alternatives. One more thing. Design case provides one statement for each alternative. If you need to execute multiple statements, you should group them into a compound statement begin..end. It is possible to specify an empty operator for an alternative by placing the ";" symbol. (semicolon) immediately after the colon, which will do nothing. And the branch syntax else provides for specifying a sequence of operators separated by the symbol ‘;’ (semicolon).

 

---

x>5
f:=8 *x-3 ; ... Read: Bioshock remastered won't start How to set your melody to the desired contact on a Nokia X2 smartphone with two SIM cards Free programs for Windows download for free