Problem:
寂しがり屋のついた嘘
パケットモンスターというゲームがあります。モンスターを捕まえ、育て、戦わせたり交換したりするゲームで、日本中で大流行しています。もちろん、わたしのクラスでも。だからわたしもこのゲームでみんなと遊べるようにモンスターを育てているけど、悲しいことに対戦する相手がいません。わたしは積極的に人に話しかけるのが得意なタイプではないからです。だから今日も、クラスメイトが誘ってくれるのを待ちながら、独り寂しくモンスターのレベルを上げています。
そしてついに、待ち望んでいた瞬間が訪れました。クラスメイトの一人が対戦しないかとわたしに話を持ちかけてきたのでした。彼女は自慢気に、彼女のモンスターたちを見せてくれました。
一般的なパケットモンスターの対戦ルールでは、各プレイヤーがそれぞれN 匹のモンスターを用意し、互いに1 匹ずつ戦わせます。各モンスターには成長の度合いを示す「レベル」という数値があり、レベルが大きいモンスターが必ず勝ちます。同レベルのときは引き分けです。一度戦ったモンスターは、それ以上戦わせることができません。こうして一対一の戦いをN 回行ったあと、過半数の勝利を収めたプレイヤーが勝者となります。
わたしは、彼女のモンスターを見た瞬間、嫌な予感がしました。彼女のモンスターはどれも、とても強そうなのです。わたしと戦ってくれるのなら負けてもかまいません。でも、あまりにもひどい負け方をしたら、"こいつと戦っても面白くないな"とか思われて、もう遊んでくれなくなるんじゃないかな。それは、とても嫌です。だから、
「ごめん、わたしまだモンスターをN 匹持ってなくて」
嘘をつきました。
N 回勝負では勝ち目がなくても、それより少ない数のモンスターで勝負する特別ルールなら、もしかしたら勝てるかもしれません。さっきは負けたってかまわないと言ったけど、やっぱり勝てたら嬉しいです。
彼女はこの特別ルールを受け入れてくれました。つまり、二人が持っているモンスターからお互いに k 匹選んで一匹ずつ順番に戦わせ、過半数の(つまり、k/2 より大きな数の) 勝利を収めた方が勝ちとなります。
さっきわたしは、彼女のモンスターのレベルを知ってしまいました。彼女がどのモンスターを選び、どんな順番で出してくるのかはわかりません。でも、対戦させるモンスターの数kをわたしがうまく決めれば、彼女がどんな選択をしようとわたしが勝つことができるかもしれません。
皆さんにお願いです。モンスターの数 N と、二人が持っているモンスターのレベルを入力すると、彼女がどんな選択をしようとわたしが勝てるような最小のモンスターの数 k を出力するプログラムを作成して下さい。
入力
入力は複数のデータセットからなる。入力の終わりはゼロ１つの行で示される。各データセットは以下の形式で与えられる。
N
a
1
a
2
... a
N
b
1
b
2
... b
N
１行目にモンスターの数 N (1 ≤ N ≤ 40000) が与えられる。２行目に自分のモンスターのレベル a
i
(1 ≤ a
i
≤ 100000) が１つの空白区切りで与えられる。３行目にクラスメイトのモンスターのレベル b
i
(1 ≤ b
i
≤ 100000) が１つの空白区切りで与えられる。
データセットの数は 50 を超えない。
出力
データセットごとに、k (1 ≤ k < N) が存在すれば最小値を１行に出力する。もし、k が存在しないか、k が N に等しければ NA と出力する。
入力例
10
4 9 1 9 5 9 2 3 2 1
8 7 6 5 10 5 5 4 7 6
5
4 3 2 5 1
4 4 4 4 4
4
4 1 3 2
4 3 2 1
0
出力例
3
1
NA
１つ目のデータセットでは、わたしは３匹での対戦を提案し、レベルが [9, 9, 9] のモンスターを選べば良い。相手のレベル 10 以外のどのモンスターにも勝てるので、少なくとも２勝できる。２匹での対戦では １勝１敗になる可能性があり、これは過半数の勝利とは言えないので、2 は答えにならない。
２つ目のデータセットでは、わたしは最強のモンスターを１匹選べば良い。
３つ目のデータセットでは、わたしがどの k 匹を選び、どの順番で出したとしても、彼女が全く同じモンスターを同じ順番で出してきて引き分けになる可能性がある。したがって、「彼女がどんな選択をしようとわたしが勝つことができる」とは言い切れない。

