While <истинное условие> <ваши операторы, которые нужно повторять> wend

Сразу обратите внимание на «step X». Я больше об этом никогда говорить не буду, потому как я это не использую. Если это не писать (можно не писать), то программа после каждого прохода увеличивает переменную на 1. Если написать step X, то программа будет увеличивать переменную на Х.

Обратите внимание, что в операторе for нужно использовать переменную как счетчик. Используйте незанятую переменную, которую Вы нигде больше не используете, я называю её всегда cnt, вы называйте хоть «m». Пример:

Cls
a = 0
Input “Сумму скольки первых чисел нужно находить? ”, n
for cnt = 1 to n
a = a + cnt
next cnt
print a

Вот и все. Теперь смысл. Первая строчка очищает экран. Во второй строчке я делаю очень важную вещь – я собираюсь в переменную «а» складывать сумму всех чисел и перед этим присваиваю этой переменной значение 0. Если Вы собираетесь искать произведение чисел, то следует переменой присвоить 1, т.к. если бы там был 0, то произведение всех чисел было бы 0. Короче, это просто нужно думать по ходу написания программ. Для суммы нужно присваивать 0, для произведения – 1. В общем, в 4 строчке написано «n раз повторять все что после 4 строчки и перед next n». В самой программе я могу использовать и cnt, но присваивать счетчику значения нужно только если знаешь, что делаешь. В общем, next cnt говорит, что это конец куска кода, который надо повторять. А после этого я вывожу a, в которой содержится сумма чисел от 1 до n.

Теперь разберем алгоритм программы, важно понять его:

1. Мы получили n. Это сколько раз надо повторять. Для наглядности пусть будет 3.

2. a = a + cnt. Сначала в «a» было ноль, после первого раза n + cnt. Cnt сначала 1.

3. теперь увеличиваем cnt и возвращаемся на второй шаг. Если cnt уже достиг n, то прекратить выполнение цикла.

После первого захода в n было 1, после второго 1+2, а после третьего – 1+2+3. А теперь догадайтесь, что в конце в n будет? Правильно – 6!

Смысл оператора for такой, что он несколько раз (n раз) прогоняет операторы, что перед next cnt, притом номер число cnt – номер повтора. Не обязательно его использовать в самой программе, можно делать, что хотите, просто это что-то будет выполнено n раз.

Оператор for очень удобно группировать с массивами. Пример:

Cls
dim a(5)
for cnt = 1 to 5
input “Введите число”, a(cnt)
next cnt
print a(1), a(2), a(3), a(4), a(5)

В данном примере я вместо числа в скобках в обозначении массива в 4 строчке использую счетчик, которые после каждого повторения увеличивается на 1, в качестве номера элемента массива. Всего будет 5 заходов, как Вы видите из третьей строчки. В общем, это называется «заполнение массива с клавиатуры». Потренеруйтесь ещё! Измените пример выше таким образом, чтобы он принимал три текстовых строчки. Затрудняетесь? Ничего сложного!

Cls
dim a$(3)
for cnt = 1 to 3
input “Введите текст”, a$(cnt)
next cnt
print a$(1), a$(2), a$(3)

Вот ещё пример того, как можно использовать массив в связке с оператором повторений. Если Вы затруднились с написанием своего варианта, то рекомендую остановиться на этом этапе изучения языка, пойти попить кофе, в общем – пока приостановить изучение и отдохнуть. С новыми силами попробуйте написать программу, которая сначала будет ждать ввода трех чисел, а затем пяти строк. Хранить числа в массиве a(3), а строки в массиве b(5). Это довольно сложно, но вполне решаемо. Если Вы сможете написать это – есть повод гордиться J.

 

Случайное число.

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

Если интересно: на самом деле термин «случайное число» не верный. Полученное этим способом число не является случайным – это текущая дата и время, с которыми произвели математические операции. Это очень сложный процесс и для простоты принято говорить, что это число случайно. Но мы – то знаем, что такого не бывает J...

Итак, использование случайного числа – довольно легкий процесс, если понять суть его. Случайное число, как и массив, нужно в начале программы инициализировать строчкой randomize timer. Это делается один раз в начале программы (обычно после имени программы и объявления массивов, если такие есть). В самой программе наше случайное число хранится в переменной rnd, которую мы должны использовать только для чтения и никак больше. Например, вот неполная программа:

Randomize timer
print rnd

Если Вы её запустите, она выдаст Вам что-то типа «.3587412». Это происходит потому, что в начале ноль программа не пишет. Т.е. «как есть» число rnd не доходит до целого. Но ведь нам нужны целые числа, причем в заданных пределах? Именно поэтому переменную rnd «как есть» не используют. Делают так:

Randomize timer
print int(rnd*10)

