русс | укр

Языки программирования

ПаскальСиАссемблерJavaMatlabPhpHtmlJavaScriptCSSC#DelphiТурбо Пролог

Компьютерные сетиСистемное программное обеспечениеИнформационные технологииПрограммирование

Все о программировании


Linux Unix Алгоритмические языки Аналоговые и гибридные вычислительные устройства Архитектура микроконтроллеров Введение в разработку распределенных информационных систем Введение в численные методы Дискретная математика Информационное обслуживание пользователей Информация и моделирование в управлении производством Компьютерная графика Математическое и компьютерное моделирование Моделирование Нейрокомпьютеры Проектирование программ диагностики компьютерных систем и сетей Проектирование системных программ Системы счисления Теория статистики Теория оптимизации Уроки AutoCAD 3D Уроки базы данных Access Уроки Orcad Цифровые автоматы Шпаргалки по компьютеру Шпаргалки по программированию Экспертные системы Элементы теории информации

Решение


Дата добавления: 2015-09-15; просмотров: 1008; Нарушение авторских прав


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

1. Нам нужен будет счетчик, который будет хранить количество пробелов. Это не проблема - заведем переменную Byte.

2. Нам нужно сканировать все символы веденной строки по очереди и проверять, текущий символ является пробелом? Если да, то увеличиваем счетчик.

3. Выведем счетчик на экран.

Что скажете? Есть мысли по поводу того, как будем решать? Особых проблем возникнуть не должно, но как проверить все символы по очереди? Какой здесь использовать алгоритм?

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

Итак, что нам нужно, чтобы проверить все символы по очереди? Нам нужно всего лишь знать количество этих символов, после чего мы сможет пустить цикл - от 1 до этого количества. В этом цикле и будем производить сравнение. При этом текущим символом будет являться значение цикла. Догадались? Если что-то непонятно, просмотрите материал выше, ну а если все ясно, привожу текст программы:

 
Program N6;
var
I: Byte;
Count: Byte;
S: String;
begin
Write('Введите строку: ');
Readln(S);
For I := 1 to Length(S) do
If S[I] = ' ' then Inc(Count);
Write('Количество пробелов: ', Count);
Readln;
end.

Вот, собственно и есть вся релизация этого алгоритма. В качестве комментариев хочу сказать следующее:

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

2. Также заметьте, что я не пишу begin...end в цикле For, хотя там и не однин оператор. Это потому, что констрункция if...then...else вместе с теми операторами, что в ней заключены, является всеже одним действием и выполняется едино.

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



Задания:

1.По теме "циклы": - напишите программу, печатающую столбик строк такого вида:

1 0 0 0 0 0 0 0 0

0 2 0 0 0 0 0 0 0

0 0 3 0 0 0 0 0 0

0 0 0 4 0 0 0 0 0

0 0 0 0 5 0 0 0 0

0 0 0 0 0 6 0 0 0

0 0 0 0 0 0 7 0 0

0 0 0 0 0 0 0 8 0

0 0 0 0 0 0 0 0 9

2.По теме "строки": напишите программу, присваивающую переменной Char последний символ введенной строки

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

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

Работая с циклом FOR вы наверняка заметили, что программа повторяется всегда фиксированное количество раз - пусть даже это количество и задается в ходе выполнения программы, но изменять его в ходе выполнения цикла нельзя. Если сказано прокрутить цикл десять раз, десять раз он и прокрутиться. Наводит на мысль, что цикл For использовать удобно при подходящей ситуации - например, каких-нибудь математических расчетах или внутреннем выполнении действий. А вот если нам понадобилось внешняя работа с данными, циклически оформлеными? Это например, может быть таже программа ввода строки, которая будет читать строку, пока та не будет содержать слова "end". Мы кстати писали подобную программу, она использовала в качестве зацикливания процедуру goto, переходя на новое чтение при определенных условиях. Вы замечаете разницу? Задумайтесь - чтение строки, это ведь работа с внешними данными? Так ведь? И если это чтение происходит по кругу, то это ведь цикл? Тоже верно. Но выполнение этого цикла несколько специфичное - он работает до возникновения определенных условий (опять же со стороны внешних данных).

Вот здесь как раз и будет удобо использовать цикл While. Особенностью этого цикла является то, что он будет выполнять свою работу до возникновения каких-либо условий, то есть сам он ничего не изменяет в переменных, он всего лишь что-либо проверяет. (Помните, цикл FOR изменяет переменную-счетчик?) В заголовке этого цикла стоит не диапазон значений, а собственная процедура проверки - вроде известной нам if...then...else, далее вы сами это увидите.