Submitted solutions:

code_snippet: #include <bits/stdc++.h>

using namespace std;

constexpr int N = 40000;
int a[N], b[N];
int cnt[N];
int n;

void solve() {
    for (int i = 0; i < n; ++i) cin >> a[i];
    for (int i = 0; i < n; ++i) cin >> b[i];
    sort(a, a + n);
    sort(b, b + n);

    int i = n - 1, j = n - 1;
    while (i >= 0 && j >= 0) {
        if (a[i] > b[j]) {
            cnt[i] = 1;
            --i;
        } else {
            cnt[i] = 0;
            --i;
            --j;
        }
    }
    for (int i = n - 2; i >= 0; --i) {
        cnt[i] += cnt[i + 1];
    }
    for (int k = 1; k < n; ++k) {
        int need = k / 2 + 1;
        if (cnt[n - k] >= need) {
            cout << k << '\n';
            return;
        }
    }
    cout << "NA\n";
}

int main() {
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
#endif
    while (true) {
        cin >> n;
        if (n == 0) break;
        solve();
    }
}
accuracy: 1
time_ms: 180
memory_kb: 3908
final_rank: 11

code_snippet: #include <bits/stdc++.h>
using namespace std;

int main() {
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
#endif

    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    while (true) {
        int N;
        cin >> N;
        if (!cin || N == 0) break;

        vector<int> A(N), B(N);
        for (int i = 0; i < N; i++) cin >> A[i];
        for (int i = 0; i < N; i++) cin >> B[i];

        sort(A.begin(), A.end());
        sort(B.begin(), B.end());

        // Собираем жадные блокирующие пары для полного массива
        vector<int> matched;
        int i = N - 1, j = N - 1;
        while (i >= 0 && j >= 0) {
            if (B[j] >= A[i]) {
                matched.push_back(min(i, j));
                i--;
                j--;
            } else {
                i--;
            }
        }
        sort(matched.begin(), matched.end());

        // Ищем минимальное k
        int answer = -1;
        for (int k = 1; k < N; k++) {
            int s = N - k;
            auto it = lower_bound(matched.begin(), matched.end(), s);
            int blocks = matched.end() - it;
            int wins = k - blocks;
            if (wins * 2 > k) {
                answer = k;
                break;
            }
        }

        if (answer == -1)
            cout << "NA\n";
        else
            cout << answer << "\n";
    }

    return 0;
}
accuracy: 1
time_ms: 130
memory_kb: 3976
final_rank: 8

code_snippet: #include<iostream>
#include<algorithm>
#include<map>
#include<queue>
#include<stack>
#include<set>
#include<bitset>
#include<vector>
#include<string>
#include <iomanip>
#include <deque>
#include<list>
#include<cmath>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
using ll=long long;
using P=pair<int,int>;
using P_S=pair<int,string>;
using P_D=pair<double,int>;
using T=tuple<int,int,char,ll,string>;

int main(){
    while(1){
        int n;
        cin>>n;
        if(n==0) break;
        vector<int> a(n),b(n);
        rep(i,n) cin>>a[i];
        rep(i,n) cin>>b[i];
        sort(a.begin(),a.end());
        sort(b.begin(),b.end());
        int a_w=0,b_w=0,count=0,id=n-1;
        for(int i=n-1;i>=0;i--){
            count++;
            if(a[i]>b[id]) a_w++;
            else if(a[i]<=b[id]) id--;
            if(a_w>count/2) break;
        }
        if(count==n) cout<<"NA"<<endl;
        else cout<<count<<endl;
    }
}
accuracy: 1
time_ms: 180
memory_kb: 3472
final_rank: 9

code_snippet: #include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<string.h>



int  A[40001];
int  A_d[40001];
int B[40001];
int B_d[40001];
int count[100006];

