Инфоурок / Информатика / Другие методич. материалы / Материалы по подготовке к олимпиадам по инфрматике
Обращаем Ваше внимание: Министерство образования и науки рекомендует в 2017/2018 учебном году включать в программы воспитания и социализации образовательные события, приуроченные к году экологии (2017 год объявлен годом экологии и особо охраняемых природных территорий в Российской Федерации).

Учителям 1-11 классов и воспитателям дошкольных ОУ вместе с ребятами рекомендуем принять участие в международном конкурсе «Законы экологии», приуроченном к году экологии. Участники конкурса проверят свои знания правил поведения на природе, узнают интересные факты о животных и растениях, занесённых в Красную книгу России. Все ученики будут награждены красочными наградными материалами, а учителя получат бесплатные свидетельства о подготовке участников и призёров международного конкурса.

ПРИЁМ ЗАЯВОК ТОЛЬКО ДО 21 ОКТЯБРЯ!

Конкурс "Законы экологии"

Материалы по подготовке к олимпиадам по инфрматике

Выберите документ из архива для просмотра:

44 КБ Ввод вывод 3 урок.doc
24 КБ Дано два числа гипотенузу.dot
71 КБ Оператор присваивания 2 урок.doc
43 КБ Стандартные функции и процедуры 4 урок.doc
49 КБ Это занятие мы посвятим вопросам программирования обменов с клавиатурой компьютера 7 урок.doc
36.5 КБ Вложенные условные операторы 3 урок.doc
38.5 КБ Оператор выбора CASE 4 урок.doc
36 КБ Переменные логического типа описываются посредством служебного слова BOOLEAN 2 урок.doc
51.5 КБ ветвление 1 урок.doc
37.5 КБ Вставка элементов в одномерный массив.doc
16.4 КБ Доступ к элементам массива.docx
34 КБ Удаление элементов из одномерного массива.doc
32 КБ ерестановка элементов массива.doc
46 КБ Знакомство с языком Паскаль.doc
66.52 КБ оператор присваивания 1 урок начало.pdf
33.5 КБ Тип данных char.doc
49 КБ паскаль 1 урок.doc
33 КБ цикл с постусловием 6 урок.doc
57 КБ цикл с предусловием 5 урок.doc
38 КБ В цикле со счетчиком тело цикла повторяется заранее определенное число раз.doc

Выбранный для просмотра документ Ввод вывод 3 урок.doc

библиотека
материалов

Ввод - вывод. Операторы Read (Readln), Write (Writeln). Простейшие линейные программы

Решим задачу, прокомментировав каждое свое действие в фигурных скобках. Напомним, что комментарий не воспринимается компьютером, а нам он нужен для того, чтобы лучше понять, как работает программа.

Задача. Напишите программу, которая бы очищала экран и вычисляла произведение двух чисел, вводимых пользователем.

Program Proizv2;
Uses
  Crt;{Подключаем модуль Crt}
Var
  number1, {переменная, в которой будет содержаться первое число}
  number2, {переменная, в которой будет содержаться второе число}
  result {переменная, в которой будет содержаться результат}
  : integer;
 
Begin
  ClrScr;{Используем процедуру очистки экрана из модуля Crt}
  Write ('Введите первое число ');
  {Выводим на экран символы, записанные между апострофами}
  Readln (number1);
  {Введенное пользователем число считываем в переменную number1}
  Write ('Введите второе число ');
  {Выводим на экран символы, записанные между апострофами}
  Readln (number2);
  {Введенное пользователем число считываем в переменную number2}
  result := number1 * number2;
  {Находим произведение введенных чисел и присваиваем переменной result}
  Write ('Произведение чисел ', number1, ' и ', number2, ' равно ', result);
  {Выводим на экран строчку, содержащую ответ задачи}
  Readln;{Процедура задержки экрана}
End.

Чтобы лучше понять действие программы, наберите ее на компьютере и проверьте ее действие. Ответьте на вопросы:

  • почему программу назвали Proizv2?

  • зачем в раздел Uses поместили модуль Crt?

  • какое назначение переменных number1, number2, result?

  • какой тип у этих переменных? что это значит?

  • если присвоить переменным number1 и number2 соответственно значение 5 и 7, то какую строчку выдаст компьютер при исполнении последней процедуры Write?

  • в каких строчках у пользователя запрашиваются значения переменных?

  • в какой строчке происходит умножение чисел?

  • что делает оператор присваивания в этой программе?

Задание. Измените программу так, чтобы она запрашивала у пользователя еще одну переменную и выводила результат произведения трех чисел.

Операторы Write и WriteLn

Мы уже использовали операторы Write и WriteLn, но нам необходимо подробнее остановиться на правилах применения этих операторов.

Write (англ. писать) - оператор, который используется для вывода информации на экран. Оператор WriteLn выполняет то же самое действие, но так как у него есть еще окончание Ln (line - англ. линия, строка), то после вывода на экран нужного сообщения, он дополнительно переводит курсор в начало следующей строки.

Общий вид:
  Write (список выражений)
  WriteLn (список выражений)

Процедуры Write и WriteLn используются не только для вывода результата, но и для вывода различных сообщений или запросов. Это позволяет вести диалог с пользователем, сообщать ему, когда ему нужно ввести значения, когда он получает результат, когда он ошибся и др.

Например, при выполнении процедуры WriteLn(‘Найденное число ‘,а), будет напечатана строчка, заключенная в апострофы, а затем выведено значение переменной а.

Оператор WriteLn можно применить и без параметров. В этом случае курсор просто будет переведен в начало следующей строки. Это иногда нам нужно для лучшего восприятия ввода данных.

Операторы Read и ReadLn

Вспомним, что основное назначение ЭВМ - сэкономить человеческий труд. Поэтому необходимо обеспечить возможность, однажды написав программу, многократно ее использовать, вводя каждый раз другие данные. Такая гибкость в языке обеспечивается операторами Read и ReadLn. Этими операторами вводится информация с клавиатуры.

Общий вид:
  Read(переменная, переменная...)
  ReadLn(переменная, переменная...)

При выполнении процедуры Read ожидается ввод перечисленных в скобках значений. Вводимые данные нужно отделить друг от друга пробелами. Присваивание значений идет по очереди.

Например, если вводятся значения 53 и Х, то при выполнении оператора Read(a,b) переменной а будет присвоено число 53, а переменной b - буква Х. Причем, отметим, чтобы не было аварийной ситуации, нужно правильно определить тип данных в разделе Var; в нашем случае а:integer, а b:char.

Особых различий при чтении и записи в использовании операторов Read и ReadLn нет. Часто процедуру ReadLn без параметров применяют в конце программы для задержки: до нажатия на клавишу результат выполнения программы остается на экране. Это очень полезно делать для анализа результатов.

Примечание. Когда Вы ставите задержку экрана, обратите внимание на предыдущий ввод. Если данные запрашивались процедурой Read, задержки не будет.

Решим задачу, в которой рассмотрим все возможные употребления этих процедур.

Задача. Найти среднее значение трех чисел.

Примечание. Чтобы найти среднее значение нескольких чисел, нужно сложить эти числа и сумму разделить на количество этих чисел.

Program Srednee;
Uses
 
  Crt;
Var
  First, Second, Third : integer;
  Sum : real;
Begin
  ClrScr;
  Write ('Введите первое число ');
  ReadLn(First);
  Write ('Введите второе и третье числа через пробел ');
  ReadLn(Second, Third);
  Sum := First + Second + Third;
  Sum := Sum/3;
  Write ('Среднее значение ', First, ', ',Second, ' и ', Third, ' равно ', Sum:5:2);
  ReadLn;
End.

Наберите текст задачи и внимательно рассмотрите каждую строчку. Имя программы Srednee отражает содержание задачи. Кстати, договоримся о том, чтобы имя программы и имя файла, который содержит эту программу, совпадали. Далее идет подключение модуля Crt. В разделе Var описаны First, Second, Third как переменные целого типа, а Sum - действительного типа. Раздел операторов начинается со стандартной процедуры очистки экрана ClrScr (Clear Screen), которая находится в модуле Crt. Далее оператором Write мы выводим на экран сообщение ‘Введите первое число ‘, получив которое пользователь должен ввести число.

Теперь компьютер должен считать введенные символы и занести их в переменную First, это произойдет при выполнении следующего оператора ReadLn(First). Затем с помощью оператора Write запрашиваем значения еще двух чисел и считываем их в переменные Second и Third. Затем вычисляем их сумму и присваиваем полученное число переменной Sum. Чтобы найти среднее, нужно теперь полученное число разделить на 3 и сохранить результат в какой-либо переменной.

Совсем не обязательно описывать еще одну переменную для сохранения результата. Можно, как в нашей программе, значение переменной Sum разделить на 3 и результат опять присвоить той же переменной Sum. Теперь можно вывести результат вычислений на экран с помощью процедуры Write. И, наконец, последняя процедура ReadLn задержит наш вывод на экране до нажатия на клавишу.

Нажмите клавиши +. Введите значения переменных 5, 7 и 12, на экране увидите следующее:

Среднее значение 5, 7 и 12 равно 8.00

Просмотрите внимательно эту строчку и сравните со строчкой вывода результата в нашей программе. Протестируйте программу еще несколько раз для других значений переменных.



Выбранный для просмотра документ Оператор присваивания 2 урок.doc

библиотека
материалов

Оператор присваивания. Арифметические выражения. Типы данных

Оператор присваивания

Первый оператор, с которым мы познакомимся,- оператор присваивания.

Оператор присваивания - основной оператор любого языка программирования. Общая форма записи оператора:

  имя величины := выражение

Например, V:=A; или V:=A+1;

При помощи оператора присваивания переменной могут присваиваться константы и выражения, значения переменных любого типа.

Как только в программе встречается переменная, для неё в памяти отводится место. Оператор присваивания помещает значение выражения в место, отведённое переменной.

Если в процессе выполнения программы встречается переприсваивание (т.е. та же самая переменная принимает другое значение), то старое значение переменной стирается, на свободное место записывается новое значение. Команда присваивания позволяет лучше понять смысл слова переменная (т.е. меняющая своё значение по ходу программы).

Выражение может быть арифметическим, логическим или литерным. Важно, чтобы тип величины был согласован с видом выражения.

Арифметические выражения

Арифметические выражения должны быть записаны в так называемой линейной записи согласно следующим правилам:

  • выражение должно быть записано в виде линейной цепочки символов;

  • используемые операции приведены в таблице:

 НАЗВАНИЕ ОПЕРАЦИИ

 ФОРМА ЗАПИСИ

 сложение

 x + y

 вычитание

 x - y

 умножение

 x * y

 деление

 x / y

  • нельзя опускать знаки операций, например, писать 5b. Для записи произведения чисел 5 и b надо писать 5*b;

  • аргументы функций (sin, cos и др.) как и аргументы вспомогательных алгоритмов, записываются в круглых скобках, например sin(x), cos(4*x).

Порядок выполнения операций при вычислении арифметических выражений можно регулировать при помощи скобок по обычным правилам. Там, где скобки отсутствуют, ЭВМ выполняет операции в следующем порядке:

  • вычисляет значение всех алгоритмов-функций и стандартных функций;

  • выполняет справа налево все операции возведения в степень;

  • выполняет слева направо все операции умножения и деления;

  • выполняет слева направо все операции сложения и вычитания.

В нашем случае(*) сначала переменной number1 присваивается значение равное 3 и переменной number2 присваивается значение равное 4, затем вычисляется значение выражения (number1 + number2) и оно присваивается переменной result.

Сумма чисел посчитана.

Теперь надо вывести ее значение на экран. Для этого используют оператор Write - записать (вывести) на экран значение переменной, записанной в скобках. В нашем случае значение переменной number1, затем символ + , далее значение переменной number2, символ = и, наконец, значение результата result.

И, наконец, в конце раздела операторов стоит служебное слово End, после которого стоит точка.

Задание. Наберите текст программы на компьютере и выполните ее (для запуска программы воспользуйтесь комбинацией клавиш Ctrl и F9).

Внимание! Не забывайте о порядке на дискете и в файле:

  • имя программы должно соответствовать ее содержанию,

  • имя файла должно быть таким же, как и имя программы,

  • файлы, содержащие программы, относящиеся к одной теме, должны находиться в одном каталоге,

  • название этого каталога должно отражать его содержание.

Задание. Измените программу так, чтобы она подсчитывала сумму четырех чисел.

Сохраните файл на дискете, для этого из меню F10-File выберите команду Save и в предложенной строке наберите путь a:\Vvod\Summa (каталог Vvod должен быть уже организован для файлов, содержащих программы данной темы).

Основные определения

Познакомимся с основными понятиями языка.

Алгоритм - четкая последовательность действий, необходимая для решения задачи.

Программа - алгоритм, записанный на языке программирования.