Ну а теперь для демонстрации этого цикла давайте напишем программу, которая и будет выполнять чтение строки до того момента, пока она не будет строкой "end". Смотрите программу:

Program N1;
var
S: String;
begin
While S <> 'end' do
Readln(S);
Write('Вот и все! Вы ввели end!');
Readln;
end.

Запустите программу. Видите, она читает строки до того момента, пока введенная строка не будет равна "end"? Просто, не правда ли? Теперь внимательно посмотрите на программу. Здесь налицо, что вместо типичного диапазона значений цикла (как FOR - повторять от сих до сих) стоит процедура проверки, то есть "повторять пока". Кстати, while переводиться с английского как "пока". Теперь необходимые комментарии к изученному циклу.

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

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

3. После указания условия ставится служебное слово do.

4. Теперь идет само тело цикла. Здесь помните, что если в теле цикла содержиться один оператор (как в первом примере), то он указывается без дополнительных выделений. Если же идет несколько операторов, то они все заключаются в конструкицю begin-end. Это очень принципиально, не забывайте про это!

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

Пока A < B и B > C

Это может быть использовано и в конструкции if...then...else и в цикле while. Однако рассказывать о том, как реализуются сложные конструкции сравнения я буду в следующих уроках, в частности, практических, где мы будем решать задачи.

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

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

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

1. Ввести А;

2. Ввести В;

3. Ввести знак действия;

4. В зависимости от того, что это за знак, выполнить действие:

1. Это "+"?
-> C = A + B;

2. Это "-"?
-> C = A - B;

3. Это "*"?
-> C = A * B;

5. Вывести результат;

6. Спросить - сначала?

7. Если ответ утвердительный, то начать все сначала (переход к пункту 1);

8. Конец нашей программки.

Вот исходный текст, реализующий этот алгоритм:

Program Simple_Calculator;
var
A,B,C: Integer;
Ch, Sign: Char;
begin
While UpCase(Ch) <> 'N' do
begin
Write('Введите А: ');
Readln(A);
Write('Введите B: ');
Readln(B);
Write('Введите знак действия: ');
Readln(Sign);
If Sign='+' then C := A + B;
If< Sign='-' then C := A - B;
If Sign='*' then C := A * B;
Writeln('Результат: ', C);
Write('Сначала? (Y/N): ');
Readln(Ch);
end;
Write('Калькулятор завершает свою работу...');
Readln;
end.

Вот такая вот программа. Что скажете? Думаю, вы уже обратили внимание, что она не использует процедуру goto для сравнения. Все операции протекают в цикле, который оформлен в виде while и уже является полноценным циклом, в отличии от макета goto if...., который мы использовали ранее.

Вообще, я хочу вам сказать, что goto лучше по возможности не использовать; эта процедура затрудняет чтение программы и запутывает ее логику, что в более-менее больших программах недопустимо.

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

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

В других случаях (например, переменная Char является цифрой) ничего не произойдет.

Это и есть вся работа функции UpCase.

Теперь вам небольшое задание по этой программе:
Как вы думаете, зачем я использую функцию UpCaseв процедуре проверки цикла While?

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

Как же мы будем поступать в этом случае? Давайте как всегда запишем алгоритм работы нашей программы:

1. Вводим число;

2. Пока это число меньше нуля, делаем следующее:

3. Получаем остаток от деления введенного числа на 10; Получившийся остаток и будет первым разрядом, т.е. единицами;

4. Вычитаем получившийся остаток из имеющегося числа;

5. Делим получившееся число на 10 без остатка

6. Выводим его на экран;

7. Спрашиваем, сначала?

8. Если да, то переходим к пункту 1;

9. Завершаем программу;

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

Program Get_numbers;
var
A, B: Integer;
Ch: Char;
begin
While UpCase(Ch) <> 'N' do
begin
Write('Введите число: ');
Readln(A);
While A > 0 do
begin
B := A mod 10;
Dec(A, B);
A := A div 10;
Writeln('Разряд: ', B);
end;
Write('Сначала? (Y/N): ');
Readln(Ch);
end;
Write('Конец программы...');
Readln;
end.

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

