Представим решения задачи двумя одношаговыми схемами алгоритма. Первая (рис. 7.8) реализует вариант арифметического цикла с искусственным выходом, вторая (рис. 7.9) соответствует типовому итерационному циклу.
Программирование задачи
Программирование по алгоритму варианта 1 (рис. 7.8) выполним с использованием массивов для хранения конечных результатов. Идентификация переменных этого варианта представлена в табл. 7.4.
Таблица 7.4
| Обозначение в алгоритме | n | x | 
| i | ai | bi | ci | di |
| Обозначение в программе | n | x | eps | i | a[ i ] | b[ i ] | c[ i ] | d[ i ] |
Программирование по алгоритму варианта 2 (рис. 7.9) выполним без использования массивов для хранения конечных результатов. При этом идентификация переменных примет вид табл. 7.5.
Таблица 7.5
| Обозначение в алгоритме | n | x |
| i | ai | bi | ci | di |
| Обозначение в программе | n | x | eps | i | a[ i ] | b[ i ] | ci | di |
Программы решения задачи по полученным схемам алгоритма с учетом таблицы идентификации переменных представлены ниже.
Классический вариант программирования задачи
Программа решения по схеме алгоритма рис. 7.8
#include <stdlib.h> /* директивы */
Рис. 7.8. Схема алгоритма задачи вычисления произведений (вариант 1)
Рис. 7.9. Схема алгоритма задачи вычисления произведений (вариант 2)
#include <stdio.h> /* препроцессора */
#include <conio.h>
#include <windows.h>
main() /* заголовок головной функции */
{
float x, eps, a[ 50 ], b[ 50 ], c[ 50 ], d[ 50 ];
int i, n;
char buf[50]; /*описание символьного массива*/
CharToOem("Введите значения n, x, eps: ",buf);
printf("\n %s",buf);
scanf("%d%f%f", &n, &x, &eps);
printf("\n n = %d x = %.3f eps = %.4f ", n, x, eps);
for(i = 0; i < n; i++)
{
CharToOem("Введите поэлементно массив A(",buf);
printf("\n %s %d):", buf, i+1);
scanf("%f", &a[ i ]);
}
for(i = 0; i < n; i++)
{
CharToOem("Введите поэлементно массив B(",buf);
printf("\n %s %d):", buf, i+1);
scanf("%f", &b[ i ]);
}
printf("\n--------------------------------------"
"\n | i |a(i) |b(i) | c(i) |d(i) |"
"\n --------------------------------------");
for(i = 0; i < n; i++)
{
c[ i ] = a[ i ] * b[ i ];
d[ i ] = x/c[ i ];
printf("\n| %2d |%7.3f|%7.3f|%7.3f|%7.3f|",i+1, a[i], b[i], c[i], d[i]);
if(d[ i ] < eps)
{
printf("\n --------------------------------------");
break;
}
else
if(i == n-1)
{
printf("\n --------------------------------------");
CharToOem("Нормальный выход из "
"итерационного цикла не выполнен! ",buf);
printf("\n %s ", buf);
}
}
getch();
}
10 0.65 0.01
0.8 1.3 2.7 2.96 3.5 4.1 5.17 5.9 7.4 12.2
1.1 1.6 2.71 3.04 4.4 6.7 9.3 11.6 13.7 17.0
10 2.16 0.01
0.8 1.3 2.7 2.96 3.5 4.1 5.17 5.9 7.4 12.2
1.1 1.6 2.71 3.04 4.4 6.7 9.3 11.6 13.7 17.0
Два блока исходных данных с различными значениями х (под закрывающей скобкой) позволяют проверить нормальный выход из цикла, либо его невыполнение.
Результаты решения по каждому из вариантов представлены в приложении 7.5 (а, б).
Программа решения по схеме алгоритма рис. 7.9
#include <stdlib.h> /* директивы */
#include <stdio.h> /* препроцессора */
#include <conio.h>
#include <windows.h>
main() /* заголовок головной функции */
{
float x, eps, a[ 50 ], b[ 50 ], ci, di;
int i, n;
char buf[50]; /*описание символьного массива*/
CharToOem("Введите значения n, x, eps: ",buf);
printf("\n %s \n",buf);
scanf("%d%f%f", &n, &x, &eps);
printf("\n n = %d x = %.3f eps = %.4f ", n, x, eps);
for(i = 0; i < n; i++)
{
CharToOem("Введите поэлементно массив A(",buf);
printf("\n %s %d):", buf, i+1);
scanf("%f", &a[ i ]);
}
for(i = 0; i < n; i++)
{
CharToOem("Введите поэлементно массив B(",buf);
printf("\n %s %d):", buf, i+1);
scanf("%f", &b[ i ]);
}
printf("\n --------------------------------------"
"\n | i |a(i) |b(i) | c(i) |d(i) |"
\n --------------------------------------");
i = 0;
do
{
ci = a[ i ] * b[ i ];
di = x/ci;
printf("\n | %2d |%7.3f|%7.3f|%7.3f|%7.3f|", i+1, a[i], b[i], ci, di);
i = i + 1;
if(i >= n)
{
printf("\n --------------------------------------");
CharToOem("Нормальный выход из "
"итерационного цикла не выполнен! ",buf);
printf("\n %s ", buf);
break;
}
}
while(di >= eps);
printf("\n --------------------------------------");
getch();
}
10 0.65 0.01
0.8 1.3 2.7 2.96 3.5 4.1 5.17 5.9 7.4 12.2
1.1 1.6 2.71 3.04 4.4 6.7 9.3 11.6 13.7 17.0
10 2.16 0.01
0.8 1.3 2.7 2.96 3.5 4.1 5.17 5.9 7.4 12.2
1.1 1.6 2.71 3.04 4.4 6.7 9.3 11.6 13.7 17.0
Два блока исходных данных с различными значениями х (под закрывающей скобкой) позволяют проверить нормальный выход из цикла, либо его невыполнение.
Результаты решения по каждому из вариантов представлены в приложении 7.6 (а, б).
Программирование задачи с графическим интерфейсом
Программирование задачи при использовании графического интерфейса предварим его разработкой. Для ввода размера массивов n, делимого х и граничного значения вычислений e планируем однострочные поля редактирования (EditN, EditX, EditEps). Под ввод элементов входных массивов А и В – многострочные поля редактирования (EditА, EditВ). Для вывода расчетных значений произведений и частных – поля-списки (ListBoxС и ListBoxD). Статическое поле (Label) предназначено для вывода информации об аварийном выходе из цикла.
Управление процессом решения (в двух планируемых вариантах) реализуем тремя командными кнопками, расположенными в нижней части окна. Назначение каждой определяется ее названием.
|
|
|
|
|
|
|
|
С учетом планируемого интерфейса выполним последовательное программирование задачи по каждой схеме. Каждый вариант расчета оформим в виде отдельной функции.
Программа решения по схеме алгоритма рис. 7.8
#include <stdlib.h> /* директивы */
#include <stdio.h> /* препроцессора */
…
void TIter3DlgClient::BNClickedOK1()
{
// INSERT>> Your code here.
float x, eps, a[ 50 ], b[ 50 ], c[ 50 ], d[ 50 ];
int i, n;
char buf[10];
ListBoxC->ClearList();
ListBoxD->ClearList();
Label->SetText(" ");
EditN->GetText(buf,10);
n=atoi(buf); /* ввод размера массивов */
EditX->GetText(buf,10);
x=atof(buf); /* ввод делимого*/
EditEps->GetText(buf,10);
eps=atof(buf); /* ввод границы вычислений */
for(i = 0; i < n; i++)
{
EditA->GetLine(buf, 10, i);
a[i]=atof(buf); /* ввод значения элемента массива A*/
}
for(i = 0; i < n; i++)
{
EditB->GetLine(buf, 10, i);
b[i]=atof(buf); /* ввод значения элемента массива B*/
}
for(i = 0; i < n; i++)
{
c[ i ] = a[ i ] * b[ i ];
d[ i ] = x/c[ i ];
sprintf(buf,"%5.3f",c[i]);
ListBoxC->AddString(buf); /* вывод текущих значений элементов массивa C */
sprintf(buf,"%5.3f",d[i]);
ListBoxD->AddString(buf); /* вывод текущих значений элементов массивa D */
if(d[ i ] < eps)
break;
else
if(i == n-1)
Label->SetText("Нормальный выход из итерационного цикла не выполнен!");
}
}
10 0.65 0.01
0.8 1.3 2.7 2.96 3.5 4.1 5.17 5.9 7.4 12.2
1.1 1.6 2.71 3.04 4.4 6.7 9.3 11.6 13.7 17.0
10 2.16 0.01
0.8 1.3 2.7 2.96 3.5 4.1 5.17 5.9 7.4 12.2
1.1 1.6 2.71 3.04 4.4 6.7 9.3 11.6 13.7 17.0
Два блока исходных данных с различными значениями х (под закрывающей скобкой) позволяют проверить нормальный выход из цикла, либо его невыполнение.
Результаты решения по каждому из вариантов представлены в приложении 7.7 (а, б).
Программа решения по схеме алгоритма рис. 7.9
#include <stdlib.h> /* директивы */
#include <stdio.h> /* препроцессора */
…
void TIter3DlgClient::BNClickedOK2()
{
// INSERT>> Your code here.
float x, eps, a[ 50 ], b[ 50 ], ci, di;
int i, n;
char buf[10];
ListBoxC->ClearList();
ListBoxD->ClearList();
Label->SetText(" ");
EditN->GetText(buf,10);
n=atoi(buf); /* ввод размера массивов */
EditX->GetText(buf,10);
x=atof(buf); /* ввод делимого*/
EditEps->GetText(buf,10);
eps=atof(buf); /* ввод границы вычислений */
for(i = 0; i < n; i++)
{
EditA->GetLine(buf, 10, i);
a[i]=atof(buf); /* ввод значения элемента массива A*/
}
for(i = 0; i < n; i++)
{
EditB->GetLine(buf, 10, i);
b[i]=atof(buf); /* ввод значения элемента массива B*/
}
i = 0;
do
{
ci = a[ i ] * b[ i ];
di = x/ci;
sprintf(buf,"%5.3f",ci);
ListBoxC->AddString(buf); /* вывод текущих значений C */
sprintf(buf,"%5.3f",di);
ListBoxD->AddString(buf); /* вывод текущих значений D */
i = i + 1;
if(i>=n)
{
Label->SetText("Нормальный выход из итерационного цикла не выполнен!");
break;
}
}
while(di >= eps);
}
10 0.65 0.01
0.8 1.3 2.7 2.96 3.5 4.1 5.17 5.9 7.4 12.2
1.1 1.6 2.71 3.04 4.4 6.7 9.3 11.6 13.7 17.0
10 2.16 0.01
0.8 1.3 2.7 2.96 3.5 4.1 5.17 5.9 7.4 12.2
1.1 1.6 2.71 3.04 4.4 6.7 9.3 11.6 13.7 17.0
Два блока исходных данных с различными значениями х (под закрывающей скобкой) позволяют проверить нормальный выход из цикла, либо его невыполнение.
Результаты решения по каждому из вариантов представлены в приложении 7.8 (а, б).
Анализ представленных программ позволяет сделать вывод, что каждая из них обладает как достоинствами, так и недостатками. Так, первая позволяет проконтролировать невыполнение поставленной задачи, но использует дополнительный логический оператор организации выхода из цикла.
Вторая соответствует более компактной схеме тела цикла, также позволяя определить невыполнение основного условия при конкретных численных значениях.
Вторая из «чистых» итерационных – задача (7.4) о последовательном делении.