Алфавит языка - набор элементарных символов, используемый для составления программ. Алфавит содержит:

  • 52 буквы латинского алфавита (строчные и заглавные);

  • арабские цифры (0-9);

  • специальные символы;

  • знаки математических действий (+ - * / );

  • знаки пунктуации (. : , ; " ` );

  • скобки ( [ ] ( ) { } );

  • знак пробела;

  • знаки отношений (< > =).

Идентификатор (имя) – имя какого-либо элемента программы, которое должно удовлетворять следующим требованиям:

  • длина имени не должна превышать 63 символов;

  • идентификатор может состоять из букв, цифр и символов подчеркивания (значение ASCII $5F);

  • идентификатор должен начинаться с буквы или с символа подчеркивания;

  • буквы русского алфавита и пробелы не могут входить в идентификатор в Turbo Pascal;

  • имя не должно совпадать с зарезервированным (служебным) словом;

  • прописные и строчные буквы воспринимаются одинаково.

Правильно выбранные идентификаторы значительно облегчают чтение и понимание программы, а также уменьшают вероятность появления ошибок при модификации программ. Например, значение даты удобнее обозначить идентификатором Date, чем просто буквой D или любым другим символом. 

Зарезервированные (служебные) слова - это слова, использующиеся только по своему прямому назначению. Их нельзя использовать в качестве имен переменных, так как они выполняют определенную смысловую нагрузку.

Примеры зарезервированных слов: AND, GOTO, PROGRAM, ELSE, IF, RECORD, NOT, ARRAY, REPEAT, UNTIL, BEGIN, IN, SET, END, CASE, CONST, USES, INTERFACE, STRING, LABEL, THEN, OF, DIV, TO, VAR, DO, TYPE, WHILE, DOWNTO, FILE, FUNCTION, PROCEDURE и другие.

Переменные (Var) - вид данных, который может изменять свое значение в ходе программы, описывают переменные после зарезервированного слова Var.

Константы (Const) - вид данных, который является постоянным на всем протяжении выполнения программы, описывают константы после зарезервированного слова Const.

Комментарии - некоторая запись, служащая для пояснения программы, которая записывается в фигурных скобках.

Типы данных

Для временного хранения информации в операторах памяти машины в языке Паскаль используются константы и переменные. Они могут быть различных типов:

  •   целых чисел (см. ниже);

  •   действительных чисел (real);

  •   символьный тип (char);

  •   строковый (string);

  •   логический (boolean);

  •   сложные (комбинированный (record), множественный (set) и другие).

Целые типы:

 Название

 Длина в байтах

 Диапазон значений

 Byte

 1

 0 ... 255

 ShortInt

 1

 -128 ... 127

 Word

 2

 0 ... 65535

 Integer

 2

 -32768 ... 32767

 LongInt

 4

 -2147483648 ... 2147483647

Над целыми типами определены такие операции:

  1. "+" - сложение;

  2. " * " - умножение;

  3. " - " вычитание;

  4. div - целочисленное деление;

  5. mod - получение остатка от целочисленного деления.

Вещественные типы:

Вещественные типы представляются с некоторой точностью, которая зависит от компьютера. Вам необходимо знать, что вещественный тип разделяется на несколько типов, но использовать мы будем вещественные данные только типа Real, которые занимают 6 байт, имеют диапазон возможных значений модуля от 2.9Е-39 до 1.7Е+38 и точность представления данных - 11...12 значащих цифр.

Примечание. Несмотря на то, что в Turbo Pascal имеется широкий выбор вещественных типов, доступ к некоторым из них (single, double, extended) возможен при особых режимах компиляции. Особое положение в Turbo Pascal занимает тип comp, трактующийся как вещественное число без экспоненциальной и дробной частей. Он сохраняет 19 - 20 значащих цифр и знак числа. В то же время comp полностью совместим с любыми другими вещественными типами.

В языке Паскаль числа могут быть представлены в двух видах: с фиксированной точкой и плавающей точкой.

Числа с фиксированной точкой изображаются десятичным числом с дробной частью, которая может быть и нулевой. Например, 27.9, 5.00

Такие большие числа, как 137.000.000, можно записать в формате с десятичным порядком: 1.37·108. В Turbo Pascal для подобных чисел принята форма записи mEp, где m - мантисса; E - признак записи числа с десятичным порядком; p - показатель степени числа 10.  Такое представление чисел  и называется форматом с плавающей точкой. Число 1.37·10 в этом формате запишется так: 1.37Е+8. Рассмотрим еще несколько примеров:

 Математическая запись

 Запись на Паскале

 4·10-4

 4E -4

 0,62·105

 0.62E+5

 -10,88·1012

 -10.88E12

По умолчанию, действительные числа выводятся в виде чисел с плавающей точкой. Такое представление чисел не очень нравится пользователям. Поэтому мы будем “заставлять” компьютер выдавать действительные числа в более привычном варианте следующим образом:

R:m:n, где R – действительное число, m – общее количество позиций, отводимых числа, n – количество позиций, отводимых для дробной части.

Например, если мы хотим вывести на экран число Chislo с фиксированной точкой, причем знаем, что для вывода  этого числа достаточно 7 мест, а вывод дробной части ограничим сотыми, то мы запишем вывод так:

Write (Chislo:7:2)

Символьный тип (char):

Значением величины данного типа является символ  из множество всех символов компьютера: русская или латинская большая или маленькая буква, цифра, знак препинания, специальный знак (например, "+", "-", "*", "/", "", "=" и др.) или пробел " ". Каждый из символов имеет уникальный номер от 0 до 255, т. е. внутренний код, который возвращает функция ORD. Символьная константа  – любой символ языка, заключённый в одинарные кавычки. Например,

Var
  Simvol : char;

Строковый тип (string):

Значением строковой величины является строка переменной длины (быть может, пустая). Строковая константа  представляет собой произвольную последовательность символов, заключенную в одинарные кавычки. Например,

Var
  Stroka : string;

Логический тип (boolean):

Логический тип данных часто называют булевым по имени английского математика Д. Буля, создателя математической логики. В языке Паскаль имеются две логические константы TRUE и FALSE. Логическая переменная принимает одно из этих значений и имеет тип Boolean. Для сравнения данных предусмотрены следующие операции отношения: <, <=, =, <>, >, >= Результат операции отношения имеет логический тип, т.е. результат операции может быть истинным или ложным, например, 3>5 – ложь.

Над величинами этого типа можно выполнять специфические логические операции OR - или; AND - и; NOT - не.

Более подробно этот тип данных мы рассмотрим при изучении условного оператора.

Сложные типы:

К сложным или структурированным типам относятся массивы, записи, множества, которые требуют специального изучения и здесь рассматриваться не будут.

Задание. Откройте новый файл. Создадим программу, в которой опишем несколько переменных разного типа, введем в них значения и выведем на экран.

Program TipDann;
Uses
  Crt
Var
  Chislo1 : Integer;
  Chislo2 : Real;
  Simvol : Char;
  Stroka : String;
  Logika : Boolean;
Begin
  ClrScr;
  Chislo1:=12;
  Chislo2:=Chislo1*2;
  Chislo2:=Chislo2/5;
  Simvol:='d';
  Stroka:='Строчка';
  Logika:= Chislo1> Chislo2;
  WriteLn ('Вывод значений:');
  WriteLn ('Значение переменной Chislo1 : ',Chislo1);
  WriteLn ('Значение переменной Chislo2 : ',Chislo2:5:2);
  WriteLn ('Значение переменной Simvol : ',Simvol);
  WriteLn ('Значение переменной Stroka : ',Stroka);
  WriteLn ('Значение переменной Logika : ',Logika);
End.

Внимательно рассмотрите каждую строчку программы. Обратите особое внимание на описание переменных: Chislo1 - переменная целого типа, Chislo2 - действительного, Simvol - символьного, Stroka - строкового, Logika - логического. Далее в основной программе идет присвоение переменной Chislo1 целого числа 12, переменной Chislo2 - целого числа 24. Обратим внимание, что переменной действительного типа Chislo2 присвоено целое число; никакой ошибки нет, т. к. множество целых чисел является подмножеством множества действительных чисел. Следующая строчка еще более интересная: переменной Chislo2 присваивается значение той же переменной, только деленной на 5.

Такое присваивание используют в программах, если предыдущее значение этой переменной уже не понадобится и для более рационального использования описанных переменных. Для того чтобы переменной символьного типа присвоить какой-либо символ (например, d), надо этот символ записать в одинарных кавычках (знак «’»). Аналогично поступают с переменными строкового типа (смотри следующую строку программы). А про переменные логического типа мы знаем, что им можно присваивать только два значения: True и False. В этой программе мы присвоим значение результата сравнения двух переменных, здесь оно будет равно True. А теперь выведем присвоенные значения на экран.

Задание. Измените значения переменных и проанализируйте результаты выполнения программы. Сохраните программу на дискете под правильным именем в соответствующем каталоге. Распечатайте программу.



Выбранный для просмотра документ Стандартные функции и процедуры 4 урок.doc

библиотека
материалов

Стандартные функции и процедуры. Применение в простейших линейных программах

Для решения задач нам понадобятся стандартные функции и процедуры.

Функция - это такая организация преобразования переданного ей значения, при которой это измененное значение передается обратно.

Процедура - это такая организация преобразования переданного ей значения параметра, при которой изменяется значение этого параметра, и, в отличие от функции, не возвращается никакого значения.

Познакомимся с основными, наиболее часто используемыми процедурами и функциями.

Арифметические функции:

  1. Abs(x), где аргумент и результат являются переменными целого или вещественного типа - вычисляет модуль (абсолютную величину) числа х;

  2. Cos(x), где аргумент и результат являются переменными вещественного типа - вычисляет косинус х;

  3. Sin(x), где аргумент и результат являются переменными вещественного типа - вычисляет синус х; 

  4. Frac(x), где аргумент и результат являются переменными вещественного типа - выделяет дробную часть числа х; 

  5. Int(x), где аргумент и результат являются переменными вещественного типа - выделяет целую часть числа х;

  6. Pi, где результат является переменной вещественного типа - вычисляет значение π;

  7. Random(x), где аргумент и результат являются переменными целого типа - генерирует случайное число в пределах от 0 до х включительно. Если параметр х не задан, то формируется вещественное число от 0 до 1. Перед использованием данной функции нужно инициализировать генератор случайных чисел при помощи процедуры Randomize (см. ниже);

  8. Sqr(x), где аргумент и результат являются переменными целого или вещественного типа - вычисляет x2;

  9. Sqrt(x), где аргумент и результат являются переменными целого или вещественного типа - вычисляет √x.

Функции преобразования типов:

  1. Chr(x), где аргумент типа Byte, а результат типа Char- возвращает символ, у которого код в таблице ASCII равен х;

  2. Ord(x), где аргумент может быть любого порядкового типа, а результат типа LongInt - возвращает порядковый номер значения х при начале нумерации с нуля;

  3. Round(x), где аргумент вещественного типа, результат типа LongInt - округляет число х до ближайшего целого;

  4. Trunc(x), где аргумент вещественного типа, результат типа LongInt - выделяет целую часть числа х.

Функции для порядковых типов:

  1. Odd(x), где аргумент типа LongInt, а результат логического типа - определяет, является ли число четным (результат false) или нечетным (результат true);

  2. Pred(x), где аргумент и результат любого порядкового типа - получает предшествующее значение;

  3. Succ(x), где аргумент и результат любого порядкового типа - получает последующее значение;

  4. Upcase(x), где аргумент и результат типа Char - преобразует букву латинского алфавита в соответствующую ей заглавную (буква х может быть как строчной, так и заглавной).

Процедуры для порядковых типов:

  1. Dec(x), где аргумент любого порядкового типа - уменьшает значение переменной х на 1;

  2. Dec(x,n), где х любого порядкового типа, а n типа LongInt - уменьшает значение переменной х на n;

  3. Inc(x), где аргумент любого порядкового типа - увеличивает значение переменной х на 1;

  4. Inc(x,n), где х любого порядкового типа, а n типа LongInt - увеличивает значение переменной х на n;

  5. Randomize - инициализирует генератор случайных чисел.

Правила применения функций:

  • чтобы воспользоваться функцией, нужно указать ее в правой части оператора присваивания;

  • при обращении к функции необходимо в круглых скобках указать ее аргументы;

  • в разделе описания переменных правильно указывайте типы переменных, которые хотите употребить в качестве аргумента или результата функции;

  • в одном выражении можно обратиться к нескольким функциям.

Правила применения процедур:

  • для выполнения процедуры ее надо вызвать в программе в виде оператора;

  • в разделе описания переменных правильно указывайте тип переменной, которую хотите употребить в качестве аргумента процедуры.

Задача. Найти значения выражений:

a) (1+x)2

b)hello_html_m47eedfd.png

c) |a+ bx|

Прежде чем приступить к составлению программы, необходимо перевести данные выражения с математического языка на язык Паскаль.

a) (1+x)2 → sqr(1+x)

b) hello_html_m47eedfd.png → sqrt((1+A)*5)

c) |A+ bx| → abs(A+b*x)

Теперь уже можно переходить к составлению программы.

Program Primer;
Uses
  Crt;
Var
  A : word; {так как подкоренное выражение должно быть положительно}
  b, x, result : real;
