Вы находитесь на странице: 1из 17

МЕТОД ПОШАГОВОЙ

ДЕТАЛИЗАЦИИ С
ПОСЛЕДОВАТЕЛЬНЫМ
УТОЧНЕНИЕМ
• Метод пошаговой детализации – это последовательное
построение, при котором сложные задачи разбиваются на
ряд более простых, которые называются вспомогательным
алгоритмом.

Задача

Подзадача 1 Подзадача 1
уровня уровня

Подзадача 2 Подзадача 2 Подзадача 2 Подзадача 2


уровня уровня уровня уровня
Проектирование является одной из основных фаз жизненного цикла
программного обеспечения. Следующим шагом является детальное
проектирование. На этом этапе происходит процедурное описание
программы, выбор и оценка алгоритма для реализации каждого модуля. Для
проектирования модульных программ применяются два основных метода:
нисходящего и восходящего проектирования.
В соответствие с методом нисходящего проектирования сначала
кодируются, тестируются и отлаживаются модули самого высокого уровня.
Применение метода нисходящего проектирования основано на пошаговой
детализации решения задачи. Начиная с верхних, самых общих шагов, на
каждом следующем происходит все большее уточнение функций,
выполняемых программой, до полной их реализации.
Основная идея метода нисходящего проектирования - не пытаться
программировать сразу. Пошаговая детализация автоматически заставляет
программиста формировать понятную ему же структуру программы. Также
упрощается и последующая отладка - при получении неверного результата
программа может быть про трассирована, и проверка результата на
очередном шаге сведется к пониманию, верно или неверно отработала
очередная подзадача.
ДОСТОИНСТВА МЕТОДА ПОШАГОВОЙ
ДЕТАЛИЗАЦИИ

- сохраняется целостность программы: от сложного к простому;


- проектирование программы, кодирование, проверку и документирование можно
делать параллельно;
- в каждый момент времени, даже в начале разработки имеется работающий вариант
программы.
По методу восходящего проектирования в первую очередь разрабатываются модули
самого нижнего уровня. Эти модули, работоспособность которых уже проверена,
включаются в разрабатываемые модули более высокого уровня.
Оба метода обладают как достоинствами, так и недостатками. При нисходящем
проектировании до его завершения остаются неизвестными размер программы и ее
эксплуатационные характеристики, так как они определяются в основном модулями
нижнего уровня. А в методе восходящего проектирования принципиальные ошибки в
проекте модулей нижнего уровня будут выявлены лишь на заключительной стадии работы.
На практике наилучшие результаты дает сочетание обоих методов.
• В процессе создания программы особое внимание нужно уделять
разработке алгоритмов. Такой подход поможет избежать ошибок,
допущенных при проектировании программного продукта. Наличие
подобных ошибок потребует массу времени на исправление, возврат
на предыдущие этапы разработки с целью их доработки.
• При разработке алгоритмов обычно используют метод пошаговой
детализации (поэтапно):
• 1. На первом этапе описываются решения поставленной перед
программой задачи, выделяются подзадачи.
• 2. В последующих этапах описывается решение каждой подзадачи,
выделяя при этом новые подзадачи. Так происходит до тех пор, пока
решение подзадач не будет очевидным. Рекомендовано решение
каждой задачи описывать при помощи 1 - 2 конструкций не более,
чтобы более четко представлять структуру программы.
ПРИМЕР

 Требуется разработать программу, которая с определенной точностью eps находит


значение аргумента x по заданному значению функции y при известном значении n.
При разработке алгоритма данной программы используем метод пошаговой
детализации.
• 1 этап. Общая структура программы:
• Программа:
• Ввести y, n, eps
• Определить x
• Вывести x, y
• 2 этап. Детализируем операцию определения x:
• Определить x
• Определить x1 такое, что f(x1)<=y
• Определить x2 такое, что f(x2)>=y
• Определить x на интервале [x1, x2]

• 3 этап. Детализируем операцию определения x1. Значение x1 подбираем таким


образом, чтобы выполнялось условие f(x1)<=y. Известно, что x>0, следовательно,
берем любое значение x, например x1=1 и будем его пследовательно уменьшать,
допустим в 2 раза. Таким образом определим значение x1, удовлетворяющее данному
условию:
• Определить x1:
• x1:=1
• цикл - пока f(x1)>y
• x1:=x1/2
• Все - цикл
• 4 этап. Детализируем операцию определения x2. Значение x2 определяем
аналогично x1, но исходное значение будем последовательно увеличивать в 2
раза.
• Определить x2:
• x2:=1
• цикл - пока f(x2)< y
• x2:=x2*2
• Все - цикл

