Pascal: Примеры задач с решением (одномерные массивы)

Задача 1.

Дан массив чисел. Найти, сколько в нем пар одинаковых соседних элементов.

Переменные:

mas – массив чисел;
n – размер массива;
i – переменная цикла;
k – количество одинаковых пар соседних элементов.

Алгоритм решения задачи:

  1. вводим длину массива n, значение элементов массива и устанавливаем начальное значение k;
  2. последовательно просматриваем элементы и, если очередной mas[i] равен следующему mas[i+1], то увеличиваем значение k на единицу;
  3. выводим результат.
const m=100;
var mas : array [1..m] of integer;
        i, k, n : integer;
begin
      write('Введите размер массива n=');
      readln(n);
      k:=0;
      for i:=1 to n do
      begin
             write('Введите элемент массива');
             readln(mas[i]);
      end;
      for i:=1 to n–1 do
      if mas[i]=mas[i+1] then k:=k+1;
      wrietln('Одинаковых пар соседних элементов ',k);
end.

Задача 2.

Программа. Дано 100 целых чисел. Распечатать их в обратном порядке по 6 чисел в строке.

const n=100; d=6;
var x : array [1..n] of integer;
      i, k : integer;
begin                       {ввод массива:}
        writeln('Введите массив из ', n,' чисел');
        for i:=1 to n do read(x[i]);
         {вывод массива по d чисел в строке:}
        k:=0;                 {номер числа в строке}
        for i:=n downto 1 do
        begin
               k:=k+1;
               write(x[i]:4);
               if k=d then
                          begin
                          k:=0; writeln
                          end
        end;
        if k < > 0 then writeln
end.

Задача 3.

Сортировка слиянием

const k=50; m=20; n=70; {n=k+m}
var x : array [1..k] of real;
y : array [1..m] of real;
z : array [1..n] of real;
i,p,j : integer;

Элементы каждого из массивов x и y упорядочены по неубыванию. Объединить элементы этих двух массивов в один массив z так, чтобы они снова оказались упорядоченными по неубыванию.

const k=50; m=20; n=70;   {n=k+m}
var x : array [1..k] of real;  {k – размерность первого массива х}
      y : array [1..m] of real;  {m – размерность первого массива y}
      z : array [1..n] of real;   {n – размерность первого массива z}
      i, p, j : integer;
begin
       writeln('Введите массив x');
       for i:=1 to k do read(x[i]);
       writeln;
       writeln('Введите массив y');
       for i:=1 to m do read(y[i]);
       writeln;
       writeln('Введенные Вами массивы');
       writeln('Массив x');
       for i:=1 to k do write(x[i]:7:3);
       writeln;
       writeln('Массив y');
       for i:=1 to m do write(y[i]:7:3);
       writeln;
       p:=1;                     {индекс очередного элемента из z}
       i:=1;                      {из х}
       j:=1;                      {из y}
        {пока есть нерассмотренные элементы и в x, и в y: }
       repeat if x [i] < y [j] then
begin    z[p]:=x[i]; i:=i+1  end   else
begin     z[p]:=y[j]; j:=j+1   end;
p:=p+1        until (i > k)or(j > m);
       {один из массивов x или y исчерпан -- > перепись в z
       оставшихся элементов другого массива:}
       if i > k                  {исчерпан массив x:}
                 then repeat z[p]:=y[j]; j:=j+1; p:=p+1 until j > m
                 else repeat z[p]:=x[i]; i:=i+1; p:=p+1 until i > k;
       writeln('Полученный массив: ');
       for i:=1 to n do write(z[i]:7:3);
end.

Задача 4.

type shift=1..99;
            scale=array [1..100] of real;

Описать процедуру move(s,k), которая преобразует шкалу s, циклически сдвигая ее элементы на k позиций влево, где k – параметр типа shift.

type shift=1..99;
        scale=array [1..100] of real;
var a:scale; m:shift;n,i:integer;
procedure move( var s:scale; k:shift);
   var i:integer; t:scale;                        {вспомогательный  массив}
    begin
                                                                   {t[n–k+1..n]:=s[1..k]:}
         for i:=1 to k do t[n–k+i]:=s[i];
                                                                   {t[1..n–k]:=s[k+1..n]:}
         for i:=k+1 to n do t[i–k]:=s[i];
         s:=t
    end;

begin
       writeln('Введите размер массива');
       readln(n);
       writeln('Введите массив');
       for i:=1 to n do read(a[i]);
       writeln('Введите цикл сдвига < =', n–1);
       readln(m);
       writeln('Исходный массив');
       for i:=1 to n do write(a[i]:7:2);
       writeln;
       move(a,m);
       writeln('Полученный массив');
       for i:=1 to n do write(a[i]:7:2);
       writeln;
end.

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *