ВВЕРХ
ВНИЗ
  • Home
  • Array
  • Array 45 - 50

Array 45 - 50

Array45. Дан массив размера N. Найти номера двух ближайших элементов из этого массива (т. е. элементов с наименьшим модулем разности) и вывести эти номера в порядке возрастания.

1-2) Описание констант: nmax - максимальный размер массива (nmax=20). По смыслу задачи необходимо nmax≥2.

4-7) Описание переменных:

   MinDiff - минимальная разница (по модулю) между двумя элементами массива;

   c - временная переменная для хранения MinDiff;

   i - текущий индекс масива, j - индекс массива от 1 до i-1 (при отыскании манимальной разницы);

   N - размер массива;

   i1, i2 - номера (в порядке возрастания) элементов массива с наименьшим модулем разности между ними.

11-14) Вводим размер массива. Для этого используем цикл с послеусловием repeat - until, где на выходе проверяем, попадает ли N в интервал 2..nmax (минимальное количество элементов должно быть 2).

15) Инициализируем датчик псевдослучайных чисел (предполагается случайный ввод элементов).

16) Заходим в цикл для ввода элементов масива и поиска минимального модуля разницы между элементами.

18-19) Находим случайный вещественный элемент массива и выводим его. Если предполагается ввод элементов с клавиатуры, то вместо строк 18, 19 нужно поставить read(a[i]), а строку 15 можно удалить.

20-25) При вводе второго элемента (i=2) минимальную разницу MinDiff находим между 1-м и 2-м элементами.

26-37) Если i≠2, то заходим в цикл отыскания миниманой разницы между текущим элементом a[i] и всеми предыдущими (MinDiff): причем, если i=1, то цикл не сработает, поскольку индексация от 1 до 0 (строка 28) не имеет смысла.

30) Вычисляем с=|a[j]-a[i]|.

31) Проверяем истинность условия c<MinDiff: если число с меньше MinDiff, то:

33) Новой минимальной разницей становится c: MinDiff=c;

34, 35) Находим i1, i2 - минимальный и максимальный индексы ближайших элементов массива.


Код Pascal
1  
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  
const
  nmax = 20; { Максимальное количество элементов, nmax>1 }

var
  A: array[1..nmax] of real;
  MinDiff, c: real; { Минимальная разница }
  i, j, N, i1, i2: byte;

begin
  { Вводим размер массива N: }
  repeat
    write('N = ');
    readln(N)
  until (N > 1) and (N <= nmax); { N принадлежит [2, nmax] }
  randomize; { Датчик псевдослучайных чисел }
  for i := 1 to N do 
  begin
    a[i] := -10 + 20 * random; { Случайное число с интервала [-10, 10) }
    write(' ', a[i]:0:2);
    if i = 2 then
    begin
      MinDiff := abs(a[2] - a[1]); { Начальное значение минимальной разницы }
      i1 := 1; { Меньший индекс }
      i2 := 2  { Больший индекс }
    end
    else { Сравниваем модуль разницы текущего
       элемента a[i] со всеми предыдущими: }
      for j := 1 to i - 1 do
      begin
        c := abs(a[j] - a[i]); { Модуль разницы между a[j] и a[i] }
        if c < MinDiff then { c меньше MinDiff }
        begin
          MinDiff := c; { Новое значение MinDiff }
          i1 := j; { Меньший индекс }
          i2 := i  { Больший индекс }
        end
      end
  end;
  writeln;
  writeln('Номера ближайших элементов: ', i1, ' ', i2);
  readln
end.

Array46. Дано число R и массив размера N. Найти два различных элемента массива, сумма которых наиболее близка к числу R, и вывести эти элементы в порядке возрастания их индексов (определение наиболее близких чисел дано в задании Array40).

Задача аналогичная предыдущей Array45, только будем сравнивать не сами элементы (модуль разницы между a[i] и a[j]), а модуль разницы между суммой a[i]+a[j] и введенным ранее числом R (строки 15-16), где i - текущий номер элемента, j - один из предыдущих номеров (j=1..i-1).
Ещё одно отличие при выводе: нужно выводить не номера элементов, а их значения a[i1] и a[i2] в порядке возрастания номеров (i1<i2)

Код Pascal
1  
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  
const
  nmax = 20; { Максимальное количество элементов, nmax>1 }

var
  A: array[1..nmax] of real;
  R, MinDiffSum, c: real; { Минимальная разница }
  i, j, N, i1, i2: byte;

