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

Для решения задач этого раздела я рекомендую Вам ознакомится с материалом предыдущего: "Цикл while: введение".

  • Дано целое число, не меньшее 2. Выведите его наименьший натуральный делитель, отличный от 1.

  • Введите целое число: 15
    Наименьший натуральный делитель: 3
  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        n, i : Integer;
        --n - целое число, i - натуральный делитель
    begin
        Put("Введите целое число: ");
        Get(n);
        i := 2;           --натуральный делитель должен быть отличен от 1, следовательно, начнём с 2
        while n rem i /=0 loop  --Пока есть остаток от деления, выполняем цикл
            i := i + 1;
        end loop;
        Put("Наименьший натуральный делитель: ");
        Put(Item => i, Width => 1);
    end main;


  • По данному числу N распечатайте все целые степени двойки, не превосходящие N, в порядке возрастания.

  • Введите число: 50
    Степени двойки: 1 2 4 8 16 32
  • with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
    with Ada.Text_IO; use Ada.Text_IO;
     
    procedure main is
        n, i : Integer;
    begin
        Put("Введите число: ");
        Get(n);
        i := 0;
        Put("Степени двойки: ");
        while (2 ** i) < n loop                    -- 2 ** i означает 2 в степени i
            Put(Item => (2 ** i), Width => 1);
            Put(" ");
            i := i + 1;
        end loop;
    end main;


  • Дано натуральное число N. Выведите слово "ДА", если число N является точной степенью двойки, или слово "НЕТ" в противном случае.

  • Пример 1:
    1
    ДА

    Пример 2:
    2
    ДА

  • with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
    with Ada.Text_IO; use Ada.Text_IO;
     
    procedure main is
        subtype Natural is Integer range 1..Integer'Last;
        n : Natural;       --n - натуральное число (от 1 до Integer'Last)
        i, st : Integer;   --i - показатель степени, st - степень двойки
    begin
        Get(n);
        i := 0;
        st := 2 ** i;
     
        while st < n loop
            i := i + 1;
            st := 2 ** i;
        end loop;
     
        if st = n then
            Put_Line("ДА");
        else
            Put_Line("НЕТ");
        end if;
    end main;


  • Программа получает на вход последовательность целых неотрицательных чисел, каждое число записано в отдельной строке. Последовательность завершается числом 0, при считывании которого программа должна закончить свою работу и вывести количество членов последовательности (не считая завершающего числа 0). Числа, следующие за числом 0, считывать не нужно.

  • Пример ввода:
    1
    7
    9
    0
    5
    Пример вывода:
    3
  • with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        subtype New_Int is Integer range 0..Integer'Last;
        --n - целое число, cnt - счётчик
        n, cnt : New_Int;  --т.к. n по условию неотрицательное число,
                           --а счётчик отрицательным быть не может
    begin
        Get(n);
        cnt := 0;
     
        while n /= 0 loop
            cnt := cnt + 1;
            Get(n);
        end loop;
     
        Put(Item => cnt, Width => 1);    
    end main;


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

    Вводится последовательность целых чисел, оканчивающаяся числом 0 (само число 0 в последовательность не входит, а служит как признак ее окончания.

  • Последовательность: 3 6 8 0
    Сумма: 17
  • with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        n, sum : Integer;
    begin
        sum := 0;
     
        Put("Последовательность: "):
        Get(n);
        while n /= 0 loop
            sum := sum + n;
            Get(n);
        end loop;
     
        Put("Сумма: ");
        Put(Item => sum, Width => 1);
    end main;


  • Последовательность состоит из целых неотрицательных чисел и завершается числом 0. Определите значение наибольшего элемента последовательности.

    Вводится последовательность целых чисел, оканчивающаяся числом 0 (само число 0 в последовательность не входит, а служит как признак ее окончания).

  • Последовательность: 1 7 9 0
    Наибольший элемент: 9
  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        subtype New_Int is Integer range 0..Integer'Last;
        n, max : New_Int;
    begin
        Put("Последовательность: "):
        Get(n);
        max := n;                 --Предположим, что первое считанное число является максимальным
     
        while n /= 0 loop         --Пока не прочитан 0
            if n > max then       --если считанное число больше максимального, то
                max := n;         --запоминаем новое максимальное
            end if;
            Get(n);               --считываем следующее число
        end loop;
     
        Put("Наибольший элемент: ");
        Put(Item => max, Width => 1);    
    end main;


  • Последовательность состоит из целых неотрицательных чисел и завершается числом 0. Определите, какое количество элементов этой последовательности, равны ее наибольшему элементу.

    Вводится непустая последовательность целых чисел, оканчивающаяся числом 0 (само число 0 в последовательность не входит, а служит как признак ее окончания).

  • Пример 1:
    Последовательность: 1 7 9 0
    Количество элементов, равных наибольшему члену: 1

    Пример 2:
    Последовательность: 1 3 3 1 0
    Количество элементов, равных наибольшему члену:

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        subtype New_Int is Integer range 0..Integer'Last;
        n, max, cnt : New_Int;
    begin
        cnt := 0;               --счётчик
     
        Put("Последовательность: ");
        Get(n);                 --первый элемент последовательности
        max := n;               --Максимальный элемент последовательности
        while n /= 0 loop
            if max = n then     --если найден элемент, равный максимальному
                cnt := cnt + 1;
            elsif n > max then  --если найден элемент, превышающий максимальный
                max := n;
                cnt := 1;
            end if;
            Get(n);
        end loop;
        Put("Количество элементов, равных наибольшему члену: ");
        Put(Item => cnt, Width => 1);
    end main;


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

    Вводится последовательность целых чисел, оканчивающаяся числом 0 (само число 0 в последовательность не входит, а служит как признак ее окончания).

  • Пример 1:
    Последовательность: 4 4 2 3 0
    Второй по величине элемент: 4

    Пример 2:
    Последовательность: 2 1 0
    Второй по величине элемент: 1

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        subtype New_Int is Integer range 0..Integer'Last;
        n, max, sub : New_Int;
    begin
        max := 0;                --максимальный элемент последовательности
        sub := 0;                --второй по величине элемент последовательности
     
        Put("Последовательность: ");
        Get(n);                  --первый элемент последовательности
        while n /= 0 loop        --пока не введён 0
            if sub = 0 and then max /= 0 then  --если второй элемент равен 0, но при этом
                                               --максимальный элемент не равен 0 (т.е.
                                               --фактически мы имеем второй проход по циклу)
                sub := n;        --"заполняем" второй элемент
            end if;
            if n >= max then     --если найден элемент, превышающий максимальный, то
                sub := max;      --второй элемент становится равен текущему максимальному, а
                max := n;        --максимальный элемент - новому максимальному элементу
            end if;
            Get(n);
        end loop;
     
        Put("Второй по величине элемент: ");
        Put(Item => sub, Width => 1);
    end main;


  • Последовательность Фибоначчи определяется так:

    F(0) = 0, F(1) = 1, …, F(n) = F(n−1) + F(n−2).

    По данному числу N определите N-е число Фибоначчи F(N).

  • Номер члена последовательности Фибоначчи: 6
    Ответ: 8
  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        cur, prev, pprev : Integer;
        n, i : Integer;
        --cur - текущий член последовательности
        --prev - предыдущий член последовательности
        --pprev - член последовательности, стоящий перед предыдущим
        --i - номер члена последовательности
    begin
        Put("Номер члена последовательности Фибоначчи: ");
        Get(n);
        pprev := 0; --нулевой член последовательности
        prev := 1;  --первый член последовательности
        i := 2;     --так как нулевой и первый члены заданы, следовательно, продолжать вычисления
                    --будем с члена номер 2
        if n = 0 then
            cur := 0;
        elsif n = 1 then
            cur := 1;
        end if;
     
        --Пробегаем цикл по формуле F(n) = F(n−1) + F(n−2)
        while i <= n loop
            cur := prev + pprev; --текущий член последовательности
            pprev := prev;       --член последовательности, стоящий перед предыдущим
            prev := cur;         --предыдущий член последовательности (равен текущему и нужен
                                 --для вычисления следующего члена)
            i := i + 1;          --номер следующего члена последовательности
        end loop;
     
        Put("Ответ: ");
        Put(Item => cur, Width => 1);
    end main;


  • Последовательность Фибоначчи определяется так:

    F(0) = 0, F(1) = 1, …, F(n) = F(n−1) + F(n−2).

    Дано натуральное число A. Определите, каким по счету числом Фибоначчи оно является, то есть выведите такое число N, что F(N) = A. Если А не является числом Фибоначчи, выведите число -1. Вводится натуральное число A > 1.

  • Введите число: 8
    Ответ: 6
  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        cur, prev, pprev : Integer;
        A, i : Integer;
    begin
        Put("Введите число: "); Get(A);
        pprev := 0; --нулевой член последовательности
        prev := 1;  --первый член последовательности
        cur := 1;
        i := 1;     --так как A > 1 (по условию), номер текущего элемента будет 1
     
        while cur /= A and i /= -1 loop
            cur := prev + pprev;
            pprev := prev;
            prev := cur;
            if cur > A then
                i := -1;
            else
                i := i + 1;
            end if;
        end loop;
     
        Put("Ответ: ");
        Put(Item => i, Width => 1);
    end main;


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

    Вводится последовательность целых чисел, оканчивающаяся числом 0 (само число 0 в последовательность не входит, а служит как признак ее окончания).

  • Последовательность: 1 7 7 9 1 0
    Ответ: 2
  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        subtype New_Int is Integer range 0..Integer'Last;
        cur, prev, res, cnt : New_Int;
    begin
        cnt := 1;                 --счётчик
        res := 0;                 --результат
     
        Put("Последовательность: ");
        Get(prev); Get(cur);      --начальные значения предыдущего и текущего элементов
     
        while cur /= 0 loop
            if prev = cur then    --если предыдущий и текущий элементы равны
                cnt := cnt + 1;
            else
                if cnt > res then --если текущее значение счётчика превышает предыдущее, то
                    res := cnt;   --имеем новый результат
                end if;
                cnt := 1;
            end if;
            prev := cur;
            Get(cur);
        end loop;
     
        Put("Ответ: ");
        Put(Item => res, Width => 1);
    end main;


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

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

    Вводится последовательность целых чисел, оканчивающаяся числом 0 (само число 0 в последовательность не входит, а служит как признак ее окончания).

  • Последовательность: 1 2 1 2 1 0
    Количество строгих локальных максимумов: 2
  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        subtype New_Int is Integer range 0..Integer'Last;
        beg, mid, fin, cnt : New_Int;
    begin
        cnt := 0;          --счётчик
        Put("Последовательность: ");
        Get(beg);          --первый элемент
        if beg /= 0 then
            Get(mid);      --второй элемент
        end if;
        if mid /= 0 then
            Get(fin);      --третий элемент
        end if;
        if beg /= 0 and then mid /= 0 and then fin /= 0 then
     
            while fin /= 0 loop
                if mid > beg and then mid > fin then --проверка на предмет локального максимума
                    cnt := cnt + 1;                  --если локальный максимум обнаружен
                end if;
                beg := mid;
                mid := fin;
                Get(fin);
            end loop;
     
        end if;
        Put("Количество строгих локальных максимумов: ");
        Put(Item => cnt, Width => 1);
    end main;


  • Определите наименьшее расстояние между двумя локальными максимумами последовательности целых неотрицательных чисел, завершающейся числом 0. Если в последовательности нет двух локальных максимумов, выведите число 0.

    Примечание: Расстояние между двумя локальными максимумами рассчитывается как разность индексов (номеров позиций, на которых стоят элементы) этих максимумов. Начальное и конечное значение при этом локальными максимумами не считаются.

    Вводится последовательность целых чисел, оканчивающаяся числом 0 (само число 0 в последовательность не входит, а служит как признак ее окончания).

  • Пример 1:
    Последовательность: 1 2 1 1 2 1 2 1 0
    Наименьшее расстояние между локальными максимумами: 2

    Пример ввода 2:
    Последовательность: 1 2 3 0
    Наименьшее расстояние между локальными максимумами: 0

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        subtype New_Int is Integer range 0..Integer'Last;
        beg, mid, fin : New_Int;      --блок рассматриваемых чисел: первое, второе и третье
        mf, ms, cnt, res : New_Int;
        --mf - первый локальный максимум (его номер)
        --ms - второй локальный максимум (его номер)
        --cnt - счётчик (содержит номер текущего элемента - индекс)
        --res - результат
    begin
        mf := 0;
        ms := 0;
        res := 0;
        Put("Последовательность: ");
        Get(beg); Get(mid); Get(fin);
        cnt := 3;
        while fin /= 0 loop
            if mid > beg and then mid > fin then
                mf := ms;
                ms := cnt;
                if res /=0 and then mf /= 0 and then ms /=0 and then (ms - mf) < res then
                    res := ms - mf;
                elsif res = 0 then
                    res := ms - mf;
                end if;
            end if;
            beg := mid;
            mid := fin;
            Get(fin);
            cnt := cnt + 1;
        end loop;
        if mf = 0 or ms = 0 then
            res := 0;
        end if;
        Put("Наименьшее расстояние между локальными максимумами: ");
        Put(Item => res, Width => 1);
    end main;


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

4 comments on “Цикл while в языке Ада. Решение тематических задач

  1. Будут ли ещё уроки по адскому программированию ? 🙂

    • Будут. Сейчас немного работой завален - конец года. На подходе темы "записи", "приватные типы", "ссылочные типы", "бинарные файлы" (может, некоторые в одну тему объединю), в планах обработка исключений, ООП и задачи (т.н. параллельное программирование).

      • С нетерпением жду статью по *задачам*. Читал про *задачи* у Ю.Василеску и Алана Бёрнса.
        Вообще классно излагаете материал. 🙂

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

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