Language: C++


	/* ---------- STL Libraries ---------- */

	// IO library
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iostream>

	// algorithm library
#include <algorithm>
#include <cmath>
#include <numeric>
#include <random>

	// container library
#include <array>
#include <bitset>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>

	/* ---------- Namespace ---------- */

	using namespace std;

	/* ---------- Type Abbreviation ---------- */

	template <typename T>
	using PQ = priority_queue<T>;
	template <typename T>
	using GPQ = priority_queue<T, vector<T>, greater<T>>;

	using ll = long long;

#define fst first
#define snd second
#define mp make_pair
#define mt make_tuple

	/* ---------- conversion ---------- */

#define INT(c) static_cast<int>(c)
#define CHAR(n) static_cast<char>(n)
#define LL(n) static_cast<ll>(n)
#define DOUBLE(n) static_cast<double>(n)

	/* ---------- container ---------- */

#define ALL(v) (v).begin(), (v).end()
#define SIZE(v) (LL((v).size()))

#define FIND(v, k) (v).find(k) != (v).end()
#define VFIND(v, k) find(ALL(v), k) != (v).end()

#define gsort(b, e) sort(b, e, greater<decltype(*b)>())

	/* ----------- debug ---------- */

	template <class T>
	ostream& operator<<(ostream& os, vector<T> v) {
		os << "[";
		for (auto vv : v)
			os << vv << ",";
		return os << "]";
	}

	template <class T>
	ostream& operator<<(ostream& os, set<T> v) {
		os << "[";
		for (auto vv : v)
			os << vv << ",";
		return os << "]";
	}

	template <class L, class R>
	ostream& operator<<(ostream& os, pair<L, R> p) {
		return os << "(" << p.fst << "," << p.snd << ")";
	}

	/* ---------- Constants ---------- */

	// const ll MOD = 1e9 + 7;
	// const int INF = 1 << 25;
	// const ll INF = 1LL << 50;
	// const double PI = acos(-1);
	// const double EPS = 1e-10;
	// mt19937 mert(LL(time(0)));

	/* ---------- Short Functions ---------- */

	template <typename T>
	T sq(T a) {
		return a * a;
	}

	template <typename T>
	T gcd(T a, T b) {
		if (a > b) return gcd(b, a);
		return a == 0 ? b : gcd(b % a, a);
	}

	template <typename T, typename U>
	T mypow(T b, U n) {
		if (n == 0) return 1;
		if (n == 1) return b /* % MOD */;
		if (n % 2 == 0) {
			return mypow(b * b /* % MOD */, n / 2);
		}
		else {
			return mypow(b, n - 1) * b /* % MOD */;
		}
	}

	ll pcnt(ll b) {
		return __builtin_popcountll(b);


		// const ll dx[4] = {0, -1, 1, 0};
		// const ll dy[4] = {-1, 0, 0, 1};
		// const ll dx[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
		// const ll dy[8] = {-1, -1, -1, 0, 0, 1, 1, 1};

		/* v-v-v-v-v-v-v-v-v Main Part v-v-v-v-v-v-v-v-v */

		int main() {
			cin.tie(0);
			ios::sync_with_stdio(false);
			ll N, X[N];
			cin >> N;
			REP(i, N) {
				cin >> X[i];
			}
			REP(i, N) {
				ll Y[N - 1];
				REP(j,N){
					if (j <i) {
						Y[j] = X[i];
					}
					else if(j=>i){
						Y[j] = X[i + 1];
					}
				}
				sort(Y, Y + N - 1,greater<int>());
				cout << Y[(N - 2) / 2] << endl;
			}
			return 0;
		}

Compiler output:
a.cc: In function 'll pcnt(ll)':
a.cc:131:25: warning: empty parentheses were disambiguated as a function declaration [-Wvexing-parse]
  131 |                 int main() {
      |                         ^~
a.cc:131:25: note: remove parentheses to default-initialize a variable
  131 |                 int main() {
      |                         ^~
      |                         --
a.cc:131:25: note: or replace parentheses with braces to value-initialize a variable
a.cc:131:28: error: a function-definition is not allowed here before '{' token
  131 |                 int main() {
      |                            ^
a.cc:153:18: error: expected '}' at end of input
  153 |                 }
      |                  ^
a.cc:120:23: note: to match this '{'
  120 |         ll pcnt(ll b) {
      |                       ^