int getpartition(int  a[], int p, int r)
{
	int x = a[r];
	int k = p - 1;
	int  tmp;
	for (int i = p; i < r; i++)
	{
		if (a[i] >= x)
		{
			k++;
			tmp = a[k];
			a[k] = a[i];
			a[i] = tmp;
		}
	}
	k++;
	tmp = a[k];
	a[k] = x;
	a[r] = tmp;
	return k;
}

void quickSort(int a[], int n, int p, int r)
{
	if (p < r)
	{
		int m = getpartition(a, p, r);
		quickSort(a, n, p, m - 1);
		quickSort(a, n, m + 1, r);
	}
}


void countSort(int a[],int d[], int n)
{
	memset(count, 0, sizeof(count));
	for (int i = 0; i < n; i++)
		count[a[i]]++;
	for (int i = 100000; i >= 0; i--)
		count[i] = count[i] + count[i + 1];

	for (int i = 0; i < n; i++)
	{
		d[count[a[i]] - 1] = a[i];
		count[a[i]]--;
	}
}


void slove(int n)
{
	//quickSort(A, n, 0, n - 1);
	//quickSort(B, n, 0, n - 1);
	countSort(A_d, A, n);
	countSort(B_d, B, n);


	int ai = 0;
	int mk = 0;
	int idex = 0;
	for (int i = 0; i < n-1; i++)
	{
		mk = (i + 1) / 2;
		if (A[i] > B[idex])
		{
			ai++;
			if (ai > mk)
			{
				
				printf("%d\n", i + 1);
				return ;
			}
		}
		else
		{
			idex++;
		}

		//if ((i-ai) > n / 2)
		//	break;
	}
	
	printf("NA\n");
	
}

int main()
{
	int n;
	while (1)
	{
		std::cin >> n;
		if (n == 0) break;

		for (int i = 0; i < n; i++)
		{
			std::cin >> A_d[i];
		}
		for (int i = 0; i < n; i++)
		{
			std::cin >> B_d[i];
		}
		slove(n);
	}
}
accuracy: 1
time_ms: 200
memory_kb: 4208
final_rank: 14

code_snippet: #include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 4000000000000000000 //オーバーフローに注意
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;



#define SIZE 40005

int N;
int A[SIZE],B[SIZE];

void func(){

	for(int i = 0; i < N; i++){

		scanf("%d",&A[i]);
	}
	for(int i = 0; i < N; i++){

		scanf("%d",&B[i]);
	}

	sort(A,A+N);
	sort(B,B+N);

	reverse(A,A+N);
	reverse(B,B+N);

	/*「私」は降順に出す 敵はなるべく負けを減らそうとする*/

	int all = 0;
	int index = 0;
	int num_lose = 0;

	//敵目線
	for(int i = 0; i < N-1; i++){ //N回は不可(問題の制約)

		all++;
		int need;
		if(all%2 == 0){

			need = all/2 +1;
		}else{

			need = (all+1)/2;
		}


		if(B[index] < A[i]){ //勝てる手がない:Bはなるべく自分の中で小さいものを割り当てる

			num_lose++;


			if(num_lose >= need){

				printf("%d\n",all);
				return;
			}
		}else{ //引き分け以上

			index++;
		}
	}

	printf("NA\n");
}

int main(){

	while(true){

		scanf("%d",&N);
		if(N == 0)break;

		func();
	}


	return 0;
}
accuracy: 1
time_ms: 120
memory_kb: 3484
final_rank: 6

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

 	 	
int main() {
	    int i,j,n,c,w;
	    vector<int> a,b;
	    while(cin >> n) {
	    	if (n == 0) break;
	    	a.clear(); b.clear();
	    	for (i=0;i<n;i++) { cin >> c; a.push_back(c);}
	    	for (i=0;i<n;i++) { cin >> c; b.push_back(c);}
	    	sort(a.begin(),a.end()); sort(b.begin(),b.end());
	    	c=n-1; w=0;
	    	for (i=n-1; i>=0; i--)  {
	    		if (a[i]<=b[c]) c--; else {	w++; if (w*2>n-i && i>0) {cout << n-i << endl; break;}}
	    		}
	        if (i<0) cout << "NA" << endl;		
	    	}		
	    return 0;
	}
accuracy: 1
time_ms: 230
memory_kb: 3448
final_rank: 13

