Problem:
Income Inequality
We often compute the average as the first step
in processing statistical data.
Yes, the average is a good tendency measure of data,
but it is not always the best.
In some cases, the average may hinder the understanding
of the data.
For example, consider the national income of a country.
As the term
income inequality
suggests,
a small number of people earn a good portion of the gross national income
in many countries.
In such cases, the average income computes much higher than the
income of the vast majority.
It is not appropriate to regard the average as the income of typical people.
Let us observe the above-mentioned phenomenon in some concrete data.
Incomes of
n
people,
a
1
, ... ,
a
n
, are given.
You are asked to write a program that reports the number of people
whose incomes are less than or equal to the average
(
a
1
+ ... +
a
n
) /
n
.
Input
The input consists of multiple datasets, each in the following format.
n
a
1
a
2
...
a
n
A dataset consists of two lines.
In the first line, the number of people
n
is given.
n
is an integer satisfying 2 ≤
n
≤ 10 000.
In the second line, incomes of
n
people are given.
a
i
(1 ≤
i
≤
n
) is the income
of the
i
-th person.
This value is an integer greater than or equal to 1 and
less than or equal to 100 000.
The end of the input is indicated by a line containing a zero.
The sum of
n
's of all the datasets does not exceed 50 000.
Output
For each dataset, output the number of people whose incomes are
less than or equal to the average.
Sample Input
7
15 15 15 15 15 15 15
4
10 20 30 60
10
1 1 1 1 1 1 1 1 1 100
7
90 90 90 90 90 90 10
7
2 7 1 8 2 8 4
0
Output for the Sample Input
7
3
9
1
4

Submitted solutions:

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

