Выбрать четыре разные точки, которые являются вершинами квадрата наибольшего периметра

// Структура, описывающая точку с вещественными координатами
struct point {
    double x;
    double y;    
};
 
// Функция, вычисляющая расстояние между точками A и B по теореме Пифагора
double getDist(const point &A, const point &B) {
    return hypot(A.x - B.x, A.y - B.y);
}
 
// Функция, определяющая, являются ли точки A, B, C и D вершинами квадрата
bool isSquare(const point &A, const point &B, const point &C, const point &D) {
    bool result = true;
    
    // Честно говоря, не уверен, что такой массив одобрят, но с динамикой лень морочиться
    // В массиве храним расстояния между всеми парами точек
    double P[6] = {getDist(A, B), getDist(A, C), getDist(A, D), getDist(B, C), getDist(B, D), getDist(C, D)};
    
    // Простейшая сортировка массива расстояний по возрастанию
    for (int i = 0; i < 5; i++) {
        for (int j = i+1; j < 6; j++) {
            if (P[i] > P[j]) {
                double temp = P[i];
                P[i] = P[j];
                P[j] = temp;
            }
        }
    }
    
    // Каждый элемент делим на значение первого элемента
    for (int i = 5; i >= 0; i--) {
        P[i] /= P[0];
    }
    
    // Первые четыре элемента должны равняться единице
    for (int i = 0; i < 4; i++) {
        result *= (fabs(P[i] - 1.0) < 1e-12);
    }
    
    // Два последние элемента должны равняться sqrt(2)
    for (int i = 4; i < 6; i++) {
        result *= (fabs(P[i] - sqrt(2)) < 1e-12);
    }
    
    return result;
}

#include <iostream>
#include <utility>
 
#pragma pack(push, 1)
struct pair2
{
    int first;
    char second;
};
#pragma pack(pop)
 
int main() 
{
    std::pair<int, char> p;
    pair2 p2;
    std::cout << sizeof(p) << '\n'; // 8 bytes
    std::cout << sizeof(p2); // 5 bytes
}

#include <iostream>
#include <cmath>
#include <unordered_set>
#include <random>
#include <algorithm>
#include <iomanip>
#include <optional>
 
struct Point {
    float x;
    float y;
};
 
bool operator==(const Point &a, const Point &b) {
    return (std::abs(a.x - b.x) < std::numeric_limits<float>::epsilon()) &&
           (std::abs(a.y - b.y) < std::numeric_limits<float>::epsilon());
}
 
bool operator!=(const Point &a, const Point &b) {
    return !(a == b);
}
 
struct PointHash {
    static inline std::hash<float> HASH{};
 
    auto operator()(const Point &point) const {
        return HASH(point.x) ^ HASH(point.y);
    }
};
 
struct Square {
    Point a;
    Point b;
    Point c;
    Point d;
    float side;
};
 
std::ostream &operator<<(std::ostream &out, const Point &point) {
    return out << std::fixed << std::setprecision(2) << "[" << point.x << ", " << point.y << "]";
}
 
std::ostream &operator<<(std::ostream &out, const Square &square) {
    return out << square.a << ", " << square.b << ", " << square.c << ", " << square.d << ", side=" << square.side;
}
 
int main() {
    std::random_device rd;
    std::mt19937_64 re(rd());
    std::uniform_int_distribution<int> dis(0, 9);
 
    std::unordered_set<Point, PointHash> points;
    size_t size = 100;
    std::generate_n(std::inserter(points, points.begin()), size, [&dis, &re]() {
        return Point{(float)dis(re), (float)dis(re)};
    });
 
    Square maxSquare{};
    for (auto i = points.begin(), end = points.end(); i != end; ++i) {
        for (auto j = std::next(i); j != end; ++j) {
            if (i != j && *i != *j) {
                auto side = std::hypot(i->x - j->x, i->y - j->y);
                std::cout << *i << " - " << *j << ": " << side << std::endl;
 
                auto dx = i->x - j->x;
                auto dy = i->y - j->y;
 
                //смежные веришны первый вариант
                Point k1{i->x + dy, i->y - dx};
                Point l1{j->x + dy, j->y - dx};
                if (points.count(k1) > 0 && points.count(l1) > 0) {
                    if (side > maxSquare.side) {
                        maxSquare = {*i, *j, k1, l1, side};
                    }
                }
 
                //смежные веришны второй вариант
                Point k2{i->x - dy, i->y + dx};
                Point l2{j->x - dy, j->y + dx};
                if (points.count(k2) > 0 && points.count(l2) > 0) {
                    if (side > maxSquare.side) {
                        maxSquare = {*i, *j, k2, l2, side};
                    }
                }
 
                //диагональ
                dx = (i->x - j->x) / 2;
                dy = (i->y - j->y) / 2;
                Point k3{(i->x + j->x) / 2 - dy, (i->y + j->y) / 2 + dx};
                Point l3{(i->x + j->x) / 2 + dy, (i->y + j->y) / 2 - dx};
                if (points.count(k3) > 0 && points.count(l3) > 0) {
                    if (side > maxSquare.side) {
                        maxSquare = {*i, *j, k3, l3, side};
                    }
                }
            }
        }
    }
 
    std::cout << "Square: " << maxSquare;
 
    return 0;
}