Операция div - выполняет деление целых чисел (Integer, Byte, Word, LongInt - см. выпуск N4) без остатка. Работа этой операции очень проста - например, при делении числа на 10 (как в нашем случае) результат не всегда получится целым (123 div 10) и не может храниться в переменной целого типа. Эта же операция попросту откидывает остаток у получившегося значения. Вот пример:

123 / 10 = 12.3; (Результат обычного деления)

123 div 10 = 12; (Результат работы операции div)

Операция mod - получает остаток от деления целых чисел. При выполнении этой операции присходит выявление остатка от деления и именно он выноситься в результат. Вот пример:

123 mod 10 = 3;

17 mod 12 = 5;

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

Ну а теперь комментарии к программе.

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

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

Dec(A, B);
Помните такую операцию? Это эквивалентно:
A := A - B;
Вот весь ход выполнения опрерации получения последного знака:

* К примеру, мы ввели число 157:

1. 157 mod 10 = 7; (Вот он, последний знак!)

2. 157 - 7 = 150; (А вот мы его и отрезали!)

* Если мы ввели число 1:

1. 1 mod 10 = 1; (Опять последний знак - он же и первый)

2. 1 - 1 = 0;
(И опять мы его отрезаем, причем число стало равным нулю - оно как бы кончилось, однозначное ведь).

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

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

120 div 10 = 12;
10020 div 10 = 1002;
10 div 10 = 1;

Видите, число подвигается на один разряд? Это налицо, не так ли? Ну а теперь вспомните наши манипуляции с операцией mod - отсечение последнего знака. Чтоже получиться, если после того, как мы сдвинули число опять выполнить вышеописанные действия? Верно, мы снова получим остаток от деления или последний разряд.

Ну а теперь пустим эти две операции по кругу, организуем цикл. Причем цикл будет "пока число больше нуля", то есть пока оно у нас не кончиться. Сюда здорово вписывается цикл While, я не думаю пренебрегать этим и с удовольствием его использую.

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

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

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

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

Вопросы - ответы

Как в Турбо Паскале написать программу для Windows?

Это невозможно. Turbo Pascal 7.0, который мы с вами используем, не поддерживает Windows-программы. Для написания Windows-программ предназначена более расширенная версия языка Паскаль - Borland Pascal 7.0, кроме того, чтобы писать в нем приложения для системы Windows необходимо знание дополнительных модулей - Object Windows, а также внутренних средств операционной системы. Мы этим в ближайшее время заниматься не будем.

Как в Паскале очистить экран?

ОЧЕНЬ распространенный вопрос. На самом деле я не должен рассказывать об этом, так как процедура очистки экрана в Паскале требует вызова дополнительных модулей. О этих модулях разговор будет в следующих выпусках и мне хотелось бы, как говориться "обо всем по порядку". Но тем не менее, я уверен, эта информация поможет многим, а полезна будет практически всем, поэтому привоже пример программы, реализующей очистку экрана. Программа без комментариев, просто шаблон, не более: Program Clear_Screen; uses Crt; begin ClrScr; Write('Вызовом предыдущей процедуры был очищен экран. '); Readln; end.

 

На сей раз мы будем изучать новый цикл, так называемый цикл REPEAT-UNTIL. Этот цикл является заключительным, он единственный оставшийся из трех имеющихся в Паскале - два мы уже прошли (FOR и WHILE). Хочу также обратить ваше внимание, что в этом выпуске мы снова вернемся к типам. Дело в том, что в цикле REPEAT-UNTIL очень часто используется неизвестный вам пока тип данных, так называемый логический, или булевский, или BOOLEAN. Так вот, этот тип очень удобен в использовании циклов REPEAT-UNTIL, да и вообще в программировании. Он довольно прост, но одновременно не все его понимают. Это ничего: если вы не поймете его сегодня, то обязательно разберетесь по ходу его использования. Как говориться, нет ничего лучше практики. Ну что, начнем?

Тип BOOLEAN

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

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

1. Если среди введенных чисел был нуль, то напечатать "нули существуют".

2. Если среди введенных чисел нулей не было, то так и пишем: "нету у нас нулей!".

Задача поставлена. Думаем, как же будем ее решать. Заранее не сказано, что введенные числа нужно где-нибудь оставлять. Понимаете, о чем я? То есть ни одно из введенных чисел далее нам не потребуется, главное знать, был ли среди них нуль. Алгоритмов для решения такой задачи превеликое множество. Один из удачных вариантов (точнее, более простых) это использование массива, но таковые мы еще не проходили. Отпадает. Другой вариант - непосредственная проверка введенного числа, то есть после ввода проверять - число это нуль? Если да, выведем подтверждение. Но и это не очень гибкое решение задачи.