code_snippet: #include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;
#define int long long
#define V vector
#define vel V<int> 
#define vvel V<V<int>>
#define pin pair<int,int>
#define rep(i,n) for(int i=0;i<n;i++)
#define sor(v) sort(v.begin(),v.end())
#define mkp make_pair
#define mmax(a,b) a=max(a,b)
#define lowerbound(v,val) lower_bound(v.begin(),v.end(),val)
#define upperbound(v,val) upper_bound(v.begin(),v.end(),val)
#define rev(v) reverse(v.begin(),v.end());
#define mmin(a,b) a=min(a,b)
signed main() {
	while (true) {
		int n; cin >> n;
		if (n == 0) { break; }
		vel a(n), b(n);
		rep(i, n) { cin >> a[i]; }
		rep(i, n) { cin >> b[i]; }
		sor(a);
		sor(b);
		int now_max = n + 10;
		vel cnt(n, 0);
		for (int i = n - 1; i >= 0; i--) {
			int nex = upperbound(a, b[i]) - a.begin();
			nex--;
			mmin(nex, now_max - 1);
			if (nex >= 0) {
				now_max = nex;
				cnt[nex]++;
			}
		}
		rev(cnt);
		int sum = 0;
		rep(i, n) {
			if (i == n - 1) {
				cout << "NA" << endl; break;
			}
			sum += cnt[i];
			if ((i+1-sum) * 2 > i+1) {
				cout << i+1 << endl; break;
			}
		}
	}
	return 0;
}
accuracy: 1
time_ms: 240
memory_kb: 3840
final_rank: 17

code_snippet: #include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int i=0;i<n;i++)
#define chmin(a,b) a=min(a,b)
#define chmax(a,b) a=max(a,b)
#define mod 1000000007
#define ad(a,b) a=(a+b)%mod;
#define X 5010
ll po(ll x,ll y){
	ll res=1;
	for(;y;y>>=1){
		if(y&1)res=res*x%mod;
		x=x*x%mod;
	}
	return res;
}
ll fac[X],ivf[X];
void init(){
	fac[0]=1;
	for(ll i=1;i<X;i++)fac[i]=fac[i-1]*i%mod;
	for(ll i=0;i<X;i++)ivf[i]=po(fac[i],mod-2);
}
ll C(ll n,ll k){
	return fac[n]*ivf[n-k]%mod*ivf[k]%mod;
}
bool solve(){
	ll n,a[40010],b[40010];
	cin>>n;
	if(n==0)return 0;
	rep(i,n)cin>>a[i]; sort(a,a+n); reverse(a,a+n);
	rep(i,n)cin>>b[i]; sort(b,b+n); reverse(b,b+n);
	int p=0;
	rep(k,n-1){
		if(a[k]<=b[p])p++;
		if(k-p>=(k+1)/2){
			cout<<k+1<<endl;
			return 1;
		}
	}
	cout<<"NA"<<endl;
	return 1;
}
int main(){
	cin.tie(0);
	ios::sync_with_stdio(0);
	while(solve()){}
}
accuracy: 1
time_ms: 100
memory_kb: 3804
final_rank: 5

code_snippet: #include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
#define INF 1000000000

int a[40404],b[40404],c[40404];

int main(){
    cin.tie(0);
    ios::sync_with_stdio(0);

    while(1){
        int n; cin>>n;
        if(!n) break;

        rep(i,n) cin>>a[i]; rep(i,n) cin>>b[i];
        sort(a,a+n);
        sort(b,b+n);
        rep(i,n) c[i] = lower_bound(a, a+n, b[i] + 1) - a - 1;

        bool ok = false;
        for(int i=1;i<n;i++){
            if(c[n - (i+1)/2] < n - i){
                cout << i << endl;
                ok = true;
                break;
            }
        }
        if(!ok) cout << "NA" << endl;
    }

    return 0;
}
accuracy: 1
time_ms: 110
memory_kb: 3712
final_rank: 7

code_snippet: #include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

