В прошлом задании мы работали с числовыми типами переменных и учили арифметику, теперь познакомимся с логическим типом переменных, который называется Boolean. Переменные этого типа имеют всего два значения - true и false (соответственно, «истина» и «ложь»). Подобно числовым переменным им можно присваивать значения при помощи оператора присваивания. При этом необходимо строго соблюдать правило совместимости типов. То есть, логическим переменным нельзя присваивать числовые значения, а числовым - логические. Так же можно выводить значения логических переменных на экран, а вот вводить их с клавиатуры нельзя!
В языке Pascal определены `6` операций сравнения, результатом которых является логическое значение:
1) «больше» (>)
2) «больше или равно» (>=)
3) «меньше» (<)
4) «меньше или равно» (<=)
5) «равно» (=)
6) «не равно» (<>).
Например, операция `5>2` всегда выдаст значение true, а операция `x<>3` выдаст значение true, если переменная `x` имеет любое значение, кроме `3`.
Сравнивать можно не только числа (причём как целые, так и вещественные), но и логические значения. При этом считается, что значение true больше, чем значение false.
При выполнении сравнений также необходимо соблюдать совместимость типов. То есть, можно сравнивать число с числом или логическое значение с логическим значением, но нельзя сравнивать число с логическим значением. Такое сравнение выдаст ошибку.
Помимо операций сравнения ещё существуют и логические операции:
1) and (конъюнкция, логическое умножение, операция «И»)
2) or (дизъюнкция, логическое сложение, операция «ИЛИ»)
3) not (отрицание, инверсия)
4) xor (строгая дизъюнкция, исключающее «ИЛИ», сложение по модулю `2`).
В скобках указаны возможные названия данных операций в алгебре логики.
Операнды этих операций должны быть логического типа. Результат вычислений также будет логический. При этом операции and, or, xor имеют по два операнда, а операция not - всего один, который записывается справа от названия операции. Названия логических операций являются служебными зарезервированными словами языка.
Приведём таблицы результатов логических операций для всех возможных значений операндов (в алгебре логики такие таблицы называются таблицами истинности):
|
X |
not x |
|
false |
true |
|
True |
false |
|
X |
y |
x and y |
x or y |
x xor y |
|
false |
false |
false |
False |
false |
|
false |
true |
false |
True |
True |
|
true |
false |
false |
True |
True |
|
true |
true |
true |
True |
False |
Логический результат даёт также стандартная функция odd(x), которая применяется к целочисленному аргументу х:
odd(x) = true, если `x` нечётно;
odd(x) = false, если `x` чётно.
Приоритет операций в сложном выражении (содержащем в себе все виды операций, изученных нами) следующий:
1) Операция not.
2) Операции группы умножения and, *, /, div, mod
3) Операции группы сложения or, xor, +, -
4) Операции сравнения >, <, >=, <=, =, <>
Операции одного приоритета выполняются слева направо. Операции в круглых скобках имеют более высокий приоритет, чем операции вне скобок.
Рассмотрим несколько примеров на построение логических выражений. Пусть нам требуется записать логическое выражение по синтаксису языка программирования, имеющее значение true, в случае выполнения указанного условия.
Целое число `n` делится на `13`.
n mod 13 = 0
Надо проверять, что остаток от деления на `13` является нулём.
Целое число `n` делится на `13` и `7`.
(n mod 13 = 0) and (n mod 7 = 0)
Здесь надо проверить одновременное выполнение двух условий.
Переменная `x` имеет значение из отрезков `[2,5]` или `[-1,1]`.
(x>=2) and (x<=5) or (abs(x)<=1)
Из чисел `x`, `y`, `z` хотя бы два равны между собой.
(x = y) or (x = z) or (y = z)
Числа `x`, `y`, `z` равны между собой.
(x = y) and (x = z)
Обратите внимание, что согласно таблице приоритетов, операции сравнения имеют самый низкий приоритет. Однако, как правило, в сложных выражениях нужно сначала выполнить сравнения, а потом группировать их результаты при помощи логических операций. Поэтому не нужно забывать брать операции сравнения в скобки, чтобы не получить неправильный порядок действий.
В рассматриваемых ранее задачах на программирование процесс вычисления был линейным, то есть программа не должна была выполнять разные действия в зависимости от того, какие данные ей ввели. Теперь рассмотрим задачи с ветвящимся алгоритмом.
Ввести номер года. Вывести слово YES, если год високосный, и NO, если он - не високосный.
По условию очевидно, что в зависимости от входных данных программа должна будет выполнить один из двух операторов вывода: Writeln('YES') или Writeln('NO'). При этом написать в программе нам придётся оба, а вот выполняться должен будет только один из них. Для того чтобы реализовывать подобные ветвления алгоритма, в языке Pascal существует условный оператор. В общем виде он выглядит следующим образом:
if логическое выражение
then оператор
else оператор
Слова if, then и else являются служебными зарезервированными словами языка. Работает эта конструкция так: сначала вычисляется логическое выражение, стоящее после if. Если получилось значение true, то выполняется оператор, стоящий после слова then, а если получилось значение false, то выполняется оператор, стоящий после слова else.
Обратите внимание, что внутри условного оператора нет никаких точек с запятой, поскольку он является единой конструкцией, а точка с запятой - это разделитель между операторами. Для удобства чтения и отладки программ принято условие записывать на одной строке, а ветви then и else начинать с новой строки, однако это не является синтаксическим правилом языка.
В качестве примера условного оператора рассмотрим решение задачи, поставленной выше. Год считается високосным, если он делится нацело на `400`, или если он делится нацело на `4`, но не делится нацело на `100`. Проверять делимость мы уже умеем, поэтому осталось только записать это условие в виде программы:
var y:integer;
begin
write('Введите номер года ');
readln(y);
if(y mod 400=0)or(y mod 4=0)and(y mod 100<>0)
then writeln('YES')
else writeln('NO');
end.
По грамматике языка после слов then и else должен стоять только один оператор языка. То есть запись if x>0 then x:=4; y:=0 else z:=9; является синтаксически неверной. А как быть, если всё-таки нужно выполнить более одного оператора? Для таких случаев в языке Pascal предусмотрен составной оператор, который позволяет превратить группу операторов в один. Выглядит он следующим образом: сначала записывается служебное зарезервированное слово begin, далее - интересующая нас последовательность операторов через точку с запятой, а в конце пишется служебное зарезервированное слово end. В отличие от конца программы, точка после этого слова не ставится. Слова begin и end называют операторными скобками. Запишем правильную версию условного оператора, приведённого выше: if x>0 then begin x:=4; y:=0 end else z:=9;
Обратите внимание на следующий тонкий момент: если требуется выполнить более одного оператора в ветке then, и при этом мы забудем написать операторные скобки, то это является синтаксической ошибкой, и программа просто не будет работать. Если же забыть написать операторные скобки в ветке else, то программа работать будет, но не так, как предполагалось.
Рассмотрим пример:
if x>0 then y:=9 else z:=8; c:=5;
В этом примере условный оператор заканчивается после z:=8; в то время как оператор c:=5; является следующим оператором программы и выполняется независимо от результата сравнения `x` с нулём. Если же написать операторные скобки, то присваивание в `c` числа `5` произойдёт только в случае x<=0.
Ещё один тонкий момент заключается в том, что в ветке else в качестве оператора может стоять и пустой оператор. Рассмотрим следующий пример.
Вводятся `3` целых числа – `a`, `b`, `c`. Требуется в переменную `a` записать минимальное из этих чисел, в `b` – среднее и в `c` – максимальное.
Алгоритм решения этой задачи такой: сначала сравним значения переменных `a` и `b`, если значение `a` - больше, поменяем их местами. После этого сравним значения переменных `a` и `с`, и если значение `a` - больше, поменяем их местами. После этих двух сравнений в переменной `a` гарантированно окажется наименьшее из трёх чисел. Осталось сравнить переменные `b` и `c`, и в случае, когда в переменной `b` находится большее значение, поменять их местами.
Очевидно, что в этом алгоритме у нас три сравнения, следовательно, три последовательных условных оператора. При этом в каждом из них какие-то действия (поменять местами значения двух переменных) нужно выполнять только в ветке then, в ветке else (например, если в первом сравнении в переменной a находится уже более маленькое число, чем в переменной `b`) никаких действий выполнять не нужно. Рассмортим код программы: В этом случае, грамматика языка программирования позволяет вообще не записывать даже слово else. Такая конструкция называется сокращённой формой условного оператора.
var a,b,c,x:integer;
begin
writeln('введите три целых числа ');
readln(a,b,c);
if a>b then begin x:=a; a:=b; b:=x end;
if a>c then begin x:=a; a:=c; c:=x end;
if b>c then begin x:=b; b:=c; c:=x end;
writeln(a,b,c);
readln
end.
Как видно из примера, грамматика языка программирования позволяет вообще не записывать даже слово else, в случае, когда там не надо выполнять никаких действий. Такая конструкция называется сокращённой формой условного оператора. При использовании сокращённой формы условного оператора, если при вычислении логического выражения получилось значение false, то управление передаётся на следующий оператор программы.
Использование сокращённой формы условного оператора порождает проблему неоднозначности интерпретации логики действий программы в случае вложенных условных операторов. Рассмотрим следующий пример:
if x>0
then if y>0
then z:=0
else c:=7;
Вопрос состоит в том, какой из двух условных операторов является полным, а какой - сокращённым. К сожалению, ответ на этот вопрос существует только в виде дополнительного семантического правила языка программирования. Принято, что ветка else всегда относится к ближайшему if без else (по принципу правильной скобочной системы). То есть, в нашем случае внутренний условный оператор является полным, а внешний - сокращённым. Если же мы хотим добиться обратной логики действий (чтобы внешний условный оператор был полным), нам необходимо заключить внутренний условный оператор в операторные скобки. Выглядеть это будет следующим образом:
if x>0
then begin
if y>0
then z:=0
end
else c:=7;
При написании программ с ветвлениями очень часто возникает ситуация, когда ветвей становится слишком много. Поэтому приходится задумываться о том, как ничего не упустить из рассмотрения, как не рассматривать несущественные случаи и как обеспечить выполнение ровно одной ветви при разборе случаев.
Начнём с ответа на последний вопрос. Для того, чтобы обеспечить выполнение ровно одной ветви алгоритма, необходимо записывать весь разбор случаев в виде одного условного оператора. Конечно же, он будет сложный, с вложенными многоуровневыми проверками. Однако, если в итоге условный оператор, реализующий разбор случаев, один (а не несколько, записанных через точку с запятой), то это гарантирует нам, что в итоге выполнится ровно одна ветвь алгоритма.
Для того, чтобы не упустить из рассмотрения никаких случаев и не рассматривать несущественные случаи, нужно перебирать их не в случайном порядке, а по какой-либо стратегии. Сейчас мы рассмотрим одну из стратегий разбора случаев, которую условно можно назвать «Естественное возникновение». Её суть заключается в следующем: Изначально, мы решаем задачу так, будто бы никакого деления на случаи нет, а появляется оно лишь тогда, когда выполнить основной сценарий невозможно.
Рассмотрим следующий пример задачи:
Решить в целых числах линейное уравнение `ax=b`.
На вход программе здесь будут подаваться коэффициенты уравнения, а программа должна будет либо вычислить корень, либо вывести сообщение об особой ситуации (нет корней, бесконечно много корней и т. д.). Будем разбирать случаи согласно нашей стратегии. Сначала посмотрим, как мы в принципе решаем подобное уравнение. Для нахождения значения `x` нужно коэффициент `b` разделить на коэффициент `a`. Очевидно, что это невозможно сделать, если `a=0`. Поэтому первая проверка, которая делит всё множество случаев на две принципиально разные ветки: верно ли, что `a=0`? Если это так, то у нас получается уравнение `0x=b`, существование решений которого зависит от значения `b`. Если `b=0`, то решений бесконечно много, если же это не так, то решений нет вообще. Вернёмся к проверке коэффициента `a`. Если он не равен нулю, то это означает, что уравнение имеет единственное решение. Вопрос теперь в том, целое оно или нет. Поэтому здесь нужно будет проверить, что `b` нацело делится на `a` (остаток от деления должен быть равен нулю). Если это так, то находится единственное решение, если же нет, то целых решений у уравнения нет. Запишем теперь все наши рассуждения в виде программы:
var a,b:integer;
begin
readln(a,b);
if a=0
then if b=0
then writeln('many solutions')
else writeln('no solution')
else if b mod a = 0
then writeln( b div a)
else writeln('no solution')
end.
Мы видим, что программа получилось достаточно удобно читаемой и содержит только очень простые проверки (без логических связок). Простота проверок является одним из существенных достоинств используемой стратегии разбора случаев. К сожалению, это именно стратегия, а не алгоритм. Поэтому существует много задач, где такое рассуждение не сработает, однако рекомендуется взять данный метод на вооружение.
Теперь вам будут предложены контрольные вопросы и задачи. За каждый правильный ответ будут ставиться баллы. Максимальное количество баллов за задание указано в скобках после его номера. Если задание стоит более одного балла, то возможно получить частичный балл за частично верное решение. Имейте в виду, что более объёмные и сложные задания стоят дороже. Итоговая оценка будет определяться по сумме набранных баллов. Желаем успеха!
1.1 Алгоритмическая конструкция «Цикл»
Зачастую в задаче нужно повторять одни и те же действия много раз. Рассмотрим следующий пример: вывести на экран квадраты чисел от `1` до `100`.
Очевидно, что для решения этой задачи нам придётся `100` раз выполнять команду вывода соответствующего числа на экран. Писать `100` операторов вывода как-то не хочется (слишком трудоёмко), поэтому будем знакомиться с алгоритмической конструкцией, которая называется «цикл».
называется повторение фрагмента алгоритма несколько раз с возвратом в более раннюю точку исполнения алгоритма. Повторяемый при этом фрагмент алгоритма называется телом цикла.
Очевидно, что если возврат в более раннюю точку алгоритма происходит абсолютно всегда, то алгоритм никогда не доходит до своего завершения (выполняется бесконечно долго). Для предотвращения бесконечного повторения нужно поставить точку ветвления: в одной из веток будет возврат, а в другой - выход из цикла и дальнейшее продвижение по алгоритму.
В зависимости от положения точки ветвления выделяются циклы с предусловием (точка ветвления располагается перед телом цикла) и с постусловием (точка ветвления располагается после тела цикла).
1.2. Оператор while
В языке программирования есть несколько операторов цикла, реализующих как конструкцию с предусловием, так и конструкцию с постусловием. Познакомимся с ними.
Первый оператор цикла называется While и реализует алгоритмическую конструкцию с предусловием. В общем виде он записывается следующим образом:
while условие do оператор
Слова while и do являются служебными зарезервированными словами языка. Под условием (аналогично оператору if) понимается выражение, результат вычисления которого имеет тип boolean. Работает этот оператор следующим образом. Сначала вычисляется условие. Если в результате получилось true, то мы заходим в цикл, то есть выполняем тело цикла и возвращаемся вновь к вычислению условия. Если же получилось false, то происходит переход к следующему оператору в программы, и входа в цикл не будет. Фактически оператор while является многократным применением оператора if с пустой веткой else. Аналогично оператору if, тело цикла должно состоять из `1` оператора. Если нужно исполнить несколько, то следует использовать операторные скобки (begin end).
Возможна ситуация, когда цикл будет выполняться бесконечное количество раз (зациклится). Например, while 2*2=4 do… Что написать после do, совершенно не важно, важно, что оно будет выполняться, пока 2*2=4, а это всегда так, и никогда не изменится. Значит, чтобы избегать зацикливания, параметры условия должны быть переменными, например while x*x=4 do … Хотя это тоже не гарантирует отсутствие зацикливания. Поэтому при написании программ нужно всегда внимательно следить за тем, какие условия мы пишем в операторе цикла, чтобы не случилось ситуации зацикливания.
Также обратите внимание, что поскольку условие проверяется до входа в цикл, возможна ситуация, что при первой же проверке получится значение false и, соответственно, в цикл мы вообще не зайдём.
1.3. Примеры задач
Рассмотрим несколько примеров задач на оператор цикла.
Дано целое число, не меньшее `2`. Выведите его наименьший натуральный делитель, отличный от `1`.
Для решения этой задачи нам необходимо перебирать натуральные числа, начиная с двух и проверять каждое из них, не является ли оно делителем исходного числа. Процесс завершается, когда делитель найден. Очевидно, что процесс завершится всегда, поскольку в худшем случае число разделится само на себя. Приведём код программы.
var i,n:integer;
begin
readln(n);
i:=2;
while n mod i <> 0 do
i:=i+1;
end;
writeln (i);
end.
В первый день спортсмен пробежал `x` километров, а затем он каждый день увеличивал пробег на `10%` от предыдущего значения. По данному числу `y` определите номер дня, на который пробег спортсмена составит не менее `y` километров. Программа получает на вход действительные числа `x` и `y`. Программа должна вывести одно натуральное число.
В этой задаче нам нужно реализовать постепенное увеличение пробега. То есть, на каждом шаге цикла мы будем сохранять значение пробега в соответствующий день в одной переменной, а номер этого дня – в другой. Завершение, когда значение первой переменной станет не меньшим чем `y`. Приведём код программы. Все переменные, отвечающие за километры, имеют тип real (из условия).
var x,y:real; i:integer;
begin
readln(x,y);
i:=1;
while x<y do begin
x:=x/100*10+x;
i:=i+1;
end;
writeln(i);
end.
Дано натуральное число `N`. Вычислите его сумму цифр.
Для решения этой задачи на каждом шаге цикла нужно изменять наше число: при помощи операции mod можно выделить последнюю цифру из числа и прибавить её к сумме, а затем её надо выбросить из числа при помощи операции div. Делить нужно, естественно, на `10`. Критерий завершения – когда число станет равным нулю, ибо это будет означать, что мы уже рассмотрели все цифры и поделили на `10` однозначное число (по свойствам операции целочисленного деления известно, что при делении меньшего числа на большее получается ноль). Приведём код программы.
var a,n,s:integer;
begin
readln(n);
s:=0;
while n>0 do begin
a:=n mod 10;
s:=s+a;
n:=n div 10;
end;
writeln(s);
end.
Ввести целое число `n`. Вывести `"YES"`, если оно простое, и `"NO"`, если оно составное.
Эта задача демонстрирует сразу две важные вещи. Во-первых, как проверять делимость целых чисел, а во-вторых, технику флажков. Флажком называется переменная, которая имеет некоторое начальное значение и меняет его, если происходит определённое событие. Как правило, флажок имеет тип boolean.
В нашей задаче мы будем перебирать числа от `2` до квадратного корня из `n` и проверять, делится ли `n` на каждое из них. Изначально предположим, что `n` - простое, и присвоим флажку значение true, но если `n` поделится на какое-нибудь число, это будет значить, что оно составное, и, соответственно, флажок «упадёт» на значение false. Проверять на делимость нужно, сравнивая остаток от деления с нулём.
var n,i:integer;
f:boolean;
begin
readln(n);
f:=true;
for i:=2 to round(sqrt(n)) do
if n mod i = 0 then f:=false else;
if f=true
then writeln('YES')
else writeln('NO');
end.
1.4 Оператор repeat
Теперь познакомимся с другим оператором цикла, который реализует алгоритмическую конструкцию цикла с постусловием. Рассмотрим его синтаксис.
repeat
Оператор 1;
Оператор 2;
….
Оператор N
until условие
Все операторы, написанные между repeat и until, являются телом цикла. Это выгодно отличает оператор repeat от других циклов - составной оператор здесь не требуется, а операторными скобками можно считать слова repeat и until. Работает этот оператор по следующему алгоритму:
1) выполняется тело цикла;
2) вычисляется значение условия. Если получилось true, то выход из цикла и переход к следующему оператору программы, в противном случае переход к пункту 1.
Отличительная особенность оператора цикла repeat заключается в том, что тело всегда выполняется, по крайней мере, один раз. Это нужно учитывать в задачах при выборе оператора цикла. Аналогично оператору while, цикл repeat может зациклиться, правда в случае, когда условие никогда не принимает значение true, например, repeat…until 2*2=5.
Этот оператор цикла реализует следующую идею: «Повторять некоторую последовательность команд `N` раз, где `N` известно до начала повторения». Познакомимся с синтаксисом этого оператора.
for имя переменной := начальное значение to конечное значение do оператор
В этой конструкции переменная, стоящая после слова for, называется параметром или счётчиком цикла, а оператор, стоящий после слова do, называется телом цикла. Начальное и конечное значения, по сути, являются константами или выражениями одного типа со счётчиком. Алгоритм выполнения цикла for следующий:
1) вычисляются начальное и конечное значения;
2) счётчику цикла присваивается начальное значение;
3) значение счётчика сравнивается с конечным. Если оно больше ко-нечного, то выполнение цикла завершается и начинает выполняться следующий оператор программы, в противном случае переход к пункту 4;
4) выполняется тело цикла;
5) значение счётчика увеличивается на `1`;
6) переход к пункту 3.
В качестве примера рассмотрим решение задачи, поставленной в самом начале. В качестве счётчика будем использовать переменную i.
var i:integer;
begin
for i:=1 to 100 do write(i*i,' ');
end.
Согласитесь, что решение фактически в одну строчку выглядит гораздо приятнее, чем в `100` строк (если не пользоваться оператором цикла).
Необходимо сделать несколько замечаний по поводу цикла for.
1) Типы счётчика начального и конечного значений должны совпадать, при этом в настоящий момент из известных нам типов можно использовать только integer и boolean. Вещественный тип использовать нельзя.
2) Начальное и конечное значения вычисляются один раз до начала цикла (и после не перевычисляются). Рассмотрим пример.
i:=1; for i:=i to i do writeln('HI');
Этот оператор цикла выполнится всего один раз, а не бесконечно много.
3) В теле цикла значение счётчика изменять нельзя. Так прописано в стандарте языка Pascal, и это требование поддерживается в системах семейства Delphi и PascalABC. Однако в системах семейства Borland Pascal значение счётчика изменять можно, что может приводить к непредсказуемым последствиям (поэтому будем считать, что независимо от системы значение счётчика изменять нельзя).
4) После завершения цикла значение счётчика не определено, то есть нельзя считать, что оно равно конечному значению или больше на единицу и пользоваться этим в дальнейшем алгоритме.
5) Тело цикла по грамматике должно состоять только из `1` оператора. Если же там по алгоритму должно быть несколько, нужно использовать составной оператор. В этом смысле оператор for солидарен с операторами if и while.
6) Можно слово to заменить на слово downto. В этом случае значение счётчика после каждого выполнения тела цикла будет уменьшаться на `1`, а выход из цикла произойдёт, когда значение счётчика окажется меньше, чем конечное.
Выполнение любого оператора цикла можно завершить досрочно, если использовать процедуру break. На данном этапе она особенно актуальна, если надо досрочно прервать цикл for. Выполнение этой процедуры передаст управление на оператор, который следует за прерываемым оператором цикла.
Проиллюстрируем её работу следующим примером:
вводится натуральное число `x` `(2 <= x <= 30000)`. Выведите наименьший делитель числа `x`, отличный от `1`.
Мы уже разбирали алгоритм решения этой задачи выше. Продемонстрируем его с использованием цикла for.
var a,i: integer;
begin
readln(a);
for i := 2 to a do
if a mod i = 0 then
begin
writeln(i);
break;
end;
end.
В данном классе формулировка всех задач начинается со слов: «Вводится последовательность чего-нибудь…». Для простоты будем считать, что чисел - с ними мы умеем работать, но в общем случае это необязательно так. Далее нам нужно оценить какое-то свойство данной последовательности. Например, сколько в ней нулей, является ли она возрастающей (каждое следующее число больше предыдущего) и т. д. Причём, для оценки данного свойства, сохранение всей последовательности в памяти не требуется.
Общий алгоритм решения задач этого класса таков: мы считываем очередной элемент последовательности, обрабатываем его так, как поставлено в задаче, и после про него забываем. Для реализации данного алгоритма нам придётся поместить оператор ввода внутрь цикла.
Рассмотрим стандартные шаблоны решения задач данного класса:
Количество элементов в последовательности известно заранее (`N`).
readln(N);
for j:=1 to N do begin
read(a);
{Содержательна обработка}
end;
Обращаем внимание, что внутрь оператора цикла обязательно помещается оператор read, а не readln. Дело в том, что, как правило, числа будут вводиться в строчку и оператор ввода будет на каждом шаге забирать из буфера по `1` числу. Оператор readln при этом ещё удаляет из буфера всё лишнее до конца строки, поэтому числа прочитаны не будут. Количество элементов последовательности, как правило, задаётся отдельным числом в первой строке, поэтому его логичнее читать оператором readln.
Рассмотрим примеры задач данного класса.
Вводится натуральное число `N`, а затем `N` натуральных чисел, сумму которых необходимо вычислить.
var i,N,a,s:integer;
begin
readln(N);
s:=0;
for i:=1 to N do begin
read(a);
s:=s+a;
end;
writeln(s)
end.
Вводится натуральное число `N`, а затем `N` целых чисел. Выведите `"YES"`, если среди введенных чисел есть хотя бы один ноль, или `"NO"` в противном случае.
var n,i,k,a,s:integer;
begin
s:=0;
readln(n);
for i:=1 to n do begin
read(a);
if a=0 then k:=k+1;
end;
if k<>0
then writeln('YES')
else writeln('NO')
end.
Теперь рассмотрим второй тип задач из класса «Обработка последовательностей», когда количество элементов неизвестно заранее, но известен признак конца.
Признак конца - это служебный элемент, который в саму последовательность не входит. При обработке числовых последовательностей чаще всего признаком конца является ноль (но может быть и любое другое число). Наиболее распространённая ошибка - обработать признак конца как содержательный элемент (например, при расчёте среднего арифметического элементов последовательности). Поэтому порядок действий должен быть таким:
1) Считывание
2) Проверка на признак конца
3) Содержательная обработка
За 3 пунктом алгоритм замыкается в цикл. Выход из цикла - на втором пункте, в случае положительного ответа. Соответственно, шаблон алгоритма должен отражать данную логику действий.
read(a);
while a<>0 do begin
{содержательная обработка};
read(a)
end;
В теле цикла оператор ввода ставится последним, чтобы следующим действием за вводом было вычисление условия цикла (то есть, проверка на признак конца).
Программа получает на вход последовательность целых неотрицательных чисел. Ноль - признак конца. Вывести количество членов последовательности (не считая завершающего числа `0`).
var a,k:integer;
begin
read(a);
k:=0;
while a<>0 do begin
k:=k+1;
read(a);
end;
writeln(k);
end.
Вводится последовательность целых чисел. Ноль - признак конца. Вывести, сколько элементов данной последовательности больше (строго) предыдущего элемента.
При решении этой задачи нам нужно будет сохранять в отдельную переменную значение предыдущего числа перед вводом нового. Приведём код программы.
var a,pr,k:integer;
begin
read(a);
pr:=a;
k:=0;
while a<>0 do begin
if (a > pr) then k:=k+1;
pr:=a;
read(a);
end;
writeln(k);
end.
Вводится последовательность натуральных чисел. Ноль - признак конца. Вывести значение максимального элемента.
Это очень важная эталонная задача, которую обязательно надо уметь решать. Для поиска максимума применяется следующая стратегия. Нужно каждый элемент сравнить с текущим значением максимума и, если элемент оказался больше, то обновить текущее значение максимума. Рассмотрим код программы.
var a,m:integer;
begin
read(a);
m:=a;
while a<>0 do begin
if (a > m) then m:=a;
read(a);
end;
writeln(m);
end.
При решении этой задачи ещё остался вопрос корректной инициализации. В общем случае есть два способа.
Первый вариант - в качестве начального значения максимума брать «минус бесконечность» (для минимума - плюс бесконечность). Под «минус бесконечностью» в данном случае понимается некое число, которое гарантированно меньше чем любой элемент, который может нам встретиться. Инициализация бесконечностью допустима, если мы заранее знаем диапазон элементов последовательности. Это её недостаток, зато она пишется в один оператор присваивания.
Второй вариант - в качестве начального значения брать первый подходящий элемент последовательности. В случае глобального максимума берётся просто первый элемент последовательности. Сложнее в ситуации, когда первый элемент может оказаться неподходящим.
Найти максимальный чётный элемент последовательности в предположении, что он существует.
var a,m:integer;
begin
read(a);
while (a<>0)and(a mod 2 <> 0) do read(a);
m:=a;
while a<>0 do begin
if (a mod 2 = 0)and(a>m) then m:=a;
read(a);
end;
writeln(m);
end.
Мы рады приветствовать вас на курсе Информатики. Данный курс рассчитан на три года обучения. Ориентировочно, это девятый, десятый и одиннадцатый классы средней школы. Поэтому в ходе изложения будут использоваться соответствующие знания из курсов математики.
Данный курс состоит из трёх больших частей, которые будут чередоваться по заданиям. Первая часть курса – теоретическая. В ней будут рассматриваться общие знания, которые необходимы любому человеку, собирающемуся связать свою жизнь с техническими специальностями. В частности, будут рассматриваться особенности представления информации различного вида (числовая, текстовая, графическая и т. д.), алгебра логики, математическая теория информации, теория алгоритмов и многое другое.
Вторая часть курса – программистская. В этой части мы будем рассматривать основные концепции языков программирования и учиться писать полноценные программы. Вас ждёт большое множес-тво задач самого разного вида. По завершении курса вы сможете не просто писать программы на одном языке программирования, но уже будете обладать достаточными знаниями, чтобы самостоятельно легко изучать другие языки.
Третья часть курса – технологическая. Здесь будут рассматриваться информационно-коммуникационные технологии. В частности, компьютерные сети, обработка баз данных, работа с электронными таблицами и т. д.
На первом году обучения теоретических заданий не будет, а основная масса будет посвящена программистской части курса. Основная цель первого года обучения – овладеть языком программирования как инструментом для дальнейшего использования. В качестве учебного языка программирования мы выберем язык Pascal. Тому есть несколько причин. Во-первых, этот язык изначально создавался для обучения программированию, и в нём нет большого количества сложных тонкостей, для понимания которых требуются глубокие специальные знания (как, например, в языках C/C++). Во-вторых, концептуально Pascal является каноническим языком процедурной парадигмы программирования, и после него можно очень легко переходить на любые другие языки.
Также нам будет интересно не просто решить конкретную задачу, а овладеть стратегиями для решения больших классов задач. Нужно будет научиться видеть общие моменты в предлагаемых задачах и сформировать определённые шаблоны для быстрого написания программ. Кроме того, особое внимание мы будем уделять красоте и эффективности алгоритмов.
Для выполнения заданий программистской части курса вам будет необходимо установить себе среду программирования, либо воспользоваться online-компилятором. Имейте в виду, что даже для языка Pascal различные среды программирования могут серьёзно различаться (например, free pascal и Pascal ABC.NET). Мы будем обращать внимание на данные различия по ходу изложения материала.
В рамках первого задания мы будем изучать основы языка программирования и особенности выполнения арифметических операций.
Ввести значения $$ x$$ и $$ n$$. Вычислить сумму ряда $$ 1+x+{x}^{2}+{x}^{3}+\dots +{x}^{n}$$.
Сумма вычисляется накопительным путём: сначала вычисляется каждое слагаемое, а потом оно добавляется в сумму. Каждое слагаемое также вычисляется накопительным путём.
var x,n,i,s,a:integer;
begin
write('введите значения x и n');
readln(x,n);
S:=1; a:=1
for i:=1 to n do
begin
a:=a*x; s:=s+a
end;
writeln(s);
readln
end.
Заметим, что эту задачу можно решить, воспользовавшись формулой суммы первых `n` членов геометрической прогрессии, но наша цель не решить конкретную задачу, а понять принцип накапливания (суммы). Ибо далеко не любая последовательность чисел является геометрической или арифметической прогрессией.
Вводится последовательность натуральных чисел. Признак конца ввода – число `0`. Вывести среднее арифметическое чисел из последовательности (`0` не учитывается).
Эта задача относится к очень важному классу задач – обработка последовательностей с признаком конца и заранее неизвестным количеством элементов. В таких задачах нужно пользоваться операторами while и repeat. Причём, если оговаривается, что последовательность непустая, можно использовать repeat, а если этого не оговаривается, как в данной задаче, то нужно обязательно пользоваться циклом while, так как цикл repeat всегда выполняется, по крайней мере, один раз. Приведём полный текст решения. Переменная `s` подсчитывает сумму элементов последовательности, а переменная `k` – их количество.
var a,s,k:integer;
begin
s:=0; k:=0;
writeln('Введите последовательность натуральных чисел. Ноль – признак конца');
read(a);
while a<>0 do
begin s:=s+a; k:=k+1; read(a) end;
Writeln('среднее арифметическое=',s/k:0:4)
end.
Обратите внимание, что для ввода данных используется оператор read. Это позволяет набивать элементы в строчку через пробел. Если же использовать readln, то набивать значения придётся в столбик, что неудобно. Ещё одно важное замечание в этой задаче – оператор ввода внутри цикла должен быть последним, чтобы сразу попадать на проверку признака конца. Эти замечания относятся ко ВСЕМ задачам на обработку последовательностей с признаком конца.
Ввести целое число `n`. Вывести YES, если оно простое, и NO, если оно составное.
Эта задача демонстрирует сразу две важные вещи. Во-первых, как проверять делимость целых чисел, а во-вторых, технику флажков. Флажком называется переменная, которая имеет некоторое начальное значение и меняет его, если происходит определённое событие. Как правило, флажок имеет тип boolean.
В нашей задаче мы будем перебирать числа от `2` до квадратного корня из `n` и проверять, делится ли `n` на каждое из них. Изначально предположим, что `n` – простое, и присвоим флажку значение true, но если `n` поделится на какое-нибудь число, это будет значить, что оно составное, и, соответственно, флажок «упадёт» на значение false. Проверять на делимость нужно, сравнивая остаток от деления с нулём.
var n,i:integer;
f:boolean;
begin
Write('Введите значение n ');
Readln(n);
f:=true;
for i:=2 to round(sqrt(n)) do
if n mod i = 0 then f:=false else;
if f=true
then writeln('YES')
else writeln('NO');
Readln
end.
Зачастую в задаче нужно повторять одни и те же действия много раз. Повтор некоторого фрагмента программы несколько раз называется циклом. Рассмотрим следующий пример.
Вывести на экран квадраты чисел от `1` до `100`.
Очевидно, что для решения этой задачи нам придётся `100` раз выполнять команду вывода соответствующего числа на экран. Писать `100` операторов вывода как-то не хочется (слишком трудоёмко), поэтому будем знакомиться с операторами цикла. В языке Pascal существует три оператора цикла: for, while, repeat. Начнём с цикла for. Этот оператор цикла реализует следующую идею: «Повторять некоторую последовательность команд `N` раз, где `N` известно до начала повторения». Познакомимся с синтаксисом этого оператора.
for имя переменной := начальное значение to конечное значение do оператор
В этой конструкции переменная, стоящая после слова for, называется параметром или счётчиком цикла, а оператор, стоящий после слова do, называется телом цикла. Начальное и конечное значения, по сути, являются константами или выражениями одного типа со счётчиком.
Алгоритм выполнения цикла for следующий:
1) вычисляются начальное и конечное значения;
2) счётчику цикла присваивается начальное значение;
3) значение счётчика сравнивается с конечным. Если оно больше конечного, то выполнение цикла завершается и начинает выполняться следующий оператор программы, в противном случае переход к пункту 4;
4) выполняется тело цикла;
5) значение счётчика увеличивается на `1`;
6) переход к пункту 3.
В качестве примера рассмотрим решение задачи, поставленной выше. В качестве счётчика будем использовать переменную `i`.
var i:integer;
begin
for i:=1 to 100 do write(i*i,' ');
Readln
end.
Согласитесь, что решение фактически в одну строчку выглядит гораздо приятнее, чем в `100` строк (если не пользоваться оператором цикла).
Необходимо сделать несколько замечаний по поводу цикла for.
1) Типы счётчика начального и конечного значений должны совпадать, при этом в настоящий момент из известных нам типов можно использовать только integer и boolean. Вещественный тип использовать нельзя.
2) Начальное и конечное значения вычисляются один раз до начала цикла (и после не перевычисляются). Рассмотрим пример.
i:=1; for i:=i to i do writeln('HI');
Этот оператор цикла выполнится всего один раз, а не бесконечно много.
3) В теле цикла значение счётчика изменять нельзя. Так прописано в стандарте языка Pascal, и это требование поддерживается в системах семейства Delphi. Однако в системах семейства Borland Pascal значение счётчика изменять можно, что может приводить к непредсказуемым последствиям (поэтому будем считать, что независимо от системы значение счётчика изменять нельзя).
4) После завершения цикла значение счётчика не определено, то есть нельзя считать, что оно равно конечному значению или больше на единицу и пользоваться этим в дальнейшем алгоритме.
5) Тело цикла по грамматике должно состоять только из `1` оператора. Если же там по алгоритму должно быть несколько, нужно использовать составной оператор.
6) Можно слово to заменить на слово downto. В этом случае значение счётчика после каждого выполнения тела цикла будет уменьшаться на `1`, а выход из цикла произойдёт, когда значение счётчика окажется меньше, чем конечное.
Перейдём к знакомству с другими операторами цикла: while и repeat. Эти операторы реализуют следующие идеи: «Повторять некоторую последовательность команд пока выполняется некоторое условие» (цикл while) и «Повторять некоторую последовательность команд до тех пор, пока не выполнится некоторое условие» (цикл repeat). Познакомимся с синтаксисом оператора цикла while.
while условие do оператор.
После слова while должно быть логическое выражение (называемое условием), которое может принимать значение true или false. Оператор, стоящий после do, аналогично оператору for является телом цикла. Выполняется цикл while так:
1) вычисляется значение условия, если получилось true, то переход к пункту 2, иначе выход из цикла и переход на следующий оператор программы;
2) выполняется тело цикла;
3) переход к пункту 1.
Фактически оператор while является многократным применением оператора if с пустой веткой else. Аналогично оператору for, тело цикла должно состоять из `1` оператора. Однако в отличие от цикла for возможна ситуация, когда цикл будет выполняться бесконечное количество раз (зациклится). Например, while 2*2=4 do...
Что написать после do, совершенно не важно, важно, что оно будет выполняться, пока 2*2=4, а это всегда так и никогда не изменится.
Значит, чтобы избегать зацикливания, параметры условия должны быть переменными, например while x*x=4 do ... Хотя это тоже не гарантирует отсутствие зацикливания.
Осталось познакомиться с последним оператором цикла. Рассмотрим его синтаксис.
repeat
Оператор 1;
Оператор 2;
....
Оператор N
until условие
Все операторы, написанные между repeat и until, являются телом цикла. Это выгодно отличает оператор repeat от других циклов – составной оператор здесь не требуется, а операторными скобками можно считать слова repeat и until. Работает этот оператор по следующему алгоритму:
1) выполняется тело цикла;
2) вычисляется значение условия. Если получилось true, то выход из цикла и переход к следующему оператору программы, в противном случае переход к пункту 1.
Отличительная особенность оператора цикла repeat заключается в том, что тело всегда выполняется, по крайней мере, один раз. Это нужно учитывать в задачах при выборе оператора цикла. Аналогично оператору while, цикл repeat может зациклиться, правда в случае, когда условие никогда не принимает значение true, например,
repeat...until 2*2=5.
В рассматриваемых ранее задачах процесс вычисления был линейным, то есть программа не должна была выполнять разные действия в зависимости от того, какие данные ей ввели. Теперь вспомним задачи с ветвящимся алгоритмом.
Ввести номер года. Вывести слово YES, если год високосный, и NO, если он – не високосный.
По условию очевидно, что в зависимости от входных данных программа должна будет выполнить один из двух операторов вывода: Writeln('YES') или Writeln('NO'). При этом написать в программе нам придётся оба, а вот выполняться должен будет только один из них. Для того чтобы реализовывать подобные ветвления алгоритма, в языке Pascal существует условный оператор. В общем виде он выглядит следующим образом:
if логическое выражение
then оператор
else оператор
В этой конструкции слова if, then и else являются служебными зарезервированными словами языка. Работает эта конструкция так: сначала вычисляется логическое выражение, стоящее после if. Если получилось значение true, то выполняется оператор, стоящий после слова then, а если получилось значение false, то выполняется оператор, стоящий после слова else.
Обратите внимание, что внутри условного оператора нет никаких точек с запятой, поскольку он является единой конструкцией, а точка с запятой – это разделитель между операторами. Для удобства чтения программ принято условие записывать на одной строке, а ветви then и else начинать с новой строки, однако это не является синтаксическим правилом языка.
В качестве примера условного оператора рассмотрим решение задачи, поставленной выше. Год считается високосным, если он делится нацело на `400`, или если он делится нацело на `4`, но не делится нацело на `100`. Приведём полный текст решения:
var y:integer;
begin
write('Введите номер года ');
readln(y);
if (y mod 400 = 0)or(y mod 4 = 0)and(y mod 100 <> 0)
then writeln('YES')
else writeln('NO');
end.
По грамматике языка после слов then и else должен стоять только один оператор языка. То есть запись if x>0 then x:=4; y:=0 else z:=9; является синтаксически неверной. А как быть, если всё-таки нужно выполнить более одного оператора? Для таких случаев в языке Pascal предусмотрен составной оператор, который позволяет превратить группу операторов в один. Выглядит он следующим образом: сначала записывается ключевое слово begin, далее – интересующая нас последовательность операторов через точку с запятой, а в конце пишется ключевое слово end. В отличие от конца программы, точка после этого слова не ставится. Слова begin и end называются операторными скобками. Запишем правильную версию условного оператора, приведённого выше: if x>0 then begin x:=4; y:=0 end else z:=9;
Обратите внимание на следующий тонкий момент: если требуется выполнить более одного оператора в ветке then, и при этом мы забудем написать операторные скобки, то это является синтаксической ошибкой, и программа просто не будет работать. Если же забыть написать операторные скобки в ветке else, то программа работать будет, но не так, как предполагалось. Рассмотрим пример: if x>0 then y:=9 else z:=8; c:=5;
В этом примере условный оператор заканчивается после z:=8; в то время как оператор c:=5; является следующим оператором программы и выполняется независимо от результата сравнения `x` с нулём. Если же написать операторные скобки, то присваивание в `c` числа `5` произойдёт только в случае x<=0.
Последнее замечание заключается в том, что в ветке else в качестве оператора может стоять и пустой оператор.
Рассмотрим следующий пример.
Вводятся `3` целых числа – `a`,`b`,`c`. Требуется в переменную `a` записать минимальное из этих чисел, в `b` – среднее и в `c` – максимальное.
Алгоритм решения этой задачи такой: сначала сравним значения переменных `a` и `b`, если значение `a` – больше, поменяем их местами. После этого сравним значения переменных `a` и `c`, и если значение `a` – больше, поменяем их местами. После этих двух сравнений в переменной `a` гарантированно окажется наименьшее из трёх чисел. Осталось сравнить переменные `b` и `c`, и в случае, когда в переменной `b` находится большее значение, поменять их местами.
Очевидно, что в этом алгоритме у нас три сравнения, следовательно, три последовательных условных оператора. При этом в каждом из них какие-то действия (поменять местами значения двух переменных) нужно выполнять только в ветке then, в ветке else (например, если в первом сравнении в переменной a находится уже более маленькое число, чем в переменной `b`) никаких действий выполнять не нужно. Но мы всё равно будем её записывать, чтобы избегать путаницы. Приведём полный текст решения, используя для обмена значений двух переменных дополнительную переменную `x`.
var a,b,c,x:integer;
begin
writeln('введите три целых числа ');
readln(a,b,c);
if a>b then begin x:=a; a:=b; b:=x end
else;
if a>c then begin x:=a; a:=c; c:=x end
else;
if b>c then begin x:=b; b:=c; c:=x end
else;
writeln(a,b,c);
end.
В языке Pascal кроме уже изученных нами числовых типов ещё есть логический, который называется Boolean. Переменные этого типа занимают `1` байт оперативной памяти и могут принимать всего два значения – true и false (истина и ложь). Логическим переменным можно присваивать значения точно так же, как и числовым. Так же можно выводить их значения на экран, а вот вводить их с клавиатуры нельзя!
В языке Pascal определены `6` операций сравнения, результатом которых является логическое значение. Это операции: «больше» (>), «больше или равно» (>=), «меньше» (<), «меньше или равно» (<=), «равно» (=), и «не равно» (<>). Например, операция 5 > 2 выдаст значение true, а операция x<>3 выдаст значение true, если переменная `X` имеет любое значение, кроме `3`. Сравнивать можно не только числа (причём как целые, так и вещественные), но и логические значения. При этом считается, что значение true больше, чем значение false.
Помимо операций сравнения ещё существуют и логические операции: AND (конъюнкция, логическое умножение, операция «И»), OR (дизъюнкция, логическое сложение, операция «ИЛИ»), NOT (отрицание, инверсия), XOR (строгая дизъюнкция, исключающее «ИЛИ», сложение по модулю `2`). В скобках указаны возможные названия данных операций в алгебре логики. Операнды этих операций должны быть логического типа. Результат вычислений также будет логический. При этом операции AND, OR, XOR имеют по два операнда, а операция NOT – всего один, который записывается справа от названия операции. Названия логических операций являются ключевыми словами языка. Приведём таблицы результатов логических операций для всех возможных значений операндов (в алгебре логики такие таблицы называются таблицами истинности):
| x | not x |
| false |
true |
|
true |
false |
|
x |
y | x and y |
x or y |
x xor y |
| false | false | false | false | false |
| false | true | false | true | true |
| true | false | false | true | true |
| true | true | true | true | false |
Логический результат даёт также стандартная функция odd(x), которая применяется к целочисленному аргументу `x`:
odd(x) = true, если `x` нечётно;
odd(x) = false, если `x` чётно.
Приоритет операций в логическом выражении следующий:
1) Операция NOT.
2) Операции группы умножения AND, *, / ,div, mod
3) Операции группы сложения OR, XOR, +, -
4) Операции сравнения >, <, >=, <=, =, <>
Операции одного приоритета выполняются слева направо. Операции в круглых скобках имеют более высокий приоритет, чем операции вне скобок.
Записать логическое выражение, истинное в случае, когда переменная `X` имеет значение из отрезков `[2,5]` или `[-1,1]`.
(X>=2) AND (X<=5) OR (abs(X)<=1).
Теперь воспользуемся всеми полученными знаниями и рассмотрим примеры простейших программ. Условимся в примерах не различать заглавные и строчные буквы, а ключевые слова выделять жирным шрифтом.
Ввести координаты трёх вершин треугольника. Вывести его площадь. Гарантируется, что треугольник существует (ввод корректный).
Для решения этой задачи нам потребуется `6` переменных, в которые будут введены значения координат `(x1, y1, x2, y2, x3, y3)`. Можно сделать их целыми для простоты, а можно вещественными, чтобы решать задачу в более общем случае. Так же потребуются переменные, в которые мы запишем длины сторон треугольника `(a, b, c)` и площадь `(S)`. Эти переменные однозначно должны быть вещественными, так как при вычислении расстояния между точками нам придётся извлекать квадратный корень, и, соответственно, результат получится вещественным. И ещё предлагается ввести вещественную переменную `p`, в которой будет храниться полупериметр треугольника, так как площадь будет вычисляться по формуле Герона. Приведём полный текст программы:
Var x1,y1,x2,y2,x3,y3:integer; a,b,c,p,S:real;
Begin
Write('Введите координаты вершин треугольника ');
Readln(x1,y1,x2,y2,x3,y3);
a:=sqrt(sqr(x1-x2)+sqr(y1-y2));
b:=sqrt(sqr(x1-x3)+sqr(y1-y3));
c:=sqrt(sqr(x2-x3)+sqr(y2-y3));
p:=(a+b+c)/2;
S:=sqrt(p*(p-a)*(p-b)*(p-c));
Writeln('Площадь треугольника равна ',S:5:2);
Readln;
End.
Идёт `k`-ая секунда суток (`k` вводится). Вывести, сколько полных часов `h` и полных минут `m` прошло с начала суток.
В этой задаче все параметры целые. Решается она с помощью операций div и mod. Эти операции можно использовать для «срезания периодов» при переводе мелких единиц измерения в более крупные (например, секунд в минуты). Операция div нам выдаст количество полных периодов (сколько полных минут содержится в большом количестве секунд), а операция mod – количество единиц в последнем неполном периоде (сколько секунд не укладывается в полное количество минут). Приведём полный текст решения.
Var k,h,m:integer;
Begin
Write('Введите номер секунды в сутках');
Readln(k);
h:=k div 3600;
m:=k mod 3600 div 60;
writeln('С начала суток прошло ',h,' часов и ',m,' минут');
readln;
end.
Вводится четырёхзначное число. Вывести произведение его цифр.
Эта задача показывает ещё одно применение операций div и mod – выделение цифр из целого числа. Описанное ниже решение работает только для случая, когда количество цифр в числе заранее известно. В противном случае придётся использовать циклический алгоритм. Приведём текст решения.
Var N,c1,c2,c3,c4:integer;
Begin
Write('Введите целое четырёхзначное число');
Readln(N);
c1:=N div 1000;
c2:=N div 100 mod 10;
c3:=N div 10 mod 10;
c4:=N mod 10;
Writeln('Произведение цифр вашего числа равно',c1*c2*c3*c4);
Readln;
End.
Операторы read и readln предназначены для задания значений переменным путём ввода их с клавиатуры. Правило их применения одно и то же: после слова read или readln в скобках через запятую перечисляются имена переменных, значения которых мы хотим ввести (список ввода). Число этих имён не ограничено. Запятая служит разделителем между именами переменных:
readln(имя, имя, ..., имя)
При срабатывании оператора read или readln выполнение программы будет приостановлено до тех пор, пока пользователь не введёт соответствующее количество значений. Вводимые значения должны быть того же типа, что и переменные. Если в read или readln переменных несколько, то они могут быть набиты в одной строке, но одно число от другого должно отделяться пробелом или переводом строки.
Чтобы выполнить оператор read или readln после набивания значений с клавиатуры, нужно нажать клавишу «Enter». В результате переменные приобретут заданные вами значения. Между read и readln существует единственное различие: после выполнения readln курсор переходит на новую строку, игнорируя всю оставшуюся информацию в прежней строке, а после выполнения read курсор остаётся в той же строке, и новая набивка данных для read или readln будет проходить в той же строке. Но, так как после нажатия клавиши «Enter» курсор в любом случае переходит на новую строчку, для однократного ввода значений переменных разницу между операторами read и readln заметить невозможно. Тем не менее, в данном случае лучше использовать readln. Оператор readln можно использовать и без параметров вообще. Тогда программа просто будет находиться в режиме ожидания, пока пользователь не нажмёт клавишу «Enter». Такой оператор, например, удобно ставить самым последним оператором в программе. Тогда можно сразу посмотреть результат работы программы, а потом нажать «Enter», и только тогда работа программы завершится.
Перед вводом данных с клавиатуры рекомендуется выдавать на экран приглашение, например:
write('Введите число a => ');
readln(a);
Операторы вывода являются важнейшей частью языка программмирования, ведь только благодаря им, мы можем увидеть на экране компьютера результат работы нашей программы. В языке Pascal существует два оператора вывода: write и writeln. Правило их использования одно и то же: после слова write или writeln в скобках через запятую перечисляются параметры, которые мы хотим вывести (называемые списком вывода). Число этих параметров не ограничено. Разделителем между параметрами служит запятая:
writeln(параметр, параметр,...,параметр)
Существует три вида параметров: константы, переменные и выражения (например, арифметические выражения). Константы бывают числовые (это просто различные числа — целые и вещественные), логические и строковые. Любой текст, набранный с клавиатуры и заключённый в апострофы (одиночные кавычки), называется строковой константой. Если в текст нам нужно поместить апостроф, например, в слове O'key, на этом месте нужно набить два апострофа подряд вместо одного: write('O''key'). Все параметры в write или writeln независимы друг от друга, поэтому в одном и том же операторе могут встречаться параметры разных типов, в произвольном порядке.
При выполнении оператора вывода все параметры будут выведены в одной строке в том же порядке, в каком они перечислены в списке параметров. Любая константа, числовая или строковая, будет выведена так, как вы её написали в вызове write или writeln (в строковой константе начальный и конечный апострофы отображаться на экране не будут, а вместо двух апострофов, расположенных в строковой константе подряд, на экране появится в этом месте один); вместо переменной на экране появится её значение, а вместо арифметического выражения — результат его вычисления.
Между write и writeln существует единственное различие: после выполнения writeln курсор переходит на новую строку, а после выполнения write курсор остаётся в той же строке, и новый вывод данных с помощью write или writeln или ввод данных при помощи операторов ввода данных будут проходить в той же строке.
При выводе параметров пробелы между ними автоматически не вставляются, например, при печати чисел 1, 2, 3 с помощью writeln(1,2,3) все они сольются в одно число — 123. Чтобы разделить выводимые элементы, можно поместить между ними символ пробела, например, writeln(1,' ',2,' ',3) или отформатировать вывод, поставив после каждого элемента списка вывода двоеточие и целое число (называемое модификатором ширины поля), которое указывает, сколько позиций на экране должна занимать выводимая величина, например, writeln(1:3,2:3,3:3). Отметим, что элемент дополняется начальными пробелами слева с тем, чтобы соответствовать указанной после двоеточия величине. Результаты выполнения двух последних операторов будут выглядеть так:
| 1_2_3 __1__2__3 |
Если указанное в модификаторе ширины поля число меньше, чем необходимо, то модификатор ширины поля игнорируется.
При выдаче на экран значений вещественных выражений в формате вывода полезно использовать ещё один модификатор, который записывается через двоеточие после модификатора ширины поля и называется модификатором точности. Он будет обозначать количество символов после десятичной точки, которые мы хотим вывести. Например, при выводе результата стандартной функции pi, которая с машинной точностью выдаёт значение числа $$ \pi $$, оператор write(pi:0:0,pi:6:2, pi/2:2:0) выдаст на экран:
3 3.14 2
Заметим, что при печати фиксированного количества цифр вещественного числа оно предварительно округляется по правилам математики. Если вещественное число содержит после десятичной точки меньше цифр, чем количество символов для печати, указанное в модификаторе точности, то число выводится с незначащими нулями, например, оператор write(3.14:3:4) выдаст на экран:
3.1400
Модификатор точности можно применять только к параметрам вещественного типа. Использование модификатора точности с параметрами других типов является критической ошибкой (программа не будет работать). Модификатор ширины поля можно использовать с любым типом параметра вывода.
Арифметические выражения состоят из операций и операндов. В языке программирования Pascal существует шесть операций: сложение (обозначается знаком «+»), вычитание (обозначается знаком «-»), умножение (обозначается знаком «*»), деление (обозначается знаком «/»), деление нацело (обозначается словом «div») и взятие остатка от деления нацело (обозначается словом «mod»). Слова div и mod являются служебными зарезервированными.
Важным понятием в арифметике является понятие операнда. Операндами называются те объекты, над которыми выполняется арифметическая операция. В математике различные операции могут иметь разное количество операндов, но все арифметические имеют два операнда. Операндом для операции может являться как одиночное число или имя переменной, так и целое арифметическое выражение. Рассмотрим выражение (2+2)*2. У операции сложения операндами являются два числа `2`, а у операции умножения правый операнд – это число `2`, а левый – это выражение в скобках `(2+2)`. Прежде чем выполнять операцию, необходимо вычислить оба её операнда.
Приоритет операций в Паскале точно такой же, как и в математике. Сначала выполняются операции умножения, деления, div и mod (это тоже операции деления), а потом операции сложения и вычитания. Операции одного приоритета выполняются слева направо. Для изменения порядка действий можно использовать круглые скобки. Операции в скобках имеют более высокий приоритет, чем операции вне скобок. Так при вычислении выражения 2+2*2 получается число `6`, потому что операция умножения имеет более высокий приоритет, чем сложение, и, следовательно, выполняется первой. Если же записать выражение (2+2)*2, то при вычислении получается число `8`, потому что сложение в скобках выполняется раньше умножения.
Рассмотрим, как определить тип результата при вычислении арифметического выражения. Операции сложения, вычитания и умножения выдают целый результат, если оба их операнда целые, и вещественный, если хотя бы один из операндов – вещественный. Операция деления «/» всегда выдаёт вещественный результат. Даже если мы `4` делили на `2`, всё равно в итоге получается нецелое число. На первый взгляд это кажется странным, но в отличие от математики в программировании каждое число кроме значения ещё имеет тип, и если типы у чисел не совпадают, то они НЕ считаются равными. Нужно уяснить, что `bb(1!=1.0)`. Это несложно понять, если помнить, что раз числа `1` и `1.0` имеют различные типы, то будут представлены совершенно разными последовательностями битов. Операции div и mod всегда выдают целый результат и, в отличие от всех остальных арифметических операций, могут иметь только целые операнды. Попытка применить данные операции к вещественным числам приведёт к тому, что программа просто не будет работать.
Давайте подробнее познакомимся с двумя последними операциями. Операция a div b выдаёт целую часть от деления числа a на число b. То есть 5 div 2 = 2, а 3 div 7 = 0. Операция a mod b выдаёт остаток от деления a на b по следующему закону:
a mod b = a – ((a div b) * b)
Приведём примеры выполнения этих их операций для всех возможных знаков операндов:
5 div 3 = 1; 5 mod 3 = 2;
-5 div 3 = -1; -5 mod 3 = -2;
5 div -3 = -1; 5 mod -3 = 2;
-5 div -3 = 1; -5 mod -3 = -2;
Операндами в арифметическом выражении также могут быть стандартные математические функции, которые приведены в таблице ниже.
| Функция | Комментарий | Тип аргумента | Тип результата |
| abs(x) | $$ │x│$$ — модуль $$ x$$ | integer, real | совпадает с типом аргумента |
| sqr(x) | $$ {x}^{2}$$ | integer, real | совпадает с типом aргумента |
| sqrt(x) | `sqrt x` |
integer, real | real |
| Pi | `3.1415926535897932385` | нет | real |
| sin(x) | $$ \mathrm{sin}x$$ | integer, real | real |
| cos(x) | $$ \mathrm{cos}x$$ | integer, real | real |
| arctan(x) | `"arctg"x` | integer, real | real |
| trunc(x) | отсекание дробной части $$ x$$ | real | integer |
| round(x) | округление $$ x$$ до ближайшего целого. Половины округляются в сторону увеличения модуля. | real | integer |
Необходимо отметить, что функциям sin и cos угол следует подавать в радианах, а не в градусах! Также функция arctan возвращает результат в радианах.
Рассмотрим два основных числовых типа переменных.
Этот тип характеризует целые числа. Переменные этого типа занимают в оперативной памяти `4` байта и могут принимать значения из диапазона
`[ –2147483648, 2147483647]`.
Точное значение запоминать необязательно, главное помнить, что переменная этого типа может вмещать целые числа примерно до `2` миллиардов по модулю.
Этот тип предназначен для работы с вещественными (действительными) числами. Переменные этого типа занимают в оперативной памяти `8` байт. При записи констант этого типа целая часть числа отделяется от дробной точкой, а не запятой, как в математике, например: `3.14`.
Оператор присваивания позволяет изменить значение любой переменной программы (присвоить ей новое значение). Этот оператор выглядит следующим образом: записывается имя переменной, затем знак присваивания (:=), а потом значение, которое мы хотим присвоить переменной. Присвоить можно константу или выражение соответствующего типа.
X:=5; {в переменную `X` присвоили число `5`}
Y:=X; {в переменную `Y` присвоили текущее значение переменной `X`}
Z:=X+Y; {в переменную `Z` присвоили сумму текущих значений переменных `X` и `Y`}
Если переменной присвоено некоторое значение, то в дальнейшем в программе при вычислениях вместо её имени будет подставляться это значение, пока мы не присвоим ей новое.
X:=5;
Y:=X+4; {в переменную `Y` запишется число `9`, так как текущее значение переменной `X` равно `5`}
При использовании операторов присваивания необходимо соблюдать правило совместимости типов.
Это правило заключается в том, что тип присваемого значения должен соответствовать типу переменной, которой мы хотим это значение присвоить.
Есть исключение из этого правила:
переменной типа real можно присвоить целое значение.
