ВВЕРХ
ВНИЗ
  • Home
  • Array
  • Array 7 - 10

Массив: обратный порядок, четные, нечетные числа, их количество

На этой странице дано решение задач Array7 - Array10 на одномерные массивы раздела Array из задачника Абрамяна.

Array7. Дан массив размера N. Вывести его элементы в обратном порядке.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
var
  A: array[1..20] of integer;
  i, N: byte;

begin
  write('N = ');
  readln(N);
  writeln('Введите массив из ', N, ' целых чисел: ');
  { Вводим элементы массива: }
  for i := 1 to N do read(a[i]);
  writeln('Элементы массива в порядке убывания индексов: ');
  { Выводим элементы массива в обратном порядке: }
  for i := N downto 1 do write(' ', a[i]);
  writeln;
  readln
end.

Array8. Дан целочисленный массив размера N. Вывести все содержащиеся в данном массиве нечетные числа в порядке возрастания их индексов, а также их количество K.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
var
  A: array[1..20] of integer; 
  N, i, K: integer;

begin
  K := 0;
  write('N = '); 
  readln(N);
  writeln('Введите ', N, ' элементов массива: ');
  for i := 1 to N do
    read(a[i]); { <-- Задаем массив размера N }
  writeln;
  for i := 1 to N do
    if odd(a[i]) then { <-- Если элемент массива нечётный, }
    begin 
      K := K + 1;  { <== то увеличиваем количество на единицу }
      write(a[i],' ') { <-- и выводим на экран этот элемент }
    end;
  { В конце выводим общее количество нечётных элементов: }
  writeln('Количество нечетных чисел K = ', K);
  readln
end.

Array9. Дан целочисленный массив размера N. Вывести все содержащиеся в данном массиве четные числа в порядке убывания их индексов, а также их количество K.

Код 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  
var
  i, k, N: integer;               
  A, B: array[1..100] of integer;

begin
  write('N = ');
  readln(N);
  K := 0; { <-- количество четных чисел }
  writeln('Введите массив из ', N, ' чисел: ');
  for i := 1 to N do begin
    read(a[i]); { <-- Вводим i-й элемент массива }
    if a[i] mod 2 = 0 then { <-- элемент a[i] четный }  
    begin
      inc(K); { <-- увеличиваем количество K }
      b[K] := a[i] { <-- и находим очередной элемент нового массива }
    end
  end;
  if K > 0 then begin
    writeln('Четные элементы в обратном порядке: ');
    for i := K downto 1 do write(' ', b[i]);
    writeln('Количество четных элементов: ', K)
  end
  else writeln('В массиве нет четных элементов');
  readln
end.

Array10. Дан целочисленный массив размера N. Вывести вначале все содержащиеся в данном массиве четные числа в порядке возрастания их индексов, а затем — все нечетные числа в порядке убывания их индексов.

Имеем первый вариант решения, в котором просто выводим элементы массива, предварительно анализируя их:

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
var
  A: array[1..255] of integer;    
  i, N: byte;

begin
  write('N = ');
  readln(N);
  writeln('Введите массив из ', N, ' чисел: ');
  for i := 1 to N do 
    read(a[i]); { <-- Вводим i-й элемент массива }
  writeln('Четные числа (в порядке возрастания инденксов):');
  { Выводим четные элементы массива: }
  for i := 1 to N do
    if odd(a[i] + 1) then write(' ', a[i]);
  writeln;
  writeln('Нечетные числа (в порядке убывания индексов):');
  { Выводим нечетные элементы массива в обратном порядке: }
  for i := N downto 1 do
    if odd(a[i]) then write(' ', a[i]);
  readln
 end.

Во втором варианрте сначала составляем два массива с указанными элементами, а потом выводим их.

Код 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  
var
  A, B, C: array[1..255] of integer;
  i, k, t, N: byte;

begin
  write('N = ');
  readln(N);
  writeln('Введите массив из ', N, ' чисел: ');
  for i := 1 to N do 
  begin
    read(a[i]); { <-- Вводим i-й элемент массива }
    if Odd(a[i]+1) then { <-- Если он четный, }
    begin 
      inc(k); { <-- то увеличиваем k на 1 }
      b[k] := a[i] { <-- и запоминаем очередной элемент
        с четными элементами. }
    end
    else begin
      inc(t); { <-- увеличиваем t на 1 }
      c[t] := a[i] { <-- и находим очередной элемент 
        массива с нечетными элементами. }
    end
  end;
  if k > 0 then begin
    writeln('Четные числа (в порядке возрастания инденксов):');
    for i := 1 to k do write(' ', b[i])
  end
  else writeln('В массиве нет четных элементов');
  writeln;
  if t > 0 then begin
    writeln('Нечетные числа (в порядке убывания индексов):');
    for i := t downto 1 do write(' ', c[i])
  end
  else writeln('В массиве нет нечетных чисел');
  readln
 end.


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