begin
  { Вводим размер массива N: }
  repeat
    write('N = ');
    readln(N)
  until (N > 1) and (N <= nmax); { N принадлежит [2, nmax] }
  write('R = ');
  readln(R);
  randomize; { Датчик псевдослучайных чисел }
  for i := 1 to N do 
  begin
    a[i] := -10 + 20 * random; { Случайное число с интервала [-10, 10) }
    write(' ', a[i]:0:2);
    if i = 2 then
    begin
      MinDiffSum := abs(a[2] + a[1] - R); { Начальное значение минимальной разницы }
      i1 := 1; { Меньший индекс }
      i2 := 2  { Больший индекс }
    end
    else { Проверяем предыдущие элементы a[j], j=1..i-1: }
      for j := 1 to i - 1 do
      begin { Вычисляем модуль разницы между 
         суммой элементов a[i], a[j] и числом R: }
        c := abs(a[j] + a[i] - R);
        if c < MinDiffSum then { Находим c меньшее MinDiffSum }
        begin
          MinDiffSum := c; { Новое значение MinDiffSum }
          i1 := j; { Меньший индекс }
          i2 := i  { Больший индекс }
        end
      end
  end;
  writeln;
  writeln('Элементы с наиболее близкой к ', R, ' суммой: ', a[i1]:0:2, ' ', a[i2]:0:2);
  readln
end.

Array47. Дан целочисленный массив размера N. Найти количество различных элементов в данном массиве.

Все пояснения в комментариях кода.

Код Pascal
1  
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  
const
  nmax = 20; { Максимальное количество элементов, nmax>1 }

var
  A: array[1..nmax] of integer;
  N, i, j, Q: byte;
  
begin
  { Вводим размер массива N: }
  repeat
    write('N = ');
    readln(N)
  until (N > 0) and (N <= nmax); { N принадлежит [1, nmax] }
  Q := 0; { Количество различных элементов вначале равно 0 }
  randomize;
  for i := 1 to N do
  begin
    a[i] := random(10); { Случайный элемент 0..9 }
    write(' ', a[i]);
    j := 1; { Промежуточная переменная для предыдущих номеров: j=1..i-1 }
    { Проверяем все предыдущие по отношению к i номера (j < i): если 
    при этом элементы не равны (a[i] ≠ a[j]), то переходим к следующему 
    элементу: inc(j), в противном случае автоматический выход из цикла. }
    while (j < i) and (a[i] <> a[j]) do
      inc(j);
    { Если при выходе из цикла j = i, то это означает, что все предыдущие
    элементы a[1], a[2], ..., a[i-1] оказались не равными a[i], после
    этого мы ещё раз увеличили j и вышли из цикла, поэтому количество Q 
    различных чисел нужно увеличить на 1: }
    if j = i then inc(Q)
    { Если j < i, то в этом случае мы вышли из цикла ещё до проверки всех
    элементов, так как нашли равные элементы (a[i] = a[j]). В этом случае
    увеличивать Q не нужно. }
  end;
  writeln;
  writeln('Количество различных элементов: ', Q);
  readln
end.

Array48. Дан целочисленный массив размера N. Найти максимальное количество его одинаковых элементов.

Эта задача очень похожа по смыслу с Array47, только вместо отыскания количества различных чисел в массиве требуется найти наибольшее количество его равных элементов. Вероятно, в произвольно заданном масиве разные числа будут встречатся в разном количестве, поэтому интересует вопрос об именно максимальном количестве одинаковых элементов этого массива.

Ввод массива осуществляется вручную, все комментарии в коде программы.

Код Pascal
1  
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  
const
  nmax = 20; { Максимальное количество элементов, nmax>1 }

var
  A: array[1..nmax] of integer;
  N, i, j, Q, Qmax: byte;
  
begin
  { Вводим размер массива N: }
  repeat
    write('N = ');
    readln(N)
  until (N > 0) and (N <= nmax); { N принадлежит [1, nmax] }
  Qmax := 0; { Максимальное количество одинаковых элементов вначале = 1  }
  writeln('Введите ', N, ' целых чисел:');
  for i := 1 to N do
  begin
    read(a[i]); { Вводим элемент a[i] }
    Q := 1; { Количество различных элементов вначале равно 1 }
    { Проверяем все предыдущие по отношению к i номера (j = 1..i-1), то есть
    сравниваем данный элемент a[i] с предыдущими a[1], a[2], ..., a[i-1]: 
    если при этом найдется равный a[i] элемент при некотором j (a[i] = a[j]), 
    то увеличиваем количество Q равных чисел на 1: }
    for j := 1 to i - 1 do
      if a[i] = a[j] then inc(Q);
    { Сравниваем Q с максимальным количеством Qmax: если оно окажется 
    больше Qmax (Q > Qmax), то новым значением Qmax становится Q: }
    if Q > Qmax then Qmax := Q
  end;
  writeln;
  writeln('Наибольшее количество равных элементов: ', Qmax);
  readln