Begin
  ClrScr;
  Writeln('Введите значения переменных (A-положительно)');
  Write('A=');
  Readln(A);
  Write('b=');
  Readln(b);
  Write('x=');
  Readln(x);
  Result := sqr(1+x);
  Writeln ('sqr(1+x)=', result);
  Result := sqrt((1+A)*5);
  Writeln ('sqrt((1+A)*5)=', result);
  Result := abs(A+b*x);
  Writeln ('abs(A+b*x)=', result);
  Readln;



Выбранный для просмотра документ Это занятие мы посвятим вопросам программирования обменов с клавиатурой компьютера 7 урок.doc

библиотека
материалов

Это занятие мы посвятим вопросам программирования обменов с клавиатурой компьютера. Турбо Паскаль содержит несколько простых и ясных средств, которые позволяют организовать эффективное управление программой посредством клавиатуры.

Самая простая и часто применяемая техника организации приема информации основывается на использовании уже знакомых Bам процедур read и readln. Расширим знания о них. Эти процедуры работают со стандартным входным файлом, который отождествлен с “консолью”, т. е. с клавиатурой и экраном дисплея. На практике это означает, что информация, введенная с клавиатуры, помимо обработки процедурами, будет отображаться на экране.

Удобством указанных процедур является автоматическое преобразование ими вводимой цепочки символов в значение заданного типа. Так, если в разделе описания переменных имеется описание вида

Var
  Chislo : integer;

то выполнение оператора readln (Chislo) будет происходить следующим образом. Программа будет приостановлена в ожидании ввода с клавиатуры символов, изображающих целое число. После ввода этих изображений они будут автоматически преобразованы в соответствующие двоичные значения и присвоены переменной Chislo. Аналогично организован прием значений действительного, символьного и строкового типа. Если read(readln) не может выполнить преобразования, то генерируется ошибка № 106 – Invalid numeric format (Неверный формат числовых данных) и выполнение программы прекращается. Это является стандартной реакцией, которую выполняет программа, взявшая на себя обработку ошибок. Мы вернемся еще к обработке ошибок, вызванных некорректным вводом, в теме “Процедуры и функции”, где научимся правильно составлять и использовать вспомогательные подпрограммы. А пока приведем пример применения этих процедур ввода при организации циклов.

Program Useread;
Uses Crt;
Var
  X, Y : Byte;
  Stop : String;
Begin
  TextBackGround(5);
  ClrScr;
  Randomize;
  repeat
    X:=Random (76);
    Y:=Random (23);
    GoToXY (X, Y);
    TextColor (Random(15));
    write('***');
    X:=1;
    Y:=24;
    GoToXY (X, Y);
    TextColor (0);
    write ('Для остановки программы наберите “Стоп“');
    write ('Для продолжения – любую клавишу ');
    readln(Stop);
  until (Stop='Стоп') or (Stop ='стоп');
  readln;
End.

Примечание. Здесь использованы следующие процедуры:

GoToXY (X, Y:Byte) - перемещает курсор к элементу экрана с заданными координатами, учитывая, что размер экрана в текстовом режиме 25 строк по 80 символов.

TextBackGround (Color : Byte) – задает цвет фона.

TextColor (Color : Byte) – задает цвет символов.

Однако, несмотря на простоту и удобство, стандартные процедуры read и readln не обеспечивают всех потребностей, возникающих при работе с клавиатурой. Их важнейший недостаток в том, что вместе с приемом символов они выполняют их отображение на экран (так называемое “эхо на монитор”). В большинстве случаев это либо не нужно, либо недопустимо. Например, если программа реализует некоторый оконный интерфейс, то вывод вводимых символов испортит изображение. Кроме того, они рассчитаны только на ввод относительно небольшого подмножества символов (буквы, цифры, знаки препинания) и частичного использования специальных клавиш (например, Backspace для отмены только что введенного символа). Эти процедуры не могут распознать нажатие функциональных или редактирующих клавиш и их сочетаний с управляющими клавишами Ctrl, Alt, Shift. В силу указанных причин процедуры read и readln редко используются в серьезных программах.

Стандартная функция readKey

Более универсальным средством взаимодействия с клавиатурой является стандартная функция readKey из системного модуля Crt. Функция вызывается без параметров, возвращает значение символьного типа и работает следующим образом. Организуется задержка выполнения с ожиданием нажатия клавиши. После того, как нажатие произведено, функция завершает работу, возвращая код нажатой клавиши. Полученное значение можно использовать далее в программе. Тривиальный пример работы с функцией readKey, не требующий комментариев, может выглядеть так:

Program UsereadKey;
Uses
  Crt;
Var
  Sym : Char;
