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

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

  • Дано положительное действительное число X. Выведите его первую цифру после десятичной точки.

  • Введите число: 1.79
    Ответ: 7
  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Float_Text_IO; use Ada.Float_Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        n : Float;
        d : Integer;               --Здесь будет храниться результат (целое число)
    begin
        Put("Введите число: ");
        Get(n);
     
        n := n - Float'Floor(n);   --получаем дробную часть числа
        n := n * 10.0;             --первую цифру дробной части "перегоняем" в целую часть
                                   --(до точки)
        n := Float'Floor(n);       --Отбрасываем дробную часть
        d := Integer(n);           --Получаем одну единственную цифру
    -- Все приведённые выше действия можно записать одной строкой:
    -- d := Integer(Float'Floor((n - Float'Floor(n)) * 10.0));
        Put("Ответ: ");
        Put(Item => d, Width => 1);
    end main;


  • Даны длины сторон треугольника. Вычислите площадь треугольника.

  • Три стороны треугольника: 3 4 5
    Площадь треугольника: 6
  • Для решения этой задачи Вам понадобится функция нахождения квадратного корня числа. Для этого в Аде используется функция sqrt(). Её описание и реализация (как и многих других простых математических функций) содержится в пакете Ada.Numerics.Elementary_Functions. Этот пакет содержит описание основных математических функций (синус, косинус, тангенс, котангенс, логарифм, возведение в степень, корень, арксинус, арккосинус и т.д.).

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Float_Text_IO; use Ada.Float_Text_IO;
    --Для использования Sqrt()
    with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;
     
    procedure main is
        a, b, c : Float;
        p, s : Float;
    begin
        Put("Три стороны треугольника: ");
        Get(a); Get(b); Get(c);
        p := (a + b + c) / 2.0;                      --Полупериметр
        --По формуле из школьного курса геометрии ищем результат
        s := sqrt(p * (p - a) * (p - b) * (p - c));
        Put("Площадь треугольника: ");
        Put(Item => s, Fore => 1, Aft => 2, Exp => 0);
    end main;


  • Процентная ставка по вкладу составляет P процентов годовых, которые прибавляются к сумме вклада в конце года. Вклад составляет X рублей Y копеек. Определите размер вклада через год. При решении этой задачи нельзя пользоваться условными инструкциями и циклами. Программа получает на вход целые числа P, X, Y. Программа должна вывести два числа: величину вклада через год в рублях и копейках. Дробная часть копеек отбрасывается.

  • Процент по вкладу (годовых): 12
    Вклад (рублей): 179
    Вклад (копеек): 0
    Величина вклада через год: 200 48
  • В этой задаче Вам, возможно, понадобится округлить число с плавающей точкой по правилам математики. Для этого можно воспользоваться оператором округления Float'Rounding(). Также напоминаю о существовании оператора округления вниз Float'Floor().

  • with Ada.Float_Text_IO; use Ada.Float_Text_IO;
    with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        p, x, y : Float;
    begin
        Put("Процент по вкладу (годовых): "); Get(p);
        Put("Вклад (рублей): "); Get(x);
        Put("Вклад (копеек): "); Get(y);
     
        x := x * 100.0 + y;
        x := x + x * p / 100.0;
        y := Float'Rounding(((x / 100.0) - Float'Floor(x / 100.0)) * 100.0);
        x := Float'Floor(x / 100.0);
     
        Put("Величина вклада через год: ");
        Put(Item => Integer(x), Width => 1);
        Put(" рублей ");
        Put(Item => Integer(y), Width => 1);
        Put(" копеек ");
    end main;


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

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

  • Последовательность: 1 7 9 0
    Ответ: 5.66666666667
  • Так как итоговый вывод содержит большое количество цифр после запятой, а следовательно, нужна более высокая точность, чем может дать тип Float, будем использовать в этой задаче тип Long_Float.

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Long_Float_Text_IO; use Ada.Long_Float_Text_IO;
     
    procedure main is
        --несмотря на то, что на вход по условию подаются целые числа, мы для их чтения
        --будем использовать переменную типа Long_Float
        n, sum, cnt : Long_Float;
    begin
        sum := 0.0;    --сумма элементов последовательности
        cnt := 0.0;    --количество элементов последовательности
        Put("Последовательность: ");
        loop
            Get(n);
            exit when n = 0.0;
            sum := sum + n;
            cnt := cnt + 1.0;
        end loop;
        n := sum / cnt;
        Put("Ответ: ");
        Put(Item => n, Fore => 1, Aft => 10, Exp => 0);
    end main;


  • Дана последовательность натуральных чисел x1, x2, ..., xn. Стандартным отклонением называется величина

    q = SQRT(((x1 - S)2 + (X2 - S)2 + ... + (Xn - S)2) / (n - 1))

    где S = (X1 + X2 + ... + Xn) / n - среднее значение последовательности.

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

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

  • Последовательность: 1 7 9 0
    Стандартное отклонение: 4.16333199893
  • Как уже было сказано выше, для извлечения квадратного корня из числа типа Float используется функция sqrt() из пакета Ada.Numerics.Elementary_Functions. Однако подключение данного пакета напрямую (with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;) позволяет работать только с типом Float, а вот с типом Long_Float или Long_Long_Float будут проблемы. Для решения этой задачи нам понадобится типа Long_Float. Чтобы извлечь квадратный корень из числа типа Long_Float мы будем использовать так называемый дженерик Ada.Numerics.Generic_Elementary_Functions (дженерик - это фактически шаблон, аналог template в языке С++). Его использование несколько отличается от использования пакета Ada.Numerics.Elementary_Functions. Это более универсальный способ и позволяет работать с любым плавающим типом (включая Float).

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Long_Float_Text_IO; use Ada.Long_Float_Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
    with Ada.Numerics.Generic_Elementary_Functions; --Дженерик
     
    procedure main is
        --дженерик будет использоваться для Long_Float.
        --Вместо LF_Math можно использовать любое другое имя.
        --Мы "создаем" новый пакет с именем LF_Math, в котором содержится описание
        --элементарных математических функций для типа Long_Float:
        package LF_Math is new Ada.Numerics.Generic_Elementary_Functions (Long_Float);
     
        --Для того, чтобы не писать перед каждой функцией LF_Math.<функция>,
        --например, LF_MATH.sqrt():
        use LF_Math;
     
        x, sPow, sum, n : Integer;
        res, s : Long_Float;
    begin
        spow := 0;                   --сумма квадратов членов последовательности
        sum := 0;                    --сумма членов последовательности
        n := 0;                      --количество членов последовательности
     
        Put("Последовательность: ");
        loop
            Get(x);                  --Очередной элемент последовательности
            exit when x = 0;         --Условие выхода из цикла (по условию задачи)
            n := n + 1;              --количество членов последовательности 
            spow := spow + (x * x);  --сумма квадратов членов последовательности
            sum := sum + x;          --сумма членов последовательности
        end loop;
     
        s := Long_Float(sum) / Long_Float(n);  --среднее значение последовательности.
                                               --Используем приведение типа Integer к типу
                                               --Long_Float, т.е. вычисления будут выполнятся
                                               --по правилам дробных чисел
        -- Значение под корнем
        res := ((Long_Float(spow) - 2.0 * Long_Float(s) * Long_Float(sum) +
            Long_Float(n) * Long_Float(s * s)) / Long_Float(n - 1));
        -- Корень
        res := sqrt(res); --можно так: res := res ** 0.5
        Put("Стандартное отклонение: ");
        Put(Item => res, Fore => 1, Aft => 11, Exp => 0);
    end main;


  • Дан многочлен P(x)=anxn + an−1xn−1+ … + a1x + a0 и число x. Вычислите значение этого многочлена, воспользовавшись схемой Горнера: P(x)=(…(((anx + an−1)x + an−2)x + an−3) … )x+ a0

    Сначала программе подается на вход целое неотрицательное число n ≤ 20, затем действительное число x, затем следует n+1 вещественное число - коэффициенты многочлена от старшего к младшему.

    Программа должна вывести значение многочлена.

  • Пример 1:
    1 0.000 1.000 1.000
    Ответ: 1

    Пример 2:
    2 0.500 1.000 1.000 1.000
    Ответ: 1.75

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Long_Float_Text_IO; use Ada.Long_Float_Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        n, i : Integer;
        x, a, res : Long_Float;
    begin
        i := 0;
        Get(n); Get(x); Get(a);
        res := a;         --обработали первый член последовательности
        while i < n loop  --в цикле обрабатываем остальные n членов последовательности
            Get(a);
            res := res  * x + a;
            i := i + 1;
        end loop;
        Put("Ответ: ");
        Put(Item => res, Aft => 2, Exp => 0); --Обратите внимание, что в функции не используется
                                                  --поле Fore. Это допустимо.
    end main;


  • Даны действительные коэффициенты a, b, c, при этом a ≠ 0 . Решите квадратное уравнение ax2 + bx + c = 0 и выведите все его корни.

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

  • a = 1
    b = -1
    c = -2
    Корни уравнения: -1.00 2.00
  • with Ada.Float_Text_IO; use Ada.Float_Text_IO;
    with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Numerics.Generic_Elementary_Functions; --Дженерик
     
    procedure main is
        package FL_Math is new Ada.Numerics.Generic_Elementary_Functions (Float);
        use FL_Math;
        a, b, c : Float;
        d, x1, x2 : Float;
    begin
        Put("a = "); Get(a);
        Put("b = "); Get(b);
        Put("c = "); Get(c);
        d := b * b - 4.0 * a * c;     --Дискриминант
        if d >= 0.0 then              --Если у уравнения есть корни
            x1 := (-b - FL_Math.sqrt(d)) / (2.0 * a);
            if d = 0.0 then           --Если дискриминант = 0, то имеем один корень
                Put("Корень уравнения: ");
                Put(Item => x1, Fore => 1, Aft => 2, Exp => 0);
            else                      --Иначе имеем два корня
                x2 := (-b + FL_Math.sqrt(d)) / (2.0 * a);
                if x1 > x2 then
                    d := x1;
                    x1 := x2;
                    x2 := d;
                end if;
                Put("Корни уравнения: ");
                Put(Item => x1, Fore => 1, Aft => 2, Exp => 0);
                Put(" ");
                Put(Item => x2, Fore => 1, Aft => 2, Exp => 0);
            end if;
        end if;
    end main;


  • Даны действительные коэффициенты a, b, c. Решите уравнение ax2 + bx + c = 0 и выведите все его корни.

    Если данное уравнение не имеет корней, выведите число 0. Если уравнение имеет один корень, выведите число 1, а затем этот корень. Если уравнение имеет два корня, выведите число 2, а затем два корня в порядке возрастания. Если уравнение имеет бесконечно много корней, выведите число 3.

  • a = 1
    b = -1
    c = -2
    Ответ: 2 -1.00 2.00
  • with Ada.Float_Text_IO; use Ada.Float_Text_IO;
    with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Numerics.Generic_Elementary_Functions;
     
    procedure main is
        package FL_Math is new Ada.Numerics.Generic_Elementary_Functions (Float);
        use FL_Math;
        a, b, c : Float;                          --коэффициенты уравнения
        d, x1, x2 : Float;                        --дискриминант и корни уравнения
        tmp : Float;
     
    begin
        Put("a = "); Get(a);
        Put("b = "); Get(b);
        Put("c = "); Get(c);
        Put("Ответ: ");
        if a /= 0.0 and then b /= 0.0 and then c /= 0.0 then
            d := b * b - 4.0 * a * c;              --Дискриминант
            if d >= 0.0 then                       --Если у уравнения есть корни
                x1 := (-b - sqrt(d)) / (2.0 * a);  --Ищем первый корень
                if d = 0.0 then                    --Если у уравнения только один корень
                    Put("1 ");
                    Put(Item => x1, Aft => 2, Exp => 0);
                else                               --Иначе - у уравнения два корня
                    x2 := (-b + sqrt(d)) / (2.0 * a);
                    --Если первый корень больше второго, то меняем корни местами
                    if x1 > x2 then
                        tmp := x1;
                        x1 := x2;
                        x2 := tmp;
                    end if;
                    Put("2 ");
                    Put(Item => x1, Aft => 2, Exp => 0);
                    Put(" ");
                    Put(Item => x2, Aft => 2, Exp => 0);
                end if;
            else                                    --Ели у уравнения нет корней
                Put("0");
            end if;
        elsif a /= 0.0 and then b /= 0.0 and then c = 0.0 then --У уравнения два корня
            x1 := 0.0;
            x2 := -b;
            if x1 > x2 then 
                tmp := x1;
                x1 := x2;
                x2 := tmp;
            end if;
            Put("2 ");
            Put(Item => x1, Aft => 2, Exp => 0);
            Put(" ");
            Put(Item => x2, Aft => 2, Exp => 0);
        elsif a /= 0.0 and then b = 0.0 and then c /= 0.0 then
            if c > 0.0 then                                    --У уравнения нет корней
                Put("0");
            else                                               --У уравнения два корня
                x1 := sqrt(-c);
                x2 := -x1;
                if x1 > x2 then
                    tmp := x1;
                    x1 := x2;
                    x2 := tmp;
                end if;
                Put("2 ");
                Put(Item => x1, Aft => 2, Exp => 0);
                Put(" ");
                Put(Item => x2, Aft => 2, Exp => 0);
            end if;
        elsif a /= 0.0 and then b = 0.0 and then c = 0.0 then  --Если у уравнения много корней
            Put("3");
        elsif a = 0.0 and then b /= 0.0 then                   --У уравнения один корень
            if c = 0.0 then
                x1 := 0.0;        
            else
                x1 := (-1.0) * c / b;
            end if;
            Put("1 ");
            Put(Item => x1, Aft => 2, Exp => 0);
        elsif a = 0.0 and then b = 0.0 then                    --У уравнения нет корней
            Put("0");
        end if;
    end main;


  • Даны вещественные числа a, b, c, d, e, f. Известно, что система линейных уравнений имеет ровно одно решение. Выведите два числа x и y, являющиеся решением этой системы.
    ax + by = e
    cx + dy = f

    Вводятся шесть чисел - коэффициенты уравнений системы.

  • a = 1
    b = 0
    c = 0
    d = 1
    e = 3
    f = 3
    Ответ: 3.00 3.00
  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Float_Text_IO; use Ada.Float_Text_IO;
     
    procedure main is
        a, b, c, d, e, f : Float;
        x, y : Float;
    begin
        Put("a = "); Get(a);
        Put("b = "); Get(b);
        Put("c = "); Get(c);
        Put("d = "); Get(d);
        Put("e = "); Get(e);
        Put("f = "); Get(f);
        y := (f * a - c * e) / (a * d - c * b);
        x := (e - b * y) / a;
     
        Put("Ответ: ");
        Put(Item => x, Fore => 1, Aft => 2, Exp => 0);
        Put(" ");
        Put(Item => y, Fore => 1, Aft => 2, Exp => 0);
    end;


  • Даны вещественные числа a, b, c, d, e, f. Решите систему линейных уравнений
    ax + by = e
    cx + dy = f

    Вводятся шесть чисел - коэффициенты уравнений системы.

    Вывод программы зависит от вида решения этой системы.

    • Если система не имеет решений, то программа должна вывести единственное число 0.
    • Если система имеет бесконечно много решений, каждое из которых имеет вид y=kx+b, то программа должна вывести число 1, а затем значения k и b.
    • Если система имеет единственное решение (x0, y0), то программа должна вывести число 2, а затем значения x0 и y0.
    • Если система имеет бесконечно много решений вида x=x0, y — любое, то программа должна вывести число 3, а затем значение x0.
    • Если система имеет бесконечно много решений вида y=y0, x — любое, то программа должна вывести число 4, а затем значение y0.
    • Если любая пара чисел (x, y) является решением, то программа должна вывести число 5.

  • Пример 1:
    a = 1
    b = 0
    c = 0
    d = 1
    e = 3
    f = 3
    Ответ: 2 3.00 3.00

    Пример 2:
    a = 1
    b = 1
    c = 2
    d = 2
    e = 1
    f = 2
    Ответ: 1 -1.00 1.00

    Пример 3:
    a = 0
    b = 2
    c = 0
    d = 4
    e = 1
    f = 2
    Ответ: 4 0.5

    Пример 4:
    a = 2
    b = 3
    c = 4
    d = 6
    e = 1
    f = 2
    Ответ: 1 -0.666667 0.333333

    Пример 5:
    a = 0
    b = 1
    c = 0
    d = 3
    e = 5
    f = 15
    Ответ: 4 5.00

    Пример 6:
    a = 1
    b = 0
    c = 1
    d = 0
    e = 3
    f = 3
    Ответ: 3 3.00

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Float_Text_IO; use Ada.Float_Text_IO;
     
    procedure main is
        a, b, c, d, e, f : Float;
        x, y : Float;
        roots : Boolean := True;
    begin
        Get(a); Get(b); Get(c); Get(d); Get(e); Get(f);
        if a /= 0.0 then --a/=0
            b := b / a;
            e := e / a;
            a := a / a;
        elsif b /= 0.0 then --a = 0 and b/=0
            e := e / b;
            b := b / b;
        elsif b = 0.0 and then e /= 0.0 then
            roots := False;
        end if;
        if c /= 0.0 then
            d := d / c;
            f := f / c;
            c := c / c;
        elsif d /= 0.0 then --c = 0 and d /= 0
            f := f / d;
            d := d / d;
        elsif d = 0.0 and then f /= 0.0 then
            roots := False;
        end if;
     
        if roots = False then
            Put("0");
        elsif a = 0.0 and then b /= 0.0 then
            y := e / b;
            if c = 0.0 then -- x - любое, y = e или f
                if e / b /= f / d then roots := False; end if;
                if roots = True then
                    Put("4 ");
                    Put(Item => y, Fore => 1, Aft => 2, Exp => 0);
                end if;
            else
                x := (f - d * y) / c;
                Put("2 ");
                Put(Item => x, Fore => 1, Aft => 2, Exp => 0);
                Put(" ");
                Put(Item => y, Fore => 1, Aft => 2, Exp => 0);
            end if;
        elsif a /= 0.0 and then b = 0.0 then --a /= 0 and b = 0
            x := e / a;
            if d = 0.0 then
                if e / a = f / c then
                    Put("3 ");
                    Put(Item => x, Fore => 1, Aft => 2, Exp => 0);
                end if;
            else
                y := (f - c * x) / d;
                Put("2 ");
                Put(Item => x, Fore => 1, Aft => 2, Exp => 0);
                Put(" ");
                Put(Item => y, Fore => 1, Aft => 2, Exp => 0);
            end if;
        elsif a /= 0.0 and then b /= 0.0 then
            if c /= 0.0 and then d /= 0.0 then
                if a * d /= b * c then
                    y := (f * a - c * e) / (a * d - b * c);
                    x := (e - b * y) / a;
                    Put("2 ");
                    Put(Item => x, Fore => 1, Aft => 2, Exp => 0);
                    Put(" ");
                    Put(Item => y, Fore => 1, Aft => 2, Exp => 0);
                else --y = kx + b
                    x := -a / b;
                    y := e / b;
                    Put("1 ");
                    Put(Item => x, Fore => 1, Aft => 2, Exp => 0);
                    Put(" ");
                    Put(Item => y, Fore => 1, Aft => 2, Exp => 0);
                end if;
            elsif c /= 0.0 and then d = 0.0 then
                x := f / c;
                y := (e - a * x) / b;
                Put("1 ");
                Put(Item => x, Fore => 1, Aft => 2, Exp => 0);
                Put(" ");
                Put(Item => y, Fore => 1, Aft => 2, Exp => 0);
            elsif c = 0.0 and then d /= 0.0 then
                y := f / d;
                x := (e - b * y) / a;
                Put("1 ");
                Put(Item => x, Fore => 1, Aft => 2, Exp => 0);
                Put(" ");
                Put(Item => y, Fore => 1, Aft => 2, Exp => 0);        
            end if;
        elsif a = 0.0 and then b = 0.0 and then c = 0.0
              and then d = 0.0 and then e = 0.0 and then f = 0.0 then
            Put("5");
        end if;
    end;


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

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

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