Можно зделать иначе - проверять число на ноль, и если оно таковое, изменять какую-нибудь специально заведенную переменную. Например, Is_zero: Byte. Если у нас ноль, то пишем: Is_zero := 1;

А после ввода проверяем, если в Is_zero = 1, то нули были. Вам понятен ход моих мыслей? Мы используем как бы подтверждение наличия нулей. Вот пример для наглядного отображения:

 
Program N1;
var
Is_zero, I: Byte;
A: Integer;
begin
Is_zero := 0;
For I := 1 to 10 do
begin
Write('Введите число N',I,': ');
Readln(A);
if A = 0 then Is_zero := 1;
end;
if Is_zero = 1 then
Write('В введенной последовательности есть нули!');
else
Write('В введенной последовательности нулей ни фига нет!');
Readln;
end.

Надеюсь, программа понятна? В частности, использование переменной Is_zero? Вот мы и подошли к новому типу переменных, а именно к логическому типу - BOOLEAN. Что же это такое?

Тип BOOLEAN - это логический тип. Переменная такого типа довольно специфична, она может иметь всего два значения:

TRUE - истина;

FALSE - ложь;

Именно эти значения и проверяются в программе. Переменные такого типа крайне удобны в нашем примере. Модифицируем?

 
Program N2;
var
I: Byte;
A: Integer;
Is_zero: Boolean;
begin
For I := 1 to 10 do
begin
Write('Введите число N',I,': ');
Readln(A);
if A = 0 then Is_zero := true;
end;
if Is_zero then
Write('В введенной последовательности есть нули!');
else
Write('В введенной последовательности нулей ни фига нет!');
Readln;
end.

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

Если правда то, что нули были, то напиши об этом;

А вот если неправда, то так и напиши, что не было нулей...

То есть работа BOOLEAN это просто определение истинности условия или его ложности. Вот собственно и все. Кстати, обратите внимание на проверку:

If Is_zero then.....

Вы видите, что я не пишу If Is_zero = true? BOOLEAN - переменная логическая, поэтому и не требует в проверках указания своего значения. Она просто проверяется на истину. Как бы по умолчанию, IF ищет подлинность условия.

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


Цикл REPEAT-UNTIL

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

  • На подлинность булевской переменной;
  • На наличие какого-нибудь условия, например была введена буква "q", означающая выход из программы;
  • На значение какой-нибудь переменной (а не больше ли она пяти?)
  • и т.д...

Оформляется цикл тоже довольно просто.

Для того, чтобы озаглавить цикл REPEAT-UNTIL (кстати, по английски repeat - повторять, а until - пока, до того как) необходимо в любом месте программы вставить служебное слово REPEAT. Именно одно слово, не как во всех других циклах. Завершается цикл служебным словом UNTIL с последующей проверкой какого-нибудь условия. Пример? Пожалуйста:

 
Program N3;
var
S: String;
Exit: Boolean;
begin
REPEAT
Write('Введите строку (end - выход): ');
Readln(S);
if S = 'end' then Exit := true;
UNTIL Exit;
Write('Конец программы...');
Readln;
end.

В этом примере проверка происходит на подлинность булевской переменной, которая устанавливается если введена строка 'end'.

Здесь хочу сделать дополнительные комментарии к циклу.

Во-первых, обратите внимание, что после слова REPEAT не ставится точка с запятой, наподобие слова BEGIN. Дело в том, что REPEAT озаглавливает целый блок, поэтому знак ";" и отсутсвует.

Во-вторых, обратите внимание, что операторы внутри конструкции REPEAT-UNTIL не выделяются дополнительными begin-end. Хотя операторов и несколько, этого не происходит.

Ну а теперь еще пример, на этот раз проверяем числовую переменную:

 
Program N4;
var
A: Integer;
begin
REPEAT
Write('Введите число (0 - выход): ');
Readln(A);
UNTIL A=0;
Write('Конец программы...');
Readln;
end.