int main(){
    int n;

    while(cin >> n, n){
        vector<int> a(n + 1);
        for(int i = 1 ; i <= n ; ++i){
            cin >> a[i];
        }

        vector<int> b(n + 1);
        for(int i = 1 ; i <= n ; ++i){
            cin >> b[i];
        }

        sort(a.begin() + 1, a.end(), greater<int>());
        sort(b.begin() + 1, b.end(), greater<int>());

        vector<int> sum(n + 1, 0);
        int ai = 1, bi = 1;
        while(ai <= n && bi <= n){
            if(a[ai] <= b[bi]){
                ++sum[ai];
                ++ai;
                ++bi;
            }
            while(ai <= n && a[ai] > b[bi]){
                ++ai;
            }
        }

        for(int i = 2 ; i <= n ; ++i){
            sum[i] += sum[i - 1];
        }

        int ans = -1;
        for(int k = 1 ; k < n ; ++k){
            if((k + 2) / 2 <= k - sum[k]){
                ans = k;
                break;
            }
        }

        if(ans == -1){
            cout << "NA" << endl;
        }else{
            cout << ans << endl;
        }
    }

    return 0;
}
accuracy: 1
time_ms: 180
memory_kb: 3644
final_rank: 10

code_snippet: #include<string.h>
#include<iostream>
#include<string>
#include <vector>
#include<algorithm>

using namespace std;

int main()
{
	int n;
	cin >> n;
	while (n)
	{
		vector<pair<int, int> > vec;
		int m;
		for (int i = 0; i < n; i++)
		{
			cin >> m;
			vec.push_back(make_pair(m, 0));
		}
		for (int i = 0; i < n; i++)
		{
			cin >> m;
			vec.push_back(make_pair(m, 1));
		}
		sort(vec.begin(), vec.end(), greater<pair<int, int>>());
		int _countA = 0,_countB = 0;
		int v = 0, noV = 0;
		auto iter = vec.begin();
		bool ok = false;
		while (iter != vec.end())
		{
			if (iter->second == 0)
			{
				_countA++;
				if (noV == 0)
					v++;
				else
					noV--;
			}
			else
			{
				_countB++;
				noV++;
			}
			int k = max(_countA, _countB);
			if (k == n)
			{
				ok = false;
				break;
			}
			if (v > k / 2)
			{
				ok = true;
				cout << k << endl;
				break;
			}
			iter++;
		}
		if (!ok)
			cout << "NA" << endl;
		cin >> n;
	}
}
accuracy: 1
time_ms: 260
memory_kb: 4416
final_rank: 19

code_snippet: #include<bits/stdc++.h>

using namespace std;

int N, K;
vector<int> MyMonster, Opponent;


bool solve() {
	int myIndex, cnt;

	sort(MyMonster.begin(), MyMonster.end(), greater<int>());
	sort(Opponent.begin(), Opponent.end(), greater<int>());

	myIndex = 0;
	cnt = 0;
	K = 40001;
	for (int i = 0; i < N; ++i) {
		while (myIndex < N - 1) {
			if (Opponent[i] >= MyMonster[myIndex]) {
				++myIndex;
				break;
			}
			++cnt;
			if (cnt >= ((myIndex + 1) / 2 + 1)) {
				K = myIndex + 1;
				return true;
			}
			++myIndex;
		}
		if (myIndex == N - 1) {
			return false;
		}
	}
}

int main() {
	int num;

	while (cin >> N, N) {
		MyMonster.clear();
		Opponent.clear();
		for (int i = 0; i < N; ++i) {
			cin >> num;
			MyMonster.push_back(num);
		}
		for (int i = 0; i < N; ++i) {
			cin >> num;
			Opponent.push_back(num);
		}
		//show();
		if (solve()) {
			cout << K << endl;
			continue;
		}
		cout << "NA" << endl;
	}

	return 0;
}
accuracy: 1
time_ms: 240
memory_kb: 3528
final_rank: 15

code_snippet: #include<bits/stdc++.h>

using namespace std;

int N, K;
vector<int> MyMonster, Opponent;


