using namespace std;
using ll = long long;
using vll = vector<ll>;
int main(void)
{
    int n;
    cin >> n;
    vll p(n);
    for (auto &pi : p)
        cin >> pi;
    sort(p.begin(), p.end());
    int pivot = p[n / 2];
    cout << accumulate(p.begin(), p.end(), 0LL, [pivot](ll acc, ll x) {
        return acc + abs(pivot - x);
    }) << endl;
    return 0;
}

using namespace std;
using si = multiset<int>;
int main(void)
{
    int n, ki;
    cin >> n;
    si frontier;
    for (int i = 0; i < n; ++i)
    {
        cin >> ki;
        if (auto it = frontier.upper_bound(ki); it != frontier.end())
        {
            frontier.erase(it);
            frontier.insert(ki);
        }
        else
            frontier.insert(ki);
    }
    cout << frontier.size() << endl;
    return 0;
}

using namespace std;
using ll = long long;
ll solve(ll n)
{
    return (n * n * (n * n - 1) - 8 - 24 - (n - 4) * 16 - 16 - 24 * (n - 4) -
            8 * (n - 4) * (n - 4)) /
           2;
}
int main(void)
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++i)
        cout << solve(i) << endl;
    return 0;
}

using namespace std;
using ll = long long;
using ii = pair<ll, ll>;
ll manhattan(ii a, ii b)
{
    return abs(a.first - b.first) + abs(a.second - b.second);
}
ll solve(ll row, ll col)
{
    ll level = max(row, col);
    ll dir = level % 2;
    ll startv = (level - 1) * (level - 1) + 1;
    ii startp = (dir ? make_pair(level, 1LL) : make_pair(1LL, level));
    ll dist = manhattan(startp, {row, col});
    return startv + dist;
}
int main(void)
{
    ll t, x, y;
    cin >> t;
    while (t--)
    {
        cin >> y >> x;
        cout << solve(y, x) << endl;
    }
    return 0;
}

using namespace std;
int main(void)
{
    int n;
    cin >> n;
    if (n > 1 and n <= 3)
        cout << "NO SOLUTION" << endl;
    else
    {
        for (int i = 2; i <= n; i += 2)
            cout << i << " ";
        for (int i = 1; i <= n; i += 2)
            cout << i << " ";
        cout << endl;
    }
    return 0;
}

using namespace std;
int main(void)
{
    int ans, cur;
    char last;
    string s;
    cin >> s;
    ans = cur = 0;
    last = s[0];
    for (auto c : s)
    {
        if (c == last)
            ++cur;
        else
        {
            ans = max(ans, cur);
            cur = 1;
        }
        last = c;
    }
    ans = max(ans, cur);
    cout << ans << endl;
    return 0;
}

using namespace std;
int N;
int dp[10010];
int v[10010];
int solve(void) {
  dp[0] = max(v[0], 0);
  for (int i = 1; i < N; ++i)
    dp[i] = max(v[i] + dp[i - 1], v[i]);
  return *max_element(dp, dp + N);
}
int main(void) {
  while (cin >> N and N != 0) {
    for (int i = 0; i < N; ++i)
      cin >> v[i];
    int ans = solve();
    if (ans > 0)
      cout << "The maximum winning streak is " << ans << ".\n";
    else
      cout << "Losing streak.\n";
  }
  return 0;
}

using namespace std;
const int NMAX = 20 + 11;
const int SMAX = 200 + 11;
int w[NMAX], tsum, n;
int mem[NMAX][SMAX];
void read_integers(void)
{
    int x, i = 0;
    string s;
    tsum = 0;
    getline(cin, s);
    stringstream ss(s);
    while (ss >> x)
    {
        tsum += x;
        w[i++] = x;
    }
    n = i;
}
int dp(int pos, int capacity)
{
    int &ans = mem[pos][capacity];
    if (pos == n)
        return 0;
    if (ans != -1)
        return ans;
    if (capacity - w[pos] >= 0)
        ans = dp(pos + 1, capacity - w[pos]) + w[pos];
    return max(ans, dp(pos + 1, capacity));
}
bool solve(void)
{
    int ans;
    if (tsum % 2 == 1)
        return false;
    memset(mem, -1, sizeof(mem));
    ans = dp(0, tsum / 2);
    return ans == tsum / 2;
}
int main(void)
{
    int m;
    cin >> m;
    cin.ignore();
    while (m--)
    {
        read_integers();
        cout << (solve() ? "YES" : "NO") << endl;
    }
    return 0;
}

using namespace std;
int const NMAX = 2e5 + 11;
int n, a[NMAX];
set<int> g[NMAX];
bool bfs_check(void)
{
    int i = 0;
    queue<int> q;
    g[0].insert(1), g[1].insert(0);
    q.push(0);
    while (not q.empty())
    {
        auto p = q.front();
        q.pop();
        while (i < n and g[p].find(a[i]) != g[p].end())
            q.push(a[i++]);
    }
    return i == n;
}
int main(void)
{
    cin >> n;
    for (int i = 0; i < n - 1; ++i)
    {
        int u, v;
        cin >> u >> v;
        g[u].insert(v);
        g[v].insert(u);
    }
    for (int i = 0; i < n; ++i)
        cin >> a[i];
    cout << (bfs_check() ? "Yes" : "No") << endl;
    return 0;
}

using namespace std;
const double EPSILON = 1e-8;
int p, q, r, s, t, u;
inline double f(double x)
{
    return p * exp(-x) + q * sin(x) + r * cos(x) + s * tan(x) + t * x * x + u;
}
int main(void)
{
    double lo, hi, y, yp, mid;
    y = 0;
    while (cin >> p >> q >> r >> s >> t >> u)
    {
        lo = 0, hi = 1;
        if (f(1) > 0 or f(0) < 0)
            cout << "No solution" << endl;
        else
        {
            do
            {
                mid = lo + (hi - lo) / 2;
                yp = f(mid);
                if (yp > 0)
                    lo = mid;
                else
                    hi = mid;
            } while (abs(y - yp) > EPSILON);
            cout << fixed << setprecision(4) << mid << endl;
        }
    }
    return 0;
}