Из программы видно, что она будет повторяться пока не будет введен нуль. Теперь, когда вы более-менее познакомились с этим циклом, думаю, вы согласитесь, что он очень удобен и прост. Вы уже довольно хорошо знакомы с понятием циклов и я считаю, что дополнительных комментариев к сегодняшнему вопросу не требуется. Очень рекомендую написать как можно больше программ, использующих этот цикл; попробуйте заменить в старых вариантах циклы FOR и WHILE на REPEAT-UNTIL.

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

Не знаю, обращали ли вы серьезное внимание на известные нам типы. Если да, то знаете, что они довольно разнообразны и подходят под все случаи жизни. Например, WORD - хранит тот же диапазон, что и Integer, но без отрицательной стороны. Она как бы прибавляется к нему в качестве положительной, в два раза увеличивая возможное значение типа выше нуля.

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

Ну а сейчас я хочу, чтобы вы вспомнили, что за числа умеют хранить известные нам типы. Да, они все разные по диапазону и размеру, но они все целые. Невозможно в переменную типа Integer записать значение 3.14 (пи) или 182.1555. Мы не можем этого сделать.

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

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

Надо заметить, что вещественные типы необходимо использовать даже более рационально, чем целые. Они обычно занимают в памяти больший размер (целая часть+значения после запятой) и дольше вычисляются.

Итак, привожу таблицу всех вещественных типов языка Turbo PASCAL 7.0:

Вещественные типы данных
Тип Диапазон Значащие цифры Размер, байт
Real 2.9x10^-39 .. 1.7x10^38 11-12
Single 1.5x10^-45 .. 3.4x10^38
Double 1.5x10^-45 .. 3.4x10^38 15-16
Extended 3.4x10^-4932 .. 1.1x10^4932 19-20
Comp -2^63 + 1 .. 2^63 - 1 19-20

Здесь значок "^" обозначает степень. Думаю, вы знаете (помните) такую запись чисел. Если не знаете, что делать... на математику у нас времени нет. Ограничусь самым минимальным комментарием:

К примеру, запись типа Real: 2.9x10^-39 .. 1.7x10^38 обозначает следующее:

Минимальной границей типа является число 2.9 * 10 в степени -39. Число получается оччччень большое (точнее наоборот, маленькое :)) - я имел ввиду длинное). И писать его в обычном виде довольно нудно.

Таже история и с максимальной границей типа: 1.7 * 10 в степени 38. Число опять длинное. На сей раз действительно большое, даже громадное!

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

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

 
Program N1;
var
A: Real;
B: Single;
C: Comp;
begin
Write('Введите число вещественного типа REAL: ');
Readln(A);
Write('Введите число типа Single: ');
Readln(B);
Write('Введите число типа Comp (большое такое... не поскупитесь на значение): ');
Readln(C);
Writeln('Real: ', A);
Writeln('Single: ', B);
Writeln('Comp: ', C);
Readln;
end.

Запустите программу. При вводе чисел используйте точку как разделитель целой и дробной части:

178.13

Именно точку, а не запятую!

Вы видите, что творит Паскаль? Он выводит ужасные числа, пририсовывая к ним экспоненту. Зачем? Может, вы не хотите видеть на своем мониторе такое некрасивое число? Я вас пониманию. Для этого как раз и существует форматный вывод процедуры Write. Что же это такое?

Форматный вывод - это задание диапазона вывода. То есть мы сразу в процедуре Write (Writeln) определяем, сколько распечатывать знаков до точки и после нее.

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

Write('Real: ', A:5:2);

Теперь у нас будет выводиться в более читабельном виде. Измените в программе эти значения по своему усмотрению. Вполне нормально, не так ли?

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

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

  • Умножение - вещественные типы могут быть умножены. Знак: "*".
  • Сложение - обычное сложение. Знак: "+".
  • Вычитание - они могут вычитаться друг из друга: "-".
  • Деление - непосредсвенное деление, с остатком и т.д. Знак: "/".

То есть все действия как и с целыми, за исключением деления.

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

 
Program N1;
var
A,B: Real;
C: Integer;
begin
...
A := A * C;
A := A / C;
A := C / A;
A := A - C;
A := B / C;
A := A * B / C;
B := (C / A - B) * C;
... и так далее
end.

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

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

Думаю, программа, печатающая цикл из вещественныз чисел от 1.00 до 1.90 с шагом в 0.1 будет уместной.

 
Program N2;
var
var
A,Step: Single;
I: Byte;
begin
Writeln;
For I := 0 to 9 do
begin
Step := I * 0.1;
A := 1 + Step;
Writeln(A:5:2);
end;
Readln;
end.

