#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define int long long
#define all(x) begin(x), end(x)
#define sz(x) (int) (x).size()

const int inf = 1e18;
const int mxn = 3e3;

int n, a[mxn], foc[mxn], loc[mxn], nuq[mxn][mxn], dp[mxn][mxn];
set<int> rev;

signed main() {
	ios::sync_with_stdio(false); cin.tie(nullptr);
	
	cin >> n;
	for (int i = 0; i < mxn; i++) {
		foc[i] = inf, loc[i] = -inf;
	}
	for (int i = 0; i < n; i++) {
		cin >> a[i]; --a[i];
		foc[a[i]] = min(foc[a[i]], i);
		loc[a[i]] = max(loc[a[i]], i);
		rev.insert(a[i]);
	}
	nuq[0][n-1] = sz(rev);
	for (int l = 0; l < n; l++) {
		for (int r = n-1; r > l; r--) {
			//case 1 - remove left endpoint
			int v = a[l];
			if (foc[v] == l && loc[v] <= r) {
				nuq[l+1][r] = nuq[l][r]-1;
			} else {
				nuq[l+1][r] = nuq[l][r];
			}
			//case 2 - remove right endpoint
			v = a[r];
			if (foc[v] >= l && loc[v] == r) {
				nuq[l][r-1] = nuq[l][r]-1;
			} else {
				nuq[l][r-1] = nuq[l][r];
			}
		}
	}
	
	for (int l = n-1; l >= 0; l--) {
		for (int r = l; r < n; r++) {
			int lv = a[l], rv = a[r];
			if (l == r && foc[lv] == l && loc[lv] == r) {
				dp[l][r] = 1;
				continue;
			}
			//case 1 - take left
			int gl = nuq[l][r] - dp[l+1][r];
			//case 2 - take right
			int gr = nuq[l][r] - dp[l][r-1];
			
			dp[l][r] = max(gl,gr);
		}
	}
	
	cout << dp[0][n-1] << ":" << nuq[0][n-1] - dp[0][n-1];
	
	
	return 0;
}