ФАС++ 02.10.23

// ConsoleApplication1.cpp : Этот файл содержит функцию "main". Здесь начинается и заканчивается выполнение программы.
//

#include <iostream>
#include <vector>
#include <algorithm>

enum class ArrSortType {increasing, decreasing, nonincreasing, nondecreasing, constant, unsorted, empty};

template <typename T>
ArrSortType array_sort_type(const std::vector<T>& seq)
{
    if (seq.size() == 0)
        return ArrSortType::empty;
    if (seq.size() == 1)
        return ArrSortType::constant;
    int inc = 0, dec = 0, eq = 0;
    for (size_t i = 0; i < seq.size()-1; i++)
    {
        if (seq[i] < seq[i + 1])
            ++inc;
        else if (seq[i + 1] < seq[i])
            ++dec;
        else
            ++eq;
        if (dec > 0 && inc > 0)
            return ArrSortType::unsorted;
    }
    if (inc == seq.size() - 1)
        return ArrSortType::increasing;
    if (dec == seq.size() - 1)
        return ArrSortType::decreasing;
    if (eq == seq.size() - 1)
        return ArrSortType::constant;
    if (dec == 0)
        return ArrSortType::nondecreasing;
    if (inc == 0)
        return ArrSortType::nonincreasing;
    return ArrSortType::unsorted;
}

template <typename T>
bool permutated_arrays(const std::vector<T>& seq1, const std::vector<T>& seq2)
{
    if (seq1.size() != seq2.size())
        return false;
    for (size_t i = 0; i < seq1.size(); i++)
    {
        if (std::count(begin(seq1), end(seq1), seq1[i]) !=
            std::count(begin(seq2), end(seq2), seq1[i]))
            return false;
    }
    return true;
}

//проверяет последовательности на перестановочность, меняя сами последовательности на отсортированные
template <typename T>
bool permutated_arrays(T* seq1, T* seq2, size_t size)
{
    if (size == 0)
        return true;
    if (seq1 == nullptr || seq2 == nullptr)
        return false;
    std::sort(seq1, seq1 + size);
    std::sort(seq2, seq2 + size);
    return std::equal(seq1, seq1 + size, seq2, seq2 + size);
}

struct rectangle
{
    double x1, y1;
    double x2, y2;
};

struct segment
{
    double a, b;
};

//находит длину объединения отрезков
double segments_union_length(std::vector<segment>& s)
{
    res = 0.0;
    return res;
}

double rectangles_union_area(const std::vector<rectangle>& rect)
{
    if (rect.size() == 0)
        return 0.0;
    std::vector<double> x;
    for (const auto& r : rect)
    {
        x.push_back(r.x1);
        x.push_back(r.x2);
    }
    std::sort(begin(x), end(x));
    x.erase(std::unique(begin(x), end(x)), end(x));
    double res = 0.0;
    for (size_t i = 0; i < x.size()-1; i++)
    {
        std::vector<segment> s;
        for (const auto& r : rect)
            if (std::min(r.x1, r.x2) <= x[i] && x[i + 1] <= std::max(r.x1, r.x2))
                s.push_back({ r.y1,r.y2 });
        res += (x[i + 1] - x[i]) * segments_union_length(s);
    }
    return res;
}

double rectangles_union_area_v2(const std::vector<rectangle>& rect)
{
    if (rect.size() == 0)
        return 0.0;
    std::vector<double> x,y;
    for (const auto& r : rect)
    {
        x.push_back(r.x1);
        x.push_back(r.x2);
        y.push_back(r.y1);
        y.push_back(r.y2);
    }
    std::sort(begin(x), end(x));
    x.erase(std::unique(begin(x), end(x)), end(x));
    std::sort(begin(y), end(y));
    y.erase(std::unique(begin(y), end(y)), end(y));

    double res = 0.0;
    for (size_t i = 0; i < x.size() - 1; i++)
    {
        for (size_t j = 0; j < y.size()-1; j++)
        {
            double a = (x[i] + x[i + 1]) / 2;
            double b = (y[i] + y[i + 1]) / 2;
            for (const auto& r : rect)
            {
                if (std::min(r.x1, r.x2) < a && a < std::max(r.x1, r.x2) < a
                    && std::min(r.y1, r.y2) < b && b < std::max(r.x1, r.x2))
                {
                    res += (x[i + 1] - x[i]) * (y[j + 1] - y[j]);
                    break;
                }
            }
        }
    }
    return res;
}


int main()
{
    int a[] = { 1,0,2,9,3,8,4,7,5,6 };
    int b[] = { 0,9,8,7,6,5,4,3,2,1 };
    std::cout << permutated_arrays(a, b, 10) << std::endl;
    std::cout << "Hello World!\n";
}

// Запуск программы: CTRL+F5 или меню "Отладка" > "Запуск без отладки"
// Отладка программы: F5 или меню "Отладка" > "Запустить отладку"

// Советы по началу работы
//   1. В окне обозревателя решений можно добавлять файлы и управлять ими.
//   2. В окне Team Explorer можно подключиться к системе управления версиями.
//   3. В окне "Выходные данные" можно просматривать выходные данные сборки и другие сообщения.
//   4. В окне "Список ошибок" можно просматривать ошибки.
//   5. Последовательно выберите пункты меню "Проект" > "Добавить новый элемент", чтобы создать файлы кода, или "Проект" > "Добавить существующий элемент", чтобы добавить в проект существующие файлы кода.
//   6. Чтобы снова открыть этот проект позже, выберите пункты меню "Файл" > "Открыть" > "Проект" и выберите SLN-файл.