 |
Writeln('Нет таких элементов')
|
|
|
|
Begin
for i:=1 to N do readln(A[i]);
i1:= 1;
Sum:= A[1] + A[2];
for i:=2 to N-1 do
if A[i]+ A[i+1] > Sum then begin
i1:= i;
Sum:= A[i] + A[i+1];
End
writeln(i1);
End.
2) Выделяем целочисленные переменные k и max; в k будем хранить количество элементов, равных максимальному, а в max – значение максимального элемента. В k записываем начальное значение 1, а в max – значение первого элемента. В цикле рассматриваем все элементы массива со второго до последнего. Если текущий элемент равен переменной max, то увеличиваем счетчик k. Если текущий элемент больше max, то нашли новый максимальный элемент, запоминаем его значение в переменной max, а в счетчик k записываем единицу. В конце цикла в k записано количество элементов, равных максимальному.
const N=30;
var a:array[1..N] of integer;
max, k, i: integer;
Begin
for i:=1 to N do readln(A[i]);
k:=1;
max:=a[1];
for i:=2 to N do begin
if a[i]=max then k:=k+1;
if a[i]>max then begin
max:=a[i];
k:=1;
End
end;
writeln(k);
End.
3) Введем целые переменные Sum, Max и k. В Sum будем хранить сумму трех последовательных элементов, начиная с текущего, а в Max – максимальную (на данный момент) из этих сумм, а в k – номер первого элемента в цепочке с максимальной суммой. Сначала запишем в Sum и в Max сумму первых трех элементов, а в переменную k – единицу. В цикле рассматриваем все элементы массива со второго до N-2. Для получения очередной суммы вычитаем из Sum предыдущий элемент и добавляем элемент, который следует за текущим через один (можно также просто сложить текущий элемент и два следующих). Сравниваем Sum со значением переменной Max; если Sum больше, то заносим это значение в переменную Max и запоминаем номер текущего элемента в переменной k. По окончании работы алгоритма переменная Max содержит максимальную сумму трех подряд идущих элементов массива, а переменная k указывает на начало цепочки, которая состоит из элементов с номерами k, k+1 и k+2.
|
|
|
const N=30;
var a:array[1..N] of integer;
Max, Sum, i, k: integer;
Begin
Sum:=a[1]+a[2]+a[3];
Max:=Sum; k:=1;
for i:=2 to N-2 do begin
Sum:=Sum-a[i-1]+a[i+2]; { или Sum:=a[i]+a[i+1]+a[i+2];}
if Sum >Max then begin
Max:=Sum;
k:=i;
end;
end;
for i:=k to k+2 do
writeln('A[',i,']=',a[i]);
End.
4) Введем переменные Min (минимальная сумма элементов строки), iMin (номер строки с минимальной суммой) и Sum (сумма элементов текущей строки). Сначала в переменную iMin записываем 1, а в переменную Min – сумму элементов первой строки. Затем в цикле рассматриваем все строки, для каждой строки считаем сумму элементов и, если эта сумма меньше значения Min, записываем сумму в Min, а в iMin – номер текущей строки. В конце работы цикла в переменной Min будет находиться минимальная сумма элементов строки, а в iMin – номер этой строки.
const N=10; M=20;
var a:array[1..N,1..M] of integer;
Min, Sum, iMin, i, k: integer;
Begin
{ ввод матрицы N на N }
Sum:= 0;
for k:=1 to M do Sum:= Sum + a[1,k];
Min:= Sum;
iMin:= 1;
for i:=2 to N do begin
Sum:= 0;
for k:=1 to M do Sum:= Sum + a[i,k];
if Sum < Min then begin
Min:= Sum;
iMin:= i;
end;
end;
writeln('Строка ', iMin, ' сумма ', Min);
End.
5) Введем переменные Max (значение максимального элемента), iMax (номер строки, в которой находится максимальный элемент), Sum (сумма элементов той строки, где находится максимальный элемент). Сначала определяем максимальный элемент в матрице: в переменную Max записываем значение A[1,1], а в iMax – единицу (пока считаем, что максимальный элемент стоит в первой строке); затем в двойном цикле проходим все элементы матрицы, если очередной элемент больше Max, запоминаем его значение в Max, а номер строки – в iMax. После этого находим сумму элементов строки с номером iMax: в переменную Sum записываем 0, в цикле проходим все элементы этой строки, добавляя текущий элемент к Sum. Ответ находится в переменной Sum.
const N=10;
var A:array[1..N,1..N] of integer;
Max, Sum, iMax, i, k: integer;
Begin
{ ввод матрицы N на N }
iMax:= 1; Max:= A[1,1];
for i:=1 to N do
|
|
|
for k:=1 to N do
if A[i,k] > Max then begin
Max:= A[i,k];
iMax:= i;
end;
Sum:= 0;
for k:=1 to N do
Sum:= Sum + A[iMax,k];
writeln(Sum);
End.
6) Вводим целые переменные Sum (сумма минимальных элементов в каждой строке) и Min (минимальный элемент в текущей строке). Сначала в Sum записываем 0. В цикле рассматриваем все строки, для каждой определяем минимальный элемент и добавляем его к переменной Sum. Для поиска минимального элемента в строке записываем в Min значение первого элемента строки, а затем в цикле рассматриваем все остальные элементы строки, начиная со второго; если очередной элемент меньше Min, записываем его значение в Min. После выполнения программы результат находится в переменной Sum.
const N=6; M=10;
var A:array[1..N,1..M] of integer;
Min, Sum, i, k: integer;
Begin
{ ввод матрицы N на N }
Sum:= 0;
for i:=1 to N do begin
Min:= A[i,1];
for k:=2 to M do
if A[i,k] < Min then Min:= A[i,k];
Sum:= Sum + Min;
end;
writeln(Sum);
End.
7) Нужно найти количество учеников, получивших оценку более 20 баллов (по условию – это не нуль), и общую сумму их оценок. Средняя оценка равна сумме оценок, деленной на их количество.
В переменной x будем считать учеников, сдавших экзамен, а в переменной y – накапливать сумму их оценок. Сначала в обе эти переменные запишем нули (начальные значения). Затем в цикле от 1 до 30 рассматриваем все элементы массива A. Если очередной элемент больше 20, увеличиваем переменную x на единицу (считаем этого ученика) и добавляем значение этого элемента массива к старому значению переменной y. После окончания цикла выводим результат деления y на x. Недостающая часть программы может выглядеть так:
x:= 0; y:= 0; { не забыть начальные условия! }
for i:=1 to N do
if A[i] > 20 then begin
x:= x + 1;
y:= y + A[i];
end;
s:= y / x;
writeln('Средний балл ', s:10:3);
8) Фактически нужно найти минимальный рост ученика среди всех учеников, имеющих рост 180 см или выше.
Значение минимального роста будем хранить в переменной x. Поскольку известно, что все ученики не выше 200 см, сначала в переменную x запишем 200 (или любое большее число). Затем в цикле от 1 до 30 рассматриваем все элементы массива A. Если очередной элемент больше или равен 180 (нашли игрока-баскетболиста) и одновременно меньше x, записываем значение этого элемента в переменную x. После окончания цикла выводим значение переменной x. Недостающая часть программы может выглядеть так:
|
|
|
x:= 200; { или любое число >= 200 }
for i:=1 to N do
if (A[i] >= 180) and (A[i] < x) then
x:= A[i];
writeln('Рост ', x);
9) Нужно найти количество дней, когда была оттепель, и общую сумму температур в эти дни. Средняя температура вычисляется как сумме температур, деленная на количество дней.
В переменной x будем считать дни оттепели, а в переменной y – накапливать сумму температур. Сначала в обе эти переменные запишем нули (начальные значения). Затем в цикле от 1 до 31 рассматриваем все элементы массива A. Если очередной элемент больше 0, увеличиваем переменную x на единицу (считаем этот день) и добавляем значение этого элемента массива к старому значению переменной y. После окончания цикла выводим результат деления y на x. Недостающая часть программы может выглядеть так:
x:= 0; y:= 0; { не забыть начальные условия! }
for i:=1 to N do
if A[i] > 0 then begin
x:= x + 1;
y:= y + A[i];
end;
s:= y / x;
writeln('Средняя температура ', s:10:3);
10) Фактически нужно найти в массиве минимальный элемент среди всех элементов, которые больше или равны 20. В отличие от классического алгоритма поиска минимального элемента в массиве, здесь требуется «отсечь» все элементы, которые меньше 20, с помощью дополнительного условия.
Записываем в переменную min начальное значение, равное 100. В цикле от первого элемента до тридцатого сравниваем элементы исходного массива с 20. Если текущий элемент больше или равен 20, то сравниваем значение текущего элемента массива со значением переменной min. Если текущий элемент массива меньше min, то записываем в min значение этого элемента массива. Переходим к следующему элементу. После завершения цикла выводим значение переменной min.
Недостающая часть программы может выглядеть так:
min:= 100; { не забыть начальные условия! }
for i:=1 to N do
if (a[i] >= 20) and (a[i] < min) then
min:= a[i];
writeln (min);
11) В этой задаче нужно сначала найти среднее арифметическое всех элементов главной диагонали. Для этого требуется один простой (не вложенный!) цикл, потому что для элементов главной диагонали номер строки равен номеру столбца.
Пусть N (константа) – количество строк (и столбцов!) матрицы A. Введем вещественную переменную sred, в которой сначала подсчитаем сумму всех элементов главной диагонали. Введем целую переменную i, обозначающую номер строки. Запишем в sred начальное значение 0. В цикле изменяем i от 1 до N с шагом 1, добавляем к значению переменной sred значение элемента матрицы A[i,i]. После окончания цикла разделим sred на N (на главной диагонали всего N элементов), таким образом, в sred находится среднее значение элементов главной диагонали.
|
|
|
Теперь можно суммировать (только!) положительные элементы всей матрицы, которые больше sred. Вводим целочисленные переменные j (номер столбца) и count (счетчик «нужных» элементов). В счетчик записываем начальное значение 0.
Организуем двойной цикл, перебирающий все комбинации (i,j) для i=1..N и j=1..N. В теле цикла проверяем элемент матрицы A[i,j]: если он больше нуля и больше sred, увеличиваем счетчик count на 1.
После окончания двойного цикла выводим значение count.
Программа может выглядеть так:
const N=5;
var A:array[1..N,1..N] of integer;
i, j, count: integer;
sred: real;
Begin
for i:=1 to N do { ввод матрицы }
for j:=1 to N do readln(A[i,j]);
sred:= 0; { находим сумму главной диагонали }
for i:=1 to N do
sred:= sred + A[i,i];
sred:= sred / N; { находим среднее }
count:= 0; { считаем нужные элементы }
for i:=1 to N do
for j:=1 to N do
if (A[i,j] > 0) and (A[i,j] > sred) then
count:= count + 1;
writeln(count);
End.
Заметим, что можно немного улучшить программу. В условном операторе в последнем двойном цикле можно заменить сложное условие простым, если вместо 0 и sred использовать максимальное из этих значений. Перед двойным циклом нужно добавить оператор
if sred < 0 then sred:= 0;
а условный оператор изменить так:
if A[i,j] > sred then
count:= count + 1;
Во-вторых, можно немного более грамотно обработать условие A[i,j] > sred. Дело в том, что при делении в операторе
sred:= sred / N; { находим среднее }
может получиться вещественное число (с дробной частью). Вещественные числа (за редким исключением[1]) хранятся в памяти компьютера неточно, потому что в двоичном коде содержат (теоретически) бесконечное число разрядов. Поэтому лучше НЕ делить полученную сумму sred на N, а для проверки вместо условия A[i,j] > sred/N использовать равносильное ему A[i,j]*N > sred. Плюс в том, что в последнем случае все операции выполняются с целыми числами и ошибок из-за неточного представления дробных чисел в памяти гарантированно не будет. Однако, есть и минус: вместо одного деления (на всю программу) придется выполнять N2 умножений (для каждого элемента матрицы). Вот еще одна версия программы:
const N=5;
var A:array[1..N,1..N] of integer;
i, j, count: integer;
sred: real;
Begin
for i:=1 to N do { ввод матрицы }
for j:=1 to N do readln(A[i,j]);
sred:= 0; { находим сумму главной диагонали }
for i:=1 to N do
|
|
|
sred:= sred + A[i,i];
count:= 0; { считаем нужные элементы }
if sred < 0 then sred:= 0;
for i:=1 to N do
for j:=1 to N do
if A[i,j]*N > sred then
count:= count + 1;
writeln(count);
End.
12) Эта задача в целом напоминает упрощенный вариант предыдущей, поэтому можно сразу привести решение. Единственная тонкость – можно исключить операции с вещественными числами, которые (теоретически) могут привести к ошибкам. Подробно этот прием описан в решении предыдущей задачи.
Решение на естественном языке. Записываем в переменную s начальное значение 0. В цикле добавляем все значения элементов массива, от 1-ого до 30-ого, к значению переменной s. После завершения цикла делим значение s на 30, чтобы найти среднее значение. Далее записываем в переменную j начальное значение 0. В цикле рассматриваем все элементы массива, от
1-ого до 30-ого, сравниваем значение текущего элемента со значением переменной s. Если значение текущего элемента больше значения s, увеличиваем счетчик j на 1. После завершения цикла выводим значение переменной j.
В приведенном выше решении на естественном языке дан «чистый» алгоритм. При работе на реальном компьютере нужно заботиться о точности вычислений, поэтому в программе на Паскале вместо проверки условия a[i] > среднего мы используем равносильное ему a[i]*N > суммы элементов. При этом переменную s можно было бы сделать и целой (но она вещественная по условию задачи, это нельзя менять!).
const N=30;
var a: array [1..N] of integer;
i, j: integer;
s: real;
Begin
for i:=1 to N do readln(a[i]);
s:= 0;
for i:=1 to N do s:= s + a[i];
j:= 0;
for i:=1 to N do
if a[i]*N > s then j:= j + 1;
writeln(j);
End.
13) Хитрость этой задачи в том, что нужно найти первый элемент, равный X. Вроде бы все просто – в цикле перебираем все элементы массива, если очередной элемент равен X, записываем его номер в переменную j.
for i:=1 to N do
if a[i] = x then
j:= i; { запомнили номер }
Однако при этом в конце цикла в переменной j оказывается номер последнего элемента, равного X. Чтобы выйти их этой ситуации, можно остановить цикл, как только мы нашли первый элемент, равный X. В Паскале (и в Си) это делается с помощью оператора break (досрочный выход из цикла):
for i:=1 to N do
if a[i] = x then begin
j:= i; { запомнили номер }
break;
end;
Есть и другой способ – просматривать элементы с конца, при этом не нужен досрочный выход из цикла:
for i:=N downto 1 do
if a[i] = x then
j:= i; { запомнили номер }
Как определить, что элемента, равного X, нет в массиве? Для этого до цикла в переменную j нужно записать любое значение, которое не может быть номером элемента массива, например, 0. Если по окончании цикла в переменной j остался 0, ни одного элемента, равного X, не нашли.
Решение на естественном языке. Записываем в переменную j начальное значение 0. В цикле рассматриваем последовательно все элементы массива в обратном порядке, с 30-го до 1-го. Если очередной элемент равен X, записываем его номер в переменную j. Если после завершения цикла переменная j равна 0, выводим сообщение, что таких элементов нет, иначе выводим значение переменной j.
Решение на Паскале.
const N=30;
var a: array [1..N] of integer;
i, j, x: integer;
Begin
for i:=1 to N do readln(a[i]);
readln(x);
j:=0;
for i:=N downto 1 do
if a[i] = x then
j:= i; { запомнили номер }
if j = 0 then
writeln('Нет таких элементов')
else writeln(j);
End.
Можно также использовать цикл while со сложным условием:
i:=0;
while (i <= N) and (a[i] <> x) do
i:= i + 1;
Цикл остановится, когда i станет больше N или найдем элемент, равный X. Если после цикла переменная i больше N, значит, ни одного элемента, равного X, в массиве нет. Иначе в переменной i находится номер первого элемента, равного X.
if i > N then
|
|
|