bool solve() {
	int myIndex, cnt;

	sort(MyMonster.begin(), MyMonster.end(), greater<int>());
	sort(Opponent.begin(), Opponent.end(), greater<int>());

	myIndex = 0;
	cnt = 0;
	K = 40001;
	for (int i = 0; i < N; ++i) {
		while (myIndex < N - 1) {
			if (Opponent[i] >= MyMonster[myIndex]) {
				++myIndex;
				break;
			}
			++cnt;
			if (cnt >= ((myIndex + 1) / 2 + 1)) {
				K = myIndex + 1;
				break;
			}
			++myIndex;
		}
		if (myIndex == N - 1 || K != 40001) {
			break;
		}
	}

	if (K != 40001) {
		return true;
	}

	return false;
}

int main() {
	int num;

	while (cin >> N, N) {
		MyMonster.clear();
		Opponent.clear();
		for (int i = 0; i < N; ++i) {
			cin >> num;
			MyMonster.push_back(num);
		}
		for (int i = 0; i < N; ++i) {
			cin >> num;
			Opponent.push_back(num);
		}
		//show();
		if (solve()) {
			cout << K << endl;
			continue;
		}
		cout << "NA" << endl;
	}

	return 0;
}
accuracy: 1
time_ms: 240
memory_kb: 3528
final_rank: 15

code_snippet: #include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max()/32*15+208;

void solve(int n){
    vector<int> A(n), B(n);
    for (auto &&i : A) scanf("%d", &i);
    for (auto &&i : B) scanf("%d", &i);
    sort(A.begin(),A.end(), greater<>());
    sort(B.begin(),B.end(), greater<>());
    int cur = 0;
    for (int i = 1; i < n; ++i) {
        if(A[i-1] <= B[cur]) cur++;
        if(i-i/2 > cur) {
            cout << i << "\n";
            return;
        }
    }
    puts("NA");
}

int main() {
    int n;
    while(cin >> n, n) solve(n);

    return 0;
}
accuracy: 1
time_ms: 120
memory_kb: 3340
final_rank: 4

code_snippet: #include<cstdio>
#include<algorithm>
#include<functional>
using namespace std;
static const int MAX_N = 40000;

int n;
int a[MAX_N], b[MAX_N];

int main(){
	for(;;){
		scanf("%d", &n);
		if(n == 0) break;
		for(int i = 0; i < n; i++) scanf("%d", &a[i]);
		for(int i = 0; i < n; i++) scanf("%d", &b[i]);
		sort(a, a + n, greater<int>());
		sort(b, b + n, greater<int>());
		int res = -1;
		int cnt = 0;
		int index = 0;
		for(int i = 0; i < n - 1; i++){
			if(a[i] <= b[index]) index++;
			else cnt++;
			if(cnt > (i + 1) / 2){
				res = i + 1;
				break;
			}
		}
		if(res == -1) printf("NA\n");
		else printf("%d\n", res);
	}
	return 0;
}
accuracy: 1
time_ms: 120
memory_kb: 3060
final_rank: 2

code_snippet: #include <bits/stdc++.h>
using namespace std;

using ll = long long int;
using P = pair<int, int>;
using P3 = pair<int, P>;
using PP = pair<P, P>;
constexpr int INF = 1 << 30;
constexpr ll MOD = ll(1e9) + 7;
constexpr int di[] = {0, 1, 0, -1};
constexpr int dj[] = {1, 0, -1, 0};

bool solve(){
    ll n, r;
    cin >> n;
    if(n == 0) return true;
    vector<P> v;
    for(int i=0;i<n;i++){
        int a;
        cin >> a;
        v.push_back(P(a,0));
    }
    for(int i=0;i<n;i++){
        int b;
        cin >> b;
        v.push_back(P(b,1));
    }
    sort(v.rbegin(),v.rend());
    int ans = 0, cnt = 0, s = 0;
    for(int i=0;i<n*2;i++){
        if(v[i].second == 0){
            cnt++;
            s++;
            if(s > cnt/2){
                ans = cnt;
                break;
            }
        }else{
            s--;
        }
    }
    if(ans > 0 && ans < n){
        cout << ans << endl;
    }else{
        cout << "NA" << endl;
    }
    return false;
}

int main() {
    while(!solve());
    return 0;
}
accuracy: 1
time_ms: 270
memory_kb: 4428
final_rank: 20

