Подпрограммы в языке Ада. Решение тематических задач

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

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

  • Пример 1:
    Квадратное уравнение имеет вид: ax^2 + bx + c = 0
    Введите коэффициенты уравнения:
    a = 2
    b = 5
    c = -3
    Уравнение имеет два корня:
    x1 = 0.50; x2 = -3.00

    Пример 2:
    Квадратное уравнение имеет вид: ax^2 + bx + c = 0
    Введите коэффициенты уравнения:
    a = 0
    b = 2
    c = 5
    Введены некорректные данные!

    Пример 3:
    Квадратное уравнение имеет вид: ax^2 + bx + c = 0
    Введите коэффициенты уравнения:
    a = 1
    b = 1
    c = 1
    Уравнение не имеет корней!

    Пример 4:
    Квадратное уравнение имеет вид: ax^2 + bx + c = 0
    Введите коэффициенты уравнения:
    a = 1
    b = 6
    c = 9
    Уравнение имеет только один корень:
    x1 = x2 = -3.00

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Float_Text_IO; use Ada.Float_Text_IO;
    with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;
     
    procedure main is
        a, b, c : Float; --Коэффициенты
        x1, x2 : Float; --Неизвестные
        discr : Float; --дискриминант
        ans : Integer := 0; --Количество корней уравнения
        raits : Boolean := False; --Результат проверки корректности коэффициентов
     
        procedure Get_Raits(a, b, c : out Float) is
        --Считывает коэффициенты уравнения с клавиатуры
        begin
            Put_Line("Введите коэффициенты уравнения:");
            Put("a = ");
            Get(a);
            Put("b = ");
            Get(b);
            Put("c = ");
            Get(c);
        end Get_Raits;
     
        function Check_Raits(a : Float) return Boolean is
        --Проверяет, что a не равно 0. Иначе это уравнение не будет квадратным
        begin
            if a * 10.0 = 0.0 then
                return False;
            end if;
            return True;
        end Check_Raits;
     
        function Compute_Discriminant(a, b, c : Float) return Float is
        --Вычисляет дискриминант
            d : Float;
        begin
            d := (b * b - (4.0 * a * c));
            return d;
        end Compute_Discriminant;
     
        function Check_Discriminant(d : Float) return Integer is
        --Проверяет, имеет ли уравнение корни, и, если имеет, то сколько.
        begin
            --Так как вещественные типы при сравнении дают погрешность, преобразуем вещественный
            --тип к целому с допустимой для данного случая погрешностью и сравним с целым
            if Integer(d * 100_000.0) < 0 then --Корней нет
                return 0;
            elsif Integer(abs(d * 100_000.0)) = 0 then --Один корень
                return 1;
            else --Два корня
                return 2;
            end if;
        end Check_Discriminant;
     
        procedure Solve_Task(ans : Integer; x1, x2 : out Float; a, b, discr : in Float) is
        --Вычислить корни уравнения
        begin
            x1 := (-b + sqrt(discr)) / (2.0 * a);
            if ans /= 0 then --Если корней два
                x2 := (-b - sqrt(discr)) / (2.0 * a);
            end if;
        end Solve_Task;
    begin
        Put_Line("Квадратное уравнение имеет вид: ax^2 + bx + c = 0");
        Get_Raits(a, b, c); --Получить коэффициенты
        raits := Check_Raits(a); --Проверка первого коэффициента
        if not raits then --Если первый коэффициент равен 0, то выходим из программы
            Put_Line("Введены некорректные данные!");
            return;
        end if;
        discr := Compute_Discriminant(a, b, c);    --Вычислить дискриминант
        ans := Integer(Check_Discriminant(discr)); --Проверка, сколько решений имеет уравнение
        if ans = 0 then
            Put_Line("Уравнение не имеет корней!");
        else
            Solve_Task(ans, x1, x2, a, b, discr);
            if ans = 1 then
                Put_Line("Уравнение имеет только один корень:");
                Put("x1 = x2 = ");
                Put(Item => x1, Fore => 0, Aft => 2, Exp => 0);
            else
                Put_Line("Уравнение имеет два корня:");
                Put("x1 = ");
                Put(Item => x1, Fore => 0, Aft => 2, Exp => 0);
                Put("; x2 = ");
                Put(Item => x2, Fore => 0, Aft => 2, Exp => 0);
            end if;
        end if;
    end main;


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

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
    with Ada.Numerics.Discrete_Random;
     
    procedure Main is
        imax, tmp : Integer;
        mas_size : constant Integer := 20; --Размер массива - константа
     
        subtype RandNum is Integer range -99..99; --Числа, которые массив может содержать
        type Vector is array(Integer range <>) of RandNum; --Тип массива с неуточнёнными границами
        subtype VectInd is Integer range 1..mas_size; --Индексы массива
        subtype subVector is Vector(VectInd); --Размерность массива (можно просто Vector(1..20))
        mas : subVector; --Массив, с которым будем работать
     
        procedure Fill_Mas(vect : in out Vector) is
        --Заполняет массив случайными числами
            package Rand is new Ada.Numerics.Discrete_Random(RandNum);
            gen : Rand.Generator;
        begin
            Rand.Reset(gen); --Запуск генератора случайных чисел
            for i in vect'First..vect'Last loop
                vect(i) := Rand.Random(gen);
            end loop;
        end Fill_Mas;
     
        procedure Show_Mas(vect : in Vector) is
        --Выводит массив на экран
        begin
            for i in vect'First..vect'Last loop
                Put(Integer'Image(vect(i)) & " ");
            end loop;
            New_Line;
        end Show_Mas;
     
        function Get_Max(vect : Vector) return Integer is
        --Возвращает максимальный элемент переданного массива
        --Обратите внимание, что аргумент mas имеет тип Vector, границы которого не заданы!
        --При этом параметр, передаваемый в подпрограмму, имеет тип subVector - производный от Vector
        --В данной подпрограмме это имеет значение, т.к. размер аргумента/параметра каждый раз новый
            imax : Integer;
        begin
            imax := vect'First;
            for i in vect'First..vect'Last loop
                if vect(i) > vect(imax) then
                    imax := i;
                end if;
            end loop;
            return imax;
        end Get_Max;
     
    begin
            Fill_Mas(mas);
            Put_Line("Исходный массив:");
            Show_Mas(mas);
            for i in mas'First..mas'Last loop
                imax := Get_Max(mas(i..mas'Last)); --параметр функции - срез
                --Обмен местами максимального элемента массива с текущим
                tmp := mas(i);
                mas(i) := mas(imax);
                mas(imax) := tmp;
            end loop;
            Put_Line("Отсортированный массив:");
            Show_Mas(mas);
    end Main;


  • В одномерном массиве из 20 элементов удалить самую длинную цепочку чётных элементов. Реализовать: подпрограмму ввода массива, подпрограмму поиска цепочки, подпрограмму удаления элементов из массива, подпрограмму вывода массива/участка массива на экран.

  • Задача: в одномерном массиве из 20 элементов удалить самую длинную цепочку чётных элементов.
    Введите 20 элементов массива:
    2 4 8 6 5 7 9 2 6 5 8 4 6 2 8 6 4 2 5 9

    Длина самой длинной цепочки чётных элементов: 8
    Начало цепочки: 11
    Конец цепочки: 18
    Самая длинная цепочка чётных элементов выглядит следующим образом:
    8 4 6 2 8 6 4 2
    Обработанный массив:
    2 4 8 6 5 7 9 2 6 5 5 9

  • 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(1..20) of Integer;
     
      --Процедура считывания с клавиатуры одномерного массива
      procedure Get_Mas(mas : in out Vector) is
      begin
        for i in mas'First..mas'Last loop
          Get(mas(i));
        end loop;
      end Get_Mas;
     
      --Процедура ищет в массиве самую длинную цепочку чётных элементов
      --После выполнения процедуры параметр chain_begin будет содержать
      --индекс, с которого начинается цепочка, а chain_end - индекс,
      --которым заканчивается цепочка
      procedure Get_Chain(chain_begin, chain_end : in out Integer; mas : in Vector) is
        tmp_begin, tmp_end : Integer := 1; --Для запоминания индексов текущей цепочки чётных элементов
        in_chain : Boolean := false; --Признак четности текущего элемента массива
      begin
        for i in mas'First..mas'Last loop
          --Если текущий элемент чётный, но признак чётности не выставлен
          if mas(i) rem 2 = 0 and then in_chain = false then
            tmp_begin := i;
            in_chain := true;
          --Если текущий элемент нечётный, но признак четности выставлен в True
          --Или текущий элемент чётный и при этом он является последним элементом массива (т.е.
          --самая длинная цепочка вполне может находится и в конце массива)
          elsif (mas(i) rem 2 /= 0 and then in_chain = true) or (mas(i) rem 2 = 0 and then i = mas'Last) then
            if mas(i) rem 2 /= 0 then
              tmp_end := i - 1;
            elsif i = mas'Last then --Если мы находимся в конце массива и последний элемент чётный
              tmp_end := i;
            end if;
            in_chain := false;
            --Если текущая цепочка чётных элементов оказалась длиннее предыдущей
            --или если она первая, то сохраняем её индексы
            if (tmp_end - tmp_begin) > (chain_end - chain_begin) then
              chain_begin := tmp_begin;
              chain_end := tmp_end;
            end if;
          end if;
        end loop;
      end Get_Chain;
     
      --Процедура для вывода массива и среза (отрезка) массива.
      --В процедуру передаётся сам массив и начало и конец отрезка, который нужно вывести
      procedure Show_Mas(mas : in Vector; ch_begin, ch_end : in out Integer) is
      begin
        if ch_begin = 0 and then ch_end = 0 then
          ch_begin := mas'First;
          ch_end := mas'Last;
        end if;
        for i in ch_begin..ch_end loop
          Put(Item => mas(i), Width => 0);
          Put(" ");
        end loop;
        New_Line;
      end Show_Mas;
     
      --Процедура удаляет из массива цепочку элементов. На самом деле, длина массива остаётся
      --неизменной (20 элементов), просто, перезаписывается один участок. Поэтому для корректной
      --работы процедура в переменной index_end сохраняет индекс элемента, до которого включительно
      --осуществляется вывод
      procedure Del_Chain(mas : in out Vector; chain_begin, chain_end : in out Integer) is
        index_end : Integer;
      begin
        if chain_end /= mas'Last then
          chain_end := chain_end + 1;
        end if;
        --Если самая длинная цепочка находится в конце массива
        if chain_end = mas'Last then
          index_end := chain_begin - 1;
        else
          index_end := chain_begin + (mas'Last - chain_end);
          mas(chain_begin..index_end) := mas((chain_end)..mas'Last);
        end if;
        chain_begin := mas'First;
        chain_end := index_end;
      end Del_Chain;
     
      mas : Vector;
      num : Integer := 0;
      chain_begin, chain_end : Integer := 1;
     
    begin
      Put_Line("Задача: в одномерном массиве из 20 элементов удалить самую длинную цепочку");
      Put_Line("чётных элементов.");
      Put_Line("Введите 20 элементов массива:");
      Get_Mas(mas);
      New_Line;
      Get_Chain(chain_begin, chain_end, mas);
      Put_Line("Длина самой длинной цепочки чётных элементов:" & Integer'Image(chain_end - chain_begin + 1));
      Put_Line("Начало цепочки:" & Integer'Image(chain_begin));
      Put_Line("Конец цепочки:" & Integer'Image(chain_end));
      Put_Line("Самая длинная цепочка чётных элементов выглядит следующим образом:");
      Show_Mas(mas, chain_begin, chain_end);
      Del_Chain(mas, chain_begin, chain_end);
      Put_Line("Обработанный массив:");
      Show_Mas(mas, chain_begin, chain_end);
      New_Line;
    end main;


  • Написать функцию, обеспечивающую ввод с клавиатуры целого положительного числа (не более 10 цифр). При нажатии клавиши соответствующий символ должен появляться на экране только в том случае, если этот символ является цифрой. Функция должна позволять редактировать введенное число при помощи клавиши <Backspace>. При нажатии клавиши <Enter> функция должна завершать работу и возвращать введенное число.

  • Клавиша Backspace в Unix-системах имеет код 127, а в Dos/Windows - 8, (на код 127 в Windows обычно "вешают" кнопку "home") поэтому для обработки нажатия клавиши Backspace код для этих систем немного различается. Подробнее об этом можно прочитать в Википедии. Да и обработка Enter тоже отличается: 13 для Windows и 10 для Unix-like систем. Для написания кроссплатформенной программы необходимо учесть этот факт. Для того, чтобы не возиться с цифровыми кодами клавиш, я воспользуюсь пакетом Ada.Characters.Latin_1, где BS - 8, DEL - 127, LF - 10, CR - 13

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Characters.Latin_1; use Ada.Characters.Latin_1;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        n : Integer;
     
        function Get_Number return Integer is
        --Считывает и обрабатывает вводимые символы и возвращает число
            res : array (1..10) of Integer; --Сюда будем сохранять вводимые цифры
            ch : Character := 'a'; --Сюда считываются символы
            n : Integer := 0; --Количество введённых символов
            num : Integer := 0; --Итоговое число
        begin
            while (ch /= LF and ch /= CR) and then n <= 10 loop --Обработка Enter
                Get_Immediate(ch); --Считывание символа без отображения на экране
                if ch >= '0' and then ch <= '9' then --Если считали цифру
                    n := n + 1;
                    Put(ch);
                    --Сохраняем цифру в массив, предварительно преобразовав Character в Integer:
                    res(n) := (Character'Pos(ch) - Character'Pos('0'));
                --Обработка Backspace
                elsif (ch = BS or ch = DEL) and then n /= 0 then
                    Put(BS); --Возвращаемся по строке на одну позицию назад
                    Put(' '); --Затираем текущий символ пробелом
                    Put(BS); --Снова возвращаемся на одну позицию назад
                    res(n) := 0;
                    n := n - 1;
                end if;
            end loop;
            New_Line;
            for i in res'First..n loop
                num := num * 10 + res(i);
            end loop;
            return num;
        end Get_Number;
     
    begin
        n := Get_Number;
        Put("Введённое число =" & Integer'Image(n));
    end main;

  • Решение можно сделать немного короче, задействовав строки. В Аде обычные строки - это то же самое, что массив, только объявляются они не как array, а как String. Следующее решение можно пропустить, т.к. оно использует строку для выполнения задачи, но со строками мы познакомимся через одну-две темы, а можно и просмотреть для общего развития. Отмечу только, что для преобразования строки к целому типу используется атрибут:

    Integer n : Integer'Value("2345");

    Переменная n после этого будет иметь значение 2345.

    with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Characters.Latin_1; use Ada.Characters.Latin_1;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        n : Integer;
     
        function Get_Number return Integer is
        --Считывает и обрабатывает вводимые символы и возвращает число
            res : String(1..10) := (others => ' ');
            ch : Character := 'a';
            n : Integer := 1;
        begin
            while (ch /= LF and ch /= CR) and then n <= 10 loop --Обработка Enter
                Get_Immediate(ch); --Считывание символа без отображения на экране
                if ch >= '0' and then ch <= '9' then --Если считали цифру
                    Put(ch);
                    res(n) := ch;
                    n := n + 1;
                --Обработка Backspace
                elsif (ch = BS or ch = DEL) and then n /= 0 then
                    Put(BS); --Возвращаемся по строке на одну позицию назад
                    Put(' '); --Затираем текущий символ пробелом
                    Put(BS); --Снова возвращаемся на одну позицию назад
                    res(n - 1) := ' ';
                    n := n - 1;
                end if;
            end loop;
            New_Line;
            --Преобразование строки в число
            return Integer'Value(res);
        end Get_Number;
     
    begin
        n := Get_Number;
        Put("Введённое число =" & Integer'Image(n));
    end main;


  • Написать функцию, обеспечивающую ввод с клавиатуры положительного дробного числа (не более 10 символов). При нажатии клавиши соответствующий символ должен появляться на экране только в том случае, если этот символ является допустимым в данной позиции. Функция не должна допускать ввод более чем одной точки. Функция должна позволять редактировать введенное число при помощи клавиши <Backspace>. При нажатии клавиши <Enter> функция должна завершать работу и возвращать введенное число.

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Characters.Latin_1; use Ada.Characters.Latin_1;
     
    procedure main is
        ch : Character := 'a';
        type Vector is array(1..10) of Character;
        mas : Vector := (others => ' ');
        point : Integer range 0..1 := 0; --Признак: 0 - точка ещё не вводилась, 1 - точка уже вводилась.
        ind : Integer := 0; --текущий индекс массива
     
        procedure Get_Num(ch : in out Character) is
        --Считывает дробное число с клавиатуры
        --Возможные символы: цифровые, точка, BackSpace и Enter
            got : Boolean := False;
        begin
            Get_Number: while not got loop
                Get_Immediate(ch);
                if (ch >= '0' and ch <= '9') or ch = '.' or ch = BS or ch = DEL or ch = LF or ch = CR then
                    got := True;
                end if;
            end loop;
        end Get_Num;
    begin
        loop
            --Обработка нажатия клавиши
            Get_Num(ch);
            --Обработка Enter
            exit when ch = LF or ch = CR;
            --Обработка BackSpace
            if ch = BS or ch = DEL then
                Put(BS);
                Put(' ');
                Put(BS);
                if ind /= 0 and then mas(ind) = '.' then
                    point := 0;
                end if;
                if ind /= 0 then
                    ind := ind - 1;
                end if;
            else
                --Обработка точки
                if ch = '.' then
                    --Если точка - самый первый из вводимых символов
                    if ind = 0 and point = 0 then
                        point := 1;
                        ind := 1;
                        mas(ind) := '0';
                        ind := ind + 1;
                        mas(ind) := ch;
                        Put(ch);
                    --Проверяем, что точка до этого не вводилась и если это так,
                    --то добавляем её
                    elsif point = 0 then
                        ind := ind + 1;
                        mas(ind) := ch;
                        point := 1;
                        Put(ch);
                    end if;
                else
                    ind := ind + 1;
                    mas(ind) := ch;
                    Put(ch);
                end if;
            end if;
            exit when ind >= 10;
        end loop;
        New_Line;
        --Вывод числа на экран. Преобразовывать содержимое массива в цифру я не буду,
        --просто выведу содержимое массива.
        if ind /= 0 then
            for i in mas'First..ind loop
                Put(mas(i));
            end loop;
            if mas(ind) = '.' then
                Put('0');
            end if;
            New_Line;
        end if;
    end main;


  • Написать игру "Угадай число": компьютер загадывает четырёхзначное число, пользователь должен это число угадать. После каждого пользовательского ввода программа выводит сообщение, сколько цифр было угадано и сколько из них находится на своих местах. Также необходимо учесть, что вводится могут только цифровые символы, Bacspace и Enter, а также, что 0 не может быть первой цифрой числа.


  • Компьютер задумал четырёхзначное число. Вы должные его угадать!
    Ваше число: 1234
    Неправильно! Угадано: 2 На своих местах: 1
    Ваше число: 9231
    Неправильно! Угадано: 3 На своих местах: 3
    Ваше число: 9201
    Поздравляю! Вы угадали за 3 шага!
  • Обратите внимание, вместо явного указания границ массива mas'First..mas'Last в решении используется атрибут mas'Range, который представляет собой то же самое, что и mas'First..mas'Last

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
    with Ada.Characters.Latin_1; use Ada.Characters.Latin_1;
    with Ada.Numerics.Discrete_Random;
     
    procedure main is
        --число может состоять только из положительных чисел, плюс резервируется -1
        --для проверки. См. процедуру Guess
        type Dec is new Integer range -1..9;
        subtype subDec is Dec range 0..9; --для генератора случайных чисел
        type Vector is array(1..4) of Dec;
        num : Vector; --Хранит задуманное число
        res : Vector := (others => 0); --Сюда пользователь вводит свой ответ
        step : Integer := 0; --Количество шагов, за которые угадано число
        in_num, on_place : Integer range 0..4 := 0;
     
    ------------------------------------------------------------------------
        procedure Fill_Num(mas : out Vector) is
        --"Загадывает" случайное число из четырёх цифр
            package ANDR is new Ada.Numerics.Discrete_Random(subDec);
            g : ANDR.Generator;
        begin
            ANDR.Reset(g);
            for i in mas'Range loop
                mas(i) := ANDR.Random(g);
                --Ноль не может быть первой цифрой
                while mas(i) = 0 and i = 1 loop
                    mas(i) := ANDR.Random(g);
                end loop;
            end loop;
        end Fill_Num;
     
        function Get_User_Number(len : Integer) return Vector is
        --Пользовательский ввод. Возвращает число, введённое пользователем
            res : Vector := (Others => 0);
            ch : Character;
            i : Integer range 1..(len + 1) := 1;
        begin
            Put("Ваше число: ");
            while i <= len loop
                Get_Immediate(ch);
                if ch >= '0' and ch <= '9' then
                    if ch = '0' and i = 1 then
                        New_Line;
                        Put("Ноль не может быть первой цифрой числа! Повторите попытку: ");
                    else
                        --Преобразовать Character в Integer:
                        res(i) := Character'Pos(ch) - Character'Pos('0');
                        i := i + 1;
                        Put(ch);
                    end if;
                --Обработка Backspace
                elsif (ch = BS or ch = DEL) then
                    if i > 1 then
                        Put(BS);
                        Put(' ');
                        Put(BS);
                        i := i - 1;
                    end if;
                else
                    New_Line;
                    Put("Число должно состоять из четырёх цифр! Ваше число: ");
                end if;
            end loop;
            New_Line;
            return res;
        end Get_User_Number;
     
        procedure Guess(num, res : in Vector; in_num, on_place : out Integer) is
        --Проверяет, сколько цифр угадано и какие из них стоят на своих местах
            tmp_num : Vector := num;
            tmp_res : Vector := res;
        begin
            in_num := 0;
            on_place := 0;
            --Проверку можно организовать за один цикл, но тогда сложнее будет
            --проверить вхождение одной цифры в число несколько раз. Например,
            --компьютер загадал 1234, а пользователь ввёл 1111. Сколько чисел угадано?
            --Первый цикл проверяет нахождение элементов на своих местах
            for i in tmp_num'Range loop
                for j in res'Range loop
                    if tmp_res(j) = tmp_num(i) and then i = j and then tmp_res(j) /= -1 then
                        on_place := on_place + 1;
                        tmp_num(i) := -1; --Исключаем совпадения
                        tmp_res(j) := -1; --Исключаем совпадения
                        in_num := in_num + 1; --цифра присутствует в задуманном числе
                        exit;
                    end if;
                end loop;
            end loop;
            --Второй цикл досчитывает, сколько элементов присутствует в массиве
            for i in tmp_num'Range loop
                for j in tmp_res'Range loop
                    if tmp_res(j) = tmp_num(i) and then tmp_res(j) /= -1 then
                        in_num := in_num + 1;
                        tmp_num(i) := -1; --исключаем совпадения
                        tmp_res(j) := -1; --исключаем совпадения
                        exit;
                    end if;
                end loop;
            end loop;
        end Guess;
     
    ------------------------------------------------------------------------
    begin
        Put_Line("Компьютер задумал четырёхзначное число. Вы должные его угадать!");
        Fill_Num(num); --Загадать число
     
        --Вывод задуманного числа (для тестирования)
        --for i in num'First..num'Last loop
        --    Put(Item => Integer(num(i)), Width => 0);
        --end loop;
        --New_Line;
     
        loop
            res := Get_User_Number(res'Length); --Пользовательский ввод
            step := step + 1;
            exit when res = num;
            Guess(num, res, in_num, on_place); --Сравнение чисел
            Put_Line("Неправильно! Угадано:" & Integer'Image(in_num) & " На своих местах:" & Integer'Image(on_place));
        end loop;
        Put_Line("Поздравляю! Вы угадали за" & Integer'Image(step) & " шагов!");
    end main;


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

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

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