Go: /*
	http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=1600&lang=jp
	Entrance Examination
*/

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

// 標準入力を取得するScannerのインスタンスを作成
var scanner = bufio.NewScanner(os.Stdin)

// 標準入力で各行を読み込みintとして返す

func readLine() int {
	if scanner.Scan() {
		number, _ := strconv.Atoi(scanner.Text())
		return number
	}
	return 0
}

func main() {
	// 改行から空白区切りに変更
	scanner.Split(bufio.ScanWords)

	// 0 0 0の行に到達するまでループする
	for {
		// 合格者、不合格者の境目=ギャップ
		m := readLine()   // 受験者の人数
		min := readLine() // 合格者の最小人数
		max := readLine() // 合格者の最大人数

		// 0 0 0の行に到達したのでループを抜け終了する
		if m == 0 && min == 0 && max == 0 {
			break
		}

		// 得点を格納するsliceを初期化
		ps := make([]int, 0, m)

		// sliceに得点を格納する
		for i := 0; i < m; i++ {
			ps = append(ps, readLine())
		}

		tmp := 0    // ギャップを一時的に保存
		gap := 0    // ギャップの最大値を保存
		answer := 0 // ギャップが最大になった時のindex(合格人数)を保存

		// 合格者の最小人数〜最大人数のギャップを計算する
		for i := min; i <= max; i++ {
			tmp = ps[i-1] - ps[i]

			// ギャップの最大値が更新された場合、最大値と合格人数を更新する
			// ギャップが同じ値だった場合も合格人数を更新する
			// (合格人数が多い方が優先されるので後から現れた値が優先される)
			if tmp >= gap {
				gap = tmp
				answer = i
			}
		}
		fmt.Println(answer)
	}
}

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

using namespace std;

using i64 = long long int;
using ui64 = unsigned long long int;

////////

int main(){
    int i,j,k;
    while(cin >> i >> j >> k,i){
        vector<int> a(i);
        for(int l=0;l<i;l++){
            cin >> a[l];
        }
        sort(a.begin(),a.end(),greater<int>());
        int g = -1,s = -1;
        for(int l=j;l<=k;l++){
            if(s <= a[l-1] - a[l]){
                s = a[l-1] - a[l];
                g = l;
            }
        }
        cout << g << endl;
    }
}

C++: #include <bits/stdc++.h>
 
using namespace std;
 
int main(){
	int m,nmin,nmax;
	while(cin >> m >> nmin >> nmax,m){
		vector<int> v(m);
		for(int i=0;i<m;i++){
			cin >> v[i];
		}
		int n = 0;
		int maxi = 0;
		for(int unsigned i=nmin-1;i<nmax;i++){
			if(v[i] - v[i+1] >= maxi){
				n = i+1;
				maxi = v[i] - v[i+1];
			}
		}
		cout << n << endl;
	}
	return 0;
}

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

using namespace std;

typedef long long ll;

int main() {
  int m, n_min, n_max;
  int p[200];
  
  while(cin >> m >> n_min >> n_max, m) {
    for (int i = 0; i < m; i++) {
      cin >> p[i];
    }
    sort(p, p+m);

    int gap = 0;
    int ans;
    for(int i = n_max; i >= n_min; i--) {
      if(gap < p[m-i] - p[m-i-1]) {
        gap = p[m-i] - p[m-i-1];
        ans = i;
      }
    }
    cout << ans << endl;
  }
}

C++: #include<iostream>
#include<algorithm>

using namespace std;

int main(){

    while(1){
        int m, mi, ma;
        cin>> m>> mi>> ma;
        if(!(m||mi||ma)) break;
        int P[m];
        for(int i=0; i<m; i++) cin>> P[i];

        sort(P, P+m);
        reverse(P, P+m);
        int ans=0, magap=0;
        for(int n=mi; n<=ma; n++){
            if(magap<=P[n-1]-P[n]){
                ans=n;
            }
            magap=max(magap, P[n-1]-P[n]);
        }

        cout<< ans<< endl;
    }

    return 0;
}

C++: #include<iostream>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<algorithm>
#include<complex>
#include<string>
#include<cstring>

using namespace std;
#define rep2(x,from,to) for(int x=(from);(x)<(to);(x)++)
#define rep(x,to) rep2(x,0,to)
#define INF 100000000
#define all(x) x.begin(),x.end()
typedef pair<int,int> P;
typedef pair<int,P> PP;
int m,a,b;
int ans_sa;
int ans;
vector<int> stu;
int main()
{
	while(1)
	{
		stu.clear();
		int input;
		cin>>m>>a>>b;
		if(m==0)break;
		rep(i,m)
		{
			cin>>input;
			stu.push_back(input);
		}
		sort(all(stu),greater<int>());
		ans_sa=-1;
		for(int i=a-1;i<b;i++)
		{
			if(stu[i]-stu[i+1]>=ans_sa)
			{
				ans_sa=stu[i]-stu[i+1];
				ans=i+1;
			}
		}
		cout<<ans<<endl;
	}
	return 0;
}