Разобрались? Хочу сделать несколько комментариев к программе.

1.Еще раз обращаю ваше внимание на то, что целая часть отделяется от дробной точкой, а не запятой.

2. Напоминаю, что целые типы совместимы с дробными (Почему?), но не наоборот: Step := I * 0.1; , где I: Byte, Step: Single;

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

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

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

Итак, мы определились. С чего начнем? С определения квадратного уравнения. (Извиняюсь, конечно, но меня терзают смутные сомнения, что кто-нибудь, да не знает, что это такое... Говорю по собственным наблюдениям!!)

Усложнять мы не будет, на этом этапе сделаем все по минимуму. Давайте вспомним вид квадратного уравнения (^ - это степень):

Ax^2 + Bx + C = 0, A<>0.

А корни находятся так:

X 1,2 = (+,- B - sqrt(D)) / 2A, D = B^2 - 4AC.

Не пугает вид такой формулы? На самом деле здесь все элементарно:

X 1,2 - это X1 и X2. Соответсвенно находим их сложением и вычитанием дискриминанта.

  • +,- B - это +B и -B.
  • sqrt - функция Паскаля, извлекающая корень.
  • D - Это дискриминант. Он имеет правила:
    • D > 0 " X1 <> X2;
    • D = 0 " X1 = X2;
    • D < 0 " Жаль, но корней у нас нету...

Вот так мы с вами и разобрались, что же такое квадратное уравнение. Я хочу обратить ваше внимание на возникшие по ходу рассуждения условия: A <> 0, а также правила, связанные с дискриминантом. Естественно, при вводе А нужно его соответсвующе проверить. Также сначала надо найти дискриминант и выдать соответсвующие данные.

Вот программа, выполняющая эти действия:

 
Program N3;
var
A,B,C: Real;
X1,X2: Real;
D: Real;
begin
Writeln('Программа решения квадратных уравнений. Welcome!');
Write('Введите A: ');
Readln(A);
if A = 0 then
begin
Write('Нельзя, чтобы A было равно нулю!');
Readln;
Halt;
end;
Write('Введите B: ');
Readln(B);
Write('Введите C: ');
Readln(C);
Writeln('Решаем уравнение: ',A:5:2,'x^2 +',B:5:2,'x +',C:5:2,' = 0');
Writeln;
D := B*B-(4*A*C);
if D < 0 then
begin
Write('D меньше нуля! Так нельзя...');
Readln;
Halt;
end;
X1 := (B*-1) + sqrt(D);
X1 := X1 / (2*A);
X2 := (B*-1) - sqrt(D);
X2 := X2 / (2*A);
Writeln('D: ',D:5:2);
Write('X1: ',X1:5:2, ' X2: ',X2:5:2);
Readln;
end.

Посмотрите внимательно на эту программу. В ней появились новые для вас слова:

  • Halt; Эта процедура производит немедленный выход из программы в любой ее точке. То есть эта процедура попросту останавливает программу. В нашем варианте она вызывается при возникновенни недопустимых условий (см. текст программы), прерывая работу.
  • Sqrt; Это функция получения квадратного корня.
  • В качестве параметра к процедуре ставится число типа REAL.
  • Как результат от своей работы функция также возвращает тип REAL (это и понятно, корень очень часто не бывает целым), поэтому не забывайте присваивать ее только переменным REAL.

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

  • A := 2;
  • B := 5;
  • C := 2;

При таких данных ответ будет: X1 := -0.50, X2 := -2;

Кроме того, у меня к вам есть задание:

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

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

при удачном выполнении спрашивает, 'Сначала? (Y/N): ' и принимает соответсвующее решение: завершает работу или начинается сначала.

 

Понятие массивов

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

Для того, чтобы Вы лучше поняли, я приведу простой пример. Давайте представим работу такой программы, как нахождение среднего арифметического среди 100 чисел. Что нам понадобиться для написания такой программы? Конечно, сами числа. Для хранения 100 чисел мы должны использовать 100 переменных. Описать их можно, скажем, следующим образом:

Var

n1,n2,n3,n4,n5,

n6,n7, ..., n100: Integer;

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

Помните строку? Я имею в виду тип String, который позволяет обратиться к любому символу своему символу:

S: String; S[2] := 'a';