Если Вы вникли во все предыдущие главы самоучителя, то должны понять, что тут делается. А делается вот что: первая строка говорит программе, что мы вообще будем использовать случайное число. Во второй строке мы берем rnd, умножаем его на 10 (получилось что-то типа 3.587412) и отбрасываем дробную часть (ответ - 3) и печатаем результат вычислений. Помните, что сначала математические действия вычисляются и только в последнюю очередь печатается их результат. И что мы получили? По идее rnd может принимать значения от 0.0000001 до 0.9999999, т.е. указанная выше программа будет выдавать результат от нуль до девяти. Ещё пример:

Randomize timer
print int(rnd*10-5)

Вот теперь она будет выдавать значения от 0-5 до 9-5, т.е. от -5 до 4. Помните, Вы никогда не сможете заставить выдавать значения от -5 до 5, можно лишь от -5 до 4, чтобы между минимумом и максимумом было 9 цифр.

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

Randomize timer
print rnd, rnd

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

Оператор цикла.

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

While a <> 5
input “Введите число 5 для выхода: ”, a
wend

Что будет делать эта программа? Она будет выдавать запрос на ввод числа до тех пор, пока Вы не введете число 5. Синтаксис оператора цикла:

While <истинное условие> <ваши операторы, которые нужно повторять> wend

Итак, рассказываю: как только Qbasic находит слово while, он начинает проверять условие после этого слова на истинность. Если оно истинно (как в данном случае, т.к. а сначала - ноль), то будет проделано то, что после этой строчки и перед wend (это просто служебное слово, обозначающее конец цикла). Он один раз прогнал <ваши операторы, которые нужно повторять> и снова оценивает выражение, и если оно снова истинно, он снова повторяет цикл до тех пор, пока он не станет ложным. Если выражение ложно, он приступает к следующей после wend строчке. Обратите внимание, что сам Qbasic ничего не делает для того, чтобы сделать выражение ложным, так что обязательно продумывайте ситуацию, когда цикл будет окончен, иначе придется нажать Ctrl+Break и программа остановится с ошибкой. (когда нажимаете эти кнопки, программа сама останавливается. После этого надо нажать Выполнить - Перезапустить). Вот ещё пример использования цикла:

While x <= 5
print “Сейчас Х равен ”, x
x = x + 1
wend

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

Подпрограммы.

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

10 cls
20 input “Введите число: ”, a
30 gosub 100
40 print a
50 gosub 100
60 print a
70 end

100 rem подпрограмма деления и возведения в степень
110 a = (a / 2)^3
120 return

Вот. Обратите внимание, что если Вы используете подпрограммы, Вы обязаны вести нумерацию строк (а как – это не важно. У меня вот после 70 сразу 100 J). Итак рассказываю. В строчке (буду называть по номерам) 10 я очищаю экран. В 20-й строчке я жду ввода числа а. После этого идет новая команда – gosub – она говорит, чтобы Qbasic перешел на строчку с заданным номером, здесь – 100. После этого Qbasic находится на строчке 100, которая соержит только комментарий. Хорошим стилем считается начинать подпрограмму с комментария, который рассказывает, как подпрограмма называется. В общем, дальше идет 110 строчка. Что она делает – понятно. А вот 120 строчка содержит команду return, которая говорит, чтобы Qbasic вернулся туда, откуда перескочил на подпрограмму, т.е. на 30 строчку. Т.к. она уже выполнена, то он переходит на 40 строчку. Печатает переделанное число «а» и переходит на 50. Здесь он снова перескакивает на 100 и делает, как я рассказал выше. После этого он на 60 строчке снова печатает число а и заканчивает программу словом end на 70 строчке.

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

Q <ваши операторы>
w gosub X
e <ваши операторы>

Х rem <название подпрограммы>
z <операторы>
n return

Вот так. Буквы в начале строк обозначают то, что строчки надо нумеровать.

Оператор перехода.

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

10 Cls
20 input “Сколько Вам лет? ”, a
30 print “Превед!”
40 if a < 18 then goto 200
50 print “Пиво будешь?”
200 print “Ну ладно, удачи!”
210 end

В строчке 40 идет проверка на возраст. Если возраст меньше 18, то переход на строчку с номером 200. Все просто и понятно.

Подведение итогов.

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

Решение задач.

У любого языка программировать должно быть назначение, иначе его просто бы не было. У Qbasic это – решение математических задач. Основные задачи бывают трех типов: решение по формуле, работа с массивами и диалоговые.

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

05 rem Задачи диалоговые
10 cls
20 print “Превед! Ща будет первый вопрос!!!”
30 print “Скока бит в одном байте?”
40 print “1. 1024 3. 8”
50 print “2. 32 4. 64”
60 input “Ваш ответ? ”, a
70 if a <> 3 then goto 100
80 print “Вы выиграли миллион рублей! Ваш миллион Вы сможите получить на Антарктиде, пятая юрта справа”.
100 print “!!!КОНЕЦЦ ЭГРЫ!!!”

Собственно, в таком стиле. Строчки 30 – 70 составляют один вопрос. Их можно копировать с изменением текста. Суть в том, что если пользователь отвечает неверно, то программа сразу переходит в конец, иначе просто идет дальше.

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