end.

Array49. Дан целочисленный массив размера N. Если он является перестановкой, т. е. содержит все числа от 1 до N, то вывести 0; в противном случае вывести номер первого недопустимого элемента.

Ввод массива осуществляется вручную, все комментарии в коде программы.

Код Pascal
1  
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  
const
  nmax = 10; { Максимальное количество элементов, nmax>1 }

var
  A: array[1..nmax] of byte;
  N, i, j: byte;
  
begin
  { Вводим размер массива N: }
  repeat
    write('N = ');
    readln(N)
  until (N > 0) and (N <= nmax); { N принадлежит [1, nmax] }
  writeln('Введите ', N, ' элементов целочисленного массива:');
  i := 0;
  repeat
    inc(i);
    read(a[i]); { Вводим элемент с клавиатуры }
    j := 1;
    { Проверяем элемент a[i] с предыдущими элементами a[1], a[2], ..., a[i-1] 
    на равенство: если a[i] ≠ a[j] для всех j=1..i-1, то переходим к следующему
    элементу, в противном случае (a[i] = a[j] для некоторого j < i) выходим из
    цикла и выводим результат: }
    while (j < i) and (a[i] <> a[j]) do
      inc(j)
    { Выходим из цикла в одном из двух случаев: 
       1)мы нашли равные элементы в предыдущем цикле (j < i);
       2)Мы дошли до конца массива (i = N): }
  until (j < i) or (i = N);
  writeln;
  if j < i then writeln('Номер первого недопустимого элемента: ', i)
  else writeln(0);
  readln
end.

Array50. Дан целочисленный массив A размера N, являющийся перестановкой (определение перестановки дано в задании Array49). Найти количество инверсий в данной перестановке, т. е. таких пар элементов AI и AJ, в которых большее число находится слева от меньшего: AI > AJ при I < J.

Задача разделяется на 2 этапа:

1) Вводим перестановку; для этого сначала вводим перестановку без инверсий (строки 15-17), потом перемешиваем случайным образом (строки 18-26). Обратим внимание на то, что обмен данными a[i] и a[j] осуществляется "классическим" способом: сначала запоминается величина a[i] (её значение записываем в c), потом в a[i] записываем значение a[j], а в a[j], в свою очередь, записываем c, равное a[i]. Если у вас есть среда PascalABC.Net, то обмен данными a и b можно осуществить проще - с помощью процедуры Swap(a, b) (посмотрите задачу Proc10 задачника Абрамяна). Далее выводим получившуюся перестановку (строки 27-29).

2) Определяем, собственно, количество инверсий. Для этого используем вложенный цикл: внешний параметр i - индекс массива, где проходим все элементы кроме предпоследнего, внутренний параметр j - сравниваем текущий элемент a[i] со всеми последующими a[j], где j=i+1..N-1. Если находим инверсию, то увеличиваем количество инверсий count. Ещё надо обратить внимание на то, что индекс i всегда меньше j, по крайней мере на 1.

Код Pascal
1  
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  
const
  nmax = 10; { Максимальное количество элементов, nmax>1 }

var
  A: array[1..nmax] of byte;
  N, i, j, c: byte;
  count: word;
  
begin
  { Вводим размер массива N: }
  repeat
    write('N = ');
    readln(N)
  until (N > 0) and (N <= nmax); { N принадлежит [2, nmax] }
  { Формируем массив-перестановку 1, 2, 3, ..., N: }
  for i := 1 to N do
    a[i] := i;
  { Перемешаем элементы перестановки случайным образом: }
  randomize;
  for i := 1 to N do begin
    j := 1 + random(n); { Выбираем случайный номер от 1 до N }
    { МЕНЯЕМ ЗНАЧЕНИЯ a[i] и a[j] МЕСТАМИ: }
    c := a[i]; { Запоминаем i-е значение, записывая его в переменную c }
    a[i] := a[j]; { Меняем i-е значение на j-е }
    a[j] := c { Меняем j-е значение на i-е (c равно a[i]) }
  end;
  { Выводим перестановку: }
  for i := 1 to N do 
    write(' ', a[i]);
  count := 0; { Начальное значение количества перестановок: }
  { Определяем количество перестановок: }
  for i := 1 to N - 1 do
    for j := i + 1 to N do
      if a[i] > a[j] then inc(count);
  writeln;
  if count > 0 then writeln('Количество инверсий: ', count)
  else writeln('Нет инверсий');
  readln
end.


Яндекс.Метрика