// sample.cpp: определяет точку входа для консольного приложения.
//

#include "stdafx.h"
#include <vector>
#include <math.h>
#include <algorithm>

using namespace std;

bool criteriaInvertion(vector<int> data) {
    int invertions = 0;
    int index = 0;
    for (int i = 0; i<data.size(); i++) {
        index += 1;
        for (int j = i; j<data.size(); j++) {
            if (i>j) invertions += 1;
        }
    }
    int n = data.size();
    double z2 = (invertions - n * (n - 1) / 4.) * 6. / pow(n, 3. / 2);
    return z2 <= 1.96;
}


bool phaseFrequency(std::vector<double> data) {
    vector<bool> delta(data.size());
    for (int i = 0; i < data.size() - 1; i++) {
        if (data[i + 1] != data[i]) {
            delta.push_back(data[i + 1]>data[i]);
        }
    }
    int phases = 0;
    bool old_sign = delta[0];
    for (bool b : delta) {
        bool new_sign = b;
        if (new_sign != old_sign){
            phases += 1;
            old_sign = new_sign;
        }
    }
    int n = data.size();
    int _ = 0;
    if (n < 30) {
        _ = 0.5;
    }
    double z1 = z1 = (abs(phases - (2 * n - 7) / 3.) - _) / sqrt((16 * n - 29) / 90.);
    return z1 <= 1.96;
}

bool medianCriteria(vector<double> data) {
    int data_len = data.size();
    // поиск медианы
    vector<double> sorted_data(data);
    sort(sorted_data.begin(), sorted_data.end());
    double median = 0;
    if (data_len % 2 == 0){
        median = (sorted_data[int(data_len / 2.) - 1] + sorted_data[int(data_len / 2.)]) / 2.;
    }
    else {
        median = sorted_data[data_len / 2];
    }
    // вычисление массива с дельтами
    vector<bool> delta(data.size());
    for (double a : data) {
        delta.push_back(a - median);
    }
    int max_series = 0;
    int series = 0;
    int series_number = 1;
    bool old_sign = delta[0] > 0;
    // подсчет количества серий и длины максимальной из них
    for (double a : delta) {
        bool new_sign = a > 0;
        if (new_sign == old_sign) {
            series += 1;
        }
        else {
            max_series = max(series, max_series);
            series = 0;
            series_number += 1;
            old_sign = new_sign;
        }
    }
    bool cond1 = series_number > (data_len + 1 - 1.96 * sqrt(data_len - 1.)) / 2.;
    bool cond2 = max_series < 3.3 * log10(data_len + 1);
    return cond1 && cond2;
}

int main()
{
    vector<int> plane1 = { 90,10,60,186,61,49,14,24,55,20,79,84,44,59,59,118,25,156,310,76,26,44,23,62,130,70,101,208 };
    bool result = criteriaInvertion(plane1);
    cout << result;
    return 0;
}