Двумерные массивы в языке Ада. Решение тематических задач

Для решения задач этого раздела я рекомендую ознакомиться с материалом статьи «Двумерные массивы в языке Ада. Введение».

  • Дано нечетное число n, не превосходящее 15. Создайте двумерный массив из n×n элементов, заполнив его символами "." (каждый элемент массива является строкой из одного символа). Затем заполните символами "*" среднюю строку массива, средний столбец массива, главную диагональ и побочную диагональ. В результате "*" в массиве должны образовывать изображение звездочки. Выведите полученный массив на экран, разделяя элементы массива пробелами.

  • Введите размер массива (нечётное число от 1 до 15): 5
    Ответ:

    * . * . *
    . * * * .
    * * * * *
    . * * * .
    * . * . *

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        type MasSize is new Integer range 1..15;
        type Matrix is array(MasSize range <>, MasSize range <>) of Character;
        n : MasSize;
     
        function Get_Range return MasSize is
        --Считывает размер массива с клавиатуры
            n : MasSize;
        begin
            Put("Введите размер массива (нечётное число от 1 до 15): ");
            Get(Integer(n));
     
            --По условию задачи нам нужно нечётное количество строк и столбцов.
            --Делаем проверку этого условия.
            --Проверка приведена просто для примера, как один из возможных вариантов.
            --В следующих задачах я такой проверки делать не буду. К тому же можно 
            --изначально задать тип, который не будет включать в себя чётные числа.
            if n rem 2 = 0 then
              while n rem 2 = 0 loop
                Put("Введено чётное число. Введите размер массива (нечётное число от 1 до 15): ");
                Get(Integer(n));
              end loop;
            end if;
     
            return n;
        end Get_Range;
     
        procedure Show_Mas(mas : in Matrix) is
        --Выводит содержимое двумерного массива на экран
        begin
            for i in mas'Range(1) loop
                for j in mas'Range(2) loop
                    Put(mas(i, j));
                    Put(" ");
                end loop;
                New_Line;
            end loop;
        end Show_Mas;
     
    begin
        n := Get_Range;
        declare
            --Объявление массива и его одновременное заполнение символом '.'
            --в соответствии с условием задачи
            mas : Matrix(1..n, 1..n) := (others => (others => '.'));
        begin
     
            --Заполняем среднюю строку массива символом '*'
            for j in mas'Range(2) loop
                mas((mas'Last(1) / 2) + 1, j) := '*'; --индекс средней строки равен
                                                      --количеству строк делённому на 2 плюс 1
            end loop;
     
            --Заполняем средний столбец массива символом '*'
            for i in mas'Range(1) loop
                mas(i, (mas'Last(2) / 2) + 1) := '*'; --индекс среднего столбца равен
                                                      --количеству столбцов делённому на 2 плюс 1
            end loop;
     
            --Заполняем главную диагональ массива символом '*'
            for i in mas'Range(1) loop
                for j in mas'Range(2) loop
                    if i = j then     --индексы строки и столбца главной диагонали равны
                        mas(i, j) := '*';
                    end if;
                end loop;
            end loop;
     
            --Заполняем побочную диагональ массива символом '*'
            for i in mas'Range(1) loop
                for j in mas'Range(2) loop
                    if i + j = n + 1 then   --сумма индексов строк и столбцов побочной
                                            --диагонали на 1 больше размера массива
                        mas(i, j) := '*';
                    end if;
                end loop;
            end loop;        
     
            --Вывод массива на экран
            Put_Line("Ответ:");
            Show_Mas(mas);
        end;
    end main;


  • Дано число n, не превышающее 100. Создайте массив размером n×n и заполните его по следующему правилу. На главной диагонали должны быть записаны числа 0. На двух диагоналях, прилегающих к главной, числа 1. На следующих двух диагоналях числа 2, и т.д.

  • Размер массива: 5
    Итоговый массив:

    0 1 2 3 4
    1 0 1 2 3
    2 1 0 1 2
    3 2 1 0 1
    4 3 2 1 0

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        type MasSize is new Integer range 1..100;
        type Matrix is array(MasSize range <>, MasSize range <>) of Integer;
        n : MasSize;
    begin
        Put("Размер массива: ");
        Get(Integer(n));
        declare
            mas : Matrix(1..n, 1..n);
        begin
            for i in mas'Range(1) loop
                for j in mas'Range(2) loop
                    if i = j then
                        mas(i, j) := 0;
                    else
                        mas(i, j) := abs(Integer(i - j));
                    end if;
                end loop;
            end loop;
     
            Put_Line("Итоговый массив: ");
            for i in mas'Range(1) loop
                for j in mas'Range(2) loop
                    Put(Item => mas(i, j), Width => 1);
                    Put(" ");
                end loop;
                New_Line;
            end loop;
        end;
    end main;


  • Дан двумерный массив и два числа: i и j. Поменяйте в массиве столбцы с номерами i и j. Программа получает на вход размеры массива n и m, не превосходящие 100, затем элементы массива, затем числа i и j.

  • Размерность массива (два целых числа): 3 4
    Введите массив 3 х 4:

    11 12 13 14
    21 22 23 24
    31 32 33 34

    Какие столбцы нужно поменять местами (два числа): 1 2
    Итоговый массив:

    12 11 13 14
    22 21 23 24
    32 31 33 34

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        type MasSize is new Integer range 1..100;
        type Matrix is array(MasSize range <>, MasSize range <>) of Integer;
        n, m : MasSize;
        ch_i, ch_j : MasSize;
        tmp : Integer;
    begin
        Put("Размерность массива (два целых числа): ");
        Get(Integer(n)); Get(Integer(m));
     
        declare
            mas : Matrix(1..n, 1..m);
        begin
            Put_Line("Введите массив" & Integer'image(Integer(n)) & " х" & Integer'image(Integer(m)) & ":");
            for i in mas'Range(1) loop
                for j in mas'Range(2) loop
                    Get(mas(i, j));
                end loop;
            end loop;
     
            Put("Какие столбцы нужно поменять местами (два числа): ");
            Get(Integer(ch_i)); Get(Integer(ch_j));
     
            --обмен столбцов местами
            for i in 1..mas'Last(1) loop
                tmp := mas(i, ch_i);
                mas(i, ch_i) := mas(i, ch_j);
                mas(i, ch_j) := tmp;
            end loop;
     
            --вывод массива
            Put_Line("Итоговый массив: ");
            for i in mas'Range(1) loop
                for j in mas'Range(2) loop
                    Put(Item => mas(i, j), Width => 1);
                    Put(" ");
                end loop;
                New_Line;
            end loop;
        end;    
    end main;


  • Дано число n, не превосходящее 10, и массив размером n × n. Проверьте, является ли этот массив симметричным относительно главной диагонали. Выведите слово “Да”, если массив симметричный, и слово “Нет” в противном случае.

  • Размерность массива: 3

    Массив 3 х 3:

    0 1 2
    1 2 3
    2 3 4

    Ответ: Да

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        subtype MasSize is Integer range 1..10;
        type Matrix is array(MasSize range <>, MasSize range <>) of Integer;
        n : MasSize;
        sim : Boolean := true; --Предположим, что изначально массив симметричен относительно главной диагонали
    begin
        Put("Размерность массива: ");
        Get(n);
        declare
            mas : Matrix(1..n, 1..n);
        begin
            --ввод массива
            Put_Line("Массив" & Integer'image(n) & " x" & Integer'image(n) & ":");
            for i in mas'Range(1) loop
                for j in mas'Range(2) loop
                    Get(mas(i, j));
                end loop;
            end loop;
     
            --Проверка массива на симметричность
            Verify:                                   --Присвоим внешнему циклу метку
            for i in mas'Range(1) loop
                for j in mas'Range(2) loop
                    --условие симметричности
                    if i /= j then
                        --Если есть хотя бы одна пара несимметричных элементов,
                        if mas(i, j) /= mas(j, i) then
                            sim := false;
                            --то дальше нет смысла проверять, выходим из внешнего цикла
                            exit Verify;
                        end if;
                    end if;
                end loop;
            end loop Verify;                --Конец цикла с меткой Verify    
        end;
     
        if sim = true then
            Put("Да");
        else
            Put("Нет");
        end if;
    end main;


  • Дан квадратный двумерный массив размером n × n и число k. Выведите элементы k-й по счету диагонали ниже главной диагонали (т.е. если k = 1, то нужно вывести элементы первой диагонали, лежащей ниже главной, если k = 2, то второй диагонали и т.д.). Значение k может быть отрицательным, например, если k = −1, то нужно вывести значение первой диагонали лежащей выше главной. Если k = 0, то нужно вывести элементы главной диагонали. Программа получает на вход число n, не превосходящие 10, затем массив размером n × n, затем число k.

  • Пример 1:

    Размер массива: 4
    Массив 4 х 4:

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

    Номер диагонали: 1
    Ответ:

    5 1 6

    Пример 2:

    Размер массива: 4

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

    Номер диагонали: -2
    Ответ:

    3 8

  • 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 <>, Integer range <>) of Integer;
        n, k, j, i : Integer;
    begin
        Put("Размер массива: ");
        Get(n);
        declare
            mas : Matrix(1..n, 1..n);
        begin
            Put_Line("Массив" & Integer'image(n) & " x" & Integer'image(n) & ": ");
            for i in mas'Range(1) loop
                for j in mas'Range(2) loop
                    Get(mas(i, j));
                end loop;
            end loop;
            Put("Номер диагонали: ");
            Get(k);
     
            Put_Line("Ответ:");
            if k > 0 then
                j := 1;
                for i in (k + 1)..mas'Last(1) loop
                    Put(Item => mas(i, j), Width => 1);
                    Put(" ");
                    j := j + 1;
                end loop;
            elsif k < 0 then
                i := 1;
                for j in (-k + 1)..mas'Last(2) loop
                    Put(Item => mas(i, j), Width => 1);
                    Put(" ");
                    i := i + 1;
                end loop;
            end if;
        end;
    end main;


  • Дан двумерный массив размером n×m (n и m не превосходят 1000). Для данного массива постройте транспонированный массив (транспонированный массив - это когда первая строка становится первым столбцом, вторая строка - вторым столбцом и т.д.) и выведите его на экран.

    Если массив А имеет размерность (MxN), то массив B, симметричный ему относительно главной диагонали, называется транспонированным к массиву А. Массив В имеет размерность (MxN): строки исходного массива F становятся столбцами транспонированного к нему массива В, столбцы исходного массива становятся строками транспонированного.

  • Размерность массива (N и M): 3 4

    Массив 3 х 4:

    11 12 13 14
    21 22 23 24
    31 32 33 34

    Ответ :

    11 21 31 
    12 22 32 
    13 23 33 
    14 24 34

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        subtype Index is Integer range 1..1000;  --можно использовать и type, но я взял subtype для
                                                 --напоминания, что так тоже можно
        type Matrix is array(Index range <>, Index range <>) of Integer;
        n, m, i, j : Index;
    begin
        Put("Размерность массива (N и M): ");
        Get(n); Get(m);
        declare
            masA : Matrix(1..n, 1..m);
            masB : Matrix(1..m, 1..n);
        begin
            Put_Line("Массив:");
            for i in masA'Range(1) loop
                for j in masA'Range(2) loop
                    Get(masA(i, j));
                end loop;
            end loop;
     
            --Для разнообразия используем цикл while
            i := masA'First(1);
            j := masA'First(2);
            while i <= masA'Last(1) loop
                while j <= masA'Last(2) loop
                    masB(j, i) := masA(i, j);
                    j := j + 1;
                end loop;
                i := i + 1;
                j := 1;
            end loop;
     
            Put_Line("Ответ:");
            for i in masB'Range(1) loop
                for j in masB'Range(2) loop
                    Put(Item => masB(i, j), Width => 1);
                    Put(" ");
                end loop;
                New_Line;
            end loop;
        end;
    end main;


  • В кинотеатре n рядов по m мест в каждом (n и m не превосходят 20). В двумерном массиве хранится информация о проданных билетах, число 1 означает, что билет на данное место уже продан, число 0 означает, что место свободно. Поступил запрос на продажу k билетов на соседние места в одном ряду. Определите, можно ли выполнить такой запрос.

    Программа получает на вход числа n и m. Далее идет n строк, содержащих m чисел (0 или 1), разделенных пробелами. Затем дано число k. Программа должна вывести номер ряда, в котором есть k подряд идущих свободных мест. Если таких рядов несколько, то выведите номер наименьшего подходящего ряда. Если подходящего ряда нет, выведите число 0.

  • Рядов в кинотеатре: 3

    Мест в каждом ряду: 4

    Массив (информация о занятых и свободных местах):

    0 1 0 1
    1 0 0 1
    1 1 1 1

    Запрос на количество мест (на соседние места): 2

    Удовлетворяющий запросу ряд: 2

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        subtype Cinema is Integer range 1..20;
        subtype Place is Integer range 0..1;
        type Matrix is array(Cinema range <>, Cinema range <>) of Place;
        n, m, k: Cinema;
        sum : Integer := 0;
    begin
        Put("Рядов в кинотеатре: ");
        Get(n);
        Put("Мест в каждом ряду: ");
        Get(m);
        declare
            Places : Matrix(1..n, 1..m);
        begin
            Put_Line("Массив (информация о занятых и свободных местах): ");
            for i in Places'Range(1) loop
                for j in Places'Range(2) loop
                    Get(Places(i, j));
                end loop;
            end loop;
            Put("Запрос на количество мест (на соседние места): ");
            Get(k);
     
            Search: for i in Places'Range(1) loop --Цикл с меткой
                for j in Places'Range(2) loop
                    if Places(i, j) = 0 then
                        sum := sum + 1;
                        --Если найдено нужное количество идущих подряд мест, то
                        if sum = k then
                            sum := i;     --Заносим найденный ряд в переменную sum
                            exit Search;  --И выходим из внешнего цикла.
                        end if;
                    else
                        sum := 0;
                    end if;
                end loop;
                sum := 0;
            end loop Search;
     
            if sum /= 0 then
                Put("Удовлетворяющий запросу ряд:" & Integer'Image(sum));
            else
                Put("Места не обнаружены!");
            end if;
        end;
     
    end main;


  • Дан прямоугольный массив размером n×m. Поверните его на 90 градусов по часовой стрелке, записав результат в новый массив размером m×n.

    Вводятся два числа n и m, не превосходящие 100, затем массив размером n×m. Выведите получившийся массив. Числа при выводе разделяйте одним пробелом.

  • n = 3

    m = 4

    Массив 3 х 4:

    11 12 13 14
    21 22 23 24
    31 32 33 34

    Перевёрнутый массив:

    31 21 11 
    32 22 12 
    33 23 13 
    34 24 14

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        subtype MasSize is Integer range 0..100;
        type Matrix is array(MasSize range <>, MasSize range <>) of Integer;
        n, m : MasSize;
    begin
        Put("n = ");
        Get(n);
        Put("m = ");
        Get(m);
        declare
            mas : Matrix(1..n, 1..m);
            res_mas : Matrix(1..m, 1..n);
        begin
            Put_Line("Массив" & Integer'image(n) & " x" & Integer'image(m) & ":");
            for i in mas'Range(1) loop
                for j in mas'Range(2) loop
                    Get(mas(i, j));
                end loop;
            end loop;
     
            --В этой задаче можно и не создавать второй массив, а сразу настроить циклы
            --таким образом, чтобы на экран был выведен перевёрнутый массив.
            --Однако по условию задачи нам нужно создать ещё один массив.
            for j in mas'Range(2) loop
                for i in reverse mas'Range(1) loop
                    res_mas(j, (mas'Last(1) - i + 1)) := mas(i, j);
                end loop;
            end loop;
     
            Put_Line("Перевёрнутый массив:");
            for i in res_mas'Range(1) loop
                for j in res_mas'Range(2) loop
                    Put(Item => res_mas(i, j), Width => 1);
                    Put(" ");
                end loop;
                New_Line;
            end loop;
        end;
    end main;


  • По данным числам n и m заполните двумерный массив размером n×m числами от 1 до n×m “змейкой”, как показано в примере. Вводятся два числа n и m, каждое из которых не превышает 30. Выведите полученный массив, отводя на вывод каждого элемента ровно 4 символа.

  • Размерность массива (n m): 3 5

       1   2   3   4   5
      10   9   8   7   6
      11  12  13  14  15

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        subtype Snake is Integer range 1..30;
        n, m : Snake;
        type Matrix is array(Snake range <>, Snake range <>) of Integer;
        Num, i, j :Integer;
        right : Boolean := True;      --Направление заполнения строки массива
    begin
        Put("Размерность массива (n m): ");
        Get(n); Get(m);
     
        Num := 1; --Количество элементов массива (порядковый номер текущего элемента)
        i := 1;   --Счётчик строк
        j := 1;   --Счётчик столбцов
     
        declare
            mas : Matrix(1..n, 1..m);
        begin
            for Num in 1..(n * m) loop      --Количество элементов массива будет равно n * m
                mas(i, j) := Num;           --Записать текущее значение Num в позицию (i, j)
                if right = True then        --Заполнение строки массива слева направо
                    j := j + 1;
                    --если расчётный номер столбца превысил количество допустимых
                    --столбцов в массиве, то
                    if j > mas'Last(2) then
                        --переходим к заполнению следующей строки
                        i := i + 1;
                        --номер текущего столбца равен последнему допустимому
                        --столбцу массива
                        j := mas'Last(2);
                        --метка, что заполнение следующей строки массива будет
                        --происходить справа налево
                        right := False;
                    end if;
                elsif right = False then    --Заполнение строки массива справа налево
                    j := j - 1;
                    --если расчётный номер столбца меньше 1, то
                    if j < 1 then
                        --переходим к заполнению следующей строки
                        i := i + 1;
                        --номер текущего столбца равен первому столбцу массива
                        j := 1;
                        ----метка, что заполнение следующей строки массива будет
                        происходить слева направо
                        right := True;
                    end if;
                end if;
            end loop;
     
            --Вывод массива на экран
            for i in mas'Range(1) loop
                for j in mas'Range(2) loop
                    Put(Item => mas(i, j), Width => 4);
                end loop;
                New_Line;
            end loop;
        end;
    end main;


  • По данным числам n и m заполните двумерный массив размером n×m числами от 1 до n×m “диагоналями”, как показано в примере. Вводятся два числа n и m, не превышающие 100. Выведите полученный массив, отводя на вывод каждого элемента ровно 4 символа.

  • Введите размерность массива (n, m): 3 5
    Итоговый массив:

       1   2   4   7  10
       3   5   8  11  13
       6   9  12  14  15

  • with Ada.Text_IO; use Ada.Text_IO;
    with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
     
    procedure main is
        subtype MasSize is Integer range 0..100;  --размерность начинается с 0, т.к. это нужно 
                                                  --для проверки значений в циклах (см. код ниже)
        n, m: MasSize range 1..100; --Так как подтип допускает значение 0, а размерность 0 быть 
                                    --не может, определим диапазон возможных значений
        type Matrix is array (MasSize range <>, MasSize range <>) of Integer;
    begin
        Put("Введите размерность массива (n, m): ");
        Get(n);
        Get(m);
        declare
            mas : Matrix(1..n, 1..m);
            i, j, l : MasSize;
            cnt : Integer := 1;
        begin
            --Заполняем первую часть по столбцам (до последнего столбца)
            for j in 1..mas'Last(2) loop
                l := j;
                i := 1;
                while l >= 1 and then i <= mas'Last(1) loop
                    mas(i, l) := cnt;
                    l := l - 1;
                    i := i + 1;
                    cnt := cnt + 1;
                end loop;
            end loop;
     
            --Заполняем вторую часть по строкам (до последней строки и последнего столбца)
            for i in 2..mas'Last(1) loop
                l := i;
                j := mas'Last(2);
                while l <= mas'Last(1) loop
                    mas(l, j) := cnt;
                    cnt := cnt + 1;
                    l := l + 1;
                    j := j - 1;
                end loop;
            end loop;
     
            for i in mas'Range(1) loop
                for j in mas'Range(2) loop
                    Put(Item => mas(i, j), Width => 4);
                end loop;
                New_Line;
            end loop;
        end;
    end;


  • Дан массив NxN, где N не превышает 10. Заполните двумерный массив размером N×N числами от 1 до N*N змейкой, как показано в примере. Выведите полученный массив, отводя на вывод каждого элемента ровно 4 символа.

  • Размерность массива (от 1 до 10): 5

    Итоговый массив:

       1   2   3   4   5
      16  17  18  19   6
      15  24  25  20   7
      14  23  22  21   8
      13  12  11  10   9

  • with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
    with Ada.Text_IO; use Ada.Text_IO;
     
    procedure main is
        subtype Index is Integer range 0..11;    --Индекс массива. 0 и 11 понадобятся для проверки
                            --выхода за границы массива
        subtype Elements is Integer range 1..100; --Элементы массива
        type Matrix is array(Index range <>, Index range <>) of Elements;
        type Direction is (left, right, down, up); --Направление обхода массива
        n, first_row, first_col, end_row, end_col : Elements;    --текущие границы массива (т.к массив будет
                                    --сужаться по мере заполнения)
        max : Integer; --максимальный элемент массива
        i, j : Index;
        dir : Direction;
    begin
        Put("Размерность массива (от 1 до 10): ");
        Get(n);
        declare
            mas : Matrix(1..n, 1..n);
        begin
            max := 1;
            i := 1;
            j := 1;
            dir := right; --начинаем двигаться вправо
            first_col := 1;
            first_row := 1;
            end_row := n;
            end_col := n;
            while max <= n * n loop
                mas(i, j) := max; --установили текущий элемент массива
                max := max + 1;   --следующий элемент масcива
                --далее меняем индексы массива
                case dir is
                  when right => j := j + 1; --если двигаемся вправо
                        --если вышли за правую границу массива
                        if j > end_col then
                            --восстанавливаем текущий столбец (т.к. вышел за границу)
                            j := end_col;
                            i := i + 1;     --переходим к следующей строке массива
                            --задаём дальнейшее направление движения - вниз
                            dir := down;
                            --сужаем массив на одну строку (т.к. строка заполнена).
                            first_row := first_row + 1;
                        end if;
                  when down => i := i + 1;
                        if i > end_row then
                            i := end_row;
                            j := j - 1;
                            dir := left;
                            end_col := end_col - 1;
                        end if;
                  when left => j := j - 1;
                        if j < first_col then
                            j := first_col;
                            i := i - 1;
                            dir := up;
                            end_row := end_row - 1;
                        end if;
                  when up => i := i - 1;
                        if i < first_row then
                            i := first_row;
                            j := j + 1;
                            dir := right;
                            first_col := first_col + 1;
                        end if;
                end case;
            end loop;
     
            for i in 1..n loop
                for j in 1..n loop
                    Put(Item => mas(i, j), Width => 4);
                end loop;
                New_Line;
            end loop;
        end;
    end main;


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

One comment on “Двумерные массивы в языке Ада. Решение тематических задач

  1. Мне кажется,можно было бы давать некоторые сравнения с известными языками программирования.
    Пример: массивы с неуточненными границами в Ада это динамические массивы в Си. 🙂

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

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