#include <bits/stdc++.h>

using namespace std;

string ltrim(const string &);
string rtrim(const string &);
vector<string> split(const string &);

enum struct OutputMode { HackerRank, Linux };

OutputMode outputMode = OutputMode::Linux;

map<string,pair<string,string>> testCases = {
    //  n    input                              expected result
    // ---   -------------------------------    ----------
    {  "9",  {"3 7 8 5 12 14 21 13 18",         "6 12 16"  }},
    { "11",  {"6 7 15 36 39 40 41 42 43 47 49", "15 40 43" }},
    {  "6",  {"7 15 36 39 40 41",               "15 37 40" }}, 
    { "10",  {"3 7 8 5 12 14 21 15 18 14",      "7 13 15"  }},
};

// The first quartile is the middle number between the smallest number in a data set and its median.
// The second quartile is the median ( percentile) of the data set.
// The third quartile is the middle number between a data set's median and its largest number.
// It is guaranteed that Q1, Q2, and Q3 are integers.

map<string,pair<string,string>>::const_iterator testCase;

/*
 * Complete the 'quartiles' function below.
 *
 * The function is expected to return an INTEGER_ARRAY.
 * The function accepts INTEGER_ARRAY arr as parameter.
 */
    
vector<int> quartiles(vector<int> arr) {
    sort(arr.begin(), arr.end());

    for (auto i: arr) { cerr << i << " "; } cerr << endl;

    int Q1, Q2, Q3;
    int index1, index2;
    vector<int> q1Vector, q3Vector;

    //*********************************************************************
    if ((arr.size() % 2) == 0) // array size even, split into 2 equal parts
    {
        // second quartile is median of entire array
        index1 = arr.size()/2;
        index2 = index1 - 1;
        Q2 = (arr[index1] + arr[index2])/double(2);        
        cerr << "Q2: " << Q2 << endl;
        
        size_t index = arr.size()/2;
        for (size_t i = 0; i < index; i++) q1Vector.push_back(arr[i]);
        for (size_t i = index; i < arr.size(); i++) q3Vector.push_back(arr[i]);

        for (auto i: q1Vector) { cerr << i << " "; } cerr << endl;
        for (auto i: q3Vector) { cerr << i << " "; } cerr << endl;
        
        if (q1Vector.size() % 2 == 0) // size even, calc median
        {            
            index1 = q1Vector.size()/2;
            index2 = index1 - 1;
            Q1 = (q1Vector[index1] + q1Vector[index2])/double(2);
            cerr << "Q1: " << Q1 << endl;
            
            index1 = q3Vector.size()/2;
            index2 = index1 - 1;
            Q3= (q3Vector[index1] + q3Vector[index2])/double(2);        
            cerr << "Q3: " << Q3 << endl;
        }
        else // size odd, get midpoints
        {
            index1 = floor(q1Vector.size()/2);
            Q1 = q1Vector[index1];
            index2 = floor(q3Vector.size()/2);
            Q3 = q3Vector[index2];
            cerr << "Q1: " << Q1 << endl;            
            cerr << "Q3: " << Q3 << endl;            
        }        
        vector<int> r{Q1,Q2,Q3};
        return r;    
    }
    //*********************************************************************
    else // array size odd, second quartile is midpoint number
    {
        size_t index = (int)floor(arr.size()/2);
        // cerr << "index: " << index << endl;
        Q2 = arr[index];
        cerr << "Q2: " << Q2 << endl;
        
        for (size_t i = 0; i < index; i++) q1Vector.push_back(arr[i]);
        for (size_t i = index + 1; i < arr.size(); i++) q3Vector.push_back(arr[i]);
        
        for (auto &i: q1Vector) { cerr << i << " "; } cerr << endl;
        for (auto &i: q3Vector) { cerr << i << " "; } cerr << endl;

        if (q1Vector.size() % 2 == 0) // even, calc median
        {            
            index1 = q1Vector.size()/2;
            index2 = index1 - 1;
            Q1 = (q1Vector[index1] + q1Vector[index2])/double(2);        
            cerr << "Q1: " << Q1 << endl;
        
            index1 = q3Vector.size()/2;
            index2 = index1 - 1;
            Q3= (q3Vector[index1] + q3Vector[index2])/double(2);        
            cerr << "Q3: " << Q3 << endl;
        }
        else // odd, first and third quartile are the midpoints
        {
            index1 = floor(q1Vector.size()/2);
            Q1 = q1Vector[index1];
            index2 = floor(q3Vector.size()/2);
            Q3 = q3Vector[index2];
            cerr << "Q1: " << Q1 << endl;
            cerr << "Q3: " << Q3 << endl;
        }
        vector<int> r{Q1,Q2,Q3};
        return r;
    }
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));        

    testCase = testCases.find("11");
                                   
    string n_temp;
    if (outputMode == OutputMode::HackerRank)
        getline(cin, n_temp);
    else
        n_temp = testCase->first;
     
    int n = stoi(ltrim(rtrim(n_temp)));

    string data_temp_temp;
    if (outputMode == OutputMode::HackerRank)
        getline(cin, data_temp_temp);
    else
        data_temp_temp = testCase->second.first;
        
    vector<string> data_temp = split(rtrim(data_temp_temp));

    vector<int> data(n);

    for (int i = 0; i < n; i++) {
        int data_item = stoi(data_temp[i]);

        data[i] = data_item;
    }

    vector<int> res = quartiles(data);

    for (size_t i = 0; i < res.size(); i++) {
        fout << res[i];

        if (i != res.size() - 1) {
            fout << "\n";
        }
    }

    fout << "\n";

    fout.close();

    cerr << "expected result: " << testCase->second.second << endl;

    return 0;
}

std::function<int(int)> f_isspace = [](int x){ return isspace(x); };

string ltrim(const string &str) {
    string s(str);

    s.erase(
        s.begin(),
        find_if(s.begin(), s.end(), not_fn(f_isspace))
        );

    return s;
}

string rtrim(const string &str) {
    string s(str);

    s.erase(
        find_if(s.rbegin(), s.rend(), not_fn(f_isspace)).base(),
        s.end()
        );

    return s;
}

vector<string> split(const string &str) {
    vector<string> tokens;

    string::size_type start = 0;
    string::size_type end = 0;

    while ((end = str.find(" ", start)) != string::npos) {
        tokens.push_back(str.substr(start, end - start));

        start = end + 1;
    }

    tokens.push_back(str.substr(start));

    return tokens;
}