int main(){
    vector<int>ans(0);
    while(true){
        double n;
        cin >> n;
        if(n==0){
            break;
        }
        vector<double>A(n);
        for(int i=0;i<n;i++){
            cin >> A[i];
        }
        double sum = accumulate(A.begin(),A.end(),0);
        // cout << sum << endl;
        double ave = sum/n;
        // cout << ave << endl;

        int cnt=0;
        for(int i=0;i<n;i++){
            if(A[i]<=ave)cnt++;
        }
        ans.push_back(cnt);       
    }
    for(int i=0;i<ans.size();i++){
        cout << ans[i] << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3284
final_rank: 2

code_snippet: #include <bits/stdc++.h>  
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef queue<int> qi;
typedef priority_queue<int> pqi;
typedef priority_queue<int, vector<int>, greater<int>> mpqi;
typedef pair<int, int> pi;
typedef vector<ll> vl;
#define mp make_pair
#define pb push_back
#define MAX_N 200005
ll INF = 1e18;
#define md107 1000000007
#define rep(i, a, b) for (int i = (int)(a); i <= (int)(b); i++)
#define rrep(i, a, b) for (int i = (int)(a); i >= (int)(b); i--)
typedef vector<vector<int>> vvi;
int n;
void solve(){
    while (true)
    {
        int n; cin >> n;
        if (n == 0) {
            break;
        }
        vi vc(MAX_N, 0);
        ll sum = 0;
        int cnt = 0;
        rep(i, 1, n) {
            cin >> vc[i];
            sum += vc[i];
        }
        float aver = sum / n;
        rep(i, 1, n) {
            if (vc[i] <= aver) cnt++;
        }
        cout << cnt << endl;
    }
    
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    solve();
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 4144
final_rank: 3

code_snippet: #include <iostream> // cout, endl, cin
#include <string> // string, to_string, stoi
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <utility> // pair, make_pair
#include <tuple> // tuple, make_tuple
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include<math.h>
#include <iomanip>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
using namespace std;
typedef long long ll;




//const long long mod=1000000007;
//const long long mod2=998244353;
using ll=long long;

const ll inf=1e18;
using P= pair<ll, ll>;

const int MAX = 200005;
// 今回採用する大きい素数
const int MOD = 1e9+7;

// メモを保管する場所
ll fact[MAX], inv_fact[MAX], inv[MAX];

// メモを計算する
void init() {
    // 初期値設定と1はじまりインデックスに直す
    fact[0] = 1;
    fact[1] = 1;
    inv[0] = 1;
    inv[1] = 1;
    inv_fact[0] = 1;
    inv_fact[1] = 1;
    // メモの計算
    repi(i, 2, MAX){
        // 階乗
        fact[i] = fact[i - 1] * i % MOD;
        // 逆元
        inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
        // 逆元の階乗
        inv_fact[i] = inv_fact[i - 1] * inv[i] % MOD;
    }
}

// 二項係数の実体
ll nCk(int n, int k) {
    ll x = fact[n]; // n!の計算
    ll y = inv_fact[n-k]; // (n-k)!の計算
    ll z = inv_fact[k]; // k!の計算
    if (n < k) return 0; // 例外処理
    if (n < 0 || k < 0) return 0; // 例外処理
    return x * ((y * z) % MOD) % MOD; //二項係数の計算
}


ll pow_pow(ll x,ll n,ll mod){
    if(n==0) return 1;
    x%=mod;
   
    ll res=pow_pow(x*x%mod,n/2,mod);
    if(n&1)res=res*x%mod;
    return res;
}



int extgcd(int a,int b,int &x,int &y){
  int d=a;
  if(b!=0){
    d=extgcd(b,a%b,y,x);
    y-=(a/b)*x;
  }else{
    x=1;y=0;
  }
  return d;
}
int mod_inverse(int a,int m){
  int x,y;
  extgcd(a,m,x,y);
  return (m+x%m)%m;
}

struct UnionFind {
    vector<int> par, siz;

    UnionFind(int n) : par(n, -1) , siz(n, 1) { }

    // 根を求める
    int root(int x) {
        if (par[x] == -1) return x;
        else return par[x] = root(par[x]);
    }

    // x と y が同じグループに属するかどうか (根が一致するかどうか)
    bool issame(int x, int y) {
        return root(x) == root(y);
    }

    // x を含むグループと y を含むグループとを併合する
    bool unite(int x, int y) {
        x = root(x), y = root(y);
        if (x == y) return false; 
        if (siz[x] < siz[y]) swap(x, y);
        par[y] = x;
        siz[x] += siz[y];
        return true;
    }

    // x を含むグループのサイズ
    int size(int x) {
        return siz[root(x)];
    }
};
  
  //min(x,y)が0以下の場合はmax(x,y)が返される
//ユークリッドの互除法を元に実装
ll gcd(ll x,ll y){
    if(y==0)return x;
    return gcd(y,x%y);
}

//オーバフローしないようにかける順番を気を付ける
ll lcm(ll x,ll y){
    return ll(x/gcd(x,y))*y;
}




template<class T> bool chmin(T& a, T b) {
    if (a > b) {
        a = b;
        return true;
    }
    else return false;
}
template<class T> bool chmax(T& a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    else return false;
}

//using Graph1=vector<vector<Edge> >;
//using Graph=vector<vector<int> >;

// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod =  1e9+7;
struct mint {
  ll x; // typedef long long ll;
  mint(ll x=0):x((x%mod+mod)%mod){}
  mint operator-() const { return mint(-x);}
  mint& operator+=(const mint a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += mod-a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator*=(const mint a) { (x *= a.x) %= mod; return *this;}
  mint operator+(const mint a) const { return mint(*this) += a;}
  mint operator-(const mint a) const { return mint(*this) -= a;}
  mint operator*(const mint a) const { return mint(*this) *= a;}
  mint pow(ll t) const {
    if (!t) return 1;
    mint a = pow(t>>1);
    a *= a;
    if (t&1) a *= *this;
    return a;
  }
 
  // for prime mod
  mint inv() const { return pow(mod-2);}
  mint& operator/=(const mint a) { return *this *= a.inv();}
  mint operator/(const mint a) const { return mint(*this) /= a;}
};
istream& operator>>(istream& is, const mint& a) { return is >> a.x;}
ostream& operator<<(ostream& os, const mint& a) { return os << a.x;}
// combination mod prime
// https://www.youtube.com/watch?v=8uowVvQ_-Mo&feature=youtu.be&t=1619
struct combination {
  vector<mint> fact, ifact;
  combination(int n):fact(n+1),ifact(n+1) {
    //assert(n < mod);
    fact[0] = 1;
    for (int i = 1; i <= n; ++i) fact[i] = fact[i-1]*i;
    ifact[n] = fact[n].inv();
    for (int i = n; i >= 1; --i) ifact[i-1] = ifact[i]*i;
  }
  mint operator()(int n, int k) {
    if (k < 0 || k > n) return 0;
    return fact[n]*ifact[k]*ifact[n-k];
  }
  mint p(int n, int k) {
    return fact[n]*ifact[n-k];
  }
} c(1000005);
 



//const ll INF=1e18;


class segment_tree {
private:
	int sz;
	std::vector<int> seg;
	std::vector<int> lazy;
	void push(int k) {
		if (k < sz) {
			lazy[k * 2] = max(lazy[k * 2], lazy[k]);
			lazy[k * 2 + 1] = max(lazy[k * 2 + 1], lazy[k]);
		}
		seg[k] = max(seg[k], lazy[k]);
		lazy[k] = 0;
	}
	void update(int a, int b, int x, int k, int l, int r) {
		push(k);
		if (r <= a || b <= l) return;
		if (a <= l && r <= b) {
			lazy[k] = x;
			push(k);
			return;
		}
		update(a, b, x, k * 2, l, (l + r) >> 1);
		update(a, b, x, k * 2 + 1, (l + r) >> 1, r);
		seg[k] = max(seg[k * 2], seg[k * 2 + 1]);
	}
	int range_max(int a, int b, int k, int l, int r) {
		push(k);
		if (r <= a || b <= l) return 0;
		if (a <= l && r <= b) return seg[k];
		int lc = range_max(a, b, k * 2, l, (l + r) >> 1);
		int rc = range_max(a, b, k * 2 + 1, (l + r) >> 1, r);
		return max(lc, rc);
	}
public:
	segment_tree() : sz(0), seg(), lazy() {};
	segment_tree(int N) {
		sz = 1;
		while (sz < N) {
			sz *= 2;
		}
		seg = std::vector<int>(sz * 2, 0);
		lazy = std::vector<int>(sz * 2, 0);
	}
	void update(int l, int r, int x) {
		update(l, r, x, 1, 0, sz);
	}
	int range_max(int l, int r) {
		return range_max(l, r, 1, 0, sz);
	}
  //cin.tie(0);
  //ios_base::sync_with_stdio(false); これらをmain関数の先頭に
};

const ll seg_size=100005;
ll seg[seg_size*2];

void seg_set(int ind,ll v){
  ind+=seg_size;
  seg[ind]=max(seg[ind],v);
  while(true){
    if(ind==0)break;
    ind/=2;
    seg[ind]=max(seg[ind*2],seg[ind*2+1]);
  }
}

ll seg_take(int l,int r){
  l+=seg_size;
  r+=seg_size;
  ll ans=0;
  while(l<r){
    if(l%2==1){
      ans=max(ans,seg[l]);
      l++;
    }
    l/=2;
    if(r%2==1){
      ans=max(ans,seg[r-1]);
      r--;
    }
    r/=2;

  }
  return ans;
}
struct  Edge{
  int to;ll w;
  Edge(int to,ll w):to(to),w(w){}
};

void comp(vector<int>&a){
  set<int>s(a.begin(),a.end());
  map<int,int>d;
  int cnt=0;
  for(auto x:s)d[x]=cnt++;
  for(auto&x:a)x=d[x];
}

using graph = vector<vector<ll> > ;

int main(){
  vector<ll> ans;
  while(1){
    int n; cin >> n;
    if(n==0)break;
    vector<ll> a(n);
    ll tot=0;
    rep(i,n){
      cin >> a[i];
      tot+=a[i];
    }
    int cnt=0;
    rep(i,n)if(n*a[i]<=tot)cnt++;
    ans.push_back(cnt);
  }
  for(auto u: ans)cout << u << endl;
  
}
accuracy: 1
time_ms: 10
memory_kb: 18932
final_rank: 4

code_snippet: #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<long long> vll;
typedef vector<double> vd;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repll(i, n) for (long long int i = 0; i < n; i++)
#define fin(ans) cout << (ans) << endl
#define P 1000000007
#define STI(s) atoi(s.c_str())  // string to int
#define mp(p, q) make_pair(p, q)
#define All(a) a.begin(), a.end()
#define Sort(a) sort(a.begin(), a.end())


/////////////////////////////////////////

int main(void) {
    /////////////////////////////////////////////////////

    double n;
    while (cin >> n) {
        if (!n) break;

        vd a(n);
        double sum = 0;
        rep(i, n) {
            cin >> a[i];
            sum += a[i];
        }

        int count = 0;
        rep(i, n) {
            if (a[i] <= sum / n) count++;
        }
        cout << count << endl;
    }

    //////////////////////////////////////////////////////
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3228
final_rank: 1