При решении задач с большим количеством данных одинакового типа использование переменных с различными именами, не упорядоченных по адресам памяти, затрудняет программирование. В подобных случаях в языке Си используют объекты, называемые массивами.
Массив — это непрерывный участок памяти, содержащий последовательность объектов одинакового типа, обозначаемый одним именем.
Массив характеризуется следующими основными понятиями:
Элемент массива (значение элемента массива) – значение, хранящееся в определенной ячейке памяти, расположенной в пределах массива, а также адрес этой ячейки памяти.
Каждый элемент массива характеризуется тремя величинами:
- адресом элемента — адресом начальной ячейки памяти, в которой расположен этот элемент;
- индексом элемента (порядковым номером элемента в массиве);
- значением элемента.
Адрес массива – адрес начального элемента массива.
Имя массива – идентификатор, используемый для обращения к элементам массива.
Размер массива – количество элементов массива
Размер элемента – количество байт, занимаемых одним элементом массива.
Графически расположение массива в памяти компьютера можно представить в виде непрерывной ленты адресов.
Представленный на рисунке массив содержит q элементов с индексами от 0 до q-1. Каждый элемент занимает в памяти компьютера k байт, причем расположение элементов в памяти последовательное.
Адреса i-го элемента массива имеет значение
n+k·i
Адрес массива представляет собой адрес начального (нулевого) элемента массива. Для обращения к элементам массива используется порядковый номер (индекс) элемента, начальное значение которого равно 0. Так, если массив содержит q элементов, то индексы элементов массива меняются в пределах от 0 до q-1.
Длина массива – количество байт, отводимое в памяти для хранения всех элементов массива.
ДлинаМассива = РазмерЭлемента * КоличествоЭлементов
Для определения размера элемента массива может использоваться функция
Например,
sizeof(int) = 4;
sizeof(float) = 4;
sizeof(double) = 8;
Объявление и инициализация массивов
Для объявления массива в языке Си используется следующий синтаксис:
тип имя[размерность]={инициализация};
Инициализация представляет собой набор начальных значений элементов массива, указанных в фигурных скобках, и разделенных запятыми.
Если количество инициализирующих значений, указанных в фигурных скобках, меньше, чем количество элементов массива, указанное в квадратных скобках, то все оставшиеся элементы в массиве (для которых не хватило инициализирующих значений) будут равны нулю. Это свойство удобно использовать для задания нулевых значений всем элементам массива.
Если массив проинициализирован при объявлении, то константные начальные значения его элементов указываются через запятую в фигурных скобках. В этом случае количество элементов в квадратных скобках может быть опущено.
При обращении к элементам массива индекс требуемого элемента указывается в квадратных скобках [].
Пример на Си
2
3
4
5
6
7
8
int main()
{
int a[] = { 5, 4, 3, 2, 1 }; // массив a содержит 5 элементов
printf("%d %d %d %d %d\n", a[0], a[1], a[2], a[3], a[4]);
getchar();
return 0;
}
Результат выполнения программы:
Однако часто требуется задавать значения элементов массива в процессе выполнения программы. При этом используется объявление массива без инициализации. В таком случае указание количества элементов в квадратных скобках обязательно.
Для задания начальных значений элементов массива очень часто используется параметрический цикл:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
int main()
{
int a[5]; // объявлен массив a из 5 элементов
int i;
// Ввод элементов массива
for (i = 0; i<5; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]); // &a[i] - адрес i-го элемента массива
}
// Вывод элементов массива
for (i = 0; i<5; i++)
printf("%d ", a[i]); // пробел в формате печати обязателен
getchar(); getchar();
return 0;
}
Результат выполнения программы
Многомерные массивы
В языке Си могут быть также объявлены многомерные массивы. Отличие многомерного массива от одномерного состоит в том, что в одномерном массиве положение элемента определяется одним индексом, а в многомерном — несколькими. Примером многомерного массива является матрица.
Общая форма объявления многомерного массива
Элементы многомерного массива располагаются в последовательных ячейках оперативной памяти по возрастанию адресов. В памяти компьютера элементы многомерного массива располагаются подряд, например массив, имеющий 2 строки и 3 столбца,
будет расположен в памяти следующим образом
Общее количество элементов в приведенном двумерном массиве определится как
КоличествоСтрок * КоличествоСтолбцов = 2 * 3 = 6.
Количество байт памяти, требуемых для размещения массива, определится как
КоличествоЭлементов * РазмерЭлемента = 6 * 4 = 24 байта.
Инициализация многомерных массивов
Значения элементов многомерного массива, как и в одномерном случае, могут быть заданы константными значениями при объявлении, заключенными в фигурные скобки {}. Однако в этом случае указание количества элементов в строках и столбцах должно быть обязательно указано в квадратных скобках [].
Пример на Си
2
3
4
5
6
7
8
9
int main()
{
int a[2][3] = { 1, 2, 3, 4, 5, 6 };
printf("%d %d %d\n", a[0][0], a[0][1], a[0][2]);
printf("%d %d %d\n", a[1][0], a[1][1], a[1][2]);
getchar();
return 0;
}
Результат выполнения
Однако чаще требуется вводить значения элементов многомерного массива в процессе выполнения программы. С этой целью удобно использовать вложенный параметрический цикл.
Пример на Си
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
int main()
{
int a[2][3]; // массив из 2 строк и 3 столбцов
int i, j;
// Ввод элементов массива
for (i = 0; i<2; i++) // цикл по строкам
{
for (j = 0; j<3; j++) // цикл по столбцам
{
printf("a[%d][%d] = ", i, j);
scanf("%d", &a[i][j]);
}
}
// Вывод элементов массива
for (i = 0; i<2; i++) // цикл по строкам
{
for (j = 0; j<3; j++) // цикл по столбцам
{
printf("%d ", a[i][j]);
}
printf("\n"); // перевод на новую строку
}
getchar(); getchar();
return 0;
}
Передача массива в функцию
Обработку массивов удобно организовывать с помощью специальных функций. Для обработки массива в качестве аргументов функции необходимо передать
- адрес массива,
- размер массива.
Исключение составляют функции обработки строк, в которые достаточно передать только адрес.
При передаче переменные в качестве аргументов функции данные передаются как копии. Это означает, что если внутри функции произойдет изменение значения параметра, то это никак не повлияет на его значение внутри вызывающей функции.
Если в функцию передается адрес переменной (или адрес массива), то все операции, выполняемые в функции с данными, находящимися в пределах видимости указанного адреса, производятся над оригиналом данных, поэтому исходный массив (или значение переменной) может быть изменено вызываемой функцией.
Пример на Си Дан массив из 10 элементов. Поменять местами наибольший и начальный элементы массива. Для операций поиска максимального элемента и обмена использовать функцию.
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <stdio.h>
// Функция обмена
void change(int *x, int n)
{
// x - указатель на массив (адрес массива)
// n - размер массива
int i;
int max, index;
max = x[0];
index = 0;
// Поиск максимального элемента
for (i = 1; i<n; i++)
{
if (x[i]>max)
{
max = x[i];
index = i;
}
}
// Обмен
x[index] = x[0];
x[0] = max;
}
// Главная функция
int main()
{
int a[10];
int i;
for (i = 0; i<10; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]);
}
change(a, 10); // вызов функции обмена
// Вывод элементов массива
for (i = 0; i<10; i++)
printf("%d ", a[i]);
getchar();
getchar();
return 0;
}
Результат выполнения
Пример на Си Дан массив размерности n. Вычислить произведение четных элементов
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <stdio.h>
// Функция вычисления произведения чётных элементов
int func(int *x, int n) // произведение четных элементов
{
int p = 1; // начальное значение произведения
int i;
for (i = 0; i<n; i++)
{
if (x[i] % 2 == 0) // остаток от деления на 2 равен 0?
p = p * x[i];
}
return p;
}
// Главная функция
int main()
{
int a[5]; // объявлен массив a из 5 элементов
int i;
int pr;
// Ввод элементов массива
for (i = 0; i<5; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]); // &a[i] - адрес i-го элемента массива
}
pr = func(a, 5); // вычисление произведения
printf("\n pr = %d", pr); // вывод произведения четных элементов
getchar(); getchar();
return 0;
}
Результат выполнения
Назад: Язык Си
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
int choice; //обраний пункт меню
double arr_C[100]; //одновимірний масив c
int n; //кількість елементів масиву c
double a, b;
int j;
int index;
double k;
//введення кількості елементів масиву B
printf("\nУведіть кількість елементів масиву C(n)-(максимум 100) = ");
while (1)
{
if (scanf("%d", &n)!=1 n <= 0)
{
//якщо не виконуються умови-виведення запиту на повторне введення
printf("Ви ввели неправильне значення. Спробуйте ще раз:\n");
while(getchar() != '\n') //очистка буфера вводу та очікуання на правильний результат
continue;
}
else if (n > 100)
{
//якщо переповнення масиву-виведення запиту на повторне введення
printf("Забагато елементів. Спробуйте ще раз:\n");
while(getchar() != '\n') //очистка буфера вводу та очікуання на правильний результат
continue;
}
else
break;
}
//введення елементів масиву B
for (int i = 0; i < n; i++) {
printf("arr_C[%d] = ", i);
while (scanf("%lf", &arr_C[i])!=1)
{
//якщо не виконуються умови-виведення запиту на повторне введення
printf("Ви ввели неправильне значення. Спробуйте ще раз:\n");
while(getchar() != '\n') //очистка буфера вводу та очікуання на правильний результат
continue;
}
}
a = DInput("Введіть a:");
b = DInput("Введіть b:");
k=0;
for (j=0; j<n; j++)
if ((arr_C[j]<a)(arr_C[j]>b)){
if (k == 0)
index = j;
if (k == 1) {
arr_C[j] = arr_C[index];
arr_C[index] = arr_C[j];
break;
}
k++;
}
2
3
arr_C[j]=arr_C[index];
arr_C[index]=temp;
2
3
for(int i=0; i<n; i++)
sum+=mas[i];
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
int main(void)
{
int i, j, min, imin, jmin, max, imax, jmax;
int a [3][7];
for (i=0; i<3; i++)
for (j=0; j<7; j++)
{
printf("Give temperature [%d][%d]= ",i+1, j+1);
scanf("%d", &a[i][j]);
}
max = a[0][0];
imax = 0;
jmax = 0;
for (i=0; i<3; i++)
for (j=0; j<7; j++)
if (a[i][j] > max)
{
max = a[i][j];
imax = i;
jmax = j;
}
min = a[0][0];
imin = 0;
jmin = 0;
for (i=0; i<3; i++)
for (j=0; j<7; j++)
if (a[i][j] < min)
{
min = a[i][j];
imin = i;
jmin = j;
}
for (i=0; i<3; i++)
{
for (j=0; j<7; j++)
printf("%d \t",a[i][j]);
printf("\n");
}
printf("\n");
printf("Maximum temperature %d and its in %d and in column %d \n ", max, imax+1, jmax+1);
printf(Minimum temperature %d and its in %d and in column %d \n ", min, imin+1, jmin+1);
printf("\n");
system("pause");
return 0;
}
Чтобы случайные числа не повторялись - возможно два варианта
1. Перетасовать случайным образом последовательность чисел. 2. При генерации следующего случайного числа сравнивать его со всеми предыдущими.
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int n;
printf("n = ");
scanf("%i",&n);
int i, a[n]; // Почему не ругается?
for (i=0; i<n; i++) {
printf("enter element #%i:", i);
scanf("%i",&a[i]);
}
printf("\nResult array:");
for (i=0; i<n; i++)
printf(" %i", a[i]);
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
int str;
int stlb;
int vvod_massiva (const double [][stlb]);
double srednee_znach (const double[][stlb], int n);
double srednee_znach_vseh (const double[][stlb]);
double bolshee_znach (const double[][stlb]);
int vuvod_znach (const double[][stlb], double[], double, double);
int main(void)
{
const double massiv[str][stlb];
double sred [stlb];
double c;
double d;
int i=0;
int j=0;
int ch;
while (1)
{
printf ("Введите количество строк\n");
scanf("%d", &str);
printf ("Введите количество столбцов\n", stlb);
scanf("%d", &stlb);
printf ("Введите %d массива по %d элементов типа double каждый\n", str, stlb );
vvod_massiva(massiv);
for (i=0, j=0; i<str;i++, j++)
{
sred [i]=srednee_znach (massiv, j);
}
c=srednee_znach_vseh (massiv);
d=bolshee_znach (massiv);
vuvod_znach (massiv, sred, c, d );
printf ("Для повтора программы нажмите -1. Для завершения - 2\n");
scanf("%d", &ch);
if (ch!=1)
{
break;
}
}
return 0;
}
int vvod_massiva (const double a[][stlb])
{
int stroka;
int stolbets;
for(stroka=0; stroka<str; stroka++)
{
for (stolbets=0; stolbets<stlb; stolbets++)
{
scanf("%lf", &a[stroka][stolbets]);
}
printf ("\n");
}
}
double srednee_znach (const double a[][stlb], int n)
{
double sum=0;
double srednee=0;
int i;
for(i=0; i<stlb; i++)
{
sum+=a[n][i];
}
srednee=sum/stlb;
return srednee;
}
double srednee_znach_vseh (const double a[][stlb])
{
int stroka;
int stolbets;
double sum=0;
double srednee;
for(stroka=0; stroka<str; stroka++)
{
for (stolbets=0; stolbets<stlb; stolbets++)
{
sum+=a[stroka][stolbets];
}
}
srednee=sum/(str*stlb);
printf("%f\n", sum );
return srednee;
}
double bolshee_znach (const double a[][stlb])
{
int i=0;
int j;
int n=1;
int p1=1;
double massiv [str];
int k;
for(j=0, k=0; j<str; j++, k++)
{
p1=1;
i=0;
while (p1<stlb)
{
if(a[j][i]<=a[j][i+n])
{ i=i+n;
n=1;
p1++;
}
else
{
n++;
p1++;
}
}
massiv [k]=a[j][i];
}
p1=1;
k=0;
n=1;
while (p1<str)
{
if(massiv[k]<=massiv [k+n])
{ k=k+n;
n=1;
p1++;
}
else
{
n++;
p1++;
}
}
return massiv[k];
}
int vuvod_znach (const double a[][stlb], double b[], double c, double d)
{
int stroka;
int stolbets;
int i;
int j;
for(stroka=0; stroka<str; stroka++)
{
for (stolbets=0; stolbets<stlb; stolbets++)
{
printf("%f ", a[stroka][stolbets]);
}
printf ("\n\n");
}
for(i=0; i<str; i++)
{
printf("Среднее значение %d - массива равно %f\n", i+1, b[i] );
}
printf("\n" );
printf("Среднее значение из %d равно %f\n", (str*stlb), c );
printf("большее значение из %d равно %f\n", (str*stlb), d );
}
2
3
4
{
display = N_ELEMENTS (strRU)
};
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#include <stdio.h>
void kisa2(double * * , int, int);
int main() {
int i, j, R, C , y;
printf("Введите количество строк в матрице:\n");
scanf("%d", & R);
printf("Введите количество столбцов в матрице:\n");
scanf("%d", & C);
double * * matr = (double * * ) malloc(R * sizeof(double * ));
for (i = 0; i < R; i++) {
matr[i] = (double * ) malloc(C * sizeof(double));
}
for (i = 0; i < R; ++i) {
for (j = 0; j < C; ++j) {
printf("matr[%d][%d]:", i, j);
scanf("%lf", & ( * ( * (matr + i) + j)));
printf("\n");
}
}
for (i = 0; i < R; ++i) {
for (j = 0; j < C; ++j) {
printf("%.2lf ", matr[i][j]);
}
printf("\n");
}
printf("\n\n\n");
printf("введите номер функции :");
scanf("%d", & y);
switch (y) {
case (2):
kisa2(matr, R, C);
break;
default:
printf("видимо вы ошиблись ");
}
return 0;
}
void kisa2(double * * matr, int R, int C) {
int n = R, m = C, i, j, cnt = 0, ipos = -1, maxcnt = 0, icnt = -1;
for (i = 0; i < n; i++) //поиск
{
cnt = 0; //номера
for (j = 1; j < m; j++) { //строки
if (matr[i][j] == matr[i][j - 1]) //в которой
cnt++; //находится
else { //самая
if (cnt > maxcnt) { //длинная
maxcnt = cnt;
ipos = i; //серия
icnt++; //счетчик
} //одинаковых
cnt = 0;
} //элементов
}
if (cnt > maxcnt) {
maxcnt = cnt;
ipos = i;
icnt++; //счетчик
}
}
if (-1 == icnt)
printf("\nСтрок с одинаковыми элементами нет!");
else
printf("\nНомер строки, в котором находится самая длинная серия одинаковых элементо в:%d ", ipos);
}
}
2
3
4
5
6
7
8
9
for(int i=p+1; i<m; i++)
{
for(int j=0; j<n; j++)
{
if(a[i][j]>0)
sum+=a[i][j];
}
}
2
3
4
5
6
7
8
9
for(int i=p; i<m; i++)
{
for(int j=0; j<n; j++)
{
if(a[i][j]>0)
sum+=a[i][j];
}
}
2
3
4
5
6
7
8
9
10
for ..
for ...
m[i][j] = rand () % 10;
}
int main (){
int mas [3][3], **m_1 = mas;
data (**m_1, 3);
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdlib.h>
void data(int** m, int n) {
for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
m[i][j] = rand() % 10;
}
int main() {
int mas[3][3];
int** m = (int**)malloc(3 * sizeof(int*)); // или int* m[3];
for (int i = 0; i < 3; i++)
m[i] = (int*)mas[i];
data(m, 3);
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
printf("%d ", m[i][j]);
}
printf("\n");
}
getchar();
return 0;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <stdlib.h>
#include <locale.h>
#include <string.h>
#include <limits.H>
#include <malloc.h>
int main()
{
int *a;
int i, j, n, m;
system("chcp 1251");
system("cls");
oo:
printf("Введите количество строк: ");
scanf("%d", &n);
if(n>0 && n<=15);
else
goto oo;
pp:
printf("Введите количество столбцов: ");
scanf("%d", &m);
if(m>0 && m<=15);
else
goto pp;
// Выделение памяти
a = (int*)malloc(n*m * sizeof(int));
// Ввод элементов массива
for (i = 0; i<n; i++)
{
for (j = 0; j<m; j++)
{
printf("Элемент[%d][%d] = ", i+1, j+1);
scanf("%d", (a + i*m + j));
}
}
// Вывод элементов массива
for (i = 0; i<n; i++)
{
for (j = 0; j<m; j++)
{
printf("%d ", *(a + i*m + j));
}
printf("\n");
}
//Максимальное положительное
return 0;
}
2
3
4
{
{0x0E,0x11,0x11,0x11,0x1F,0x11,0x11,0x00},
};
2
3
4
5
{
uint16_t a = simvol[0][i]; // все символы по порядку
// Что-то с ними делаем
}
2
3
4
{
uint16_t chars = pgm_read_byte(chars8_8 [ascii][i]) ;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
*/
#include "M66_Main.h"
//---------------------------------------------
M66_NetWorkOperatorTypedef NetWorkOperators[8] =
{
{"\0","\0","\0","\0","\0","\0"},
{"MTS\0","internet\0","*111*0887#\0","\0","\0","#100#\0"},
{"MegaFon\0","internet\0","*205#\0","\0","\0","#100#\0\0"},
{"Beeline\0","internet.beeline.ru\0","*110*10#\0","beeline\0","beeline\0","#102#\0"},
{"\0","\0","\0","\0","\0","\0"},
{"\0","\0","\0","\0","\0","\0"},
{"\0","\0","\0","\0","\0","\0"},
{"\0","\0","\0","\0","\0","\0"}
};
2
extern M66_NetWorkOperatorTypedef NetWorkOperators[8];
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
int m, k, n;
cin >> n >> m;
int matrix1[m][k];
int matrix2[k][n];
int matrix_pr[k][n] = {0};
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
cin >> matrix1[i][j];
}
}
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
cin >> matrix2[i][j];
}
}
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
matrix_pr[i][j] = matrix1[i][j] * matrix2[i][j];
cout << matrix_pr[i][j] << " ";
}
cout << endl;
}
return 0;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <stdlib.h>
#include <time.h>
#define CONST 50
int main()
{
int r,a,inner,outer,temp;
int rnd[CONST]={};
srand((unsigned)time(NULL));
puts("Массив случайных чисел:");
for (a=0;a<CONST;a++)
{ r=rand();
rnd[CONST]=(r%100)+1;
printf("%d\t",rnd[CONST]);
}
putchar('\n');
for(outer=0;outer<CONST-1;outer++)
{
for (inner=outer+1;inner<CONST;inner++)
{
if(rnd[outer]>rnd[inner])
{
temp=rnd[outer];
rnd[outer]=rnd[inner];
rnd[inner]=temp;
}
}
}
puts("Отсортированный массив:");
for(a=0;a<CONST;a++)
printf("%d\t",rnd[a]);
putchar('\n');
return 0;
}
2
3
4
5
6
{
r = rand();
rnd[a] = (r % 100) + 1;
printf("%d\t", rnd[a]);
}
2
3
4
5
6
7
8
9
10
11
int *a;
a = (int*)malloc(SIZE*SIZE*sizeof(int));
for(int i=0; i<SIZE; i++)
for(int j=0; j<SIZE; j++)
*(a+i*SIZE+j)=0;
for(int i=0; i<SIZE; i++)
{
cout << "a[" << i << "][" << i << "]= ";
cin >> *(a+i*SIZE+i);
}
2
3
4
5
for(int i = 0; i < size*size; i++, p_elements++)
*p_elements = 0; //присваивание диагональным
for(double i = 0; i < size; i++,p_elements = i * (1+col_size))
*p_elements= diagonal_value;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
using namespace std;
#define SIZE 3
int main()
{
int* a;
a = (int*)malloc(SIZE * SIZE * sizeof(int));
int* head = a;
for (int i = 0; i < SIZE; i++)
for (int j = 0; j < SIZE; j++)
*a++ = 0;
a = head;
for (int i = 0; i < SIZE; i++, a+=SIZE+1)
{
cout << "a[" << i << "][" << i << "]= ";
cin >> *a;
}
a = head;
for (int i = 0; i < SIZE; i++)
{
for (int j = 0; j < SIZE; j++)
cout << *a++ << " ";
cout << endl;
}
}
2
3
4
{ double A1[n][n];
.....
}
2
3
4
5
{ scanf("%i",&n);
double A1[n][n];
.....
}
2
3
4
5
6
7
8
9
10
11
12
using namespace std;
int main()
{
char str[] = "823793087";
for (int i = 0; i < strlen(str); i += 3)
{
int a = (str[i] - '0') * 100 + (str[i + 1] - '0') * 10 + (str[i + 2] - '0');
cout << a << endl;
}
cin.get();
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int back = n-1;
for(int i=0; i<n; i++)
{
if(x[i]<=a || x[i]>=b)
{
y[back] = x[i];
back--;
}
else
{
y[front]=x[i];
front++;
}
}
А вообще - в цикле после ввода очередного элемента должна стоять проверка требуемого условия, и если условие выполняется, то выходим из цикла через break;
2
3
4
5
6
7
8
9
10
11
12
13
14
int count = 0;
int odd = 0;
int even = 0;
for(int i=0; i<20; i++)
{
printf("a[%d]=", i);
scanf("%d", &a[i]);
count++; // количество введенных элементов
if(a[i] %2 == 0) even++;
else odd++;
if((odd >=3) && (even >=4))
break;
}
Услуги по написанию кода "для зачёта" не оказываю.
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#define SEMYA 6
#define OCENKI 6
int main()
{
int j, i;
int otvet[SEMYA] ={2,2,1,3,3,3};
int freq[OCENKI]={};
for(i=0; i<=SEMYA-1; i++)
{
freq[otvet[i]] = freq[otvet[i]]+1;
}
printf(" ocenka: ferq:\t\n");
for (j=0;j<=OCENKI-1; j++)
{
printf(" \t%d \t%d\n", j, freq[j]);
}
return (0);
}