code_snippet: // includes {{{
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<tuple>
#include<cmath>
#include<random>
#include<cassert>
#include<bitset>
#include<cstdlib>
// #include<deque>
// #include<multiset>
// #include<cstring>
// #include<bits/stdc++.h>
// }}}
using namespace std;
using ll = long long;

// #undef DEBUG
// #define DEBUG
// DEBUG {{{
#include <array>
#include <deque>
#include <list>
#include <ostream>
#include <queue>
#include <stack>
#include <tuple>
#include <valarray>
#include <vector>
template < int n, class... T >
typename std::enable_if< (n >= sizeof...(T)) >::type __output_tuple(
    std::ostream &, std::tuple< T... > const &) {}
template < int n, class... T >
typename std::enable_if< (n < sizeof...(T)) >::type __output_tuple(
    std::ostream &os, std::tuple< T... > const &t) {
  os << (n == 0 ? "" : ", ") << std::get< n >(t);
  __output_tuple< n + 1 >(os, t);
}
template < class... T >
std::ostream &operator<<(std::ostream &os, std::tuple< T... > const &t) {
  os << "(";
  __output_tuple< 0 >(os, t);
  os << ")";
  return os;
}
template < class T, class U >
std::ostream &operator<<(std::ostream &os, std::pair< T, U > const &p) {
  os << "(" << p.first << ", " << p.second << ")";
  return os;
}
template < class T >
std::ostream &operator<<(std::ostream &os, const std::stack< T > &a) {
  os << "{";
  for(auto tmp = a; tmp.size(); tmp.pop())
    os << (a.size() == tmp.size() ? "" : ", ") << tmp.top();
  os << "}";
  return os;
}
template < class T, class Container, class Compare >
std::ostream &operator<<(std::ostream &os,
    std::priority_queue< T, Container, Compare > a) {
  os << "{ (top) ";
  while(a.size()) os << a.top() << (a.size() == 1 ? "" : ", "), a.pop();
  os << " }";
  return os;
}
template < class T, class Container >
std::ostream &operator<<(std::ostream &os, std::queue< T, Container > a) {
  os << "{ ";
  while(a.size()) os << a.front() << (a.size() == 1 ? "" : ", "), a.pop();
  os << " }";
  return os;
}
#ifdef DEBUG
#if !defined(DEBUG_OUT)
#define DEBUG_OUT std::cerr
#endif
#define dump(...)                                                                \
  [&]() {                                                                        \
    auto __debug_tap = std::make_tuple(__VA_ARGS__);                             \
    DEBUG_OUT << "[" << __LINE__ << "] " << #__VA_ARGS__ << " = " << __debug_tap \
    << std::endl;                                                      \
  }()
template < class T >
inline void dump2D(T &d, size_t sizey, size_t sizex) {
  for(size_t i = 0; i < sizey; i++) {
    DEBUG_OUT << "\t";
    for(size_t j = 0; j < sizex; j++)
      DEBUG_OUT << d[i][j] << (j + 1 == sizex ? "" : "\t");
    DEBUG_OUT << std::endl;
  }
}
template < class T >
inline void dump1D(T &d, size_t sizey) {
  for(size_t i = 0; i < sizey; i++) {
    DEBUG_OUT << d[i] << (i + 1 == sizey ? "" : " ");
  }
  DEBUG_OUT << std::endl;
}
template <
class T, class = typename std::iterator_traits< decltype(begin(T())) >::value_type,
      class = typename std::enable_if< !std::is_same< T, std::string >::value >::type >
      std::ostream &operator<<(std::ostream &os, const T &a) {
        os << "{";
        for(auto ite = begin(a); ite != end(a); ++ite)
          os << (ite == begin(a) ? "" : ", ") << *ite;
        os << "}";
        return os;
      }
#else
#define dump(...) (42)
#define dump2D(...) (42)
#define dump1D(...) (42)
template <
class T, class = typename std::iterator_traits< decltype(begin(T())) >::value_type,
      class = typename std::enable_if< !std::is_same< T, std::string >::value >::type >
      std::ostream &operator<<(std::ostream &os, const T &a) {
        for(auto ite = begin(a); ite != end(a); ++ite)
          os << (ite == begin(a) ? "" : " ") << *ite;
        return os;
      }
#endif
// }}}