Begin
  ClrScr;
  while true do
    begin
      write ('
Введите букву - ');
      Sym := readKey;
      writeln ('
Вы ввели букву - ', Sym);
      if Sym = 'q'
        then
          Exit
    end
End.

Примечание. Здесь использована процедура Exit, которая позволяет досрочно выйти из программы. Применение этой процедуры является проявлением плохого стиля программирования.

Функция readKey не отображает введенный символ на экран, благодаря чему она широко используется для организации управления в различных диалоговых программах. В дополнение к этому readKey позволяет отслеживать нажатие более широкого множества клавиш, опознавая функциональные и редактирующие клавиши и их сочетания с управляющими клавишами Ctrl, Alt, Shift.

Если говорить более подробно, функция readKey исходит из того, что все множество клавиш и их сочетаний с управляющими клавишами разбито на два подмножества, которые обычно называют основным и расширенным наборами.

В основной набор входят клавиши букв, цифр, разделителей и знаков препинания, их комбинации с клавишей Shift (или, что то же самое, при включенном переключателе CapsLock), а также клавиши Tab, BackSpace, Enter и Esc. Если нажата одна из перечисленных клавиш, то readKey возвратит обычный ASCII-код соответствующего символа.

В расширенном наборе содержатся некоторые (не все) клавиши из основного набора в комбинации с клавишами Ctrl и Alt, а также функциональные и редактирующие клавиши. Если нажимается одна из клавиш расширенного набора, то функция readKey возвращает символ с кодом 0 (его представление в программе – chr(0) или #0). В этом случае повторное обращение к readKey вернет код клавиши из расширенного набора.

Коды клавиш из основного и расширенного наборов в виде, удобном для включения в Турбо Паскаль-программы, приведены в приложении.

Схема использования функции readKey для общего случая может выглядеть так:

Program UsereadKey2;
Uses
  Crt;
Var
  Sym : Char;
Begin
  ClrScr;
  while true do
    begin
      write ('Нажмите клавишу');
      Sym := readKey;
      if Sym <> #0
        then
          begin {основной набор}
            case Sym of
              #8 : writeln ('Вы нажали BackSpace');
              #9 : writeln ('Вы нажали Tab');
              #13 : writeln ('Вы нажали Enter');
              #27 : writeln ('Вы нажали Esc');
            else
              writeln ('Вы ввели символ ',Sym);
            end;
            if Sym = #27
              Then
                Exit
          end
      else
        begin {расширенный набор}
          Sym := readKey;{повт. чтение: берем расширенный код}
          writeln ('Вы нажали клавишу с кодом ', Ord (Sym));
        end
    end
End.

Большинство прикладных диалоговых программ использует описанную технику взаимодействия с клавиатурой. Однако встречаются случаи, когда возможностей функции readKey оказывается недостаточно. На самом деле функция readKey воспринимает нажатия не всех клавиш: достаточно попробовать, запустив вышеприведенную программу, нажать клавиши F11, F12, ввести комбинацию Alt+Esc и т.д. Тому, кто желает более детально изучить работу этой функции, предлагаем самостоятельно найти в книгах по Турбо Паскалю этот материал. А мы ограничимся вышесказанным.

Стандартная функция KeyPressed

Второй базовой функцией взаимодействия с клавиатурой является функция KeyPressed. В отличие от readKey, она предназначена не для приема кода нажатой клавиши, а для простой проверки, была ли нажата какая-либо клавиша. Эта функция вызывается без параметров и возвращает значение булевого типа: True, если было нажатие, и False в противном случае.

Важно понять, что KeyPressed не производит никаких действий с кодом нажатой клавиши, но код может быть далее прочитан функцией readKey, например,

. . .
if KeyPressed
  then
    S := readKey;
. . .

Cоотношение этих функций станет более понятным, если рассмотреть их внутреннюю организацию несколько подробнее. В системной области DOS имеется небольшой буфер, в который операционная система помещает коды нажатых клавиш. Буфер организован в виде очереди, причем помещение кодов производится в ее хвост, а считывание из головы. Таким образом, каждое обращение к функции readKey извлекает из головы очереди один содержащийся там код. Если буфер пуст, то организуется задержка выполнения до тех пор, пока в нем не появится код (появление кода соответствует нажатию клавиши). Если же к моменту вызова readKey нажатие уже произошло, то есть буфер содержит хотя бы один код, то никакой задержки не будет. Буфер очень невелик и рассчитан на хранение максимум 15 кодов, что соответствует 15 нажатиям. Кстати говоря, иногда встречается такая ситуация, когда та или иная программа “не успевает” выбирать коды клавиш из буфера (то есть нажатия производятся чаще). Ситуация переполнения буфера индицируется звуковым сигналом, после чего коды вновь нажимаемых клавиш будут пропадать.

Функция KeyPressed не извлекает код из буфера, а только проверяет, пуста ли очередь, и возвращает соответствующее булево значение. Более подробно рассмотрение системных аспектов работы с клавиатурой смотрите в соответствующей литературе.



Выбранный для просмотра документ Вложенные условные операторы 3 урок.doc

библиотека
материалов

Вложенные условные операторы

При решении задач часто приходится рассматривать не два, а большее количество вариантов. Это можно реализовать, используя несколько условных операторов. В этом случае после служебных слов Then и Else записывается новый условный оператор. Рассмотрим пример.

Задача. Вычислить значение функции:

hello_html_m412ea558.png

Для решения этой задачи рассмотрим координатную прямую и отметим на ней промежутки, на которые разбиваются все значения переменной х.

hello_html_m4bc10e99.png

Начнем записывать условный оператор:

если х>0
  то 
    вычислить у по формуле у=х-12
  иначе

Что же должно выполниться в случае "иначе"? На эту ветку оператора попадают все неположительные значения х. Если бы для этих чисел нужно было бы выполнить один и тот же оператор (или группу операторов), то проблемы бы не стояло. Но нам нужно этот промежуток разделить еще на две части (отрицательные и ноль) и для каждой части выполнить свой оператор. Поэтому ветка "иначе" будет содержать еще один условный оператор, и наш вложенный условный оператор будет иметь вид:

если х>0
  то 
    у вычислить по формуле у=х-12
  иначе 
    если х=0
      то
        у вычислить по формуле у=5
      иначе
        у вычислить по формуле у=sqr(x);

Тогда фрагмент программы для решения этой задачи будет выглядеть так:

if х>0
  then 
   
у := х-12
  else 
    if
х=0
      then 
       
у := 5
      else 
       
у := sqr(x);

Итак, когда оператор if появляется внутри другого оператора if, они считаются вложенными. Такое вложение используется для уменьшения числа необходимых проверок. Этот метод часто обеспечивает большую эффективность, однако одновременно он уменьшает наглядность программы. Не рекомендуется использовать более одного-двух уровней вложения if. За вторым уровнем вложения становится трудно восстановить последовательность проверки условий каждым условным оператором.

Если часть else используется во вложенных if, то каждое else соответствует тому if, которое ему непосредственно предшествует. Таким образом, при определении последовательности выполнения фрагментов нет двусмысленности.

Рассмотрите еще один пример.

Задача. Даны целые числа a, b, c. Если a ≤ b ≤ c, то все числа заменить их квадратами, если a>b>c, то каждое число заменить наибольшим из них, в противном случае сменить знак каждого числа.

Для решения этой задачи перепишем условие задачи следующим образом:

a:=a2, b:=b2, c:=c2, если a ≤ b ≤ c

b:=a, c:=a, если a>b>c

a:=-a, b:=-b, c:=-c, в остальных случаях

Программа для решения этой задачи представлена ниже.

Program Example3;
Var
  a, b, c : integer; 
Begin
  writeln('
Введите числа a, b, c'); 
  readln(a,b,c);
  if (a<=b) and (b<=c)
    then
      begin
        a:=sqr(a);
        b:=sqr(b);
        c:=sqr(c);
      end
    else
      if (a>b) and (b>c)
        then
          begin
            b:=a;
            c:=a;
          end
        else
          begin
            a:=-a;
            b:=-b;
            c:=-c;
          end;
  writeln(a,b,c);
  readln;
End.

Задание. Найдите в этой программе (если есть) условный оператор, вложенный условный оператор, составной оператор, булево условие.

Внимание! Подчеркнем еще раз один тонкий момент: поскольку каждый из операторов может быть оператором любого типа (в том числе и условным), и в то же время не каждый из "вложенных" условных операторов может иметь часть else, то возникает неоднозначность трактовки условий. Turbo-Pascal решает эту проблему таким радикальным способом: любая встретившаяся часть else соответствует ближайшей к ней части then.



Выбранный для просмотра документ Оператор выбора CASE 4 урок.doc

библиотека
материалов

Оператор выбора CASE

Ранее Вы познакомились с условным оператором If, который позволяет программе выполнять переходы на ту или иную ветвь по значению булева условия. Используя несколько операторов If, можно производить ветвление по последовательности условий. В приведенном фрагменте показано, как при помощи ряда операторов If можно преобразовать целое число (в диапазоне 0-9) к его словесному представлению:

if Ziphra = 0
  then
    write ('
Нуль');
if Ziphra = 1
  then
    write ('
Единица');
if Ziphra = 2
  then
    write ('
Два');

и т.д.

Вы уже, наверное, представили, насколько этот подход однообразный и утомительный. Язык Паскаль предоставляет для этих целей другую управляющую структуру (оператор выбора case), которая позволяет построить ветвление по ряду условий в форме, более удобной для чтения программ.

Оператор выбора позволяет выбрать одно из нескольких возможных продолжений программы. Параметром, по которому осуществляется выбор, служит так называемый ключ выбора (или селектор) - выражение любого типа (кроме типов REAL и STRING).

Общая форма записи следующая:

case Выражение of
значение1 : оператор (группа операторов);
значение2 : оператор (группа операторов);
. . . . . . . . . . . . . . . . . . . . . .
значениеN : оператор (группа операторов)
else оператор (группа операторов);
end;

Оператор выбора работает следующим образом. Сначала вычисляется значение выражения, стоящего после зарезервированного слова case, а затем выполняется оператор (или составной оператор), соответствующий результату вычисления выражения.

Может случиться, что в списке выбора не окажется константы, равной вычисленному значению ключа. В этом случае управление передается оператору, стоящему за словом ELSE.

Например,

case NUMBER mod 2 of
  0 : writeln (NUMBER, '-
число четное')
else writeln (NUMBER, '-
число нечетное');
end;

Если один оператор выполняется при нескольких значениях, то их можно перечислить через запятую.

case MONTH of
  1, 2, 3 : writeln ('Первый квартал');
  4, 5, 6 : writeln ('Второй квартал');
  7, 8, 9 : writeln ('Третий квартал');
  10, 11, 12 : writeln ('Четвёртый квартал');
end;

Оператором может являться не только простой оператор, но также составной и пустой операторы.

case CODE of
  1 : for i := 1 to 5 do
         writeln ('*******');
  2 : begin {
составной оператор}
         x:=sqr(y-1); 
         writeln (x);
       end;
  3 : {
пустой оператор}
       end;

Любому заданному значению селектора соответствует лишь один вход в списке операторов. Константы должны принадлежать тому же типу, что и селектор. Если селектор принимает значение, которому не соответствует ни один вход, то будет выполняться оператор, следующий за словом else. Если же этого оператора нет, то никакие альтернативы не будут выполняться.

Если оператор должен выполняться при нескольких последовательных значениях селектора, образующих некоторый промежуток, можно использовать следующую форму записи:

case Chislo of
  0..9 : write ('Это число является цифрой');

Посмотрите, как применен оператор выбора при решении следующей задачи:

Задача. Написать программу преобразования цифр в слова.

Program Number1;
Var
  a : integer; 
Begin
  writeln('Введите цифру '); 
  readln(a);
  if (a<0) or (a>9)
    then
      writeln ('Это число не является цифрой')
    else
      case a of
        0 : writeln ('ноль');
        1 : writeln ('один');
        2 : writeln ('два');
        3 : writeln ('три');
        4 : writeln ('четыре');
        5 : writeln ('пять');
        6 : writeln ('шесть');
        7 : writeln ('семь');
        8 : writeln ('восемь');
        9 : writeln ('девять');
      end;
  readln;
End.


Program Number2;
Var
  a : integer; 
Begin
  writeln('Введите цифру '); 
  readln(a);
  case a of
    0 : writeln ('ноль');
    1 : writeln ('один');
    2 : writeln ('два');
    3 : writeln ('три');
    4 : writeln ('четыре');
    5 : writeln ('пять');
    6 : writeln ('шесть');
    7 : writeln ('семь');
    8 : writeln ('восемь');
    9 : writeln ('девять')
  else writeln ('Это число не является цифрой');
  end;
  readln;
End.



Выбранный для просмотра документ Переменные логического типа описываются посредством служебного слова BOOLEAN 2 урок.doc

библиотека
материалов

Переменные логического типа описываются посредством служебного слова Boolean. Они могут принимать только два значения - False (ложь) и True (истина). Описываются они в разделе описания переменных.

Var
  Flag : Boolean;

В языке Турбо Паскаль имеются логические операции, применяемые к переменным логического типа. Это операции notandor и хor. В этой теме Вы рассмотрите три логические операции. Обозначения и результаты этих операций приведены в таблице. Рассмотрите ее.

hello_html_4a2c12bf.png

Операция not (НЕ) имеет один операнд и образует его логическое отрицание. Результат операции not есть False, если операнд истинен, и True, если операнд имеет значение ложь. Так,

not True hello_html_139c7ae2.png False (неправда есть ложь)

not False hello_html_139c7ae2.png True (не ложь есть правда)

Результат операции and (И) есть истина, только если оба ее операнда истинны, и ложь во всех других случаях.

Результат операции or (ИЛИ) есть истина, если какой-либо из ее операндов истинен, и ложен только тогда, когда оба операнда ложны.

Задание. Попробуйте определить результат выполнения булевых операций для высказываний:

  1. Школьник на зимних каникулах остается дома или уезжает куда-либо отдыхать.

  2. Филипп Киркоров является певцом и комбайнером.

  3. Школьниками являются мальчики и девочки.

Логические операции, операции отношения и арифметические операции часто встречаются в одном выражении. При этом отношения, стоящие слева и справа от знака логической операции, должны быть заключены в скобки, поскольку логические операции имеют более высокий приоритет. Вообще принят следующий приоритет операций:

  • not

  • and, *, /, div, mod

  • or, +, -

  • операции отношения.

Примечание. Логическую операцию and еще называют логическим умножением, а логическую операцию or - логическим сложением.

Кроме того, порядок выполнения операций может изменяться скобками. Например, расставим порядок действий в логическом выражении:

    4      3    2       1
A or B and not (A or B)

Сначала выполняется заключенная в скобки операция or, а затем операции not, and, or. Если подставить вместо переменных А и В значения True и False, то, используя уже рассмотренный порядок действий, получим значение всего выражения, равное True.

Задание. Вычислите значения выражений при a=10, b=20, c=true, d=false:

  • (a>5) and (b>5) and (a<20) and (b<30);

  • not (a<15) or not (b<30);

  • c or d and (b=20);

Внимание! В языке Паскаль нет возможности ввода логических данных с помощью оператора read. Однако предусмотрен вывод значений переменных логического типа с помощью оператора write.

Например, после выполнения оператора write (5>2) на экран будет выведено True



Выбранный для просмотра документ ветвление 1 урок.doc

библиотека
материалов

До сих пор Вы использовали линейные алгоритмы, т.е. алгоритмы, в которых все этапы решения задачи выполняются строго последовательно. Сегодня Вы познакомитесь с разветвляющимися алгоритмами.

Определение. Разветвляющимся называется такой алгоритм, в котором выбирается один из нескольких возможных вариантов вычислительного процесса. Каждый подобный путь называется ветвью алгоритма.

Признаком разветвляющегося алгоритма является наличие операций проверки условия. Различают два вида условий - простые и составные.

Простым условием (отношением) называется выражение, составленное из двух арифметических выражений или двух текстовых величин (иначе их еще называют операндами), связанных одним из знаков:

  < - меньше, чем...
  > - больше, чем...
  <= - меньше, чем... или равно
  >= - больше, чем... или равно
  <> - не равно
  = - равно

Например, простыми отношениями являются следующие:

x-y>10; k<=sqr(c)+abs(a+b); 9<>11; ‘мама’<>‘папа’.

В приведенных примерах первые два отношения включают в себя переменные, поэтому об истинности этих отношений можно судить только при подстановке конкретных значений:

  • если х=25, у=3, то отношение x-y>10 будет верным, т.к. 25-3>10

  • если х=5, у=30, то отношение x-y>10 будет неверным, т.к. 5-30<10

Проверьте истинность второго отношения при подстановке следующих значений:

  1. k=5, a=1, b=-3, c=-8

  2. k=65, a=10, b=-3, c=2

Определение. Выражение, о котором после подстановки в него значений переменных можно сказать, истинно (верно) оно или ложно (неверно), называется булевым (логическим) выражением.

Примечание. Название “булевы” произошло от имени математика Джорджа Буля, разработавшего в XIX веке булеву логику и алгебру логики.

Определение. Переменная, которая может принимать одно из двух значений: True (правда) или False (ложь), называется булевой (логической) переменной. Например,

К:=True;
Flag:=False;
Second:=a+sqr(x)>t

Рассмотрим пример.

Задача. Вычислить значение модуля и квадратного корня из выражения (х-у).

Для решения этой задачи нужны уже знакомые нам стандартные функции нахождения квадратного корня - Sqr и модуля - Abs. Поэтому Вы уже можете записать следующие операторы присваивания:

Koren:=Sqrt(x-y);
Modul:=Abs(x-y)

В этом случае программа будет иметь вид:

Program Znachenia;
Uses
  Crt;
Var
  x, y : integer;
  Koren, Modul : real;
Begin
  ClrScr;
  write ('Введите значения переменных х и у через пробел ');
  readln (x, y);
  Koren:=Sqrt(x-y);
  Modul:=Abs(x-y);
  write ('Значение квадратного корня из выражения (х-у) равно ', Koren);
  write ('Значение модуля выражения (х-у) равно ', Modul);
  readln;
End.

Казалось бы, задача решена. Но мы не учли области допустимых значений для нахождения квадратного корня и модуля. Из курса математики Вы должны знать, что можно найти модуль любого числа, а вот значение подкоренного выражения должно быть неотрицательно (больше или равно нулю).

Поэтому наша программа имеет свою допустимую область исходных данных. Найдем эту область. Для этого запишем неравенство х-у>=0, то есть х>=у. Значит, если пользователем нашей программы будут введены такие числа, что при подстановке значение этого неравенства будет равно True, то квадратный корень из выражения (х-у) извлечь можно. А если значение неравенства будет равно False, то выполнение программы закончится аварийно.

Задание. Наберите текст программы. Протестируйте программу со следующими значениями переменных и сделайте вывод.

  1. х=23, у=5;

  2. х=-5, у=15;

  3. х=8, у=8.

Каждая программа, насколько это возможно, должна осуществлять контроль за допустимостью величин, участвующих в вычислениях. Здесь мы сталкиваемся с разветвлением нашего алгоритма в зависимости от условия. Для реализации таких условных переходов в языке Паскаль используют операторы If и Case, а также оператор безусловного перехода Goto.

Рассмотрим оператор If.

Для нашей задачи нужно выполнить следующий алгоритм:

если х>=у,
то вычислить значение квадратного корня,
иначе выдать на экран сообщение об ошибочном введении данных.

Запишем его с помощью оператора If. Это будет выглядеть так.

if x>=y
  then
    Koren:=Sqr(x-y)
  else
write ('Введены недопустимые значения переменных');

Теперь в зависимости от введенных значений переменных х и у, вычисление квадратного корня может выполняться или не выполняться.

В общем случае полная форма конструкции условного оператора имеет вид:

if <логическое выражение> 
  then
    <оператор 1> 
  else 
    <оператор 2>

Условный оператор работает по следующему алгоритму.

Сначала вычисляется значение логического выражения, расположенного за служебным словом IF. Если его результат истина, выполняется <оператор 1>, расположенный после слова THEN, а действия после ELSE пропускаются; если результат ложь, то, наоборот, действия после слова THEN пропускаются, а после ELSE выполняется <оператор 2>.

Управляющая структура if может показаться негибкой, так как выполняемые действия могут быть описаны только одним оператором. Иногда может потребоваться выполнение последовательности операторов. В этом случае хотелось бы заключить всю последовательность в воображаемые скобки. В Паскале предусмотрен этот случай.

Если в качестве оператора должна выполниться серия операторов, то они заключаются в операторные скобки begin-end. Конструкция Begin ... End называется составным оператором.

if <логическое выражение>
  then
    begin 
      оператор 1;
      оператор 2;
      ...
    end
  else 
    begin
      оператор 1;
      оператор 2;
      ...
    end;

Определение. Составной оператор - объединение нескольких операторов в одну группу. Группа операторов внутри составного оператора заключается в операторные скобки (begin-end).

begin
  оператор 1;
  оператор 2;
end;

С учетом полученных знаний преобразуем нашу программу.

Program Znachenia;
Uses
  Crt;
Var
  x, y : integer;
  Koren, Modul : real;
Begin
  ClrScr;
  write ('Введите значения переменных х и у через пробел ');
  read (x, y);
  if x>=y
    then
      begin
        Koren:=Sqr(x-y);
        Modul:=Abs(x-y);
        write ('Значение квадратного корня из выражения (х-у) равно ', Koren);
        write ('Значение модуля выражения (х-у) равно ', Modul);
      end
    else
      write ('Введены недопустимые значения переменных');
  readln;
End.

Составным оператором является и такой оператор

begin
  S:=0;
end.

Cимвол “;” в данном случае разделяет оператор присваивания S:=0 и пустой оператор.

Пустой оператор не влечет никаких действий и в записи программы никак не обозначается.

Например, составной оператор

begin
end.

включает лишь один пустой оператор.

Если Вы обратили внимание, программа на языке Паскаль всегда содержит один составной оператор - раздел операторов программы.

Внимание! Перед служебным словом Else разделитель (точка с запятой) не ставится.

Отметим, что большинство операторов в программах на языке Паскаль заканчиваются точкой с запятой, но после некоторых операторов точка с запятой не ставится. Сформулируем общие правила употребления точки с запятой:

  1. Каждое описание переменной и определение константы заканчиваются точкой с запятой.

  2. Каждый оператор в теле программы завершается точкой с запятой, если сразу за ним не следуют зарезервированные слова End, Else, Until.

  3. После определенных зарезервированных слов, таких, как Then, Else, Var, Const, Begin, никогда не ставится точка с запятой.

Рассмотрим еще один пример.

Задача. Вывести на экран большее из двух данных чисел.

Program Example1;
Var
  x, y : integer; {вводимые числа}
Begin
  writeln('Введите 2 числа '); {вводим два целых числа через пробел}
  readln(x,y);
  if x>y
    then
      writeln (x) {если х больше y, то выводим х}
    else
      writeln (y); {иначе выводим y}
    readln;
End.

Можно также использовать и сокращенную (неполную) форму записи условного оператора. Эта форма используется тогда, когда в случае невыполнения условия ничего делать не надо.

Неполная форма условного оператора имеет следующий вид.

if <логическое выражение> 
  then
    <оператор>

Тогда если выражение, расположенное за служебным словом IF. в результате дает истину, выполняются действия после слова THEN, в противном случае эти действия пропускаются.

Задача. Составить программу, которая, если введенное число отрицательное, меняет его на противоположное.

Program Chisla;
Var
  x : integer; {вводимое число}
Begin
  writeln('Введите число '); {вводим целое число}
  readln(x);
  if x<0
    then
      x:=-x;
  writeln (x);
  readln;
End.



Выбранный для просмотра документ Вставка элементов в одномерный массив.doc

библиотека
материалов

Вставка элементов в одномерный массив

Вставка одного элемента

Вставлять элемент можно до или после данного элемента, номер этого элемента можно вводить с клавиатуры или искать по определенному условию.

Пусть k - это номер элемента, после которого мы должны вставить элемент х. Тогда вставка осуществляется следующим образом:

  • первые k элементов массива остаются без изменения,

  • все элементы, начиная с (k+1)-го, необходимо сдвинуть на один назад,

  • на место (k+1)-го элемента записываем значение х;

  • увеличиваем количество элементов в массиве на единицу.

Задача. Вставить число 100 после пятого элемента массива.

Рассмотрим конкретный пример. Пусть задан следующий одномерный массив из N (N=10) элементов:

3, -12, 5, 14, 27, -6, 1, -34, 10, -15.

Надо вставить 100 после пятого элемента массива, т. е. должен получиться следующий массив:

3, -12, 5, 14, 27, 100, -6, 1, -34, 10, -15.

Таким образом, в массиве стало 11 элементов, то есть массив надо определять на N+1 элемент:

Type
  MyArray = array[1..n+1] of integer

Кроме того, в программе необходимо выводить массив два раза, сначала первые N элементов массива, а затем полный массив из N+1 элемента.

Рассмотрите процедуру вставки Insert1(m, n, Mesto, Element), которой передаются:

m - массив, в котором делаем преобразования;
n - количество элементов в массиве,
Mesto - номер элемента, после которого надо вставить данный,
Element - число, которое вставляем.

Кроме того, сдвиг элементов будем начинать с последнего элемента.

Program Vstavka1;
Const
  n=10; 
Type
  MyArray = array [1..n+1] of integer;
Var
  A : MyArray;
  k, x : Integer;

Procedure InsertMas1(Var m : MyArray; n : integer);
  . . .

Procedure InsertMas2(Var m : MyArray; n : integer);
  . . .

Procedure PrintMas(m : MyArray; n : integer);
  . . .

Procedure Insert1(Var m : MyArray; Var n : integer; Mesto, Element : integer);
Var
  i : integer;
Begin
  for i := n downto Mesto+1 do
    m[i+1] := m[i];
  m[Mesto+1]:= Element;
  Inc(n);
End;

Begin
  . . .
  Writeln('Номер элемента, после которого вставлять > ');
  Readln(k);
  Writeln('Вставляемое число > ');
  Readln(x);
  Insert1(A, n, k, x);
  . . .
End.

Задание. На основе разобранной задачи самостоятельно напишите программу вставки числа перед некоторым заданным элементом. Дополните программу необходимыми операторами и комментариями и добейтесь работоспособности программы.

Вставка нескольких элементов

Задача. Вставить число после всех элементов массива, кратных трем.

Первое, на что необходимо обратить внимание - это описание массива: на сколько элементов может увеличиться массив? Максимальное количество элементов, после которых будет вставлен новый элемент, совпадает с количеством элементов массива, так как может случиться, что все элементы массива отвечают заданному свойству. Поэтому массив может увеличиться в два раза, а значит, соответствующее ему описание будет следующим:

Type
  MyArray[1..2*n] of Integer;

Второе. Если мы будем просматривать массив с начала и вставлять новый после элемента с заданным свойством, то номер последнего элемента каждый раз может меняться, кроме того, будет просматриваться и новый (вставленный) элемент и его необходимо будет пропускать, поэтому решение будет не очень эффективным. Лучше всего просматривать массив, начиная с конца, тогда вставляемый элемент мешать не будет. Кроме того, номер последнего элемента можно будет знать (если знать, сколько элементов вставлено на данный момент), при этом просмотр будет последовательным от N-го до 1-го.

Program VstavkaN;
Const
  n=10; 
Type
  MyArray = Array [1..2*n] of Integer;
Var
  A : MyArray;
  k, x, i : Integer;

Procedure InsertMas1(Var m : MyArray; n : integer);
  . . .

Procedure InsertMas2(Var m : MyArray; n : integer);
  . . .

Procedure PrintMas(m : MyArray; n : integer);
  . . .

Procedure InsertN(Var m : MyArray; Var n : integer; Mesto, Element : Integer;);
Var
  i : Integer;
Begin
  for i := n downto Mesto+1 do
    m[i+1] := m[i];
  m[Mesto+1]:= Element;
  Inc[n];
End;

Begin
  . . .
  Writeln('Вставляемое число > ');
  Readln(x);
  k:=0;
  for i:=n downto 1 do
    if A[i] mod 3=0
      then
        InsertN(A, n, i, x);
  . . .
End.

Задание. Дополните программу необходимыми операторами и комментариями и добейтесь работоспособности программы.



Выбранный для просмотра документ Доступ к элементам массива.docx

библиотека
материалов

Доступ к элементам массива

Рассмотрите предложенные ниже фрагменты программ для решения некоторых типичных задач.

Изменение значения некоторых элементов

Задача. Заменить отрицательные элементы на противоположные по знаку.

Для этого опишем процедуру. Ей будем передавать параметры - количество элементов в массиве и массив, который будет также и результатом выполнения процедуры, так как некоторые его элементы могут быть заменены.

Procedure Zamena (Var m : MyArray; n:integer);
Var
  i : integer;
Begin
  for i := 1 to n do
    if m[i] < 0
      then
        m[i] := -m[i];
End;

Нахождение номеров элементов с заданным свойством

Задача. Найти и вывести на экран номера четных элементов.

Для решения задачи необходимо просмотреть весь массив, и если просматриваемый элемент является четным, то выводить его номер.

Procedure PoiskChet(m : MyArray; n:integer);
Var
  i : integer;
Begin
  for i := 1 to n do
    if m[i] mod 2 =0
      then
        Write(i:5);
End;

Нахождение количества элементов с заданным свойством

Задача. Найти количество положительных и отрицательных элементов в данном массиве.

Опишем процедуру, которой будем отправлять параметры - массив, количество элементов в массиве и два счетчика, один для элементов, больших нуля, а второй - для отрицательных элементов.

Procedure OtrPol(m : MyArray; n:integer; Var k1, k2 : Integer);
Var
  i : integer;
Begin
  k1 :=0;
  k2 :=0;
  for i := 1 to n do
    if m[i] > 0
      then
        Inc(k1)
      else
        if m[i] < 0
          then
            Inc(k2);
End;

 Есть ли в данном массиве элементы с данным свойством?

Для решения таких задач удобнее использовать циклы с условиями и составлять функции, результат которых имеет логический тип.

Задача. Есть ли отрицательный элемент в массиве?

Начинаем с первого элемента (i=1). Пока не просмотрен последний элемент (i<=n) и не найден отрицательный (m[i]>=0), будем переходить к следующему (Inc(i)). Таким образом, мы закончим просмотр массива в одном из двух случаев: первый – просмотрели все элементы и не нашли отрицательный, тогда i>n, второй – нашли нужный, при этом i<=n. Опишем функцию, значение которой истина (True), если такой элемент есть, и ложь (False), если его нет.

Function Control (m : MyArray; n:integer) : Boolean;
Var
  i : integer;
Begin
  i := 1;
  while (i<=n) and (m[i]>0) do
    Inc(i);
  Control := (i<=n);
End;



Выбранный для просмотра документ Удаление элементов из одномерного массива.doc

библиотека
материалов

Удаление элементов из одномерного массива

Задача. Удалить из массива максимальный элемент, если все элементы разные.

Для того, чтобы решить задачу нужно:

  • найти номер максимального элемента k;

  • сдвинуть все элементы, начиная с k-го, на один элемент влево;

  • последнему элементу присвоить значение 0;

  • уменьшить количество элементов массива на единицу.

Рассмотрим задачу на конкретном примере. Пусть дан одномерный массив из целых чисел, состоящий из 10 элементов:

6, 3, 4, 7, 11, 2, 13, 8, 1, 5.

Номер максимального элемента равен 7 (k=7), то есть, начиная с 7-го элемента, будем сдвигать элементы на один влево: 7-му присвоим значение 8-го, 8-му присвоим значение 9-го, 9-му присвоим значение 10-го, на этом сдвиг заканчивается. Таким образом, сдвиг начинается с k-го элемента и идет по (n-1)-й (где n - количество элементов в массиве). После этого последнему элементу присвоим значение, равное 0, и тогда массив будет следующим:

6, 3, 4, 7, 11, 2, 8, 1, 5, 0.

Примечание. При удалении элемента размерность массива не изменяется.

Составим программу, удаляющую максимальный элемент из одномерного массива. В программе опустим уже знакомые Вам процедуры заполнения массива и вывода элементов массива на экран. Чтобы последний элемент не выводился, модифицируйте соответствующую процедуру таким образом, чтобы ей передавать не только массив, но и количество элементов, которые надо вывести, начиная с первого.

Program DeleteK;
Const
  n=30; 
Type
  MyArray = Array [1..n] of Integer;
Var
  A : MyArray;
  k : Integer;

Procedure InsertMas1(Var m : MyArray; n : integer);
  . . .

Procedure InsertMas2(Var m : MyArray; n : integer);
  . . .

Procedure PrintMas(m : MyArray; n : integer);
  . . .

Function Maximum (m : MyArray; n:integer) : Integer;
Var
  i, max, maxi : integer;
Begin
  max:=-maxint; {начальным значением переменной будет наименьшее значение данного типа}
  for i := 1 to n do {просматриваем все элементы массива}
    if m[i] > max {если найден элемент больше, чем тот, что мы считаем максимальным}
      then
        begin
          max:=A[i]; {то запомним найденное значение}
          maxi:=i; {а также место, на котором он стоит в массиве}
        end;
  Maximum := maxi; {имени функции присвоим найденный результат}
End;

Procedure Delete(Var m : MyArray; Var n:integer; k1 : integer);
Var
  i : integer;
Begin
  for i := k1 to n-1 do
    m[i] := m[i+1];
  m[n]:=0;
  Dec(n);
End;

Begin
  . . .
  k:=Maximum(A,n);
  Delete(A,n,k);
  . . .
End.

Задание. На основе имеющегося шаблона программы и рассмотренного алгоритма решения задачи, закончите составление работающей программы.

Изменим условие задачи. Пусть максимальный элемент встречается несколько раз.

Для решения этой задачи необходимо удалять несколько элементов. Это лучше сделать с конца массива, так как иначе, возможно, придется снова возвращаться к элементу с номером, который только что удаляли. Эта ситуация может возникнуть в случае, когда в массиве подряд идут два максимальных элемента. При удалении первого на его месте будет стоять второй максимальный элемент.

Просмотр элементов массива с конца можно реализовать при помощи цикла с параметром (downto). Кроме того, номер максимального элемента запоминать не будем. При прохождении массива с конца, если элемент имеет максимальное значение, то удалим его, при этом значение счетчика k будем увеличивать на 1.

Задание. С учетом изложенного выше составьте программу, решающую поставленную задачу или дополните предыдущую.

Внимание! Любая Ваша программа должна сопровождаться комментариями



Выбранный для просмотра документ ерестановка элементов массива.doc

библиотека
материалов

ерестановка элементов массива

Перестановка двух элементов

Задача. Поменять местами два элемента массива с номерами k1 и k2.

Рассмотрите процедуру, с помощью которой эта задача легко решается.

Procedure Obmen2(Var m : MyArray; n, k1, k2 : integer;);
Var
  x : integer;
Begin
  x:=m[k1];
  m[k1] := m[k2];
  m[k2] := x;
End;

Перестановка части массива

Задача. Дан одномерный массив А, состоящий из 2n элементов. Поменять местами первую и вторую его половины

Задание. Оформите решение этой задачи, применив процедуру обмена значений Obmen2, рассмотренную выше.

Заметим лишь, что Вы должны поменять местами элементы с номерами 1 и n+1, 2 и n+2 и т.д., последняя пара - n и 2n, а значит, обмен происходит по правилу: элемент с номером i меняется местами с элементом с номером n+i. Эту закономерность следует применить в организации обращения к процедуре обмена. Например, так:

for i := 1 to n do
  Obmen2(A, 2*n, i, i+n,);

Работа с несколькими массивами

В Turbo Pascal можно одним оператором присваивания передать все элементы какого-либо массива другому массиву того же типа, например:

Var
  a, b: array [1 .. 5] of integer;
Begin
  ...
  a:=b;
  ...
End.

После такого присваивания все пять элементов массива a получат значения из массива b.

Рассмотрим одну из типичных задач.

Задача. Найти скалярное произведение двух массивов.

Скалярным произведением двух массивов одинаковой размерности называется сумма произведений соответствующих элементов. Это можно записать так:

a[1]*b[1] + a[2]*b[2] + ... + a[n-1]*b[n-1] + a[n]*b[n],

где n - это количество элементов в массивах (размерность).

Тогда можно составить следующую функцию:

Function Sp (a, b : MyArray; n ; integer) : LongInt;
Var
  i : Integer;
  s : LongInt;
Begin
  s:= 0;
  for i := 1 to n do
    s := s+a[i]*b[i];
  Sp := s;
End;



Выбранный для просмотра документ Знакомство с языком Паскаль.doc

библиотека
материалов

Знакомство с языком Паскаль

Возникновение и назначение Паскаля

После того как построен алгоритм решения задачи, составляется программа на определенном языке программирования.

Среди современных языков программирования одним из самых популярных является язык Паскаль. Этот язык разработан в 1971 году и назван в честь Блеза Паскаля - французского ученого, изобретателя механической вычислительной машины. Автор языка Паскаль - швейцарский профессор Никлаус Вирт.

Паскаль - это универсальный язык программирования, позволяющий решать самые разнообразные задачи обработки информации.

Команду алгоритма, записанную на языке программирования, принято называть оператором.

Программа на Паскале близка по своему виду к описанию алгоритма на Алгоритмическом языке. Сравните алгоритм решения уже знакомой вам задачи - деления простых дробей с соответствующей программой на Паскале:

алг Деление дробей
цел a, b, с, d, m, n
нач
     ввод а, b, c, d
     m:= a x d
     n:= b x c
вывод m, n
кон

Program Division;
   var a, b, с, d, m, n: integer;
begin
     readln (a,b, c,d) ; {
Ввод}
     m:= a*d;    {
Числитель}
     n:= b*c;    {
Знаменатель}
     write (m, n)    {
Вывод}
end.

Структура программы на Паскале

Даже не заглядывая в учебник по Паскалю, в этой программе можно все понять (особенно помогает знание английского языка).

Заголовок программы начинается со слова Program (программа), за которым следует произвольное имя, придуманное программистом:

Program <имя программы>;

Раздел описания переменных начинается со слова Var (variables - переменные), за которым идет список имен переменных через запятую. Тип указывается после двоеточия. В стандарте языка Паскаль существуют два числовых типа величин: вещественный и целый. Слово integer обозначает целый тип (является идентификатором целого типа). Вещественный тип обозначается словом real. Например, раздел описания переменных может быть таким:

var a, b : integer; с, d : real;

Идентификаторы переменных составляются из латинских букв и цифр; первым символом обязательно должна быть буква.

Раздел операторов - основная часть программы. Начало и конец раздела операторов программы отмечаются служебными словами begin (начало) и end (конец). В самом конце программы ставится точка:

begin
< операторы >
end.

Операторы ввода, вывода, присваивания

Ввод исходных данных с клавиатуры происходит по оператору read (read - читать) или readln (read line - читать строку):

read(<список переменных>); 
или readln(<список переменных>);

При выполнении команды ввода компьютер ожидает действий пользователя. Пользователь набирает на клавиатуре значения переменных в том порядке, в каком они указаны в списке, отделяя их друг от друга пробелами. Одновременно с набором данных на клавиатуре они появляются на экране. В конце нажимается клавиша <ВВОД> (<Еnter>). Разница в выполнении операторов readln и read состоит в том, что после выполнения ввода по оператору readln экранный курсор перемещается в начало новой строки, а по оператору read этого не происходит.

Вывод результатов происходит по оператору write (write - писать) или writeln (write line - писать в строку):

write(<список вывода>);
или writeln(<список вывода>);

Результаты выводятся на экран компьютера в порядке их перечисления в списке. Элементами списка вывода могут быть константы, переменные, выражения.

Разница в выполнении операторов writeln и write состоит в том, что после выполнения вывода по оператору writeln экранный курсор перемещается в начало новой строки, а по оператору write этого не происходит.

Арифметический оператор присваивания на Паскале имеет следующий формат:

<числовая переменная> := <арифметическое выражение>

Арифметическое выражение может содержать числовые константы и переменные, знаки арифметических операций, круглые скобки. Кроме того, в арифметических выражениях могут присутствовать функции.

Знаки основных арифметических операций записываются так:

+ сложение,
- вычитание,
* умножение,
/ деление.

Правила записи арифметических выражений

Запись арифметических выражений на Паскале похожа на обычную математическую запись. В отличие от математики, где часто пропускается знак умножения (например, пишут 2А), в Паскале этот знак пишется обязательно: 2*А. Например, математическое выражение

А2 + В2 - 12С

на Паскале записывается так:

А*А + В*В - 12*С

Это же выражение можно записать иначе:

SQR(A) + SQR(B) - 12*С

Здесь использована функция возведения в квадрат - SQR. Аргументы функций всегда пишутся в круглых скобках.

Последовательность выполнения операций определяется по их приоритетам (старшинству). К старшим операциям относятся умножение (*) и деление (/). Операции сложения и вычитания - младшие. В первую очередь выполняются старшие операции. Несколько операций одинакового старшинства, записанные подряд, выполняются в порядке их записи слева направо. Приведенное выше арифметическое выражение будет вычисляться в следующем порядке (порядок вычислений указан цифрами сверху):

hello_html_289b6e3a.png




Круглые скобки в арифметических выражениях влияют на порядок выполнения операций. Как и в математике, в первую очередь выполняются операции в скобках. Если имеются несколько пар вложенных скобок, то сначала выполняются операции в самых внутренних скобках. Например:

hello_html_m5535acf0.png




Пунктуация Паскаля

Необходимо строгое соблюдение правописания (синтаксиса) программы. В частности, в Паскале однозначно определено назначение знаков пунктуации.

Точка с запятой (;) ставится в конце заголовка программы, в конце раздела описания переменных, является разделителем операторов. Перед словом end точку с запятой можно не ставить.

Запятая (,) является разделителем элементов во всевозможных списках: списке переменных в разделе описания, списке вводимых и выводимых величин.

Строгий синтаксис в языке программирования необходим потому, что компьютер является формальным исполнителем программы. Если, допустим, разделителем в списке переменных должна быть запятая, то любой другой знак будет восприниматься как ошибка. Если точка с запятой является разделителем операторов, то в качестве оператора компьютер воспринимает всю часть текста программы от одной точки с запятой до другой. Если программист забыл поставить ";" между какими-то двумя операторами, то компьютер будет принимать их за один с неизбежной ошибкой.

В программу на Паскале можно вставлять комментарии. Комментарий - это пояснение к программе, которое записывается в фигурных скобках. В комментариях можно использовать русские буквы. На исполнение программы комментарий никак не влияет.

Заметим, что в Паскале нет различия между строчными и прописными буквами. Например, для Паскаля тождественны следующие варианты записи: begin, Begin, BEGIN, BeGiN. Использование строчных или прописных букв - дело вкуса программиста.

Вопросы и задания

1. Когда появился язык Паскаль и кто его автор?

2. Как записывается заголовок программы на Паскале?

3. Как записывается раздел описания переменных?

4. С какими типами числовых величин работает Паскаль?

5. Как записываются операторы ввода и вывода в Паскале?

6. Что такое оператор присваивания?

7. Как записываются арифметические выражения?

8. По каким правилам определяется порядок выполнения операций в арифметическом выражении?

9. Какая задача решается по следующей программе?

Program Test;
   var А, В, С: integer;
begin
     readln(A,B);
     
С:=(А+В)*(В-А);
     writeln(
С
end.

Какой результат будет получен, если в качестве исходных значений А и В ввести соответственно 7 и 8?



Выбранный для просмотра документ Тип данных char.doc

библиотека
материалов

Тип данных char. Операции над символами

В большинстве применений компьютера алфавитно-цифровая информация используется наряду с числовой. Прежде чем мы сможем написать программу, которая манипулирует алфавитно-цифровыми знаками (литерами), нам потребуется тип данных для их представления. Для этих целей в языке Паскаль предусмотрен тип данных char.

Так же, как переменная типа integer может хранить одно целое число, переменная типа char может хранить один символ.

Например,

Var
  Alpha : char;
Begin
  Alpha :='p';
  Alpha :='+';
  Alpha :='3';
  Alpha :=' ';
  Alpha :='''';

Первый оператор присваивания записывает в переменную Alpha литеру р.

Второй делает Alpha равной литере плюса (+).

Третий делает Alpha равной символу 3. Заметим, что символ 3 отличается от целого числа 3 тем, что символ не может быть использован в арифметических операциях.

Четвертый оператор присваивания делает Alpha равной литере пробела. Хотя литера пробела при печати не изображается, она является обыкновенным значением типа char.

Последний оператор присваивания делает Alpha равной литере апострофа, это специальный случай, так как знак апострофа используется для ограничения значения типа char.

Мы будем пользоваться множеством литер, находящимся в таблице кодов, называемой ASCII - американский стандартный код обмена информацией.

Все символы упорядочены, т.к. имеют свой личный номер. Важно, что соблюдаются следующие отношения:

  'A' < 'B' < 'C' < ... < 'X' < 'Y' < 'Z' '0' < '1' < '2' < ... < '7' < '8' < '9'

Для проверки равенства или неравенства переменных типа char могут использоваться операторы сравнения.

Задача. Написать программу, которая считывает две литеры и печатает больше, равна или меньше первая литера второй.

Program Sravnenie;
Var
  First, Second : char;
Begin
  write ('
Введите две литеры: ');
  readln (First, Second);
  write ('
Первая литера ');
  if First > Second
    then
      write ('
больше второй. ')
    else
      if First = Second
        then
          write ('
равна второй. ')
        else
          write ('
меньше второй. ');
Еnd.

Так как char - порядковый тип, то к его значениям применимы следующие функции.

Succ - возвращает следующий символ литерного множества;

Pred - возвращает предыдущий символ литерного множества;

Ord - возвращает значение кода литеры;

Chr - возвращает значение литеры по ее коду, является обратной по отношению к функции Ord.

Например,

Succ('0')='1' - символ, следующий за символом 0, равен символу 1.

Pred('3')='2' - символ, предшествующий символу 3, равен 2;

Chr(65)='A' - символ, соответствующий коду 65, равен А;

Ord('A')=65 - код символа А равен 65.



Выбранный для просмотра документ паскаль 1 урок.doc

библиотека
материалов

Паскаль - язык профессионального программирования, который назван в честь французского математика и философа Блеза Паскаля (1623-1662) и разработан в 1968-1971 гг. Никлаусом Виртом. Первоначально был разработан для обучения, но вскоре стал использоваться для разработки программных средств в профессиональном программировании.

Паскаль популярен среди программистов по следующим причинам:

  1. Прост для обучения.

  2. Отражает фундаментальные идеи алгоритмов в легко воспринимаемой форме, что предоставляет программисту средства, помогающие проектировать программы.

  3. Позволяет четко реализовать идеи структурного программирования и структурной организации данных.

  4. Использование простых и гибких структур управления: ветвлений, циклов.

  5. Надежность разрабатываемых программ.

Турбо Паскаль - это система программирования, созданная для повышения качества и скорости разработки программ (80-е гг.). Слово Турбо в названии системы программирования - это отражение торговой марки фирмы-разработчика Borland International (США).

Систему программирования Турбо Паскаль называют интегрированной (integration - объединение отдельных элементов в единое целое) средой программирования, т.к. она включает в себя редактор, компилятор, отладчик, имеет сервисные возможности.

Основные файлы Турбо Паскаля:

Turbo.exe - исполняемый файл интегрированной среды программирования;

Turbo.hlp - файл, содержащий данные для помощи;

Turbo.tp - файл конфигурации системы;

Turbo.tpl - библиотека стандартных модулей, в которых содержатся встроенные процедуры и функции (SYSTEM, CRT, DOS, PRINTER, GRAPH, TURBO3, GRAPH3).

Запуск интегрированной среды программирования

Для запуска интегрированной среды программирования нужно установить текущим каталог с Турбо Паскалем (TP7\BIN) и ввести команду: turbo.exe.

Задание. Запустите среду программирования и рассмотрите экран. Перед вами полоса меню, область окна и строка статуса. Нажмите клавишу F10 - теперь вам доступны все опции меню. Используя клавиши управления курсором, рассмотрите меню. С командами меню мы будем знакомиться постепенно. Нажмите клавишу Esc (вы вышли из меню). Перемещая курсор в окне, следите за строкой статуса. Какая информация отражается в этой строке?

Почти все, что вы видите и делаете в среде Турбо Паскаль, происходит в окнах.

Окно - это область экрана, которую можно перемещать, изменять в размере, перекрывать, закрывать и открывать.

Интегрированная среда программирования Турбо Паскаль позволяет иметь любое количество открытых окон, но в любой момент времени активным может быть только одно.

Активное окно – это окно, с которым вы в настоящий момент работаете.

Общие горячие клавиши:

F1 - выводит окно подсказки;

F2 - сохраняет файл активного окна;

F3 - появление диалогового окна и возможность открыть файл;

F4 - запускает программу до строки, на которой стоит курсор;

F5 - масштабирует диалоговое окно;

F6 - переходит к следующему открытому окну;

F7 - запускает программу в режиме отладки с заходом внутрь процедур; 

F8 - запускает программу в режиме отладки, минуя вызов процедур;

F9 - компилирование программы в текущем окне;

F10 - возвращение в меню.

Мы начнем изучение меню с наиболее важных и необходимых режимов.

Как войти в меню? Всего есть три возможности:

  • с помощью "мышки";

  • с помощью клавиши F10; 

  • с помощью комбинации Alt+<выделенная буква>. О том, что мы в меню свидетельствует курсор - прямоугольник зеленого цвета.

С помощью клавиш управления курсором подсветите слово FILE и нажмите клавишу "Enter". Что вы видите?

Появилась вертикальная таблица со списком команд, называемая выпадающим меню. Познакомимся с ним.

Open-F3 - открыть существующий файл (при активизации этой опции появляется окно со списком файлов, где можно выбрать необходимый),

New - создать новый файл (очищает память редактора и переводит в режим создания нового файла, которому присваивается имя Noname.pas; имя можно изменить при записи файла на диск),

Save-F2 - сохранить файл (переписывает файл из памяти редактора на диск),

Save as - сохранить с новым именем,

Save all - сохранить все в окнах (записывает содержимое всех окон редактора в соответствующие файлы),

Change dir - смена каталога (позволяет изменить установленный по умолчанию диск или каталог),

Print - печать файла,

Get info - выдача информации о текущем состоянии программы и используемой памяти,

DOS Shell - выход в DOS без выгрузки из памяти (для возврата ввести команду exit),

Exit - выход и выгрузка из памяти.

Программы на языке Паскаль имеют блочную структуру:

1. Блок типа PROGRAM - имеет имя, состоящее только из латинских букв и цифр. Его присутствие не обязательно, но рекомендуется записывать для быстрого распознавания нужной программы среди других листингов.

2. Программный блок, состоящий в общем случае из 7 разделов:

  • раздел описания модулей (uses);

  • раздел описания меток (label); 

  • раздел описания констант (const);

  • раздел описания типов данных (type);

  • раздел описания переменных (var);

  • раздел описания процедур и функций;

  • раздел описания операторов.

Общая структура программы на языке Паскаль следующая:

Рrogram ИМЯ..; {заголовок программы}
Uses ...; {раздел описания модулей}
Var ..; {раздел объявления переменных}
  ...
Begin {начало исполнительной части программы}
  ... {последовательность
  ... операторов}
End. {конец программы}

Начнем знакомство с Паскалем с программы, которая складывает два числа и выводит сумму на экран.

Откройте файл, в который Вы запишите эту программу. Для этого нажмите клавишу F10, чтобы выйти в главное меню, затем клавишами перемещения курсора выберите опцию File, а в выпавшем меню команду New.

Примечание. Обратите внимание на оформление текста программы.

  
Program Summa2; 
  {Задача. Вычислить сумму двух чисел и вывести на экран.
    Решение. Иванов Петр, 10 А класс.}
Var
  number1, {переменная для хранения первого числа}
  number2, {переменная для хранения второго числа}
  result {переменная для хранения результата вычисления}
  : integer; 
Begin {признак начала программы}
  number1 := 3; {присваиваем переменной number1 значение 3}
  number2 := 4; {присваиваем переменной number2 значение 4}
  {складываем значения переменных number1 и number2 и результат присваиваем переменной result }
  result := number1 + number2;
  Write (number1, '+', number2,'=',result); {вывод примера на экран}
End. {признак конца программы}

Задание.

  1. Найдите в этой программе заголовок, раздел описания переменных, признак начала программы, признак конца программы, тело программы, комментарий.

  2. Что обозначает строчка:
    number1, number2, result : integer; 

  3. Как вы понимаете запись:
    number1 := 3;

  4. Чему равно значение переменной result после выполнения оператора:
    result := number1 + number2;

  5. Переведите с английского языка слово Write. Как вы думаете, что должен делать оператор с таким названием?

  6. Поменяем местами второй и третий операторы. Будет ли программа работать? Почему?

  7. Какой недостаток Вы видите у этой программы? Как нужно изменить условие задачи, чтобы решать подобные задачи с любыми числами. Подумайте, что должно измениться в теле нашей программы, чтобы выполнить эту задачу.

А теперь подведем итог вашим размышлениям.

Имя этой программы Summa2. Заметим, что требования к имени выполняются: оно отражает содержание программы, а также не содержит недопустимых символов.

Далее идет специально выделенный комментарий, в котором вы должны записать подробно условие задачи и указать, кто написал эту программу и когда.

Из разделов описаний имеется лишь один - раздел переменных. Он начинается со служебного слова Var. Мы описали три переменные: number1, number2, result. Все они переменные целого типа. Поэтому мы перечислили их через запятую, поставили двоеточие и указали тип переменных. Подобные объявления разделяются между собой точкой с запятой.

После описательной части идет раздел операторов, начинающийся со служебного слова Begin, после которого идут операторы языка.

Недостатком этой программы является то, что значения переменных постоянны. А нам нужно научиться писать такие программы, которые решают поставленные задачи в общем виде, т. е. для любых значений переменных. Для этого мы научимся запрашивать значения у пользователя, анализировать их и выдавать соответствующий результат



Выбранный для просмотра документ цикл с постусловием 6 урок.doc

библиотека
материалов

Вы уже умеете организовать цикл при помощи оператора while. Напомним, что при выполнении этого оператора компьютер проверяет значение условия. Если условие истинно, то исполнительная часть оператора while будет повторяться до тех пор, пока это условие не примет значение False. Если значение условия есть False в самом начале, то тело цикла while вообще не будет выполняться.

Иногда при решении задач возникает необходимость выполнить тело цикла хотя бы один раз, а потом, проверив условие, определить, повторять ли тело цикла еще раз. Эту задачу выполнит другой вид цикла – цикл Repeat.

repeat {повторяй}
  {операторы операторы}
until <условие>; {до тех пор, пока условие не будет истинным}

Есть небольшое отличие в организации цикла repeat по сравнению с while: для выполнения в цикле repeat нескольких операторов не следует помещать эти операторы в операторные скобки begin ... end. Зарезервированные слова repeat и until действуют как операторные скобки.

Конструкция repeat ... until работает аналогично циклу while. Различие заключается в том, что цикл while проверяет условие до выполнения действий, в то время как repeat проверяет условие после выполнения действий. Это гарантирует хотя бы одно выполнение действий до завершения цикла.

Например,

a) repeat
      read (Number);
      Sum := Sum+Number;
    until Number=-1

b) repeat
      i := i+1;
      writeln (Sqr(i));
    until i>=10

Задача. Определить, является ли введенное число простым.

Алгоритм решения этой задачи будет следующий. При помощи операции mod проводим проверку всех целых чисел от 2 до введенного числа Number. Мы проверяем, является ли очередное проверяемое число делителем нашего числа (значит, остаток от деления введенного числа на проверяемое число равен нулю). Если такой делитель найден, значит, цикл досрочно завершает свою работу на некотором i-том шаге. Если делитель не найден, значит, цикл проверил все числа, и значение переменной цикла i будет равно конечному значению, т.е. Number. Поэтому, после записи цикла следует анализ значения переменной i и выводится соответствующее сообщение.

Примечание. Напомним, что простым называется число, которое не имеет делителей кроме 1 и самого себя.

Цикл не может продолжаться бесконечно, так как любое число всегда делится само на себя.

Program Prostoe;
Uses
  Crt;
Var
  i, {возможный делитель}
  Number : integer; {исследуемое число}
Begin
  ClrScr;
  writeln ('Какое число должно быть проверено? ');
  read (Number);
  i := 1;
  repeat
    i := i+1;
  until Number mod i = 0;
  if Number=i
    then
      writeln (Number,'
является простым')
    else
      writeln (Number,'
делится на ',i);
  readln;
End.

При построении циклов нужно быть очень аккуратным: следить за отсутствием ошибок как в фазе входа в цикл, так и в фазе завершения цикла.

Задание. Выберите две задачи, решенных Вами с помощью цикла с предусловием, и решите их с помощью цикла с постусловием.



Выбранный для просмотра документ цикл с предусловием 5 урок.doc

библиотека
материалов

Циклические алгоритмы. Цикл с предусловием

Очень многие алгоритмы, выполнение которых поручается компьютеру, по своей природе являются циклическими. И это не случайно, потому что человек обычно поручает машине рутинную работу, где нужно много считать, и счет производится по некоторым одинаковым правилам.

ОпределениеЦикл – это последовательность операторов, которая может выполняться более одного раза.

ОпределениеЦиклический алгоритм – это алгоритм, содержащий один или несколько циклов.

Возьмем для примера задачу: найти сумму некоторого количества чисел, задаваемых пользователем.

Исходными данными в этом случае являются переменная N - количество чисел и сами эти числа. Значение очередного числа обозначим переменной x. Результатом работы алгоритма станет сумма этих чисел, которую обозначим переменной S.

  S=x1+x2+x3+...+xN

Допустимые значения переменной N должны удовлетворять условию N>0, так как количество слагаемых не может быть числом отрицательным.

Как же мы должны решать эту задачу? Сначала нужно запросить, сколько чисел нужно будет сложить и считать это число в переменную N. Затем нужно так организовать операторы, чтобы программа запрашивала очередное число, каждый раз складывала его с предыдущими и повторяла эту группу операторов N раз.

В языке Паскаль существуют удобные конструкции для организации циклов:

  • цикл с предусловием;

  • цикл с постусловием;

  • цикл со счетчиком.

Познакомимся с первым из них – оператором цикла с предусловием while.

Циклы с предусловием используются тогда, когда выполнение цикла связано с некоторым логическим условием. Оператор цикла с предусловием имеет две части: условие выполнения цикла и тело цикла.

При выполнении оператора while определенная группа операторов выполняется до тех пор, пока определенное в операторе while булево условие истинно. Если условие сразу ложно, то оператор не выполнится ни разу.

Общая форма записи следующая

while <булево выражение> do
  begin
    группа операторов
  end;

На русском языке это звучит примерно так:

пока выполняется это условие, делай
  от начала
    группа операторов
  до конца;

Вполне понятно, что операторные скобки ставят, чтобы отделить от остальной программы ту группу операторов, которую нужно повторить в цикле. Если в цикле нужно выполнить только один оператор, то операторные скобки не ставят.

При использовании цикла с предусловием надо помнить следующее:

  1. значение условия выполнения цикла должно быть определено до начала цикла;

  2. если значение условия истинно, то выполняется тело цикла, после чего повторяется проверка условия. Если условие ложно, то происходит выход из цикла;

  3. хотя бы один из операторов, входящих в тело цикла, должен влиять на значение условия выполнения цикла, иначе цикл будет повторяться бесконечное число раз.

Вернемся к нашей задаче вычисления суммы чисел. При вычислении суммы используем следующий прием: вначале, когда еще не задано ни одно слагаемое, сумму полагают равной нулю (S:=0), а затем, получая очередное слагаемое, прибавляют его к сумме (S:=S+x) (см. программу ниже).

Очень важную роль в операторе цикла играет так называемая переменная цикла. В нашей программе она называется i. С ее помощью мы обращаемся к пользователю за очередным числом (write (‘Введите ‘,i,’-ое число ’)) и считаем количество уже введенных чисел (i:=i+1), чтобы не запросить лишнее. Одновременно переменная цикла участвует в булевом выражении (i<=N).

Рассмотрите внимательно программу, решающую нашу задачу.

Program Summa;
Uses
  Crt;
Var
  i,
  N : integer;
  x, S : real;
Begin
  ClrScr;
  write ('
Сколько чисел для сложения? ');
  readln (N);
  S:=0;
  i:=1;
  while i<=N do
    begin
      write ('
Введите ',i,'-е число ');
      readln (x);
      S:=S+x;
      i:=i+1;
    end;
  write ('
Сумма введенных чисел равна ',s:5:2);
  readln;
End.

Хотелось бы, чтобы Вы смогли представить работу этой программы. Давайте попробуем вместе.

Пусть нам требуется сложить следующие числа: 5, 7, -4, 0, 8, 20. Посчитаем, сколько их всего – шесть. Это число мы введем, когда программа задаст вопрос: Сколько чисел для сложения? Теперь наша программа запросит ввести 1-ое число, т. к. на первом шаге переменная i равна 1. Мы введем число 5. Программа считает его в переменную х. Теперь число 5 сложим с числом 0 и результат присвоим переменной S (оператор S:=S+x). В этот момент S становится равной 5. Чтобы перейти к следующему числу, увеличим значение переменной i на 1 (оператор i:=i+1). Выполнение операторов тела цикла закончено. Теперь программа переходит опять к анализу условия вхождения в цикл (i<=N). Переменная цикла i=2, переменная N=6, поэтому значение логического условия 2<=6 равно True. Значит снова выполняется тело цикла:

while i<=N do {2<=6}
  begin
    write ('Введите ',i,'-ое число '); {Введите 2-е число}
    readln (x); {Считали число 7}
    S:=S+x; {S:=5+7}
    i:=i+1; {i:=2+1}
  end;

Итак, мы сложили два числа и переходим опять к проверке условия. Ответим на вопрос: 3<=6? Да. Поэтому снова начинают работать операторы тела цикла, и мы переходим к третьему числу:

while i<=N do {3<=6}
  begin
    write ('Введите ',i,'-ое число '); {Введите 3-е число}
    readln (x); {Считали число -4}
    S:=S+x; {S:=12 + (-4)}
    i:=i+1; {i:=3+1}
  end;

Аналогично, мы сложим и остальные числа. Но когда же операторы цикла выполнятся последний раз и остановится работа цикла? Когда сложим последнее число. Проверим это.

while i<=N do {6<=6}
  begin
    write ('Введите ',i,'-ое число '); {Введите 6-е число}
    readln (x); {Считали число 20}
    S:=S+x; {S:=16+20}
    i:=i+1; {i:=6+1}
  end;

Проверяется опять условие 7<=6. Значение этого условия равно False, а значит, тело цикла выполняться не будет. Цикл закончил свою работу. А мы получили результат: посчитали сумму всех шести чисел S=32.

В этом примере известно заранее количество повторений - N раз. Но чаще всего этот вид цикла используется тогда, когда количество повторений заранее не известно и зависит от выполнения какого-либо условия. Рассмотрим еще один пример.

Отвлечемся от цифр и вспомним окружающую жизнь. Сколько циклических алгоритмов можно увидеть вокруг, если внимательно посмотреть на события: чередование времен года, посещения магазинов, школы или секции, получение оценок за контрольные и др. Попробуем записать их.

Например, рассмотрите следующие циклические алгоритмы

а) Пока не сдал выпускные экзамены делай:
    начало
      готовь уроки;
      посещай школу;
    конец;

б) Пока есть желание, возможность и здоровье делай:
      посещай занятия спортом

Задание. Выберите самостоятельно сказку из предложенных (или придумайте другой циклический алгоритм из жизни или произведений известных авторов) и напишите программы, с помощью которых можно в шутливой форме проверить знания первоклассников.

  1. Репка”. “Дед тянет-потянет, вытянуть не может. Позвал бабку. Бабка за дедку, дедка за репку, тянут потянут, вытянуть не могут. Позвала бабка внучку... И вытянули репку”.

  2. Курочка ряба”. “Снесла курочка яичко. Дед бил, бил, не разбил. Баба била, била, не разбила. Мышка бежала, хвостиком задела, яичко упало и разбилось”.

  3. Колобок”. “... Катится колобок по лесу. От зайца ушел, от медведя ушел, от волка ушел. Встретил лису, она его и съела”.

  4. Волк и лиса”. “... Сидит волк у проруби, хвост в воду опустил и приговаривает: “Ловись, ловись, рыбка, большая и маленькая”. Пришла за водой баба. Прогнала волка.

  5. Горшочек каши”. “... Варит горшок кашу, варит. Каша из дома на улицу потекла. Не знает мать девочки, что надо горшочку сказать. Пришла девочка, сказала: “Горшочек, не вари”. Перестал горшок кашу варить”.

Продолжим изучение цикла с предусловием на примере решения следующей задачи.

Задача. Найти сумму чисел в непустой последовательности.

Рассмотрим алгоритм решения. Пусть нам дана такая последовательность чисел:

  3, -4, 0, 5, 19, -20, 6, 2

Для работы нам нужно организовать обращение к каждому элементу последовательности. Нетрудно догадаться, что это будет происходить через порядковый номер каждого члена последовательности. Пронумеруем эти числа:

  1    2  3  4    5     6  7  8

  3, -4, 0, 5, 19, -20, 6, 2

Получилось, что всего у нас чисел восемь, на первом месте стоит число 3, на втором - число (-4), на третьем - число 0 и т.д. Тогда переменная цикла i будет пробегать числа от 1 до 8, становясь на каждом шаге больше на 1 и запрашивая каждый раз очередное число. Поэтому общая схема цикла будет выглядеть так:

i:=1;
while i<=N do
  begin
    write ('
Введите ',i,'-ое число');
    readln (x);
    . . .
   
i:=i+1;
  end;

Здесь N - количество чисел последовательности (в нашем случае 8), х - член последовательности, i - порядковый номер очередного члена последовательности. Просмотрим, как будет работать этот цикл.

1 шаг

i:=1;
while i<=N do {Проверяется условие 1<=8? Да. Значит, выполняем тело цикла}
  begin
    write ('Введите ',i,'-ое число');{Вывод на экран “Введите 1-ое число”}
    readln (x); {Считываем число 3 в переменную х}
    . . .
    i:=i+1; {Переходим к следующему по порядку числу: i=2}
  end;

2 шаг

while i<=N do {Проверяется условие 2<=8? Да. Значит, выполняем тело цикла}
  begin
    write ('Введите ',i,'-ое число');{Вывод на экран “Введите 2-ое число”}
    readln (x); {Считываем число (-4) в переменную х}
    . . .
    i:=i+1; {Переходим к следующему по порядку числу: i=3}
  end;

3 шаг

while i<=N do {Проверяется условие 3<=8? Да. Значит, выполняем тело цикла}
  begin
    write ('Введите ',i,'-ое число');{Вывод на экран “Введите 3-ое число”}
    readln (x); {Считываем число 0 в переменную х}
    . . .
    i:=i+1; {Переходим к следующему по порядку числу: i=4}
  end;

и т. д.

8 шаг

while i<=N do {Проверяется условие 8<=8? Да. Значит, выполняем тело цикла}
  begin
    write ('Введите ',i,'-ое число');{Вывод на экран “Введите 8-ое число”}
    readln (x); {Считываем число 2 в переменную х}
    . . .
    i:=i+1; {Переходим к следующему по порядку числу: i=9}
  end;

9 шаг

while i<=N do {Проверяется условие 9<=8? Нет. Значит, цикл закончил свою работу, и компьютер переходит к обработке следующего за end оператора}

Итак, у нас уже организован цикл считывания чисел. Осталось только вписать в тело цикла оператор, который бы суммировал все эти числа. Для этого опишем переменную Summa в разделе описания переменных и присвоим ей нулевое значение перед выполнением цикла. Тогда при каждом шаге нашего цикла значение этой переменной должно быть изменено на х. Это произойдет при выполнении оператора

  Summa:=Summa+x;

Если Вам не совсем понятно, что происходит при выполнении этого оператора, Вам нужно вспомнить, как происходит присваивание значение переменной: сначала вычисляется значение выражения в правой части (в нашем случае Summa+x, т.е., значение переменной Summa увеличиваем на х), а затем присваиваем это значение переменной с именем, записанным в левой части (Summa). Таким образом, в переменной Summa собирается сумма всех считанных чисел.

Задание. Напишите полный текст программы, находящей сумму N чисел последовательности. Дополните программу нахождением среднего арифметического этих чисел.

Примечание. Средним арифметическим чисел называется сумма этих чисел, деленная на их количество.



Выбранный для просмотра документ В цикле со счетчиком тело цикла повторяется заранее определенное число раз.doc

библиотека
материалов

В цикле со счетчиком тело цикла повторяется заранее определенное число раз. Циклы со счетчиком используются довольно часто, и поэтому в языке Паскаль для этих целей имеется специальная конструкция.

Можно, конечно, циклы со счетчиком моделировать при помощи операторов while и Repeat, но структура цикла со счетчиком проще.

Общая форма записи цикла со счетчиком

for i := A to B do
  begin
    . . .
 
end;


for i := A downto B    do
  begin
    . . .
 
end;

Здесь переменная i - управляющая переменная или переменная цикла,

А - начальное значение переменной цикла,

В - конечное значение переменной цикла.

При переходе к обработке оператора цикла for управляющей переменной присваивается заданное начальное значение. Затем в цикле выполняется исполнительный оператор (или составной оператор). Каждый раз при выполнении исполнительного оператора управляющая переменная увеличивается на 1 (для for...to) или уменьшается на 1 (для for...downto). Цикл завершается при достижении управляющей переменной своего конечного значения.

Например,

1) for i := 1 to ListSize do
    begin
      readln (Number):
      S := S +Number;
    end;


2) for Dlina := 15 downto 1 do
      writeln (Sqr(Dlina));


3) for x := 1 to 10 do
      for y := 1 to 10 do
        writeln (x,'*',y,'=',x*y);


4) for Range := Number+1 to Multi*3 do
      writeln (Sqrt(Range));

При использовании цикла for компьютер выполняет за программиста черновую работу по инициализации управляющей переменной и по ее увеличению (уменьшению) при каждом повторении цикла. Единственное ограничение заключается в том, что тип управляющей переменной не должен быть real. Переменная цикла не должна изменяться какими-либо операторами внутри цикла. К ней можно обращаться и использовать в вычислениях, но нельзя присваивать новое значение. Присваивания могут выполняться только механизмом самого цикла. Таким образом, следующий цикл является некорректным:

for i := 1 to 10 do
  begin
    . . .
   
i := i-1;
    . . .
  end;

Управляющая переменная должна описываться, как и любая другая переменная. Обычно переменная цикла имеет тип integer, но позднее Вы рассмотрите другие типы данных, которые могут указываться в качестве типа управляющей переменной.

Внимание! Следует помнить, что управляющая переменная не может быть типа real.

Исполнительная часть цикла может быть либо простым, либо составным оператором. Если начальное значение цикла for ...to больше конечного значения, то никакие операции не выполнятся. Таким образом, следующий оператор не приведет ни к каким действиям

for j := 1 to 0 do
  writeln (j);

Однако цикл, представленный в такой форме, распечатает целые числа от единицы до десяти:

for j := 1 to 10 do
  writeln (j);

Как можно догадаться, следующий цикл выполняет счет в обратном порядке:

for j := 10 downto 1 do
  writeln (j);

Часто тело цикла For содержит еще один оператор цикла For. Структуры такого рода называются вложенными циклами. При завершении внутреннего цикла управляющая переменная внешнего цикла увеличивается. Повторение этих действий будет продолжаться до завершения внешнего цикла. Приведенный ниже вложенный цикл печатает пары чисел, начиная от (1,1), (1,2),... и кончая (10,10):

for х:= 1 to 10 do
  for
у:= 1 to 10 do
    writeln ('(',
х,',',y,'), ');

Задание. Выполните две задачи, уже решенные Вами задачи с помощью других видов цикла, с помощью со счетчиком.




Самые низкие цены на курсы переподготовки

Специально для учителей, воспитателей и других работников системы образования действуют 50% скидки при обучении на курсах профессиональной переподготовки.

После окончания обучения выдаётся диплом о профессиональной переподготовке установленного образца с присвоением квалификации (признаётся при прохождении аттестации по всей России).

Обучение проходит заочно прямо на сайте проекта "Инфоурок", но в дипломе форма обучения не указывается.

Начало обучения ближайшей группы: 18 октября. Оплата возможна в беспроцентную рассрочку (10% в начале обучения и 90% в конце обучения)!

Подайте заявку на интересующий Вас курс сейчас: https://infourok.ru

Общая информация

Номер материала: ДВ-244141

Похожие материалы