Rem Задачи математические
Cls
input “Введите Х: ”, x
y = (x^3+sqr(x))/(x^2)
print “Х = ”, x, “Y = ”, y

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

Работа с массивами – третий и самый сложный тип задач. Я остановлюсь на ней поподробнее. Автоматическая работа с массивами обеспечивается оператором FOR. Например: «Найти максимальный элемент в массиве X(100). Массив заполнить генератором случайных чисел.». Итак, давайте рассуждать – что от нас хотят?

1. Должен быть массив X100.

2. Заполнить его случайными числами.

3. После этого искать максимальный элемент и записать его в отдельную переменную.

4. Вывести эту переменную как максимальный элемент.

Сказано – сделано. Делаем вступление программы и массив:

Rem Работа с массивом. Часть первая.
dim X(100)
randomize timer
cls

Все, у нас есть массив и вступление программы. В нем мы назвали программу, обозначали, что у нас будет массив, что мы будем использовать генератор случайных чисел (что от нас требует условие) и что нужно для начала очистить экран. Теперь попробуем заполнить массив случайными числами. Нам нужно присвоить каждой ячейке массива случайное число. Будем писать сто раз присвоение? Как бы не так! У нас же есть for! Делаем так:

For cnt=1 to 100
X(cnt) = int(rnd*10)
next cnt

Все! Когда оператор повторений будет выполняться первый раз, он в cnt занесет 1. Первый элемент массива X получит значение «int(rnd*10)». Собственно, а почему именно это? Просто если не указаны границы случайных чисел, то имеется в виду от нуля до девяти. И именно это мы получаем при такой строчке. И вообще, вот сводная таблица:

Int(rnd*10)	0…9
Int(rnd*10+1)	1..10
Int(rnd*10-5)	-5…4
Int(rnd*100)	0…99
Int(rnd*100-50)	-50…49

Ну и дальше в таком же стиле. В общем, подставляйте, что нужно. Но мы отвлеклись. Мы заполнили массив. Теперь нужно искать максимальный элемент. Как? Берем переменную Q и присваиваем ей значение ноль. Берем первый элемент массива и сравниваем его с Q. Если Q меньше первого элемента, то значение первого заносится в Q. И так проверяем сто элементов. В конце у нас будет значение максимального из ста элементов в Q:

Q = 0
For cnt=1 to 100
if Q < X(cnt) then Q = X(cnt)
next cnt

Вот и впринципе все. Теперь в Q у нас самое большое значение. Нам остается только собрать всю задачу в кучу и вывести результат на экран:

Rem Работа с массивом. Часть первая.
dim X(100)
randomize timer
cls
For cnt=1 to 100
X(cnt) = int(rnd*10)
next cnt
Q = 0
For cnt=1 to 100
if Q < X(cnt) then Q = X(cnt)
next cnt
print “Максимальное значение массива - ”, Q

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

Теперь усложним задачу. Надо будет заполнить двухмерный массив и в нем же искать. Возьмем числа от -50 до 49 и ещё сделаем так, чтобы после каждого присвоения очередной ячейке массива присвоенное число выводилось на экран. Сложно? Ни сколько! Важно разрабатывать программу по этапам:

Rem Работа с массивом. Часть вторая.
dim X(10, 10)
randomize timer
cls

Берем двухмерный массив 10*10 ячеек. Теперь очень важная фишка: нужно сделать два оператора for, один будет отвечать за считывание первого числа, а другой – второго:

For cnt1=1 to 10
for cnt2=1 to 10
X(cnt1, cnt2) = int(rnd*100-50): print X(cnt1, cnt2)
next cnt2
next cnt1

Первое, на что нужно обратить внимание, что я использовал два вложенных друг в друга оператора повтора. И обратите внимание, что я сначала закрываю (next cnt2) последний открытый оператор повторений. Всегда нужно делать только так! И теперь обратите внимание на третью строчку – я сначала описваиваю случайное число ячейке и сразу же печатаю это число из ячейки. Видите, какое случайное число я получаю? Сверьтесь с табличкой! Теперь поиск максимального значения:

Q = 0
For cnt1=1 to 10
for cnt2=1 to 10
if Q < X(cnt1, cnt2) then Q = X(cnt1, cnt2)
next cnt2
next cnt1

Ну и снова собираем программу в кучу.

Rem Работа с массивом. Часть вторая.
dim X(10, 10)
randomize timer
cls
For cnt1=1 to 10
for cnt2=1 to 10
X(cnt1, cnt2) = int(rnd*100-50): print X(cnt1, cnt2)
next cnt2
next cnt1
Q = 0
For cnt1=1 to 10
for cnt2=1 to 10
if Q < X(cnt1, cnt2) then Q = X(cnt1, cnt2)
next cnt2
next cnt1
Print Q, “ – максимальный элемент в массиве!”

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