C++: #include <cstdio>

int P[201];

int main() {
  int m, nmin, nmax;
  while (true) {
    scanf("%d %d %d", &m, &nmin, &nmax);
    if (m == 0 && nmin == 0 && nmax == 0) break;
    for (int i=0;i<m;i++) scanf("%d", &P[i]);
    int max_gap = -1, max_n = -1;
    for (int n=nmin;n<=nmax;n++) {
      const int gap = P[n-1]-P[n];
      if (gap >= max_gap) {
        max_gap = gap;
        max_n = n;
      }
    }
    printf("%d\n", max_n);
  }
  return 0;
}

C++: #define	_USE_MATH_DEFINES
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <functional>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cfloat>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <string>
#include <set>
#include <complex>
#include <utility>
#include <numeric>
#define  rep(i,n) for(int i=0;i<(n);i++)
#define  REP(i,a,n) for(int i=a;i<(n);i++)
#define  rrep(i,n) for(int i=(n)-1;i>=0;i--)
#define  VI	vector<int>
#define	 VS vector<string>
#define  all(a) (a).begin(),(a).end()
#define  debug(x) cout<<#x<<": "<<x<<endl
using namespace std;
typedef long long ll;

const int INF=1000000;
char fi[101][101];
int day[12]={31,28,31,30,31,30,31,31,30,31,30,31};
double EPS = 1e-10;
int N,M;
int sx,sy;
int gx,gy;
int w,h;
int ans;
int dx[4]={0,0,-1,1};
int dy[4]={-1,1,0,0};
const int MAX_V=100;
const int MAX_N=100;
char o[3]={'+','-','*'};
#define md 1000003


int dp[353][353]={0};
int bow[353][353]={0};
double add(double a,double b){
	if(abs(a+b)<EPS*(abs(a)+abs(b)))
	return 0;
	return a+b;
}

struct P{
	double x,y;
	P(){}
		P(double x,double y):x(x),y(y){
		}
		P operator + (P p){
			return P(add(x,p.x),add(y,p.y));
		}
		P operator - (P p){
			return P(add(x,-p.x),add(y,-p.y));
		}
		P operator *(double d){
			return P(x*d,y*d);
		}
		double dot(P p){
			return add(x*p.x,y*p.y);
		}
		double det(P p){
			return add(x*p.y,-y*p.x);
		}
};

bool cmp_x(const P& p,const P& q){
	if(p.x!=q.x) return p.x<q.x;
	return p.y<q.y;
}

vector<P> convex_hull(P* ps, int n){
	sort(ps,ps+n,cmp_x);
	int k=0;
	vector<P> 	qs(n*2);
	
	rep(i,n){
		while(k>1&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)
			k--;
		qs[k++]=ps[i];
	}
	for(int i=n-2,t=k;i>=0;i--){
		while(k>t&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)
		k--;
		qs[k++]=ps[i];
	}
	qs.resize(k-1);
	return qs;
}

int n,m;
vector<double> p;
P ps[101];
char c[520][520];

int main(){
	
	int n,max,min;
	while(cin>>n>>min>>max,n!=0&&min!=0&&max!=0){
		int ans=0;
		int com=min;
		vector<int> p(n+100);
		rep(i,n)
			cin>>p[i];
		
		for(int i=min-1;i<max;i++){
			if(p[i]-p[i+1]>=ans){
				ans=p[i]-p[i+1];
				com=i+1;
			}
		}
		cout<<com<<endl;
	}
}

C++: #include <bits/stdc++.h>
using namespace std;
int m;
vector<int>p;
vector<int>s;
int maxn,minn;


int main(){
  int i,j,now=0,ni=0;
  while(1){
  cin >> m >> minn >> maxn;
  now = 0;
  if(m==0&&maxn==0&&minn==0)break;
  for(i=0;i<m;i++){
    cin >> j;
    p.push_back(j);
  }
  sort(p.begin(),p.end());
  for(i=0;i<m-1;i++)  s.push_back(p[i+1]-p[i]);
  for(i=m-minn-1;i>=m-maxn-1;i--){
    // cout << " bbb"<<s[i];
    if(s[i]>=now){
      now = s[i];
      ni = i;
      //cout <<"aaa"<< now << " "<< ni << endl;
    }
  }
  //cout <<endl<< ni << endl;
  cout << m-1-ni << endl;
  while(p.size())p.pop_back();
  while(s.size())s.pop_back();
  }
  return 0;
}