int main() {
  std::ios::sync_with_stdio(false), std::cin.tie(0);
  while(1) {
    int n;
    cin >> n;
    if(n == 0) break;
    vector<int> a(n), b(n);
    for(auto &e : a) cin >> e;
    for(auto &e : b) cin >> e;
    sort(a.begin(), a.end());
    sort(b.begin(), b.end());
    int head = n - 1;
    int lose = 0;
    int ans = -1;
    for(int i = 0; i < n; i++) {
      if(a[n-1-i] <= b[head]) head--, lose++;
      int win = i + 1 - lose;
      if(win * 2 > i + 1) {
        ans = i + 1;
        break;
      }
    }
    if(ans == n) ans = -1;
    if(ans == -1) {
      cout << "NA\n";
    } else {
      cout << ans << "\n";
    }
  }
  return 0;
}
accuracy: 1
time_ms: 100
memory_kb: 3256
final_rank: 1

code_snippet: #include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

int main(){
    int n;
    while(cin >> n, n){
        vector<int> a(n), b(n);
        for(int i = 0; i < n; i++)  cin >> a[i];
        for(int i = 0; i < n; i++)  cin >> b[i];
        sort(a.rbegin(), a.rend());
        sort(b.rbegin(), b.rend());
        vector<int> wod(n, 0);
        int acur = 0, bcur = 0;
        while(acur < n && bcur < n){
            while(acur < n && b[bcur] < a[acur])    acur++;
            if(acur < n){
                wod[acur]++;
                bcur++;
            }
        }
        for(int i = 1; i < n; i++)  wod[i] += wod[i-1];
        int k;
        for(k = 0; k < n; k++){
            if((k+1) - wod[k] > (k+1)/2)    break;
        }
        if(k >= n-1)    cout << "NA" << endl;
        else            cout << k+1 << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 230
memory_kb: 3400
final_rank: 12

code_snippet: #include <iostream>
#include <algorithm>
using namespace std;
#pragma warning (disable: 4996)

int N, A[1 << 18], B[1 << 18], C[1 << 18];

void init() {
	N = 0;
	for (int i = 0; i < (1 << 18); i++) { A[i] = 0; B[i] = 0; C[i] = 0; }
}
int solve() {
	sort(A, A + N); reverse(A, A + N);
	sort(B, B + N); 

	for (int i = 0; i < N; i++) {
		int pos1 = lower_bound(B, B + N, A[i] + 1) - B;
		C[i] = (N - pos1) - i;
	}
	int maxn = 0, ret = (1 << 30);
	for (int i = 0; i < N - 1; i++) {
		maxn = max(maxn, C[i / 2]);
		if (maxn > (i + 1) / 2) { ret = min(ret, i + 1); break; }
	}
	return ret;
}

int main() {
	while (true) {
		init();
		cin >> N; if (N == 0) break;
		for (int i = 0; i < N; i++) scanf("%d", &B[i]);
		for (int i = 0; i < N; i++) scanf("%d", &A[i]);
		int ans = solve();
		if (ans == (1 << 30)) cout << "NA" << endl;
		else cout << ans << endl;
	}
	return 0;
}
accuracy: 1
time_ms: 140
memory_kb: 6296
final_rank: 18

code_snippet: #include <vector>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
int main() {
	cin.tie(0);
	ios_base::sync_with_stdio(false);
	int N;
	while (cin >> N, N) {
		vector<int> A(N), B(N);
		for (int i = 0; i < N; ++i) cin >> A[i], A[i] *= -1;
		for (int i = 0; i < N; ++i) cin >> B[i], B[i] *= -1;
		sort(A.begin(), A.end());
		sort(B.begin(), B.end());
		int ans = 1 << 30;
		for (int i = 0; i < N / 2; ++i) {
			int ptr = lower_bound(A.begin(), A.end(), B[i]) - A.begin();
			int g = (ptr - i) * 2;
			if (i * 2 + 1 <= g) ans = min(ans, i * 2 + 1);
		}
		if (ans != (1 << 30)) cout << ans << "\n";
		else cout << "NA\n";
	}
	return 0;
}
accuracy: 1
time_ms: 110
memory_kb: 3268
final_rank: 3