Программирование на языке Pascal
Базисные понятия в программировании. Последовательные и максимально подробные разборы задач: анализ, составление алгоритма и детальное описание решения. Реверсная запись трехзначного числа и особенность подсчета количества единичных битов числа.
| Рубрика | Программирование, компьютеры и кибернетика |
| Вид | задача |
| Язык | русский |
| Дата добавления | 18.02.2015 |
| Размер файла | 246,9 K |
Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже
Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.
Задача № 34. Сформировать число из двух заданных чередованием разрядов
Формулировка. Даны два натуральных числа одинаковой десятичной разрядности. Сформировать из них третье число так, чтобы цифры первого числа стояли на нечетных местах третьего, а цифры второго - на четных. При этом порядки следования цифр сохраняются. Например, при вводе 1234 и 5678 программа должна выдать ответ 15263748 (для наглядности разряды обоих чисел выделены разными цветами).
Решение. Так как у чисел (обозначим их a и b) одинаковая десятичная разрядность, крайняя справа цифра у третьего числа (c, которое поначалу должно быть равно 0) всегда будет на четном месте, так как при его формировании мы работаем с длинами a и b как с числами одной четности, сумма которых всегда четна, и длина c как раз и есть позиция крайней справа цифры.
Это значит, что формирование c нужно в любом случае начинать с последнего разряда b. При этом каждый взятый из a или b разряд мы должны сместить на необходимую позицию влево, чтобы добавлять разряды c, используя операцию сложения. Мы сделаем это с помощью вспомогательной переменной z, которая перед входом в цикл будет равна 1. В цикле же она будет умножаться на последний добытый разряд b (при этом выражение z * b mod 10 нужно прибавить к c), затем умножить z на 10 и проделать то же самое с последним разрядом a и снова умножить z на 10. Кстати, при этом нужно не забыть своевременно отбросить уже рассмотренные разряды чисел.
Так как разрядность чисел неизвестна, нам нужен цикл с предусловием. В силу одинаковой десятичной разрядности a и b мы можем сделать условие по обнулению любого из них, так как второе при этом также обнулится. Возьмем условие a < > 0.
Таким будет основной цикл:
while a <> 0 do begin
c := c + z * (b mod 10);
z := z * 10;
b := b div 10;
c := c + z * (a mod 10);
z := z * 10;
a := a div 10
end;
В итоге конечное число c будет сформировано в таком виде (все направления справа налево): первая цифра b, первая цифра a, вторая цифра b, вторая цифра a и так далее до самых последних разрядов слева. Кстати, скобки в двух операторах нужны для правильного понимания компилятором приоритета выполняемых арифметических операций. Без них z умножится на соответствующее число, и остаток от деления именно этого числа прибавится к c, что неправильно.
Алгоритм на естественном языке:
1) Ввод a и b;
2) Обнуление переменной c;
3) Присвоение переменной z числа 1;
4) Запуск цикла с предусловием a < > 0. В цикле:
1. Прибавляем последний разряд b в текущий разряд c, определяемый с помощью множителя z;
2. Умножаем z на 10;
3. Избавляемся от последнего разряда в b;
4. Прибавляем последний разряд a в текущий разряд c с помощью множителя z;
5. Умножаем z на 10;
6. Избавляемся от последнего разряда в a;
5) Вывод c.
Код:
|
1. program CombineTwoNums; 2. 3. var 4. c, z: integer; 5. a, b: word; 6. 7. begin 8. readln(a, b); 9. c := 0; 10. z := 1; 11. while a <> 0 do begin 12. c := c + z * (b mod 10); 13. z := z * 10; 14. b := b div 10; 15. c := c + z * (a mod 10); 16. z := z * 10; 17. a := a div 10 18. end; 19. writeln(c) 20. end. |
Задача № 35. Вывести на экран x, записанное в системе счисления с основанием n
Формулировка. Даны натуральные числа x и n (n <= 10). Вывести на экран число x, записанное в системе счисления с основанием n.
Решение. Вспомним правило из задачи 5:
Остаток от деления любого десятичного числа x на число p дает нам разряд единиц числа x (его крайний разряд справа) в системе счисления с основанием p.
Раньше мы принимали это правило без доказательства, однако сейчас мы коснемся его, так как оно достаточно краткое.
Воспользуемся формулой записи десятичного числа x в системе счисления с основанием p, состоящего из r знаков:
x = ar-1 * pr-1 + ar-2 * pr-2 + ... + a2 * p2 + a1 * p1 + a0 * p0,
где pr-1, pr-2, …, p2, p1, p0 - основание системы счисления, возведенное в соответствующие степени, ar-1, ar-2, ..., a2,a1, a0 - цифры в записи этого числа в системе счисления с основанием p.
Например, число 378 в десятичной системе счисления выглядит так: 378 = 3 * 102 + 7 * 101 + 8 * 100. Если мы подряд выпишем цифры a2 (= 3), a1 (= 7), a0 (= 8), то исходное число восстановится.
Запишем представление числа в 22 двоичной системе счисления (переведем его с помощью калькулятора, оно равно 101102) по этой же формуле: 22 = 1 * 24 + 0 * 23 + 1 * 22 + 1 * 21 + 0 * 20. Понятно, что если мы вычислим выражение в правой части равенства, то получим как раз 22.
Теперь покажем то, что если мы возьмем остаток от деления числа 22 на 2, затем разделим его на 2, отбросив остаток, и будем повторять эти действия до обнуления числа, то в итоге получим все его разряды в порядке справа налево. Возьмем его запись 1 * 24 + 0 * 23 + 1 * 22 + 1 * 21 + 0 * 20 и разделим ее на 2. Из алгебры известно, что если мы делим сумму чисел на некоторое число, то на него делятся все слагаемые этой суммы. 1 * 24, 0 * 23, 1 * 22 и 1 * 21 делятся на 2, так как в них присутствует множитель 2. 0 * 20 = 0 * 1 = 0 не делится на 2, соответственно, это число будет остатком от деления на 2, и при этом по формуле оно является крайним справа разрядом. Затем мы делим всю эту запись на 2 и отбрасываем остаток, получаем: 1 * 23 + 0 * 22 + 1 * 21 + 1 * 20. Очевидно, что при следующем взятии остатка мы получим цифру из крайнего справа слагаемого. Повторяя эту цепочку, мы постепенно получим все цифры числа 22 в системе счисления с основанием 2.
Обобщая вышесказанное, приходим к выводу, что для формирования записи числа нам необходимо получить все остатки от деления x на основание n, при этом деля x на n после каждого взятия остатка.
Каким образом мы запишем остатки справа налево? Очень просто: умножаем очередной остаток на некоторый множитель z, добавляющий необходимое количество нулей, чтобы цифра оказалась в необходимой позиции, и прибавляем к результату r. Поначалу z будет равен 1, так как мы прибавляем цифру к разряду единиц, затем z в каждой итерации будет умножаться на 10.
В итоге мы прибавляем к результату r первый остаток, умноженный на 1, второй остаток, умноженный на 10, третий остаток, умноженный на 100 и так далее, пока не будет сформировано искомое число:
r := 0;
z := 1;
while x <> 0 do begin
r := r + z * (x mod n);
x := x div n;
z := z * 10
end;
Код:
|
1. program ConvertNotation; 2. 3. var 4. c, z, r: integer; 5. x, z: word; 6. 7. begin 8. readln(x, n); 9. r := 0; 10. z := 1; 11. while x <> 0 do begin 12. r := r + z * (x mod n); 13. x := x div n; 14. z := z * 10 15. end; 16. writeln(r) 17. end. |
Задача № 36. Найти наименьший нетривиальный делитель двух заданных чисел
Формулировка. Даны натуральные числа m и n. Вывести на экран их наименьший нетривиальный делитель или сообщить, что его нет.
Решение. Задача похожа на задачу 15, в которой поиск минимального делителя осуществлялся с помощью цикла:
for i := 2 to n do begin
if n mod i = 0 then begin
writeln(i);
break
end
end;
Здесь все просто: проверяем все числа от 2 по возрастанию - если нашли делитель, выводим его на экран и выходим из цикла с помощью break. В нашем же случае нужно проверять делимость двух введенных чисел. При этом цикл должен проходить по всем i от 2 до минимального из чисел m и n (назовем его min), так как оно может быть наименьшим нетривиальным делителем, когда оно простое. Например, для чисел 17 и 34 таковым является 17.
Найти наименьшее из двух чисел можно так:
if n < m then min := n else min := m;
Кстати, теперь в цикле мы должны не просто вывести на экран найденный делитель, а сохранить его в некоторую переменную (mindiv), которая до входа в цикл будет равна 1 (или 0), чтобы проверить, выполнилось ли условие делимости в цикле. Если да, то необходимо вывести значение наименьшего общего делителя, а если нет, и mindiv все еще равно 1 (или 0), то вывести сообщение об отсутствии делителя.
Код:
|
1. program MinDivisor; 2. 3. var 4. m, n, i, min, mindiv: word; 5. 6. begin 7. readln(m, n); 8. mindiv := 1; 9. if n < m then min := n else min := m; 10. for i := 2 to min do begin 11. if (n mod i = 0) and (m mod i = 0) then begin 12. mindiv := i; 13. break 14. end 15. end; 16. if mindiv <> 1 then writeln(mindiv) else writeln('No divisors!') 17. end. |
Задача № 37. Проверить, является ли натуральное число счастливым билетом
Формулировка. Дано натуральное число n. Проверить, является ли оно счастливым билетом.
Примечание: вообще, в математике обычно рассматриваются счастливые билеты с четным количеством цифр, потому что у них можно явно выделить левую и правую половины одинаковой длины, суммы цифр которых и сравниваются. Однако мы несколько расширим это определение, полагая, что если число имеет нечетную длину, его центральную цифру можно отбросить, так как ее логично было бы прибавить к накапливаемым суммам обоих половин, что, собственно, не изменит отношения между ними.
Например, число 14350 - счастливый билет, так как 1 + 4 = 5 + 0, а центральную цифру мы отбросили.
Решение. Задача является общим случаем задачи 10. Для ее решения необходимо знать длину числа (то есть его разрядность), вследствие чего нам необходимо скопировать переменную n в некоторую другую (например, a), чтобы на основе a посчитать количество десятичных разрядов n и сохранить его в некоторой переменной digits (digits в пер. с англ. означает «цифры»). Сделать это можно так:
a := n;
digits := 0;
while a <> 0 do begin
a := a div 10;
inc(digits)
end;
Здесь мы в каждой итерации цикла отбрасываем одну цифру от a и увеличиваем значение счетчика digits на 1. На некотором шаге число a будет однозначно и станет равным нулю при делении на 10, и после инкрементации счетчика, который теперь уже будет содержать количество цифр числа, произойдет выход из цикла.
Чтобы посчитать суммы левой и правой половины цифр числа (для накопления которых мы предусмотрим переменные left и right), мы должны запустить два последовательных цикла от 1 до digits div 2, в которых прибавлять каждый полученный разряд к соответствующей переменной и отбрасывать его. Если длина нечетная, нам необходимо отбросить серединную цифру числа без прибавления к какой-либо сумме. Так как в первом цикле мы обработали и отбросили правую половину цифр числа, то по выходе из него серединная цифра как раз будет находиться в разряде единиц. Поэтому необходим следующий шаг:
if odd(digits) then n := n div 10;
Напомним, что функция odd(n) возвращает значение true, если n нечетно, и false, если n четно. То есть, написанный выше оператор проверяет счетчик digits (в котором хранится длина исходного числа) на нечетность, и если оно нечетно, отбрасывает последнюю его цифру.
Далее необходимо накопить сумму цифр левой половины числа и вывести на экран результат сравнения сумм левой и правой половины.
Код:
|
1. program HappyTicket; 2. 3. var 4. n, a: longint; 5. left, right, digits, i: byte; 6. 7. begin 8. readln(n); 9. a := n; 10. digits := 0; 11. while a <> 0 do begin 12. a := a div 10; 13. inc(digits) 14. end; 15. left := 0; 16. right := 0; 17. for i := 1 to digits div 2 do begin 18. right := right + n mod 10; 19. n := n div 10 20. end; 21. if odd(digits) then n := n div 10; 22. for i := 1 to digits div 2 do begin 23. left := left + n mod 10; 24. n := n div 10 25. end; 26. writeln(left = right) 27. end. |
Представим, как должен работать алгоритм при вводе числа 14350:
1) Считаем длину числа, она равна 5 (строки 11-14);
2) В цикле из 5 div 2 = 2 повторений прибавляем к right крайние справа цифры 0 и 5, после чего отбрасываем их и имеем в n 143 (строки 17-20);
3) Так как odd(digits) = odd(5) = true, отбрасываем 3, после чего имеем в n 14 (строка 21);
4) В цикле из 5 div 2 = 2 повторений прибавляем к left оставшиеся цифры 1 и 4, после чего n становится равно 0, что, впрочем, нас уже не интересует (строки 22-25);
5) Выводим на экран значение выражения left = right - ответ положительный (строка 26).
Задача № 38. Проверить, является ли натуральное число палиндромом
Формулировка. Дано натуральное число n. Проверить, представляет ли собой палиндром его десятичная запись.
Решение. Задача является общим случаем задачи 9. Чтобы решить ее, необходимо разделить число n на две половины одинаковой длины, отбросить серединную цифру в случае нечетной длины n и проверить равенство одной из частей реверсной записи другой части.
Так как нам заранее неизвестна десятичная разрядность n, мы можем посчитать ее с помощью следующего цикла (подробнее это описывалось в предыдущей задаче):
a := n;
digits := 0;
while a <> 0 do begin
a := a div 10;
inc(digits)
end;
Теперь рассмотрим варианты проверки числа на палиндром вместе с разбором на примере.
Пусть дано число нечетной длины, например, 79597. Мы можем отделить его правую половину 97, проведя ряд последовательных делений с взятием остатка в цикле из digits div 2 повторений. При этом необходимо сразу сформировать ее реверс в переменную right (мы делали это в задаче 31):
right := 0;
for i := 1 to digits div 2 do begin
right := right * 10;
right := right + n mod 10;
n := n div 10
end;
Так как число нечетно, нужно отбросить его центральную цифру 5, после чего в переменной n (равной 79) будет содержаться левая половина числа, а в переменной right (также равной 79) - его перевернутая правая половина. Они равны, следовательно, ответ положительный.
Тот же порядок действий применяется и для чисел четной длины, однако теперь нам не нужно ничего отбрасывать после накопления реверсной левой части числа в переменную right, так как в числах четной длины нет серединной цифры. Например, дано число 1551: переворачиваем правую половину числа 51 (получим 15) и сравниваем ее с левой половиной: 15 = 15, ответ положительный.
Эти допущения говорят о том, что необходима проверка длины числа n на нечетность и, соответственно, отбрасывание серединной цифры в случае нечетности:
if odd(digits) then n := n div 10;
Код:
|
1. program CheckPalindrome; 2. 3. var 4. n, a, right: longint; 5. digits, i: byte; 6. 7. begin 8. readln(n); 9. a := n; 10. digits := 0; 11. while a <> 0 do begin 12. a := a div 10; 13. inc(digits) 14. end; 15. right := 0; 16. for i := 1 to digits div 2 do begin 17. right := right * 10; 18. right := right + n mod 10; 19. n := n div 10 20. end; 21. if odd(digits) then n := n div 10; 22. writeln(n = right) 23. end. |
Выполним «ручную прокрутку» алгоритма на числе 147741:
1) Считаем длину числа, она равна 6 (строки 11-14);
2) В цикле из 6 div 2 = 3 повторений прибавляем к right (формируя реверсную запись) последние три цифры числа n, после чего отбрасываем их и имеем в n 147, в right 147 (строки 16-20);
3) Так как odd(digits) = odd(6) = false, ничего не делаем (строка 21);
4) Выводим на экран значение выражения n = right - ответ положительный (строка 22).
Задача № 39. Проверить, является ли натуральное число степенью двойки
Формулировка. Дано натуральное число n. Проверить, представляет ли оно собой натуральную степень числа 2.
Решение. Проще говоря, нам нужно ответить на вопрос: можно ли возвести число 2 в какую-либо натуральную степень (или в нулевую степень, так как 20 = 1), чтобы получилось число n?
Вообще, для решения этой задачи существует достаточно красивое равенство, выполняющееся для всех натуральных степеней числа 2, позволяющее получить ответ с помощью одной единственной логической побитовой операции:
n and (n - 1) = 0
Обозначим его как (1).
Дело в том, что натуральная степень числа 2 с показателем p в двоичном виде всегда представляется как единица с p нулями справа. Это происходит потому, что двоичная запись этого числа в десятичном виде представляется как 1 * 2p + 0 * 2p-1 + ... + 0 * 21 + 0 * 20, где все пропущенные слагаемые имеют коэффициент 0, и из этой записи легко восстановить двоичное представление: 10...00, здесь нулей всего p. Поэтому если мы отнимем от любой степени двойки 1, то получим число 1...11, где всего p единиц (точнее говоря, это будет число 01...11). В итоге, если мы применим к этим двум числа побитовую конъюнкцию, то всегда будем получать результирующее число, равное 0.
Примечание: побитовая конъюнкция - это бинарная операция, которая эквивалента обычной конъюнкции, примененной к двоичным разрядам операндов (двух исходных чисел), стоящим на одинаковых позициях в двоичных представлениях этих чисел. При этом результатом применения побитовой конъюнкции является некое результирующее число, значение соответствующих битов которого зависит от значений битов исходных чисел: в соответствующем разряде будет находиться 1 тогда и только тогда, когда на этих позициях в обоих исходных числах стояли единичные биты, и 0, иначе.
Пример: выполним поразрядную конъюнкцию двоичных чисел 0110012 и 1010112 (при этом выпишем их так, чтобы соответствующие двоичные разряды стояли друг под другом):
Первый операнд: 0110012
Второй операнд: 1010112
Результат:0010012
Биты, конъюнкция которых даст 0, выделены красным цветом, а те, конъюнкция которых даст 1 - синим.
Так как 1-й разряд слева у первого числа равен 0, а у второго - 1, то в соответствующий первый разряд результата идет бит 0. 2-е разряды, соответственно, равны 1 и 0, и в результат снова идет бит 0. 3-и разряды у обоих чисел равны 1 (выделены синим цветом), поэтому в 3-й разряд результата идет 1 и так далее.
Кстати, наша формула (1) пропускает число 0 в качестве степени двойки. Так как компиляторы языка Pascal (гарантированно называются Borland Delphi 7 и PascalABC) реализуют числовые типы данных в виде кольцевых отрезков (то есть, например, в типе byte после числа 255 следует число 0, а перед числом 0 - число 255), то в любом таком типе выражение (0 - 1) имеет некоторое ненулевое битовое представление (так как нулевое битовое представление имеет лишь число 0), а побитовая конъюнкция числа 0 и любого другого числа дает в результате число 0.
Вообще, так как нам данное нам n является натуральным числом, число 0 вводиться не будет. Однако покажем, как отсечь 0 при проверке числа по формуле (1): можно осуществить проверку введенного числа на равенство нулю, и в случае равенства заменить его на какое-либо другое число, заведомо не являющееся степенью двойки, чтобы условие формулы (1) отработало правильно:
if n = 0 then n := 3;
Вообще, формула (1) требует доказательства в обе стороны: мы лишь доказали, что если n является степенью двойки, то есть n = 2p (где p - любое натуральное число или 0), то выражение n and (n - 1) гарантированно дает результат 0. Покажем это схематически еще раз:
Первый операнд: 100...00
Второй операнд: 011...11
Результат:000...00
Однако мы также должны доказать, что никакое другое число n, кроме как степень двойки, не может дать 0 в результате выполнения операции n and (n - 1). Однако мы примем это утверждение без доказательства. В итоге тело программки может выглядеть так (для натурального n, которое также может быть нулем):
readln(n);
if n = 0 then n := 3;
writeln(n and (n - 1) = 0);
Однако мы в качестве основного решения возьмем более простую идею: пусть данное число n является степенью двойки. Следовательно, его можно представить так: 2p = 1 * 2 * 2 * ... * 2 (здесь ровно p двоек). Разделив это выражение на 2 определенное количество раз, в результате мы получим число 1.
Если же число n не является степенью двойки, то на некотором шаге мы получим остаток при делении на 2. В связи с этим возникает алгоритм:
1) Вводим n;
2) В цикле с предусловием n > 1 работаем с n:
1. Если остаток от деления n на 2 равен 1 (n mod 2 = 1), то выходим из цикла;
2. Делим n на 2 (n := n div 2);
3) Выводим на экран значение выражения n = 1 (если цикл завершился, то это условие истинно и n - степень двойки, а если нет - то на каком-то шаге мы получили остаток при делении на 2 и вышли через break);
Даже если ввести n, равное 0, то программа выдаст правильный ответ, так как не будет осуществлен вход в цикл (2) и на шаге (3) будет выведено значение выражения 0 = 1, равное false.
Код:
|
1. program PowerOfTwo; 2. 3. var 4. n: integer; 5. 6. begin 7. readln(n); 8. while n > 1 do begin 9. if n mod 2 = 1 then break; 10. n := n div 2 11. end; 12. writeln(n = 1) 13. end. |
Задача № 40. Вывести на экран произведение четных элементов заданной последовательности натуральных чисел
Формулировка. Дана последовательность натуральных чисел, ограниченная вводом нуля. Вывести на экран произведение четных элементов этой последовательности. При этом ноль не считается членом последовательности.
Примечание: задачи подобного рода требуют выполнения каких-либо действий в зависимости от некоторого характеристического свойства. Большинство из них математически неинтересны, однако развивают способность совмещать отдельные приемы и методы программирования, поэтому, в основном, способствуют наработке опыта.
Решение. Так как нам заранее неизвестна длина рассматриваемой последовательности, но мы знаем о том, что она ограничивается вводом нуля, и поэтому можем сделать цикл с предусловием a < > 0, где a - текущий введенный член. Так как нет необходимости работать с несколькими членами одновременно, мы можем следовать данной схеме и в конкретный момент времени работать лишь с одним элементом последовательности.
При всем этом перед циклом нам необходимо считать первый член a, чтобы войти в цикл, если последовательность непустая (а если пустая, то есть состоит из одного нуля, то и не нужно входить в цикл и что-либо делать):
read(a);
while a <> 0 do begin
...
read(a)
end;
Кстати, мы используем оператор ввода read, чтобы можно было вводить члены через пробел, а не через enter, как при использовании readln. Внутри цикла вместо многоточия должна располагаться некоторая последовательность операторов, которые и будут выполнять обработку вводимых данных. После каждой итерации необходимо ввести следующий член последовательности и продолжить обработку, если он не равен нуля, и закончить в противном случае.
Примечательно, что лишь за некоторыми исключениями именно в цикле такого вида будет располагаться основной блок обработки для всех задач на последовательность, ограниченную вводом нуля.
Что же касается текущей задачи, то для ее решения мы в цикле должны проверить каждый элемент на четность, и если он четный, домножить на него некоторую переменную prod для накопления результата (которую поначалу нужно сделать равной 1). При этом если по завершении программы переменная prod будет по-прежнему равна 1, то это значит, что последовательность либо пуста, либо в ней нет четных элементов, что побуждает сделать в этом случае соответствующую проверку с выводом результата или сообщения об отсутствии элементов. В связи с написанным возникает такой код:
read(a);
prod := 1;
while a <> 0 do begin
if a mod 2 = 0 then prod := prod * a;
read(a)
end;
if prod <> 1 then writeln(prod) else writeln(' No such elements!');
При этом проверяется неравенство prod единице, так как хотелось бы поместить в then-блоке условного оператора вывод «положительного» ответа (который отвечает критерию задачи), а в else-блоке - обработку «вырожденного случая». На самом же деле такой порядок не должен быть самоцелью и не считается «хорошим тоном» в программировании, да и делается только по прихоти автора, так что не было бы никакой разницы, если бы в последней строчке было:
if prod = 1 then writeln(' No such elements!') else writeln(prod);
Код:
|
1. program ProductOfEven; 2. 3. var 4. a, prod: word; 5. 6. begin 7. read(a); 8. prod := 1; 9. while a <> 0 do begin 10. if a mod 2 = 0 then prod := prod * a; 11. read(a) 12. end; 13. if prod <> 1 then writeln(prod) else writeln(' No such elements!') 14. end. |
Задача № 41. Вывести на экран произведение двузначных элементов последовательности натуральных чисел, которые делятся на заданное число
Формулировка. Дано натуральное число n, а затем последовательность натуральных чисел, ограниченная вводом нуля. Вывести на экран произведение двузначных элементов этой последовательности, которые делятся на n.
Решение. Задача очень похожа на предыдущую, только в этот раз нам необходимо проверять делимость не на 2 (это было условие четности), а на n. К тому же, мы должны рассматривать только двузначные члены. Для выявления двузначного числа мы, однако, не будем считать его разрядность и сравнивать ее с двойкой, а воспользуемся тем, что любое двузначное число больше 9 и меньше 100.
В связи с этим условие поиска члена последовательности, отвечающего заданным критериям, будет выглядеть так: (a > 9) and (a < 100) and (a mod n = 0).
Напомним, что and - это конъюнкция, причем наше выражение содержит три конъюнктивных члена, так как операция применяется дважды. Оно истинно тогда и только тогда, когда истинны все три члена, и ложно во всех остальных случаях. При этом конъюнктивные члены стоят в скобках, так как логические операции в языке Pascal имеют больший приоритет, чем операции сравнения и арифметические операции. То есть, если опустить скобки, то Pascal, вычисляя значение слева направо, выполнит сначала операции 9 and a, 100 and a и т. д., что в корне неправильно.
Код:
|
1. program ProductOfReqNums; 2. 3. var 4. a, n, prod: word; 5. 6. begin 7. readln(n); 8. read(a); 9. prod := 1; 10. while a <> 0 do begin 11. if (a > 0) and (a < 100) and (a mod n = 0) then prod := prod * a; 12. read(a) 13. end; 14. if prod <> 1 then writeln(prod) else writeln(' No such elements!') 15. end. |
Задача № 42. Найти количество простых членов последовательности
Формулировка. Дана последовательность натуральных чисел, ограниченная вводом нуля. Вывести на количество простых членов этой последовательности.
Решение. Принцип решения этой задачи напоминает решения обеих предыдущих задач. При этом алгоритм распознавания простых чисел можно взять из задачи 17, немного изменив его:
s := 0;
for i := 1 to a do begin
if a mod i = 0 then inc(s)
end;
if s = 2 then inc(count);
Здесь мы предварительно поменяли названия переменных и вместо вывода ответа о простоте числа работаем со счетчиком найденных простых чисел. Напомним, что в цикле считается количество всех возможных натуральных делителей числа, и если их 2, то оно простое, и необходимо увеличить счетчик простых чисел count. Когда вся числовая последовательность будет обработана, останется только вывести на экран значение переменной count.
Код:
|
1. program NumOfPrimes; 2. 3. var 4. a, i, s, count: word; 5. 6. begin 7. read(a); 8. count := 0; 9. while a <> 0 do begin 10. s := 0; 11. for i := 1 to a do begin 12. if a mod i = 0 then inc(s) 13. end; 14. if s = 2 then inc(count); 15. read(a) 16. end; 17. writeln(count) 18. end. |
Задача № 43. Проверить, начинается ли каждый из членов последовательности с десятичной цифры, на которую оканчивается предыдущий
Формулировка. Дана последовательность натуральных чисел, ограниченная вводом нуля. Проверить, начинается ли каждый из ее членов (со второго) с десятичной цифры, на которую оканчивается предыдущий. Например, таковой последовательностью будет являться 14 47 712 2179 9 9 93 0 (также сохранен ограничивающий ноль).
Решение. Задача решается через цикл с предусловием, что характерно для задач на последовательность с ограничителем. При ее решении мы могли бы не рассматривать «вырожденные варианты», в которых на вход будет подаваться, например, пустая последовательность (то есть состоящая из единственного нуля) или последовательность из одного члена, так как на вопрос о том, удовлетворяют ли такие последовательности заданному критерию, ответить теоретически достаточно трудно. Разумнее всего было бы считать выполнение критерия для таких последовательностей неопределенным, что, однако, в формате даваемого нами ответа не представляется возможным: под «проверкой» характеристического свойства в данном случае понимается ответ на вопрос: либо «да», и последовательность отвечает заданным требованиям, либо «нет», и, соответственно, не отвечает.
Следовательно, нам нужно вместо ответа о «неопределенности» проверяемого свойства дать один из допустимых ответов. Наверное, разумно было бы дать при обработке вырожденных случаев программой ответ «нет». Мы возьмем это на заметку и попытаемся сделать контроль исключений, когда уже будет готово решение задачи для общего случая, чтобы заранее не наделать ошибок. Это необходимо потому, что мы попробуем инициализировать значения переменных при запуске программы таким образом, чтобы обработку вырожденных случаев можно было выполнить с минимальным вложением дополнительного кода - мы уже делали это в задаче 32.
Теперь о переменных. Так как нам необходимо проверять выполнение критерия на двойках (парах) элементов, то и хранить в памяти нужно сразу два элемента (a и b). Первый элемент не имеет предшественника, поэтому после ввода мы не обрабатываем его и можем вводить следующий элемент в одном операторе с ним:
read(a, b);
Имея два элемента, мы уже можем выполнить проверку нашего свойства. Однако уже на этом этапе мы можем догадаться, что в силу необходимости выполнить проверку для всех пар элементов последовательности следует сразу поместить ее в цикл. Мы будем считывать каждый очередной член последовательности в переменную b, и так как последнее вводимое число по условию - 0, то предусловием цикла будет b < > 0 (так как при b = 0 цикл должен прекратиться):
while b <> 0 do begin
...
a := b;
read(b)
end;
На месте троеточия будет располагаться код проверки каждой пары, полностью охватывающий определение нашего свойства. Примечание: в «шаблоне» основного цикла мы выделили также оператор a := b, который обеспечивает движение по каждым двум соседним элементам последовательности. Следует обратить внимание на то, что мы должны проверять выполнение нашего свойства для 1-го и 2-го, 2-го и 3-го, 3-го и 4-го и т. д. элементов последовательности.
Когда мы уже выполнили проверку для двух элементов, например, для 1-го (который хранится в переменной a) и 2-го (который хранится в переменной b), то далее мы присваиваем переменной a значение переменной b (в которой у нас хранился 2-ой элемент), затем считываем в b 3-й элемент, чтобы проверить свойство для 2-го и 3-го элементов и т. п.
При этом нужно четко понимать, что мы не можем считывать в цикле сразу две переменные, так как при таком подходе проверка будет выполняться лишь для 1-го и 2-го, 3-го и 4-го и т. д. элементов, что неверно.
Разберем саму проверку. Так как на каждом шаге цикла программе требуется выяснить, начинается ли следующий член последовательности с десятичной цифры данного, то, имея данный член в переменной a и следующий член в b, мы должны сравнить последнюю цифру a (обозначим ее как last) с первой цифрой b (обозначим ее как first). Сделать это можно так:
last := a mod 10;
first := b;
while first > 9 do begin
first := first div 10
end;
Здесь мы сначала добыли последнюю цифру a (строка 1), затем скопировали в last значение b (переменную b нельзя изменять, так как ее значение понадобится нам на следующем шаге цикла) и во вложенном цикле разделили last на 10 столько раз, чтобы в ней осталась лишь одна цифра, которая является его первой цифрой.
Добыв нужные цифры, мы можем выполнить их сравнение и выйти из цикла в том случае, когда они не равны, так как при этом нарушается наше характеристическое свойство, данное в условии, и после этого дальнейшая проверка бессмысленна:
if last <> first then break;
Когда цикл завершится, нам останется лишь вывести на экран результат сравнения переменных last и first: если цикл завершился, то последовательность отвечает заданному свойству (так как не было выхода через break), они будут равны и будет выведен ответ true; если же был совершен выход через break, то переменные неравны и ответ, соответственно, false.
Теперь попробуем оптимизировать программу для обработки вырожденных случаев для пустой последовательности (когда вводится единственный 0) и для последовательности из одного члена (когда вводится некоторое число и 0): мы договорились выводить для них ответ false.
Очевидно, в данный момент наша программа обрабатывает корректно минимальный случай из двух членов: тогда проходит одно повторение тела цикла, в котором переменные last и first получают значения, затем может произойти выход по break или завершение цикла по вводу нуля, как и должно быть.
Однако если мы введем последовательность из одного члена, то при вводе a и b в переменную a пойдет этот член, а в b окажется ограничивающий ноль, что приведет к невыполнению входа в основной цикл и программа перейдет к оператору вывода writeln(last = first), что неверно, так как значение переменных last и first в данный момент будет не определено и выражение в операторе вывода может дать любой результат. Это значит, что для избегания подобного исхода нам нужно выполнить инициализацию переменных last и first заведомо неравными значениями, чтобы получить гарантированный ответ false при вводе последовательности из одного члена. Это можно сделать так:
first := 1;
last := 0;
Но что будет, если ввести последовательность, состоящую из одного нуля? В нашей программе это невозможно, так как оператор ввода в начале содержит две переменные, и если мы сразу введем 0, то программа «зависнет» в ожидании ввода второго числа. Чтобы избежать этого, мы должны вводить одно число в переменную a, и если оно не равно 0, нужно ввести b. Вместе с этим необходимо заранее присвоить переменной b число 0, так как она была определена в случае последовательности из одного члена, чтобы не осуществился вход в основной цикл:
read(a);
b := 0;
if a <> 0 then read(b);
Эта конструкция заменит оператор read(a, b), который мы описывали в самом начале решения задачи.
Код:
|
1. program LastAndFirst; 2. 3. var 4. a, b, first, last: word; 5. 6. begin 7. first := 1; 8. last := 0; 9. read(a); 10. b := 0; 11. if a <> 0 then read(b); 12. while b <> 0 do begin 13. last := a mod 10; 14. first := b; 15. while first > 9 do begin 16. first := first div 10 17. end; 18. if last <> first then break; 19. a := b; 20. read(b) 21. end; 22. writeln(last = first) 23. end. |
Задача № 44. Проверить, является ли последовательность пилообразной
Формулировка. Дана последовательность из трех и более натуральных чисел, ограниченная вводом нуля. Проверить, является ли эта последовательность пилообразной.
Примечание: пилообразной называется последовательность чисел, в которой каждый член, имеющий соседние члены, меньше или больше их.
Пример такой последовательности: 14 12 18 7 10 2. Покажем, что данная последовательность соответствует определению: ее 1-й член (14) мы не рассматриваем, так как он имеет всего один соседний член; 2-й член (12) меньше соседних: 1-го (14) и 3-го (18); 3-й член (18) больше 12 и 7, 7 меньше 18 и 10, 10 больше 7 и 2, а последний элемент 2 мы также не рассматриваем. Эту запись можно формализовать, если между каждыми двумя соседними членами последовательности поставить знак отношения между их величинами («>» или «<»). В связи с этим приведенный выше пример можно проиллюстрировать так: 14 > 12 < 18 > 7 < 10 > 2. При этом характерно направление значков, показывающее, что каждый элемент либо меньше, либо больше соседних. При этом если мы выпишем сами знаки сравнения, то получим символьное сочетание > < > < >. А если выписать эти символы в столбик, становится понятно, почему такая последовательность названа пилообразной.
Решение. Исследуем свойства пилообразной последовательности. В определении сказано, что все ее элементы (кроме двух крайних) меньше либо больше соседних. Конкретизируем это понятие: любую тройку рядом стоящих элементов (левый элемент, центральный элемент, правый элемент) в данной последовательности мы будем называть «зубом».
Например, для указанного выше примера зубьями будут являться тройки 14 12 18, 12 18 7, 18 7 10 и 7 10 2. Каждый зуб удовлетворяет условию, данному в определении, следовательно, последовательность является пилообразной. Очевидно, что если все зубья в некоторой последовательности удовлетворяют данному условию, то эта последовательность является пилообразной.
Найдем некоторые свойства «правильных зубьев», то есть таких, которые отвечают заданному определению. Для этого формализуем рассуждения над элементами зуба, обозначив их как L (левый элемент, от англ. left - левый), M (средний элемент, от англ. medium - средний), R (правый элемент, от англ. right - правый).
Известно, что средний элемент в зубе может быть либо меньше, либо больше крайних, в связи с чем для обоих случаев возникает ряд следующих неравенств:
I случай (средний элемент меньше крайних):
Здесь знак обозначает конъюнкцию (логическое «и»), а обозначает логическое следование (то есть, из выражения, которое стоит левее знака , следует выражение, стоящее правее знака ).
II случай (средний элемент больше крайних):
Итак, в обоих случаях мы составили две разности, которые для удобства обозначили (1) и (2). В I-ом случае (1) и (2) всегда строго больше 0, а во II-ом случае - строго меньше 0.
Составим произведение выражений (1) и (2) и обозначим его как (3): (M - L) * (M - R). В I-ом случае оно всегда положительно как произведение отрицательных чисел, во II-ом случае - также всегда положительно как произведение положительных чисел.
Что же следует из этого выражения? А то, что если результат его вычисления - положительное число, то тройка элементов L, M, R образует «правильный зуб». И как мы помним, если все тройки соседних элементов последовательности образуют «правильные зубья», то она является пилообразной.
Так как в условии задачи на вход подается как минимум три элемента, мы можем прочитать их в одном операторе:
read(L, M, R);
Затем мы входим в цикл с предусловием R < > 0. В этом цикле мы должны исследовать каждую тройку L, M, R по свойству (3):
while R <> 0 do begin
if (L - M) * (R - M) <= 0 then break;
L := M;
M := R;
read(R)
end;
На каждом шаге цикла мы сначала исследуем уже имеющуюся тройку (оператор 1 в теле цикла), и если выражение (3) оказывается равно или меньше нуля, то выходим из цикла, так как нашли «неправильный зуб», который нарушает условие пилообразной последовательности, в силу чего дальнейшая проверка бессмысленна. Затем нам нужно «сдвинуть» последовательность: например, если в переменных L, M, R у нас соответственно хранились 4-й, 5-й и 6-й элементы последовательности, которые мы уже проверили, то с помощью оператора L := M мы переносим 5-й элемент в L, а с помощью M := R переносим 6-й элемент в M. Далее мы вводим 7-й элемент в R, после чего в тройке L, M, R у нас содержатся соответственно 5-й, 6-й и 7-й элементы, проверка которых на соответствие условию будет произведена на следующем шаге цикла.
На последнем шаге цикла последовательность будет в очередной раз «сдвинута» и в R будет введено число 0, после чего должен быть выведен результат. В связи с этим возможно два варианта попадания на этот этап:
a) в цикле был осуществлен выход через break. А это значит, что в переменных L, M, и R в данном случае как раз находится «неправильный зуб» и можно обойтись выводом значения выражения (L - M) * (R - M) > 0, которое как раз даст значение false:
writeln((L - M) * (R - M) > 0);
b) последовательность была проверена до конца, и выход из цикла был осуществлен по вводу в R нуля. Но здесь нужно учесть, что при этом в тройке L, M, R теперь находится «несуществующий зуб» (так как 0 не входит в саму последовательность и не должен учитываться при проверке), который может и не быть «правильным».
Самый простой выход в этом случае - если переменная R равна 0, то заменить R на L. Это приведет к тому, что в выводимом на экран выражении (3) мы перемножаем не (1) и (2), а (1) и (1), что повлечет вывод true, так как мы получаем произведение одинаковых ненулевых чисел, которое всегда положительно. Значит, перед выводом выражения на экран необходима следующая вставка:
if R = 0 then R := L;
Код:
|
1. program Saw; 2. 3. var 4. L, M, R: integer; 5. 6. begin 7. read(L, M, R); 8. while R <> 0 do begin 9. if (L - M) * (R - M) <= 0 then break; 10. L := M; 11. M := R; 12. read(R) 13. end; 14. if R = 0 then R := L; 15. writeln((L - M) * (R - M) > 0) 16. end. |
К слову, данная задача может быть обобщена и на случай, когда длина вводимой последовательности не имеет ограничений снизу, то есть, последовательность может также быть пустой или содержать один член (для двух членов она будет работать корректно - это легко проверить). Для этого можно выполнить контроль ввода в зависимости от значений первых двух вводимых элементов и провести инициализацию значений для вывода необходимого для вырожденных случаев ответа.
Задача № 45. Проверить, является ли последовательность строго монотонной
Формулировка. Дана последовательность натуральных чисел, ограниченная вводом нуля. Проверить, является ли эта последовательность строго монотонной.
Решение. Эта задача - упрощенный вариант задачи 32. Вообще, эти две задачи логично было бы в данном сборнике поменять местами, однако она оказалась на этой позиции из-за тематического распределения задач.
Единственное отличие от задачи 32 состоит в том, что в нашем случае члены последовательности вводятся с клавиатуры с помощью оператора read() - их не нужно добывать как цифры некоторого числа.
Воспользуемся формулой (II) из задачи 32:
p = delta1 * deltai
Напомним, что если произведение p отрицательно или равно нулю, то последовательность не строго монотонна, так как нашлись два delta разных знаков. Мы будем двигаться по последовательности в порядке ввода, слева направо, исследуя при этом знаки всех произведений p. Так как delta1 присутствует в формуле в качестве константы, его значение необходимо вычислить заранее:
read(a, b);
delta := a - b;
В цикле мы будем на каждом шаге считывать один очередной член, поэтому необходимо «сдвигать последовательность» и считывать его в освободившуюся переменную. Так как в переменной a хранится левый член каждой пары, а в переменной b - правый член, то очередное число мы будем считывать в переменную b. Так как ограничитель последовательности - ноль, то и цикл будет продолжаться до ввода в b нуля:
while b <> 0 do begin
if delta * (a - b) <= 0 then break;
a := b;
read(b)
end;
Здесь в первом операторе тела цикла происходит проверка произведения каждых двух delta по уже упомянутой формуле (II) из задачи 32. Далее идет «сдвиг» правого члена текущей пары и ввод нового элемента вместо него. Проще говоря, если, например, у нас в a находился 1-й член последовательности, а в b - 2-й, то данным способом мы переносим 2-й член в переменную a и считываем 3-й член в переменную b, после чего можно проводить следующее сравнение.
Если введенный элемент - не ноль, то цикл продолжается, и исследуется знак произведения delta1 и следующего вычисленного delta. Если условие монотонности нарушается на каком-либо шаге, то дальнейшая проверка бессмысленна, и можно переходить к выводу результата.
Каким же будет развитие событий после выхода из цикла?
1) Если выход был осуществлен через break, то есть по условию нарушения строгой монотонности, то можно вывести на экран значение выражения delta * (a - b) > 0, что даст ответ false;
2) Если цикл завершился по вводу нуля, то последовательность строго монотонна, и нужно, соответственно, выводить ответ true. Однако здесь мы сталкиваемся с проблемой из задачи 45, связанной с тем, что вводимый ноль не обрабатывается в основном цикле, так как не входит в последовательность, однако он вводится в обрабатываемую переменную b, чтобы можно было выйти из цикла. Однако из-за этого с помощью оператора writeln(delta * (a - b) > 0) мы можем получить неправильный ответ, так как в последовательность обрабатывается с вводимым нулем включительно.
Например, последовательность 1 2 3 0 строго монотонна, хотя программа выдаст ответ false, потому что по выходе из цикла delta будет содержать число -1, a - число 3, b - число 0, и выражение -1 * (3 - 0) > 0 - неверно.
На этот раз мы справимся с проблемой по-другому. Легко понять, что если после выхода из цикла b = 0, то последовательность строго монотонна, так как проверка прошла по всем delta вплоть до ввода ограничителя. Если же после выхода b отлично от 0, то был совершен выход по break в теле цикла и последовательность не является строго монотонной. Поэтому логично оформить вывод ответа так:
writeln(b = 0);
Кстати, в такой форме можно осуществить вывод и в задачах 32, 43 и 44, с некоторым, однако, изменением инициализации входных значений переменных.
Напоследок необходимо позаботиться о правильной обработке вырожденных случаев. Будем считать последовательность из единственного нуля не строго монотонной, в отличие от последовательности из одного члена. Она, кстати, итак уже будет обрабатываться корректно: в a вводится некоторое число, а в b вводится 0. При этом не осуществляется вход в основной цикл, и программа переходит к выводу выражения b = 0, которое верно.
Сделаем корректной обработку пустой последовательности. Во-первых, необходимо дать возможность ввода таковой, так как в нашем наброске требуется ввод минимум двух чисел. Для этого мы будем считывать сначала a, и если оно отлично от нуля, то считывать b:
read(a);
if a <> 0 then read(b) else b := 0;
При этом если a = 0, то мы обязательно присваиваем значение 0 переменной b, чтобы она была определена, и гарантированно не было входа в цикл. Однако в этом случае вывод выражения b = 0 повлечет вывод true. Чтобы избежать этого, нужна еще одна проверка: если a = 0, то присвоить b натуральное число, отличное от 0 (например, 1), что повлечет вывод false:
...Подобные документы
Запись кодов команд программы и констант в FlashROM, кодов исходных данных в EEPROM, требуемых значений установочных битов (Fuse Bits) и битов защиты (Lock Bits). Запись и чтение кодов при программировании, способы программирования в микроконтроллерах.
контрольная работа [24,2 K], добавлен 22.08.2010Теоретические и практические аспекты решения прикладных задач с применением функций и процедур структурного (модульного) программирования. Особенности разработки схемы алгоритма и программы для вычисления массива z на языке Turbo Pascal 7.0, их описание.
курсовая работа [241,7 K], добавлен 11.12.2009Запись в языке программирования – это структура данных, состоящая из фиксированного числа компонентов, называемых полями записи. Поле записи как обычная переменная. Операторы сравнения, присоединения. Программа с использованием массива структур.
реферат [11,5 K], добавлен 19.01.2009Изучение функций и возможностей среды разработки языка программирования Pascal. Рассмотрение работы с одномерными и двумерными массивами, со строками и числами. Математическая формулировка задач. Разработка алгоритмов, описание структуры программ.
курсовая работа [879,8 K], добавлен 11.02.2016Характеристика вычислительной системы и инструментов разработки. Программирование на языке Pascal в среде Turbo Pascal и на языке Object Pascal в среде Delphi. Использование процедур, функций, массивов, бинарного поиска. Создание базы данных в виде файла.
отчет по практике [2,1 M], добавлен 02.05.2014Составление структурных программ для решения практических задач по теме "Целочисленная арифметика". Алгоритм нахождения делителей натурального числа, алгоритм проверки простое ли число, алгоритм Решета Эратосфена. Система программирования Free Pascal.
разработка урока [27,1 K], добавлен 03.09.2014Решение задач с помощью языка программирования Delphi: вычисление значения функции Y от X; систем двух уравнений; прогрессий; последовательностей; вычисление числа с определенной точностью; перевод числа из десятичной в восьмеричную систему счисления.
отчет по практике [83,8 K], добавлен 08.06.2010Pascal - высокоуровневый язык программирования общего назначения и интегрированная среда разработки программного обеспечения для платформ DOS и Windows. Входная информация, требуемая для решения задачи и принятые обозначения; описание алгоритма.
курсовая работа [259,6 K], добавлен 18.01.2011Решение трансцендентного уравнения методом Ньютона. Построение графика функции. Блок-схема алгоритма решения задачи и программа решения на языке Pascal. Вычисление значения интеграла методом трапеции, блок-схема алгоритма, погрешности вычисления.
задача [163,4 K], добавлен 16.12.2009Решения задачи графическим и программным способами. Описание алгоритма решения графическим способом, укрупненная схема алгоритма. Ввод элементов двумерного массива, вывод преобразованного массива, разработка программы на языке pascal, листинг программы.
курсовая работа [115,5 K], добавлен 22.05.2010Описание алгоритма решения задачи графическим способом. Вывод элементов массива. Описание блоков укрупненной схемы алгоритма на языке Pascal. Листинг программы, а также ее тестирование. Результат выполнения c помощью ввода различных входных данных.
контрольная работа [150,4 K], добавлен 03.05.2014Файл - именованная область памяти на магнитном носителе. Программирование доступа к файлу в языке Turbo Pascal. Описание файловой переменной. Виды файлов в зависимости от способа описания: текстовые, двоичные или типизированные и нетипизированные.
реферат [14,8 K], добавлен 19.01.2009Способы сортировки задач программирования: пузырьком, пузырьковая с просеиванием, метод последовательного поиска минимумов, вставками. Распределяющая сортировка - RadixSort-цифровая - поразрядная. Теория чисел. Простые числа. Задача "Красивые числа".
реферат [90,5 K], добавлен 14.05.2008Разработка алгоритма работы устройства, описание выбора элементной базы и работы принципиальной схемы. Текст программы, инициализация указателя стека, структура системы и ресурсов микроконтроллера. Запись кодов при программировании данного устройства.
контрольная работа [18,4 K], добавлен 24.12.2010Основные понятия и структура обработчика на языке Pascal. Элективные курсы по информатике в системе профильного обучения. Элективный курс "Программирование в среде Delphi". Методические материалы по изучению программирования на языке Object Pascal.
методичка [55,4 K], добавлен 08.12.2010Этапы подготовки и решения реальных задач. Словесно-формульное, графическое описание, псевдокоды. Программа нахождения квадрата числа на языке Бейсик. Разветвляющийся и циклический алгоритм. Общие положения программирования. Базовые конструкции.
презентация [308,3 K], добавлен 31.10.2016Составление программы на алгоритмическом языке Turbo Pascal. Разработка блок-схемы алгоритма её решения. Составление исходной Pascal-программы и реализация вычислений по составленной программе. Применение методов Рунге-Кутта и Рунге-Кутта-Мерсона.
курсовая работа [385,0 K], добавлен 17.09.2009Понятие о стохастическом программировании, М-постановка и Р-постановка целевой функции. Описание этапов решения задач стохастического программирования: предварительный, оперативный анализ стохастической модели, переход к детерминированному эквиваленту.
курсовая работа [63,2 K], добавлен 15.06.2010Изучение понятия и основных задач стеганографии - науки, изучающей способы и методы сокрытия информации. Характеристика метода замены наименее значащих битов для bmp файлов. Реализация метода замены НЗБ для bmp файлов на языке программирования Java.
курсовая работа [149,2 K], добавлен 13.02.2013Разработка алгоритмов методом пошаговой детализации. Типы данных и операции в Turbo-Pascal. Организация работы с подпрограммами. Составление алгоритмов и программ задач с использованием конечных сумм. Организация работы с динамическими переменными.
учебное пособие [1,4 M], добавлен 26.03.2014
