 |
Writeln('Нет таких элементов')
|
|
|
|
else writeln(i);
Это второй вариант решения задачи.
14) Сложность в том, что нужно найти не максимальный элемент, а второй по величине. Можно, конечно, сначала найти максимум, а потом искать следующий за ним, но можно сделать это за один проход по массиву. Нам нужны две переменные, max (максимальный элемент) и max2 (второй максимум). Сначала выбираем максимальный из первых двух элементов и записываем его значение в max, а второй по величине записываем в max2:
if a[1] > a[2] then begin
max:=a[1]; max2:=a[2];
End
Else begin
max:=a[2]; max2:=a[1];
end;
Затем в цикле перебираем все элементы, начиная с 3-го (первые два уже «задействованы»!) до последнего, 30-ого. Если очередной элемент a[i] больше, чем max, записываем значение max в max2 (предыдущий максимум становится вторым), а значение a[i] – в max. Иначе, если a[i] больше, чем max2, записываем значение a[i] в max2. После завершения цикла выводим значение переменной max2. Вот решение на Паскале:
const N=30;
var a: array [1..N] of integer;
i, k, max, max2: integer;
Begin
for i:=1 to N do readln(a[i]);
if a[1] > a[2] then begin
max:=a[1]; max2:=a[2];
End
Else begin
max:=a[2]; max2:=a[1];
end;
for i:=3 to N do
if a[i] > max then begin
max2:= max;
max:= a[i];
End
else if a[i] > max2 then max2:= a[i];
writeln(max2);
End.
15) Очевидно, что нужно считать найденные положительные элементы (например, с помощью переменной k) и, когда k станет равно 3, запомнить номер текущего элемента (в переменной j).
Решение на естественном языке. Записываем в переменную k начальное значение 0. Затем в цикле перебираем все элементы массива с 1-ого по 30-ый. Если очередной элемент больше нуля, увеличиваем счетчик k. Если k=3, записываем номер текущего элемента в переменную j. Если после окончания цикла k<3, выводим сообщение, что в массиве меньше трех положительных элементов, иначе выводим значение переменной j.
|
|
|
Решение на Паскале.
const N=30;
var a: array [1..N] of integer;
i, j, k: integer;
Begin
for i:=1 to N do readln(a[i]);
k:=0;
for i:=1 to N do
if a[i] > 0 then begin
k:=k+1;
if k = 3 then j:= i;
end;
if k < 3 then
Writeln('Меньше трех положительных элементов')
else writeln(j);
End.
16) Обратим внимание, что нужно найти не длину, а сумму наибольшей (то есть, самой длинной!) возрастающей последовательности (то есть, такой, в которой каждый следующий элемент строго больше предыдущего). В переменных l и s будем хранить длину и сумму текущей (рассматриваемой сейчас) последовательности, а в переменных lmax и smax – значения для наибольшей последовательности.
Решение на естественном языке. Записываем в переменную lmax начальное значение 0, в переменную l – значение 1, а в переменную smax – значение первого элемента массива. В цикле рассматриваем все элементы массива, начиная со 2-ого до
30-ого. Если очередной элемент больше предыдущего, увеличиваем переменную l на 1, а к переменной s добавляем значение этого элемента; иначе записываем 1 в переменную l и значение этого элемента в s. После этого (в теле цикла) сравниваем l и lmax; если l > lmax (нашли новую самую длинную возрастающую цепочку), записываем значение s в smax.
Решение на Паскале.
const N=30;
var a: array [1..N] of integer;
i, l, lmax, s, smax: integer;
Begin
for i:=1 to N do readln(a[i]);
lmax:=0; l:=1; s:=a[1];
for i:=2 to N do begin
if a[i] > a[i-1] then begin
l:=l+1; s:=s+a[i];
End
Else begin
l:=1; s:=a[i];
end;
if l > lmax then begin
lmax:=l;
smax:=s;
end;
end;
writeln(smax);
End.
17) Сначала нужно найти (в переменной s) среднее арифметическое всех элементов массива – считаем в цикле их сумму и делим на N. Затем перебираем во втором цикле все элементы массива и ищем тот, для которого модуль разности этого элемента и среднего арифметического наименьший.
Решение на естественном языке. Записываем в переменную s начальное значение 0. В цикле для всех элементов с 1-го до 30-го добавляем значение текущего элемента к переменной s. После окончания цикла делим значение переменной s на N, таким образом, получаем в переменной s среднее арифметическое всех элементов массива. Записываем в переменную k начальное значение 1. В цикле рассматриваем все элементы со 2-ого до 30-ого, если модуль разности текущего элемента и переменной s меньше, чем модуль аналогичной разности для k -ого элемента, записываем в переменную k номер текущего элемента. После окончания цикла выводим значение переменной k.
|
|
|
Решение на Паскале.
const N=30;
var a: array [1..N] of integer;
i, k: integer;
s, min: real;
Begin
for i:=1 to N do readln(a[i]);
s:=0;
for i:=1 to N do s:=s+a[i];
s:=s/N;
k:=1;
for i:=2 to N do
if abs(a[i]-s) < abs(a[k]-s) then
k:=i;
writeln(k);
End.
18) Очевидно, что нужно вывести номера минимального элемента массива и «второго» минимума. Поэтому эта задача решается аналогично задаче 14 (меняем названия переменных и знаки > на знаки <, храним в переменных min и min2 не значения, а номера элементов):
const N=30;
var a: array [1..N] of integer;
i, k, min, min2: integer;
Begin
for i:=1 to N do readln(a[i]);
if a[1] < a[2] then begin
min:= 1; min2:= 2;
End
Else begin
min:= 2; min2:= 1;
end;
for i:=3 to N do
if a[i] < a[min] then begin
min2:= min;
min:= i;
End
else if a[i] < a[min2] then min2:= i;
writeln(min, ' ', min2);
End.
19) В этой задаче нужно перебрать все пары различных элементов. Для этого нужен двойной (вложенный) цикл. Чтобы не сравнивать элемент сам с собой, будем рассматривать только пары (a[i],a[j]), где j>i. Поэтому во внешнем цикле переменная i меняется от 1 до N-1 (до предпоследнего), а во внутреннем – переменная j меняется от i+1 до N (до конца массива):
for i:=1 to N-1 do
for j:=i+1 to N do
...
Решение на естественном языке. Сначала считаем, что нужная пара – это первые два элемента. Записываем в переменные min и min2 значения 1 и 2 соответственно, а в переменную s – модуль их разности. Организуем вложенный цикл. Во внешнем цикле перебираем значения переменной i от 1 до N-1. Во внутреннем цикле перебираем значения переменной j от i+1 до N. В теле цикла: если модуль разности a[i]-a[j] оказывается меньше значения переменной s, записываем в переменную s этот модуль разности, а в переменные min и min2 значения переменных i и j соответственно. После окончания двойного цикла выводим значения переменных min и min2.
Решение на Паскале.
const N=30;
var a: array [1..N] of integer;
i, j, min, min2, s: integer;
Begin
|
|
|
for i:=1 to N do readln(a[i]);
min:=1; min2:=2;
s:=abs(a[1]-a[2]);
for i:=1 to N-1 do
for j:=i+1 to N do
if abs(a[i]-a[j]) < s then begin
s:=abs(a[i]-a[j]);
min:=i; min2:=j;
end;
writeln(min, min2);
End.
20) Среднее арифметическое – это сумма всех нужных элементов, деленная на их количество.
Если значение в десятичной системе оканчивается на 5, это значит, что остаток от его деления на 10 (основание системы счисления) равен 5. Кроме того, есть еще один тонкий момент: при вычислении на компьютере остатка от деления отрицательных чисел (например, с помощью оператора mod в Паскале) этот остаток получается отрицательным [2], например -25 mod 10 = -5.
Нам нужно использовать две переменных: счетчик найденных элементов и сумму; обе переменные сначала необходимо обнулить.
Затем надо пройти в цикле весь массив, и если очередной элемент при делении на 10 дает остаток 5 или –5, увеличить счетчик на 1, а сумму – на значение этого элемента. Затем считаем среднее как отношение суммы к количеству. Поскольку сказано, что хотя бы один такой элемент есть, можно не опасаться деления на ноль.
Решение на естественном языке. Записываем в переменные x и y нулевые значения. В цикле перебираем значения переменной i от 1 до N. Если очередной элемент при делении на 10 дает в остатке 5 или –5, увеличиваем счетчик x на 1 и сумму y – на значение этого элемента. После окончания цикла записываем в переменную s результат деления y на x. Выводим значение переменной s.
Решение на Паскале.
При проверке остатка можно использовать сложное условие:
if (a[i] mod 10 = 5) or (a[i] mod 10 = -5) then
begin... end;
или перед применением операции mod взять модуль очередного элемента массива:
if abs(a[i]) mod 10 = 5 then begin... end;
Один из вариантов решения:
const N=30;
var a: array [1..N] of integer;
i, x, y: integer;
s: real;
Begin
for i:=1 to N do readln(a[i]);
x:=0; y:=0;
for i:=1 to N do
if abs(a[i]) mod 10 = 5 then begin
x:= x + 1;
y:= y + a[i];
end;
s:= y / x;
writeln(s);
End.
Варианты задачи. Если требуется определить среднее арифметическое четных или нечетных элементов, нужно проверять делимость на 2, а не на 10. Если остаток от деления на 2 равен 0, то число четное.
21) Это вариант предыдущей задачи, меняется только условие отбора. Для нечетных элементов остаток от деления на 2 равен 1, поэтому условие выглядит так:
|
|
|
if a[i] mod 2 = 1 then begin...
Решение на естественном языке. Записываем в переменные x и y нулевые значения. В цикле перебираем значения переменной i от 1 до N. Если очередной элемент при делении на 2 дает в остатке 1, увеличиваем счетчик x на 1 и сумму y – на значение этого элемента. После окончания цикла записываем в переменную s результат деления y на x. Выводим значение переменной s.
Решение на Паскале.
const N=30;
var a: array [1..N] of integer;
i, x, y: integer;
s: real;
Begin
for i:=1 to N do readln(a[i]);
x:=0; y:=0;
for i:=1 to N do
if a[i] mod 2 = 1 then begin
x:= x + 1;
y:= y + a[i];
end;
s:= y / x;
writeln(s);
End.
22) Это вариант задачи, разобранной на с. 3 а файле C3.doc. Однако нужно учитывать, что счетчики в самом начале и при обнаружении неотрицательного элемента нужно устанавливать в 0.
Решение на естественном языке. Записываем в переменные k и kMax нулевые значения. В цикле перебираем значения переменной i от 1 до N. Если очередной элемент массива A[i] отрицательный, увеличиваем счетчик k, который обозначает длину текущей последовательности отрицательных элементов. Если очередной элемент массива A[i] неотрицательный, записываем в счетчик k ноль. Если k>kMax, записываем в kMax значение k. После окончания цикла выводим значение переменной kMax.
Решение на Паскале.
const N =30;
var A: array[1..N] of integer;
i, k, kMax: integer;
Begin
for i:=1 to N do readln(A[i]); { ввод массива }
k:= 0;
kMax:= 0;
for i:=1 to N do begin { проходим весь массив }
if A[i] < 0 then { цепочка продолжается }
k:= k + 1
else k:= 0; { цепочка закончилась }
if k > kMax then kMax:= k;
end;
writeln(kMax);
End.
23) Фактически нужно найти максимум среди всех отрицательных элементов. Здесь есть тонкость – что записать в переменную max? Очевидно, что нельзя записать первый элемент массива (как это делается в классическом алгоритме поиска максимума), потому что он может не быть отрицательным. Выход – записать большое по модулю отрицательное число, которого заведомо нет в массиве, например, -100. При этом первый же отрицательный элемент окажется больше этого числа и начальное значение max будет заменено. Если значение -100 в переменной max останется после просмотра массива, то это будет означать, что отрицательных элементов нет.
Заметим, что если гарантируется, что в массиве есть хотя бы один отрицательный элемент, переменной max можно задать начальное значение -20 (наименьшее допустимое).
Решение на естественном языке. Записываем в переменную max начальное значение -100. В цикле перебираем значения переменной i от 1 до N. Если очередной элемент массива A[i] отрицательный и больше max, записываем в max значение этого элемента. После окончания цикла выводим значение переменной max.
|
|
|
Решение на Паскале.
const N=30;
var A: array [1..N] of integer;
i, max: integer;
Begin
for i:=1 to N do readln(A[i]);
max:=-100; { любое число <= -20 }
for i:=1 to N do
if (A[i] < 0) and (A[i] > max) then
max:=A[i];
writeln(max);
End.
24) Среднее арифметическое – это сумма элементов, деленная на их количество. Главная диагональ квадратной матрицы A размера N на N – это элементы, у которых индексы строки и столбца совпадают:
A[1,1], A[2,2], A[3,3],..., A[N,N]
Главная ловушка таких задач: кажется, что если используется матрица, то в решении будет двойной цикл. Например, некоторые считают сумму элементов главной диагонали так:
S:=0;
for i:=1 to N do
for j:=1 to N do
S:=S+A[i,i];
В самом деле, в этом цикле каждый элемент главной диагонали добавляется в сумму N раз. Для того, чтобы понять ошибку, можно посмотреть на то, как расположены нужные нам элементы в матрице – они «вытянуты» в одну линию. В то же время, вложенный цикл предназначен для обработки областей (например, прямоугольных или треугольных).
Второй цикл здесь не нужен, вот правильное решение:
S:=0;
for i:=1 to N do
S:=S+A[i,i];
Далее все просто: делим сумму на N (количество элементов главной диагонали) и получаем среднее арифметическое.
Решение на естественном языке. Записываем в переменную S начальное значение 0. В цикле перебираем значения переменной i от 1 до N. На каждом шаге цикла добавляем к сумме S значение очередного элемента главной диагонали матрицы A[i,i]. После окончания цикла выводим значение S/N.
Решение на Паскале.
const N=5;
var A: array [1..N,1..N] of integer;
i, S: integer;
Begin
{ ввод матрицы A }
S:=0;
for i:=1 to N do
S:=S+A[i,i];
writeln(S/N);
End.
25) Эта задача похожа на задачу 23. Здесь нужно найти минимальное из трехзначных чисел, то есть из таких, которые удовлетворяют условию
(100 <= A[i]) and (A[i] < 1000)
В переменную min вначале мы должны записать начальное значение, которое заведомо больше любого трехзначного числа в массиве, например, 1000. Если это значение останется в переменной min после проверки всего массива, это значит, что в массиве нет трехзначных чисел.
Решение на естественном языке. Записываем в переменную min начальное значение 1000. В цикле перебираем значения переменной i от 1 до N. Если очередной элемент массива – трехзначное число (больше или равно 100 и меньше 1000) и меньше, чем значение переменной min, записываем значение этого элемента в min. После окончания цикла проверяем значение min: если оно равно 1000, выводим на экран сообщение «Нет таких элементов», иначе выводим значение min.
Решение на Паскале.
const N=30;
var A: array [1..N] of integer;
i, min: integer;
Begin
for i:=1 to N do readln(A[i]);
min:=1000;
for i:=1 to N do
if (100 <= A[i]) and (A[i] < 1000) and
(A[i] < min) then min:= A[i];
if min = 1000 then
|
|
|