• 5 этап. Детализируем операцию определения x. Определение x выполняется


последовательным сокращением отрезка [x1, x2].
• Определить x:
• цикл - пока x2-x1>eps
• сократить отрезок [x1, x2]
• все - цикл
• 6 этап. Детализируем операцию сокращения отрезка [x1, x2]. Интервал определения x
сокращаем делением пополам и отбрасываем половину, которая не удовлетворяет
условию f(x1)<=y<=f(x2):
• Сократить интервал определения x:
• xt=(x1+x2)/2
• если f(xt)>y
• то x2:=xt
• иначе x1:=xt
• все - если
• Конец.
• Таким образом, за 6 этапов • все - цикл
разработан следующий алгоритм: • цикл - пока x2-x1>eps
• Программа: • xt:=(x1+x2)/2
• Ввести y, n, eps • если f(xt)>y
• x1:=1 • то x2:=xt
• цикл - пока f(x1)>y • иначе x1:=xt
• x1:=x1/2 • все - если
• все - цикл • все - цикл
• x2:=1 • Вывести xt, y
• цикл - пока f(x2)< y • Конец
• x2:=x2*2
ПРОЦЕДУРА ЗАПОЛНЕНИЯ МАССИВА

procedure zap(var x:massiv;k:integer);


var
i:integer;
begin
For i:=1 to k do x[i]:=random(40);
end;
program poisk_min_v_dvux_massivax; randomize;
const write('Кол-во эл-тов в массиве A:');
n=255; readln(na);
type write('Кол-во эл-тов в массиве B:');
massiv=array [1..n] of integer; readln(nb);
Var zap(a,na);
a,b:massiv; zap(b,nb);
na,nb:integer; writeln;
mina,minb:integer; writeln('Massiv A:');
procedure zap(var x:massiv;k:integer); print(a,na);
begin writeln;
end; writeln('Massiv B:');
procedure print(var print(b,nb);
x:massiv;k:integer); writeln;
begin END.
end;
function
min( x:massiv;k:intege):integer;
begin
end;
BEGIN
ФУНКЦИЯ ПОИСКА МИНИМУМА

function min(var x:massiv;k:integer):integer;


var i:byte; m:integer;
begin
m:=x[1];
for i:=2 to k do
if x[i]<m then m:=x[i];
min:=m;
end;
program poisk_min_v_dvux_massivax; BEGIN
const randomize;
n=255; write('Кол-во эл-тов в массиве A:');
type readln(na);
massiv=array [1..n] of integer; write('Кол-во эл-тов в массиве B:');
Var readln(nb);
a,b:massiv; zap(a,na);
na,nb:byte; zap(b,nb);
mina,minb:integer; writeln;
procedure zap(var x:massiv;k:byte); writeln('Massiv A:');
begin print(a,na);
end; writeln;
procedure print(var x:massiv;k:byte); writeln('Massiv B:');
begin print(b,nb);
end; writeln(min(a,na)); writeln(min(b,nb));
function min( x:massiv;k:byte):integer; END.
begin
end;
{сравнение минимальных элементов}
if min(a,na)<min(b,nb)
then writeln(' Наименьший в массиве A')
else
if min(b,nb)<min(a,na)
then
writeln(' Наименьший в массиве B')
else writeln('Минимальные равны');
END.
ВЫВОД

• Эффективным методом построения алгоритмов является метод


пошаговой детализации (последовательного построения). При этом
сложная задача разбивается на ряд более простых. Записывая
программу для компьютера на «понятном» ему языке
программирования , вспомогательные алгоритмы можно организовать,
например, как подпрограммы . Подпрограммы общего назначения могут
объединятся в библиотеки подпрограмм, а иногда образовывать набор
стандартных функций.
ИСТОЧНИКИ ИНФОРМАЦИИ

• http://
mirznanii.com/a/113519/metod-poshagovoy-detalizatsii-v-programmirovanii
• https://studfiles.net/preview/6186391/page:2/
• http://samzan.ru/187600
• https://www.top-technologies.ru/ru/article/view?id=32535

Вам также может понравиться