Блог-схема алгоритма функции
R inf_fun(A, N, D, size_d, POD, POD_S).
Получаемые
параметры: A
– исходная строка size_d
– количество элементов в строке
разделителей POD_S
– количество элементов
в
подстроке.
POD
- подстрока D
– строка разделителей. B
- массив чисел
Рабочие
переменные: I
– Индекс
символа строки Dl–
количество символов в текущем слове
строки K
– Количество
элементов совпавших со строкой
J
– индекс
элемента строки разделителей K_Slov
– количество подстрок в строке Возвращаемый
параметр: N
–количество
элементов в массиве чисел
1
2
3
4
5
6
7
8
9
10
11
12
13
14
16
17
18
19
20
21
22
23
Описание функции inf_fun.
Прототип R inf_fun(A, B, D, size_d, POD, POD_S);
Функция принимает строку символов A, массив чисел B, строку разделителей D, количество символов в строке разделителей size_d, строку POD, количество элементов в строке POD - POD_S. Функция попарно записывает в массив чисел по два значения которые являются: начальным индексом подстроки, и индексом символа разделителя следующего после подстроки ,в строке A, соответственно. В последний элемент массива записывается количество вхождений строки POD в строку A. Подстроки определяются символами разделителями из D. Гарантируется что строка A будет заканчиваться символом разделителем. Если строка A не заканчивается символом разделителем то функция его добавит в конец строки A. Возвращает количество элементов в сформированном массиве чисел - R.
Реализация функции на языке с++:
int inf_fun(char *A,int *B,char *D, int size_d,char* POD,int POD_S)
{
int K_slov = 0, I = 0, DL = 0, K = 0, J;
int N = 0;
while(A[I] != '\0')
{
J = 0;
while(J < size_d)
{
if (A[I] == D[J])
J = size_d;
J = J + 1;
}
if(J == size_d)
{
if(DL <= POD_S && A[I] == POD[DL])
K = K + 1;
DL = DL + 1;
}
else
{
if (DL != 0)
{
B[N+1] = I;
B[N] = I - DL;
N = N + 2;
if(K = POD_S)
K_slov = K_slov + 1;
}
K = 0;
}
I = I + 1;
}
if(DL != 0)
{
A[I] = D[0];
A[I+1] = '\0';
B[N+1] = I;
B[N] = I - DL;
N = N + 2;
}
B[N] = K_slov;
N = N + 1;
return N;
}
Таблица проверки алгоритма функции inf_fun.
|
№ блока |
I |
J |
A[I] |
A[I +1] |
Size_d |
N |
K |
K_slov |
DL DL |
POD_S |
B[N] |
B[N+1] |
A[I]!=‘\0’ |
J < size_d |
A[I] != D[J]
|
J = size_d
|
DL != 0 |
K = POD_S |
Dl <= POD_S && A[I] = POD[DL]
|
|
|
|
A = “ab.cd.”; POD = “cd”;D = “.,”;size_d = 2;POD_S = 2; |
|||||||||||||||||||
|
1 |
0 |
|
|
|
2 |
0 |
|
|
0 |
2 |
|
|
|
|
|
|
|
|
|
|
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
|
3 |
|
0 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
5 |
|
1 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
5 |
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
|
|
|
|
7 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
8 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
10 |
|
|
|
|
|
|
|
|
1 |
|
|
|
|
|
|
|
|
|
|
|
|
12 |
1 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
|
3 |
|
0 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
5 |
|
1 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
5 |
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
|
|
|
|
7 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
8 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
9 |
|
|
|
|
|
|
1 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
10 |
|
|
|
|
|
|
|
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
12 |
2 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
|
3 |
|
0 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
|
|
|
11 |
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
5 |
|
3 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
|
|
|
|
7 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
|
|
13 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
14 |
|
|
|
|
|
|
|
|
|
|
0 |
2 |
|
|
|
|
|
|
|
|
|
16 |
|
|
|
|
|
2 |
|
|
0 |
|
|
|
|
|
|
|
|
|
|
|
|
17 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
18 |
|
|
|
|
|
|
0 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
12 |
3 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
|
3 |
|
0 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
5 |
|
1 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
5 |
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
|
|
|
|
7 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
8 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
9 |
|
|
|
|
|
|
1 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
10 |
|
|
|
|
|
|
|
|
1 |
|
|
|
|
|
|
|
|
|
|
|
|
12 |
4 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
|
3 |
|
0 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
5 |
|
1 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
5 |
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
|
|
|
|
7 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
8 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
9 |
|
|
|
|
|
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
10 |
|
|
|
|
|
|
|
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
12 |
5 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
|
3 |
|
0 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
5 |
|
1 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
№ блока |
I |
J |
A[I] |
A[I +1] |
Size_d |
N |
K |
K_slov |
DL DL |
POD_S |
B[N] |
B[N+1] |
A[I]!=‘\0’ |
J < size_d
|
A[I] != D[J]
|
J = size_d
|
DL != 0 |
K = POD_S |
Dl <= POD_S && A[I] = POD[DL]
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
|
|
|
11 |
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
5 |
|
3 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
|
|
|
|
7 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
|
|
13 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
14 |
|
|
|
|
|
|
|
|
|
|
3 |
5 |
|
|
|
|
|
|
|
|
|
16 |
|
|
|
|
|
4 |
|
|
0 |
|
|
|
|
|
|
|
|
|
|
|
|
17 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
20 |
|
|
|
|
|
|
|
1 |
|
|
|
|
|
|
|
|
|
|
|
|
|
18 |
|
|
|
|
|
|
0 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
12 |
6 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
|
|
|
|
|
19 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
|
22 |
|
|
|
|
|
5 |
|
|
|
|
1 |
|
|
|
|
|
|
|
|
|
|
23 |
Возврат N |
|
||||||||||||||||||
|
|
A = “a”; POD = “cd”;D = “.”;size_d = 2;POD_S = 2; |
|
||||||||||||||||||
|
1 |
0 |
|
|
|
|
0 |
0 |
0 |
0 |
|
|
|
|
|
|
|
|
|
|
|
|
2 |
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
|
|
3 |
|
0 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
|
5 |
|
1 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
6 |
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
|
|
|
|
|
7 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
|
|
8 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
10 |
|
|
|
|
|
|
|
|
1 |
|
|
|
|
|
|
|
|
|
|
|
|
12 |
1 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2 |
|
|
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
|
|
|
|
|
19 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Да |
|
|
|
|
21 |
|
|
. |
\0 |
|
2 |
|
|
|
|
0 |
1 |
|
|
|
|
|
|
|
|
|
22 |
|
|
|
|
|
3 |
|
|
|
|
1 |
|
|
|
|
|
|
|
|
|
|
23 |
Возврат N |
|
||||||||||||||||||
Блог-схема алгоритма функции Sort(B,size):
Получаемые
параметры: B
- массив чисел size
–
количество
элементов в массиве информации
Рабочие
переменные: I
– Индекс
первого числа, в левой паре чисел J
– Индекс
первого числа, в правой паре чисел T1,
T2
– временная
переменные для копируемой пары элементов
1
2
3
4
5
6
8
9
7
10
11
Описание Функции:
Прототип : Sort(B,size);
Функция принимает массив B и размер массива size. Сортирует пары элементов в порядке убывания разности между двумя соседними элементами. Параметр Size должен быть нечетным.
Реализация функции на языке с++:
void Sort(int *A, int size)
{
int I = 0, J, T1, T2;
for(I;I < size -3;I = I + 2)
{
J = I + 2;
for(J; J < size - 2;J = J + 2)
{
if (A[I+1] - A[I] < A[J+1] - A[J])
{
T1 = A[I+1];
T2 = A[I];
A[I+1] = A[J+1];
A[I] = A[J];
A[J] = T2;
A[J+1] = T1;
}
}
}
}
Таблица проверки алгоритма функции Sort:
|
№ Блока |
I |
J |
A[I+1] |
A[I] |
T1 |
T2 |
A[J+1] |
A[J] |
I < size-3 |
A[I+1] - A[I] > A[J+1] - A[J]
|
J < size-2 |
|
|
|
A = {4,8,3,2,5,5,0};size = 7 |
|
||||||||||
|
1 |
0 |
|
|
|
|
|
|
|
|
|
|
|
|
2 |
|
|
|
|
|
|
|
|
Да |
|
|
|
|
3 |
|
2 |
|
|
|
|
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
Да |
|
|
5 |
|
|
|
|
|
|
|
|
|
Да |
|
|
|
6 |
|
|
|
|
8 |
4 |
|
|
|
|
|
|
|
7 |
|
|
3 |
1 |
|
|
|
|
|
|
|
|
|
8 |
|
|
|
|
|
|
8 |
4 |
|
|
|
|
|
9 |
|
4 |
|
|
|
|
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
Да |
|
|
5 |
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
9 |
|
6 |
|
|
|
|
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
10 |
2 |
|
|
|
|
|
|
|
|
|
|
|
|
2 |
|
|
|
|
|
|
|
|
Да |
|
|
|
|
3 |
|
4 |
|
|
|
|
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
Да |
|
|
5 |
|
|
|
|
|
|
|
|
|
Нет |
|
|
|
9 |
|
6 |
|
|
|
|
|
|
|
|
|
|
|
4 |
|
|
|
|
|
|
|
|
|
|
Нет |
|
|
10 |
4 |
|
|
|
|
|
|
|
|
|
|
|
|
2 |
|
|
|
|
|
|
|
|
Нет |
|
|
|
Получаемые
параметры: f_ar
–указатель на целочисленный массив
информации о строке. col
–
количество
элементов в массиве информации Text_or-
указатель на исходную строку
Рабочие
переменные: K
– Индекс
копируемого элемента в исходной строке
I
– Индекс
элемента в массиве информации str_size
– индекс
элемента в результирующей строке Text_n
– результирующая строка. Возвращаемый
параметр: Text_or-сформированная
строка.
Блок-схема функции Copy.
Исправить нужно добавлять нуль символ в конец строки
1
2
3
4
5
6
7
8
10
Описание функции Copy.
Прототип
Функция получает : целочисленный массив чисел f_ar с количеством элементов col и строку символов Text_or . Функция копирует символы Text_or с номерами индексов в промежутке между двумя соседними значениями элементов f_ar и возвращает сформированную строку символов.
Таблица проверки алгоритма функции Copy.
|
№ Блока |
I |
K |
Col |
str_size |
Text_n[str_size] |
I < col -1 |
K <= f_ar[I+1]
|
|
1 |
Text_or = “ab.abс.”;f_ar = “3 6 0 2 0”;col = 5; |
||||||
|
2 |
0 |
|
|
0 |
|
|
|
|
3 |
|
|
|
|
|
Да |
|
|
4 |
|
3 |
|
|
|
|
|
|
5 |
|
|
|
|
|
|
Да |
|
6 |
|
|
|
|
a |
|
|
|
7 |
|
4 |
|
1 |
|
|
|
|
5 |
|
|
|
|
|
|
Да |
|
6 |
|
|
|
|
b |
|
|
|
7 |
|
5 |
|
2 |
|
|
|
|
5 |
|
|
|
|
|
|
Да |
|
6 |
|
|
|
|
с |
|
|
|
7 |
|
6 |
|
3 |
|
|
|
|
5 |
|
|
|
|
|
|
Да |
|
6 |
|
|
|
|
. |
|
|
|
7 |
|
7 |
|
4 |
|
|
|
|
5 |
|
|
|
|
|
|
Нет |
|
8 |
2 |
|
|
|
|
|
|
|
3 |
|
|
|
|
|
Да |
|
|
4 |
|
0 |
|
|
|
|
|
|
5 |
|
|
|
|
|
|
Да |
|
6 |
|
|
|
|
a |
|
|
|
7 |
|
1 |
|
5 |
|
|
|
|
5 |
|
|
|
|
|
|
Да |
|
6 |
|
|
|
|
b |
|
|
|
7 |
|
2 |
|
6 |
|
|
|
|
5 |
|
|
|
|
|
|
Да |
|
6 |
|
|
|
|
. |
|
|
|
7 |
|
3 |
|
7 |
|
|
|
|
5 |
|
|
|
|
|
|
Нет |
|
8 |
4 |
|
|
|
|
|
|
|
3 |
|
|
|
|
|
Нет |
|