Цикл For и массивы в языке Ада. Решение тематических задач

Для решения задач этого раздела предлагаю Вам предварительно ознакомится с информацией раздела "Цикл for и одномерные массивы. Перечисления".

  • Выведите все элементы массива с четными индексами (то есть A[0], A[2], A[4], ...).

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


  • Количество элементов в массиве: 5
    Массив: 1 2 3 4 5
    Элементы с чётными индексами: 2 4
  • Так как размер массива заранее неизвестен, то в задаче используется блок declare для объявления массива и работы с ним после того, как пользователь введёт размер массива.

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        n : Integer;
    begin
        Put("Количество элементов в массиве: ");
        Get(n);
        declare                            --Начало блока declare
            mas : array(1..n) of Integer;  --анонимный массив (т.е. не имеет типа. Можно
                                               --было предварительно создать тип)
        begin
            Put_Line("Массив: ");
            for i in mas'Range loop
                Get(mas(i));
            end loop;
     
            Put("Элементы с чётными индексами: ");
            for i in mas'Range loop
                if i rem 2 = 0 then        --Если индекс массива - чётное число, то
                    --выводим элемент на экран
                    Put(Item => mas(i), Width => 1);
                    Put(" ");
                end if;
            end loop;
        end;                                 --конец блока declare
    end;


  • Выведите все четные элементы массива.

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


  • Количество элементов в массиве: 7
    Массив: 1 2 2 3 3 3 4
    Чётные элементы массива: 2 2 4
  • В решении этой задачи показано, как можно создать тип массива с неопределёнными границами, а затем, когда размер массива станет известен, объявляется массив созданного типа и сразу же в объявлении указывается размер массива (опять же в блоке declare).

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        n : Integer;
        type Vector is array(Integer range <>) of Integer;
    begin
        Put("Количество элементов в массиве: ");
        Get(n);
        declare
            mas : Vector (1..n);
        begin
            Put_Line("Массив: ");
            for i in mas'Range loop
                Get(mas(i));
            end loop;
     
            Put("Чётные элементы массива: ");
            for i in mas'Range loop
                if mas(i) rem 2 = 0 then
                    Put(Item => mas(i), Width => 1);
                    Put(" ");
                end if;
            end loop;
        end;
    end main;


  • Найдите количество положительных элементов в данном массиве. В первой строке вводится количество элементов в массиве. Во второй строке вводятся элементы массива.


  • Количество элементов в массиве: 5
    Массив: 1 -2 3 -4 5
    Количество положительных элементов: 3
  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        type Vector is array(Integer range <>) of Integer;
        n, cnt : Integer;    --n - количество элементов в массиве, cnt - счётчик положительных чисел
    begin
        Put("Количество элементов в массиве: ");
        Get(n);
        cnt := 0;
        declare
            mas : Vector (1..n);
        begin
            Put_Line("Массив: ");
            for i in mas'Range loop
                Get(mas(i));
            end loop;
     
            Put("Количество положительных элементов: ");
            for i in mas'Range loop
                if mas(i) >= 0 then
                    cnt := cnt + 1;
                end if;
            end loop;
        end;
        Put(Item => cnt, width => 1);
    end main;


  • Дан массив чисел. Выведите все элементы массива, которые больше предыдущего элемента. В первой строке вводится количество элементов в массиве. Во второй строке вводятся элементы массива.

  • Количество элементов в массиве: 5
    Массив: 1 5 2 4 3
    Элементы, больше предыдущего: 5 4

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        type Vector is array(Integer range <>) of Integer;
        n : Integer;        --Количество элементов массива
        prev : Integer;     --предыдущий элемент массива
    begin
        Put("Количество элементов в массиве: ");
        Get(n);
        declare
            mas : Vector(1..n);
        begin
            Put_Line("Массив: ");
            for i in mas'Range loop
                Get(mas(i));
            end loop;
     
            prev := mas(1);
     
            Put("Элементы, больше предыдущего: ");
            for i in 2..mas'Last loop
                if mas(i) > prev then
                    Put(item => mas(i), Width => 1);
                    Put(" ");
                end if;
                prev := mas(i);
            end loop;
        end;
    end main;


  • Дан массив чисел. Если в нем есть два соседних элемента одного знака, выведите эти числа. Если соседних элементов одного знака нет - не выводите ничего. Если таких пар соседей несколько - выведите первую пару.

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


  • Количество элементов в массиве: 5
    Массив: -1 2 3 -1 -2
    Первая пара соседних элементов одного знака: 2 3
  • Возможно, в решении этой задачи Вам может помочь использование переменных логического типа Boolean. Переменные типа Boolean могут принимать только два значения: True или False. True означает "истина", а False - "ложь". Например,

    A, B : Boolean;
    ...
    A  := True;
    B := False;

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        type Vector is array(Integer range <>) of Integer;
        n, prev : Integer;
        fl : Boolean;               --"Флаг" - признак того, что вывода на экран ещё не было
    begin
        Put("Количество элементов в массиве: ");
        Get(n);
        fl := False;
        declare
            mas : Vector(1..n);
        begin
            Put_Line("Массив: ");
            for i in mas'Range loop
                Get(mas(i));
            end loop;
     
            Put("Первая пара соседних элементов одного знака: ");
            prev := mas(1);
            for i in 2..mas'Last loop
                if (prev > 0 and mas(i) > 0) or (prev < 0 and mas(i) < 0) then
                    Put(Integer'image(prev) & " " & Integer'image(mas(i)));
                    --"Поднимаем" флаг (вывод на экран первой пары элементов произошёл)
                    fl := True;
                end if;
                    prev := mas(i);
                --если вывод на экран уже произошёл, то пробегать до конца весь
                --массив смысла нет (по условию задачи), поэтому здесь мы
                --выходим из цикла for:
                exit when fl = True;
            end loop;
        end;
    end;


  • Выведите значение наименьшего из всех положительных элементов в массиве. Известно, что в массиве есть хотя бы один положительный элемент.

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


  • Количество элементов в массиве: 5
    Массив: 5 -4 3 -2 1
    Наименьший положительный элемент: 1
  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        type Vector is array(Integer range <>) of Integer;
        n : Integer;
        min : Integer; --минимальный положительный элемент массива
    begin
        Put("Количество элементов в массиве: ");
        Get(n);
        min := -1;     --Признак того, что минимальный положительный элемент пока не найден
        declare
            mas : Vector(1..n);
        begin
            Put_Line("Массив: ");
            for i in 1..mas'Last loop
                Get(mas(i));
            end loop;
     
            for i in mas'Range loop
                if mas(i) >= 0 then  --Если текущий элемент массива положителен, то
                    if min < 0 then  --Если минимальный положительный элемент до сих
                                        --пор не был обнаружен
                        min := mas(i);
                    else             --Иначе
                        if mas(i) < min then
                            min := mas(i);
                        end if;
                    end if;
                end if;
            end loop;
        end;
        Put("Минимальный положительный элемент: ");
        Put(Item => min, Width => 1);
    end main;


  • Выведите значение наименьшего нечетного элемента списка, а если в списке нет нечетных элементов - выведите соответствующее сообщение.

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


  • Пример 1:
    Количество элементов в списке: 5
    Список: 0 1 2 3 4
    Наименьший нечетный элемент: 1

    Пример 2:
    Количество элементов в списке: 5
    Список: 2 4 6 8 10
    В списке нет нечётных элементов

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        type Vector is array(Integer range <>) of Integer;
        n : Integer;
        min : Integer; --Наименьший нечётный элемент списка
        fl : Boolean;  --Признак наличия или отсутствия в массиве нечётных элементов
    begin
        Put("Количество элементов в списке: ");
        Get(n);
        fl := False;
        declare
            mas : Vector(1..n);
        begin
            Put_Line("Список: ");
            for i in 1..mas'Last loop
                Get(mas(i));
            end loop;
     
            min := mas(1);
     
            for i in 1..mas'Last loop
                if mas(i) rem 2 /= 0 then
                    fl := True;
                    if min rem 2 = 0 or (min rem 2 /= 0 and then min > mas(i)) then
                        min := mas(i);
                    end if;
                end if;
            end loop;
        end;
        if fl = False then
            Put("В списке нет нечётных элементов");
        else
            Put("Наименьший нечетный элемент: ");
            Put(Item => min, Width => 1);
        end if;
    end main;


  • Дан список, упорядоченный по возрастанию элементов в нем. Определите, сколько в нем различных элементов.

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


  • Количество элементов в списке: 6
    Список: 1 2 2 3 3 3
    Различных элементов: 3
  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        type Vector is array(Integer range <>) of Integer;
        n, cnt : Integer;
    begin
        cnt := 1;
        Put("Количество элементов в списке: ");
        Get(n);
        declare
            mas : Vector(1..n);
        begin
            Put_Line("Список: ");
            for i in 1..mas'Last loop
                Get(mas(i));
            end loop;
     
            n := mas(1); --т.к. n в качестве определителя размера массива уже "сыграла" свою роль,
                         --то её можно ещё раз использовать для наших нужд. Теперь она
                         --будет содержать предыдущий элемент массива
            Put("Различных элементов: ");
            for i in 2..mas'Last loop
                if mas(i) /= n then
                    cnt := cnt + 1;
                end if;
                n := mas(i);
            end loop;
        end;
        Put(Item => cnt, Width => 1);
    end;


  • Переставьте соседние элементы массива (A[0] c A[1], A[2] c A[3] и т.д.). Если элементов нечетное число, то последний элемент остается на своем месте.

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


  • Количество элементов в массиве: 5
    Массив: 1 2 3 4 5
    Итоговый массив:

    2 1 4 3 5

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        type Vector is array(Integer range <>) of Integer;
        n, j, i : Integer;
    begin
        Put("Количество элементов в массиве: ");
        Get(n);
        declare
            mas : Vector(1..n);
        begin
            Put_Line("Массив: ");
            for i in 1..mas'Last loop
                Get(mas(i));
            end loop;
     
            i := 2;
            j := 1;
            while i <= mas'Last loop --Перестановка элементов массива в цикле
                n := mas(j);
                mas(j) := mas(i);
                mas(i) := n;
                i := i + 2;
                j := j + 2;
            end loop;
     
            Put_Line("Итоговый массив: ");
            for i in 1..mas'Last loop
                Put(Item => mas(i), Width => 1);
                Put(" ");
            end loop;
        end;
    end main;


  • Циклически сдвиньте элементы списка вправо на одну позицию (A[0] переходит на место A[1], A[1] на место A[2], ..., последний элемент переходит на место A[0]).

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


  • Количество элементов в списке: 5
    Список: 1 2 3 4 5
    Сдвинутый список:

    5 1 2 3 4

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        type Vector is array(Integer range <>) of Integer;
        n, lst : Integer;
    begin
        Put("Количество элементов в списке: ");
        Get(n);
        declare
            mas : Vector(1..n);
        begin
            Put_Line("Список: ");
            for i in 1..mas'Last loop
                Get(mas(i));
            end loop;
     
            lst := mas(mas'Last);              --Запомнить последний элемент
            for i in reverse 2..mas'Last loop  --сдвиг всех элементов массива в цикле
                mas(i) := mas(i - 1);
            end loop;
            mas(1) := lst;                     --Поставить последний элемент на место первого
     
            Put_Line("Сдвинутый список: ");
            for i in 1..mas'Last loop
                Put(Item => mas(i), Width => 1);
                Put(" ");
            end loop;
        end;
    end main;


  • Дан массив чисел. Посчитайте, сколько в нем пар элементов, равных друг другу. Считается, что любые два элемента, равные друг другу образуют одну пару, которую необходимо посчитать.

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


  • Пример 1:
    Количество элементов в массиве: 5
    Массив: 1 2 3 2 3
    Пар равных элементов: 2

    Пример 2:
    Количество элементов в массиве: 5
    Массив: 1 1 1 1 1
    Пар равных элементов: 10

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        type Vector is array(Integer range <>) of Integer;
        n, dbl : Integer;
    begin
        dbl := 0; --счётчик пар
        Put("Количество элементов в массиве: ");
        Get(n);
        declare
            mas : Vector(1..n);
        begin
            Put_Line("Массив: ");
            for i in 1..mas'Last loop
                Get(mas(i));
            end loop;
            --Далее используются 2 цикла (внутренний и внешний) для попарного сравнения 
                --элементов ("каждый с каждым")
            for i in 1..(mas'Last - 1) loop
                for j in (i + 1)..mas'Last loop
                    if mas(i) = mas(j) then
                        dbl := dbl + 1;
                    end if;
                end loop;
            end loop;
        end;
        Put("Пар равных элементов: ");
        Put(Item => dbl, Width => 1);
    end main;


  • Дан массив. Выведите те его элементы, которые встречаются в массиве только один раз. Элементы нужно выводить в том порядке, в котором они встречаются в списке.

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


  • Пример 1:
    Количество элементов в массиве: 6
    Массив: 1 2 2 3 3 3
    Уникальные элементы массива: 1

    Пример 2:
    Количество элементов в массиве: 8
    Массив: 4 3 5 2 5 1 3 5
    Уникальные элементы массива: 4 2 1

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        type Vector is array(Integer range <>) of Integer;
        n, dbl : Integer;
    begin
        dbl := 0;
        Put("Количество элементов в массиве: ");
        Get(n);
        declare
            mas : Vector(1..n);
        begin
            Put_Line("Массив: ");
            for i in 1..mas'Last loop
                Get(mas(i));
            end loop;
     
            Put("Уникальные элементы массива: ");        
            for i in 1..mas'Last loop
                for j in 1..mas'Last loop
                    --если текущий элемент встречается ещё раз, то
                    if j /= i and then mas(i) = mas(j) then
                        --отмечаем, что у него есть пара
                        dbl := dbl + 1;
                    end if;
                end loop;
                --Если парный элемент не найден => найден искомый элемент
                if dbl = 0 then
                    Put(Item => mas(i), Width => 1);
                    Put(" ");
                end if;
                dbl := 0;
            end loop;
        end;
    end main;


  • Известно, что на доске 8×8 можно расставить 8 ферзей так, чтобы они не били друг друга. Вам дана расстановка 8 ферзей на доске, определите, есть ли среди них пара бьющих друг друга.

    Программа получает на вход восемь пар чисел, каждое число от 1 до 8 - координаты 8 ферзей.

    Если ферзи не бьют друг друга, выведите слово "НЕТ", иначе выведите "ДА".


  • Пример 1:

    1 7
    2 4
    3 2
    4 8
    5 6
    6 1
    7 3
    8 5

    НЕТ

    Пример 2:

    1 8
    2 7
    3 6
    4 5
    5 4
    6 3
    7 2
    8 1

    ДА

  • Для решения данной задачи я советую в электронной таблице (Calc или MS Excel) выделить поле 8х8 и посмотреть, при каких условиях один ферзь будет бить другого.

  • with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
      n : constant Integer := 8;
      type Vector is array(1..n) of Integer;
      --Используем 2 массива: первый будет содержать позиции фигуры по горизонтали,
      --второй - по вертикали:
      masx, masy : Vector;
      find : Boolean := False;
    begin
     
      for i in 1..n loop
        Get(masx(i)); Get(masy(i));
      end loop;
     
      main_loop:
      for i in 1..n loop
        for j in 1..n loop
          if i /=j then
            if abs(masx(i) - masx(j)) = abs(masy(i) - masy(j)) or ((masx(i) = masx(j) or masy(i) = masy(j))) then
              find := True;
              exit main_loop;
            end if;
          end if;
        end loop;
      end loop main_loop;
     
      if find = True then
        Put("YES");
      else
        Put("NO");
      end if;  
    end main;


  • N кеглей выставили в один ряд, занумеровав их слева направо числами от 1 до N. Затем по этому ряду бросили K шаров, при этом i-й шар сбил все кегли с номерами от li до ri включительно. Определите, какие кегли остались стоять на месте.

    Программа получает на вход количество кеглей N и количество бросков K. Далее идет K пар чисел li, ri, при этом 1 ≤ li, ri ≤ N.

    Программа должна вывести последовательность из N символов, где j-й символ есть “I”, если j-я кегля осталась стоять, или “.”, если j-я кегля была сбита.


  • Пример ввода:

    10 3
    8 10
    2 5
    3 6

    Пример вывода:
    I.....I...

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        n, k : Integer;
        li, ri : Integer;
        type Vector is array(Integer range <>) of Integer;
    begin
        Get(n);   --Количество кеглей
        Get(k);   --Количество бросков
        declare
            mas : Vector (1..n);
        begin
            for i in 1..mas'Last loop
                mas(i) := 1; --изначально все кегли стоят => 1
            end loop;
     
            for i in 1..k loop
                Get(li);             --левая граница диапазона сбитых кеглей i-тым броском
                Get(ri);             --правая граница диапазона сбитых кеглей i-тым броском
                for j in li..ri loop --отмечаем в массиве нулями те позиции, которые были сбиты
                    mas(j) := 0;
                end loop;
            end loop;
     
            for i in 1..mas'Last loop
                if mas(i) = 1 then
                    Put("I");
                else
                    Put(".");
                end if;
            end loop;
        end;
        New_Line;
    end main;


  • Дан массив целых чисел. Необходимо отсортировать этот массив по возрастанию (т.е. расставить цифры по порядку от меньшего к большему). Программа получает на вход размер массива n, а затем сам массив. Необходимо вывести на экран отсортированный по возрастанию массив.


  • Размер массива: 10
    Массив: 10 8 5 4 6 7 9 3 1 2
    Отсортированный массив:

    1 2 3 4 5 6 7 8 9 10

  • 1. Сортировка методом пузырька

    Более подробно про этот алгоритм можно посмотреть здесь.

    Сортировка методом пузырька - это когда самое большое число (самый большой пузырёк) "всплывает" на самый верх, а за ним следуют все остальные.

    with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        type Matrix is array(Integer range <>) of Integer;
        n : Integer;
        imax : Integer;
        tmp : Integer;
    begin
        Put("Размер массива: ");
        Get(n);
        declare
            mas : Matrix(1..n);
        begin
            --ввод массива
            Put_Line("Массив: ");
            for i in 1..mas'Last loop
                Get(mas(i));
            end loop;
     
            --сортировка массива
            for i in reverse 1..n loop     --внешний цикл - пробегаем с конца массива в начало
                imax := mas(i);        --индекс максимального элемента
                --внутренний цикл - пробегаем с начала массива до текущего i
                for j in 1..(i - 1) loop
                --(из внешнего цикла), не включая это i
                    if mas(j) > mas(imax) then
                        --если на участке от 1 до i встретили элемент, который больше
                        --текущего максимального, то запоминаем его индекс
                        imax := j;
                    end if;
                end loop;
                --найденный на участке массива максимальный элемент "всплывает" вверх
                tmp := mas(i);
                mas(i) := mas(imax);
                mas(imax) := tmp;
            end loop;
     
            --вывод массива
            Put_Line("Итоговый массив: ");
            for i in 1..mas'Last loop
                Put(Item => mas(i), Width => 1);
                Put(" ");
            end loop;
        end;
    end main;

  • 2. Гномья сортировка

    Более подробно про этот алгоритм можно посмотреть здесь.

    Я здесь просто приведу реализацию алгоритма (немного оптимизированную), а если кому интересно, почему он так называется - Google в помощь! От предыдущего он отличается тем, что вся сортировка происходит за один проход и вместо цикла for используется цикл while:

    with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        type Matrix is array(Integer range <>) of Integer;
        n : Integer;
        tmp : Integer;
        iprev, inext, ipos : Integer;
    begin
        Put("Размер массива: ");
        Get(n);
        declare
            mas : Matrix(1..n);
        begin
            --ввод массива
            Put_Line("Массив: ");
            for i in 1..mas'Last loop
                Get(mas(i));
            end loop;
     
            --сортировка массива
            iprev := 1;
            inext := 2;
            while inext <= mas'Last loop
                --сравниваются 2 элемента, и если последующий меньше предыдущего, то
                if mas(inext) < mas(iprev) then
                    ipos := inext;              --запоминаем позицию "последующего"
                    --Сравниваем найденный элемент (меньший) со всеми элементами в массиве,
                    --стоящими до него, и производим обмен, если элемент меньше предыдущего
                    while inext - 1 >= 1 and then mas(inext) < mas(inext - 1) loop
                        tmp := mas(inext);
                        mas(inext) := mas(inext - 1);
                        mas(inext - 1) := tmp;
                        inext := inext - 1;
                    end loop;
                    inext := ipos;
                end if;
                inext := inext + 1;
                iprev := inext - 1;
            end loop;
     
            --вывод массива
            Put_Line("Итоговый массив: ");
            for i in 1..mas'Last loop
                Put(Item => mas(i), Width => 1);
                Put(" ");
            end loop;
        end;
    end main;


В разделе «Шпаргалка» кратко описаны все функции, рассмотренные в теме «Цикл for и массивы».

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

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