Так вот, String - это и есть своего рода массив. Массив из переменных типа Char. Посмотрите, мы заводим всего одну переменную, после чего можем обратиться к любому ее символу, изменить его, прочитать и т.д. (Однако предупрежу, String - это все же не массив. Просто этот тип очень подходит для примера).

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

Создание (описание) массивов

Итак, мы решили создать и использовать в своей программе массив из чисел. Для примера возьмем ту программу, которую я придумал в описании понятия массива: найти среднее арифметическое среди 100 чисел.

Массив - это переменная и как все переменные описывается в разделе var программы. Описание переменной - массива состоит из:

  • Имени переменной;
  • Служебного слова Array, означающего "массив";
  • Описания размера массива (в нашем случае 100 чисел). Диапазон записывается в квадратных скобках - [ и ]. Внутри пишется сам диапазон, в виде двух чисел, разделенных двоeточием: начало..конец;
  • · Задании типа для элементов массива (в нашем случае - целые числа, или Integer). Задание типа начинается со служебного слова of;

Вот пример описания массива на 100 чисел:

Var

Mas: Array [1..100] of Integer;

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

Теперь в программе можно обратиться к любому элементу этого массива - от 1 до 100. Делается это посредством указания имени переменной с номером элемента в квадратных скобках. Вот примеры:

begin

Mas[1] := 100;

Readln(Mas[2]);

Write(Mas[4);

if Mas[100] < 18 then Halt;

Mas[50] := Mas[49] + Mas[1];

end.

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

Ну а теперь давайте всеже напишем нашу программу.

 
Program N1;
var
M: Array [1..100] of Integer;
A: Real;
I: Byte;
begin
Randomize;
For I := 1 to 100 do
M[I] := Random(500);
For I := 1 to 100 do
A := A + M[I];
A := A / 100;
Write('Среднее арифметическое всех чисел массива: ', A);
end.

Вот такая программа. Здесь я использую новую функцию Random , думаю, она вам не знакома. Очень интересная функция.

Функция Random(A: Integer);.

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

Инициализация датчика случайных чисел (ДСЧ) происходит вызовом процедуры Randomize. Вы видите ее перед циклом.

Теперь посмотрите, как я использую эту функцию в программе. Дело в том, что вводить с клавиатуры 100 чисел не так уж и приятно, верно? Вот я и заполняю массив случайными числами. Диапазон до 500 вполне здесь подходит, числа будут не очень большие, но и не очень маленькие. При этом я циклом изменяю значение массива и с помощью переменной I пробегаюсь по всем его элементам, заполняя их случайными числами.

Этот пример хорошо демонстрирует создание массива и доступ к его элементам.

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

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

Текст программы:

 
Program N2;
var
M: Array [1..10] of Integer;
Max: Integer;
I: Byte;
begin
Writeln('Введите 10 чисел: ');
For I := 1 to 10 do
begin
Write('N',i,': ');
Readln(M[i]);
end;
Max := M[1];
For I := 1 to 10 do
if Max < M[i] then Max := M[i];
Write('Максимальное число: ', Max);
Readln;
end.

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

  • Сначала за максимальное принимается первое число;
  • После оно сравнивается со всеми оставшимися числами, при этом:
    • Если следующий элемент больше принятого за максимум (переменная Max), то оно принимается за максимум.
    • После сравнения всех элементов в конце концов остается одно число, которое больше всех в массиве.

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

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

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

 

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

 

 

Задача №1

Напомню условие:



<== предыдущая лекция | следующая лекция ==>
Задание №3 (обширное) | Напишите программу, читающую массив из 10 чисел и печатающий его в обратном порядке.


Карта сайта Карта сайта укр


Уроки php mysql Программирование

Онлайн система счисления Калькулятор онлайн обычный Инженерный калькулятор онлайн Замена русских букв на английские для вебмастеров Замена русских букв на английские

Аппаратное и программное обеспечение Графика и компьютерная сфера Интегрированная геоинформационная система Интернет Компьютер Комплектующие компьютера Лекции Методы и средства измерений неэлектрических величин Обслуживание компьютерных и периферийных устройств Операционные системы Параллельное программирование Проектирование электронных средств Периферийные устройства Полезные ресурсы для программистов Программы для программистов Статьи для программистов Cтруктура и организация данных


 


Не нашли то, что искали? Google вам в помощь!

 
 

© life-prog.ru При использовании материалов прямая ссылка на сайт обязательна.

Генерация страницы за: 0.02 сек.