FLab1-2

#include<iostream>
#include<sstream>
#include<vector>
#include<tuple>
#include<algorithm>
#define USE_MATH_DEFINITIONS
#include<math.h>

using entry_tuple = std::tuple<double, double, double, double>;

typedef union {
    struct
    {
        double x, y;
    };
    double value[2];
} vec2;

vec2 vec2Add(vec2 a, vec2 b)
{
    return {{a.x + b.x, a.y + b.y}};
}

vec2 vec2Div(vec2 a, double s)
{
    return {{ a.x / s, a.y / s }};
}

//compute the median-median line of set of points
//in: sorted by x set of points
//out: slope and point of line equation
std::pair<double, double> computeMMLine(std::vector<entry_tuple> table)
{
    vec2 medians[3];
    double slope, shift;
    for (int i = 0; i < 3; i++)
    {
        vec2 median = {0.0, 0.0};
        for (int j = 0; j < (int) (table.size() / 3); j++) {
            auto entry = table[i * (table.size() / 3) + j];
            median = vec2Add(median, {std::get<2>(entry), std::get<3>(entry)});
        }
        medians[i] = vec2Div(median, (int) (table.size() / 3));
    }
    slope = (medians[2].y - medians[0].y) / (medians[2].x - medians[0].x);
    shift = medians[0].y - slope * medians[0].x;
    shift = (slope*medians[1].x + shift - medians[1].y) * (2 / 3) + medians[1].y;
    return std::make_pair(slope, shift);
}

void fill_table(std::vector<entry_tuple> & table, std::istream & stream)
{
    std::string line;
    std::getline(std::cin, line);
    while (std::getline(std::cin, line)) {
        double a, t1, t2, t3;
        std::stringstream in(line);
        in >> a;
        in >> t1;
        in >> t2;
        in >> t3;
        double T = (t1 + t2 + t3) / 3;
        table.push_back(std::make_tuple(a, T, a*a, T*T*a));
    }
}

int main()
{
    std::vector<entry_tuple> entries;
    double L, Tmin, amin, a0, g_c, L_ev, e;
    //first line supposed to be a measured length of rod
    std::cin >> L;

    fill_table(entries, std::cin);

    //write the entries to out
    for (auto e : entries)
        {
            std::cout << std::get<0>(e) << " " << std::get<1>(e) << " " <<
                std::get<2>(e) << " " << std::get<3>(e) << std::endl;
        }

    std::sort(entries.begin(), entries.end(),
              [](entry_tuple & r, entry_tuple & l)
              {
                  return std::get<2>(r) < std::get<2>(l);
              });
    auto ss = computeMMLine(entries);

    auto minE = std::min_element(entries.begin(), entries.end(),
                          [](entry_tuple& r, entry_tuple& l)
                          {
                              return std::get<1>(r) < std::get<1>(l);
                          });

    Tmin = std::get<1>(*minE);
    amin = std::get<0>(*minE);
    g_c = (4 * M_PI * M_PI) / ss.first;
    a0 = 0.29 * L;
    L_ev = sqrt((ss.second*3*9.8)/(M_PI * M_PI));
    e = (abs(g_c - 9.8)*100)/9.8;

    std::cout << "T_min:" << Tmin << " a_0:" << a0 << " g_eks:" << g_c <<
        " k:" << ss.first << " b:" << ss.second << " L_eks:" << L_ev <<
        " e:" << e << std::endl;
    return 0;
}