Problem:
Problem C: Time Manipulation
彼女は見習いの魔法使いだ。
彼女はまず最初に時間を操る魔法を覚えた。
そして彼女は生計を立たせるために酒屋を開くことにした。
彼女の住んでいる国の住人達はみんなお酒が大好き、ということが関係している。
住人達は長い年数をかけて熟成させたお酒が特に好きで、熟成させた年数に応じてその価値も比例して上がる。
50年熟成させたお酒より100年熟成させたお酒のほうが価値が高いのは簡単に想像がつくはずだ。
そして手に入れるのが難しいということも。
彼女は自分の魔法を使って、長い年月熟成させたお酒を一瞬で作って、それを売って収入を得ようとしているのであった。
彼女はお酒を熟成させる年数に応じて値段を決めた。
例えば5年の熟成が必要なら5エメル、100年の熟成なら100エメルを払ってもらうことにした。
彼女にとってはどちらを作るのも同じ魔法を使うだけなので差は無い。
長い年数の熟成の注文の方が彼女にとっては得なのである。
彼女はまだ未熟なので今使える魔法には制約が2つある。
お酒を
n
年より長く熟成させることは今の彼女には出来ない。
また
m
個の整数が存在して、それらとその倍数の年数だけお酒を熟成させることも彼女には無理なのだ。
彼女は酒屋の経営だけ生活が出来るか不安に思っている。
どのくらいの収入を得ることが出来るか彼女には予想できない。
そこで1日の収入の期待値をもとにして、他の仕事をする必要があるかの判断を行うことにした。
幸い彼女は、野菜の栽培、ペットの世話、料理、裁縫、大工仕事など何でもできるので、酒屋での収入が少なくても困ることは無さそうだ。
彼女の1日の収入の期待値を計算するのがあなたの仕事だ。
なお期待値を計算する際に以下の3つを仮定してよい。
1日に引き受ける注文は必ず1つである。
住人は彼女に作れない年数のお酒は注文はしてこない。
住人の注文の年数は一様に分布している。
Input
入力は複数のケースからなる。
各ケースは以下のフォーマットで与えられる。
n
m
p
0
...
p
m-1
住人は
1
以上
n
以下の整数の値の年数だけ熟成させたお酒を依頼してくる。
ただしm個の整数
p
i
とその倍数を依頼してくる人はいない。
入力の終わりは
n
= 0 かつ
m
=0 で与えられる。
各値は以下の条件を満たす
2 ≤
n
≤ 2,000,000,000
1 ≤
m
≤ 20
また
p
i
は
n
を割り切ることが保証されている。
テストケースの数は200以下を超えない。
Output
彼女の一日の収入の期待値を出力せよ。
住人の注文として可能な年数が一つも存在しない場合は0を答えの期待値として出力せよ。
ジャッジが用意した正解の値と1e-5以下の誤差までが正答として許容される。
Sample input
12 3
2 3 6 
12 4
1 2 3 6
0 0
Sample output
6.0000000000
0.0000000000
The University of Aizu Programming Contest 2011 Summer
原案、問題文: Tomoya Sakai

Submitted solutions:

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

unsigned long long popcount(unsigned long long x) {
  x = ((x & 0xaaaaaaaaaaaaaaaaUL) >> 1) +
      (x & 0x5555555555555555UL);
  x = ((x & 0xccccccccccccccccUL) >> 2) +
      (x & 0x3333333333333333UL);
  x = ((x & 0xf0f0f0f0f0f0f0f0UL) >> 4) +
      (x & 0x0f0f0f0f0f0f0f0fUL);
  x = ((x & 0xff00ff00ff00ff00UL) >> 8) +
      (x & 0x00ff00ff00ff00ffUL);
  x = ((x & 0xffff0000ffff0000UL) >> 16) +
      (x & 0x0000ffff0000ffffUL);
  x = ((x & 0xffffffff00000000UL) >> 32) +
      (x & 0x00000000ffffffffUL);
  return x;
}

// calculate |gcd|.
// if  ether num is 0, return 0
long long GCD(long long left, long long right) {
  if(left == 0 || right == 0) return 0;
  if(left < 0) left *= -1;
  if(right < 0) right *= -1;
  if(left < right) swap(left, right);
  long long nextnum, ansgcd = -1;
  while(ansgcd == -1) {
    nextnum = left % right;
    if(nextnum == 0) ansgcd = right;
    left = right;
    right = nextnum;
  }
  return ansgcd;
}

long long LCM(long long left, long long right) {
  return left / GCD(left, right) * right;
}

struct div_moebius {
  long long n, m;
  map<long long, long long> res;
  vector<long long> primes;
  div_moebius() {
    n = m = 0;
    res.clear();
    primes.clear();
  }
  div_moebius(long long newn) {
    div_moebius();
    n = newn;
    for(long long i = 2; i * i <= newn; ++i)
      if(newn % i == 0) {
        primes.push_back(i);
        while(newn % i == 0) newn /= i;
      }
    if(newn != 1) primes.push_back(newn);
    m = primes.size();
    for(long long i = 0; i < (1 << m); ++i) {
      long long mu = 1, d = 1;
      for(long long j = 0; j < m; ++j)
        if(i >> j & 1) {
          mu *= -1;
          d *= primes[j];
        }
      res[d] = mu;
    }
  }
};

long long n, m;
vector<long long> p;
div_moebius dm;

long double solve();

int main() {
  cout << fixed << setprecision(10);
  while(1) {
    cin >> n >> m;
    if(n + m == 0) break;
    p.resize(m);
    for(int i = 0; i < m; ++i) cin >> p[i];
    cout << solve() << endl;
  }
  return 0;
}

long double solve() {
  long double res = (n + 1) * n / 2, cnt = n;
  for(int i = 1; i < (1 << m); ++i) {
    long long now = 1, nowcnt = 0;
    for(int j = 0; j < m; ++j)
      if(i >> j & 1) now = LCM(now, p[j]);
    nowcnt = n / now;
    now *= nowcnt * (nowcnt + 1) / 2;
    if(popcount(i) % 2) {
      cnt -= nowcnt;
      res -= now;
    }
    else {
      cnt += nowcnt;
      res += now;
    }
  }
  if(cnt == 0) return 0;
  return res / cnt;
}
accuracy: 1
time_ms: 400
memory_kb: 3296
final_rank: 8

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <math.h>
using namespace std;
typedef long long int ll;

long long GCD(long long a, long long b) { return b ? GCD(b, a%b) : a; }

long long LCM(long long a, long long b)  {return a/GCD(a,b)*b;}

int main(){
	while(1){
		ll n,m; cin >> n >> m;
		if(n==0&&m==0)break;
		vector<ll>a(m);
		for(int i=0;i<m;i++){
			cin >> a[i];
		}
		double ans=0;
		ll sum=(1+n)*n/2;
		ll cnt=n;
		for(int i=1;i<(1<<m);i++){
			int bit_count=0;
			ll lc=1;
			for(int j=0;j<m;j++){
				if(i&(1<<j)){
					bit_count++;
					lc=LCM(lc,a[j]);
				}
			}
			if(bit_count%2==1){
				sum-=(n/lc+1)*(n/lc)/2*lc;
				cnt-=n/lc;
			}
			else{
				sum+=(n/lc+1)*(n/lc)/2*lc;
				cnt+=n/lc;
			}
		}
		if(cnt==0){
			cout << 0 << endl;
		}
		else{
			ans=(double)sum/cnt;
			printf("%.8f\n",ans );
		}
	}
}
accuracy: 1
time_ms: 380
memory_kb: 3196
final_rank: 5

code_snippet: #pragma GCC optimize("Ofast")
#define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
using namespace::std;
struct __INIT{__INIT(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}} __init;
// random_device rd;
// mt19937 mt(rd());
// #include <boost/numeric/interval.hpp>
// #include <boost/numeric/interval/io.hpp>
// #include <boost/intrusive/rbtree.hpp>
// #include <boost/geometry.hpp>
// #include <boost/geometry/geometries/linestring.hpp>
// #include <boost/geometry/geometries/polygon.hpp>
// #include <boost/geometry/geometries/point_xy.hpp>
// #include <boost/multiprecision/cpp_dec_float.hpp>
// #include <boost/multiprecision/cpp_int.hpp>
// namespace mp = boost::multiprecision;
// typedef mp::number<mp::cpp_dec_float<0>> cfloat;
// typedef mp::cpp_int cint;

#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/priority_queue.hpp>
#include<ext/pb_ds/tag_and_trait.hpp>
using namespace __gnu_pbds;
template<typename T=long long>using pbds=tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
template<typename T=long long>using pqueue =__gnu_pbds::priority_queue<T, less<T>,rc_binomial_heap_tag>;
typedef long long lint;
typedef long long ll;
typedef long double ldouble;
typedef vector<lint> vec;
typedef vector<vector<lint>> mat;
typedef vector<vector<vector<lint>>> mat3;
typedef vector<double> dvec;
typedef vector<vector<double>> dmat;
typedef vector<vector<vector<double>>> dmat3;
typedef vector<string> svec;
typedef vector<vector<string>> smat;
typedef vector<vector<vector<string>>> smat3;
typedef vector<pair<lint,lint>> pvec;
typedef vector<vector<pair<lint,lint>>> pmat;
typedef vector<vector<vector<pair<lint,lint>>>> pmat3;
#define rep(i, n) for(lint i = 0; i < (lint)(n); i++)
#define irep(i) for(lint i = 0;; i++)
#define irep1(i) for(lint i = 1;; i++)
#define irep2(i) for(lint i = 2;; i++)
#define rrep(i, n) for(lint i = (lint)(n-1); i >-1; i--)
#define rrepi(i,a,b) for(lint i = (lint)(b-1); i >a-1; i--)
#define repi(i,a,b) for(lint i=lint(a);i<lint(b);i++)
#define rep2(i,a,b,c) for(lint i=lint(a);i>lint(b);i+=c)
#define all(x) (x).begin(),(x).end()
//#define PI 3.141592653589793
#define dist(x1,y1,x2,y2) (pow(pow(x2-x1,2)+pow(y2-y1,2),0.5))
#define output(v) do{bool f=0;for(auto i:v){cout<<(f?" ":"");if(i>INF/2)cout<<"INF";else cout<<i;f=1;}cout<<"\n";}while(0)
#define output2(v) for(auto j:v)output(j);
#define _output(v) do{bool f=0;rep(i,v.size()){cout<<(f?" ":"");if(v[i]>INF/2)cout<<"INF";else cout<<v[i];f=1;}cout<<"\n";}while(0)
#define _output2(v) rep(j,v.size()){_output(v[j]);}
#define input(a,n) lint n;cin>>n;vector<lint>a(n);rep(i,n)cin>>a[i];
#define SUM(v) accumulate(all(v),0LL)
#define INF (1LL<<60)
#define IINF (1<<30)
#define EPS (1e-10)
#define LINF 9223372036854775807
#define MOD 998244353
#define endl "\n"
template<typename T=lint>T in(){return *istream_iterator<T>(cin);}
inline lint gcd(lint a,lint b){return b?gcd(b,a%b):a;}
template<typename T=lint>inline T lcm(T a,T b){return a/gcd(a,b)*b;}
template<typename T=lint>inline T add(T a,T b){return a+b;}
template<typename T=lint>inline T minq(T a,T b){return min(a,b);}
inline bool chmin(auto& s,const auto& t){bool res=s>t;s=min(s,t);return res;}
inline bool chmax(auto& s,const auto& t){bool res=s<t;s=max(s,t);return res;}
vector<lint> dx={-1,1,0,0,1,1,-1,-1};
vector<lint> dy={0,0,-1,1,1,-1,1,-1};



int main(){
    while(1){
        double n;
        lint m;
        cin>>n>>m;
        if(n==0&&m==0)break;
        vec a(m);
        rep(i,m)cin>>a[i];
        double s=n*(n+1)/2,t=n;
        rep(i,1LL<<m){
            lint cnt=0,val=0;
            rep(j,m){
                if(i&1<<j){
                    cnt++;
                    if(val==0)val=a[j];
                    else val=lcm(val,a[j]);
                }
            }
            if(cnt==0)continue;
            if(cnt%2)t-=n/val;
            else t+=n/val;
            if(cnt%2)s-=val*(n/val)*(n/val+1)/2;
            else s+=val*(n/val)*(n/val+1)/2;
        }
        if(t==0)cout<<0<<endl;
        else cout<<s/t<<endl;
    }
}
accuracy: 1
time_ms: 350
memory_kb: 3260
final_rank: 4

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

typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;

#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcountll

#define INF 1e16
#define mod 1000000007

//// gcd
ll gcd(ll a,ll b){
  return b?gcd(b,a%b):a;
}

//// lcm
ll lcm(ll a,ll b){
  return a*b/gcd(a,b);
}

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

  while(1){
    ll n,m;
    vector<ll> a;
    cin>>n>>m;
    if(n==0&&m==0)break;
    a.resize(m);
    rep(i,m)cin>>a[i];

    ll num=0,sum=0;
    rep(S,(1<<m)){
      ll p=1;
      rep(i,m){
        if((S>>i)&1){
          p=lcm(p,a[i]);
        }
      }
      ll cnt=n/p;
      ll cnts=cnt*(cnt+1)/2;
      if(bcnt(S)%2==0){
        num+=cnt;
        sum+=p*cnts;
      }else{
        num-=cnt;
        sum-=p*cnts;
      }
    }

    if(num>0)printf("%.10f\n", (double)sum/(double)num);
    else printf("0\n");
  }

  return 0;
}
accuracy: 1
time_ms: 380
memory_kb: 3228
final_rank: 6

code_snippet: #include<iostream>
#include<iomanip>
#include<vector>
#include<climits>
using namespace std;
typedef long long ll;

ll gcd(ll a, ll b){
    return b == 0 ? a : gcd(b, a%b);
}

ll lcm(ll a, ll b){
    return a / gcd(a,b) * b;
}

int main(){
    ll n, m;
    while(cin >> n >> m, n+m){
        ll cnt = 0, sum = 0, p[m];
        for(int i = 0; i < m; i++)  cin >> p[i];
        for(int i = 1; i < 1<<m; i++){
            vector<ll> v;
            for(int j = 0; j < m; j++){
                if((i>>j)&1)   v.push_back(p[j]);
            }
            ll val = v[0];
            for(ll j : v){
                val = lcm(val, j);
            }
            int num = v.size();
            if(num%2 == 0)      cnt -= n/val, sum -= n/val*(n/val+1)/2*val;
            else if(num%2 == 1) cnt += n/val, sum += n/val*(n/val+1)/2*val;
        }
        cnt = n-cnt;
        sum = n*(n+1)/2-sum;
        if(cnt == 0)    sum = 0, cnt = 1;
        cout << fixed << setprecision(12) << (double)sum/cnt << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 700
memory_kb: 3260
final_rank: 11

code_snippet: #include<iostream>
#include<iomanip>
#include<vector>
#include<climits>
using namespace std;
typedef long long ll;

ll gcd(ll a, ll b){
    return b == 0 ? a : gcd(b, a%b);
}

ll lcm(ll a, ll b){
    ll tmp = a/gcd(a,b);
    // if(b > LLONG_MAX/tmp)    return -1;
    return a / gcd(a,b) * b;
}

int main(){
    ll n, m;
    while(cin >> n >> m, n+m){
        ll cnt = 0, sum = 0, p[m];
        for(int i = 0; i < m; i++)  cin >> p[i];
        for(int i = 1; i < 1<<m; i++){
            vector<ll> v;
            for(int j = 0; j < m; j++){
                if((i>>j)&1)   v.push_back(p[j]);
            }
            ll val = v[0];
            for(ll j : v){
                if(val == -1)   break;
                val = lcm(val, j);
            }
            if(val == -1)   continue;
            int num = v.size();
            if(num%2 == 0)      cnt -= n/val, sum -= n/val*(n/val+1)/2*val;
            else if(num%2 == 1) cnt += n/val, sum += n/val*(n/val+1)/2*val;
        }
        cnt = n-cnt;
        sum = n*(n+1)/2-sum;
        if(cnt == 0)    sum = 0, cnt = 1;
        cout << fixed << setprecision(12) << (double)sum/cnt << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 870
memory_kb: 3212
final_rank: 12

code_snippet: #include<iostream>
#include<iomanip>
#include<vector>
#include<climits>
using namespace std;
typedef long long ll;

ll gcd(ll a, ll b){
    return b == 0 ? a : gcd(b, a%b);
}

ll lcm(ll a, ll b){
    ll tmp = a/gcd(a,b);
    if(b > LLONG_MAX/tmp)    return -1;
    return a / gcd(a,b) * b;
}

int main(){
    ll n, m;
    while(cin >> n >> m, n+m){
        ll cnt = 0, sum = 0, p[m];
        for(int i = 0; i < m; i++)  cin >> p[i];
        for(int i = 1; i < 1<<m; i++){
            vector<ll> v;
            for(int j = 0; j < m; j++){
                if((i>>j)&1)   v.push_back(p[j]);
            }
            ll val = v[0];
            for(ll j : v){
                if(val == -1)   break;
                val = lcm(val, j);
            }
            if(val == -1)   continue;
            int num = v.size();
            if(num%2 == 0)      cnt -= n/val, sum -= n/val*(n/val+1)/2*val;
            else if(num%2 == 1) cnt += n/val, sum += n/val*(n/val+1)/2*val;
        }
        cnt = n-cnt;
        sum = n*(n+1)/2-sum;
        if(cnt == 0)    sum = 0, cnt = 1;
        cout << fixed << setprecision(12) << (double)sum/cnt << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 1090
memory_kb: 3228
final_rank: 13

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}

const ll INF = 2000000001;

ll lcm(ll x, ll y)
{
    ll ret = x/__gcd(x,y)*y;
    return min(INF,ret);
}

ll s(ll a, ll n)
{
    return n*(n+1)/2*a;
}

double solve(ll n, int m)
{
    vector<ll> p(m);
    rep(i,m) cin >>p[i];

    ll num = 0;
    rep(mask,1<<m)
    {
        ll L = 1;
        rep(i,m)if(mask>>i&1) L = lcm(L,p[i]);

        ll x = n/L;
        if(__builtin_popcount(mask)%2==1) num-=x;
        else num+=x;
    }

    if(num==0) return 0;

    double d = num;
    double ret = 0;
    rep(mask,1<<m)
    {
        ll L = 1;
        rep(i,m)if(mask>>i&1) L = lcm(L,p[i]);

        if(L>n) continue;

        ll x = n/L;
        if(__builtin_popcount(mask)%2==1) ret -= s(L,x)/d;
        else ret += s(L,x)/d;
    }

    return ret;
}

int main()
{
    int n,m;
    while(cin >>n >>m,n) printf("%.10f\n", solve(n,m));
    return 0;
}
accuracy: 1
time_ms: 570
memory_kb: 3212
final_rank: 10

code_snippet: #include <bits/stdc++.h>
#define N 50000
using namespace std;
typedef long long ll;
bool used[N];

ll SumD(ll a,ll d,ll n){return (n*(2*a+(n-1)*d))/2;}

bool mark(ll n){
  bool res=1;
  for(ll i=1;i*i<=n;i++){
    if(n%i)continue;
    if(i<N)res&=!used[i],used[i]=1;
    if(i!=n/i&&n/i<N)res&=!used[n/i],used[n/i]=1;
  }
  return res;
}

int main(){
  while(1){
    ll n,m,p[21];
    cin>>n>>m;
    if(!n&&!m)break;
    for(int i=0;i<m;i++)cin>>p[i];
    sort(p,p+m);
  
    ll sum=0,cnt=0;
    for(int i=0;i<m;i++){
      sum+=SumD(p[i],p[i],n/p[i]);
      cnt+=n/p[i];
      memset(used,0,sizeof(used));
      for(int j=0;j<i;j++){
	ll lcm=(p[i]/__gcd(p[i],p[j]))*p[j];
	if(!mark(lcm))continue;
	sum-=SumD(lcm,lcm,n/lcm);
	cnt-=(n/lcm);
      }
    }

    printf("%.8f\n",(p[0]!=1)*(1.0*SumD(1,1,n)-sum)/max(1LL,(n-cnt)));
  }
  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3308
final_rank: 1

code_snippet: #include <bits/stdc++.h>
#define N 100000
using namespace std;
typedef long long ll;
bool used[N];

ll SumD(ll a,ll d,ll n){return (n*(2*a+(n-1)*d))/2;}

bool mark(ll n){
  bool res=1;
  for(ll i=1;i*i<=n;i++){
    if(n%i)continue;
    if(i<N)res&=!used[i],used[i]=1;
    if(i!=n/i&&n/i<N)res&=!used[n/i],used[n/i]=1;
  }
  return res;
}

int main(){
  while(1){
    ll n,m,p[21];
    cin>>n>>m;
    if(!n&&!m)break;
    for(int i=0;i<m;i++)cin>>p[i];
    sort(p,p+m);
  
    ll sum=0,cnt=0;
    for(int i=0;i<m;i++){
      sum+=SumD(p[i],p[i],n/p[i]);
      cnt+=n/p[i];
      memset(used,0,sizeof(used));
      for(int j=0;j<i;j++){
	ll lcm=(p[i]/__gcd(p[i],p[j]))*p[j];
	if(!mark(lcm))continue;
	sum-=SumD(lcm,lcm,n/lcm);
	cnt-=(n/lcm);
      }
    }

    printf("%.8f\n",(p[0]!=1)*(1.0*SumD(1,1,n)-sum)/max(1LL,(n-cnt)));
  }
  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3380
final_rank: 2

code_snippet: #include <bits/stdc++.h>
#define N 20000000
using namespace std;
typedef long long ll;
bool used[N];

ll SumD(ll a,ll d,ll n){return (n*(2*a+(n-1)*d))/2;}

bool mark(ll n){
  bool res=1;
  for(ll i=1;i*i<=n;i++){
    if(n%i)continue;
    if(i<N)res&=!used[i],used[i]=1;
    if(i!=n/i&&n/i<N)res&=!used[n/i],used[n/i]=1;
  }
  return res;
}

int main(){
  while(1){
    ll n,m,p[21];
    cin>>n>>m;
    if(!n&&!m)break;
    for(int i=0;i<m;i++)cin>>p[i];
    sort(p,p+m);
  
    ll sum=0,cnt=0;
    for(int i=0;i<m;i++){
      sum+=SumD(p[i],p[i],n/p[i]);
      cnt+=n/p[i];
      memset(used,0,sizeof(used));
      for(int j=0;j<i;j++){
	ll gcd=__gcd(p[i],p[j]);
	ll lcm=(p[i]/gcd)*p[j];
	if(!mark(lcm))continue;
	sum-=SumD(lcm,lcm,n/lcm);
	cnt-=n/lcm;
      }
    }
    double ans=1.0*(SumD(1,1,n)-sum)/max(1LL,(n-cnt));
    if(p[0]==1)ans=0;
    printf("%.8f\n",ans);
  }
  return 0;
}
accuracy: 1
time_ms: 730
memory_kb: 22748
final_rank: 16

code_snippet: #include <bits/stdc++.h>
#define N 20000000
using namespace std;
typedef long long ll;
bool used[N];

ll SumD(ll a,ll d,ll n){return (n*(2*a+(n-1)*d))/2;}

bool mark(ll n){
  bool res=1;
  used[1]=0;
  for(ll i=1;i*i<=n;i++){
    if(n%i)continue;
    if(i<N)res&=!used[i],used[i]=1;
    if(i!=n/i&&n/i<N)res&=!used[n/i],used[n/i]=1;
  }
  return res;
}

int main(){
  while(1){
    ll n,m,p[21];
    cin>>n>>m;
    if(!n&&!m)break;
    for(int i=0;i<m;i++)cin>>p[i];
    sort(p,p+m);

  
    ll sum=0,cnt=0;
    for(int i=0;i<m;i++){
      sum+=SumD(p[i],p[i],n/p[i]);
      cnt+=n/p[i];
      memset(used,0,sizeof(used));
      for(int j=0;j<i;j++){
	ll gcd=__gcd(p[i],p[j]);
	ll lcm=(p[i]/gcd)*p[j];
	if(!mark(lcm))continue;
	sum-=SumD(lcm,lcm,n/lcm);
	cnt-=n/lcm;
      }
    }
    double ans=1.0*(SumD(1,1,n)-sum)/max(1LL,(n-cnt));
    if(p[0]==1)ans=0;
    printf("%.8f\n",ans);
  }
  return 0;
}
accuracy: 0.3333333333333333
time_ms: 740
memory_kb: 22800
final_rank: 19

code_snippet: #include <bits/stdc++.h>
#define N 20000000
using namespace std;
typedef long long ll;
bool used[N];

ll SumD(ll a,ll d,ll n){return (n*(2*a+(n-1)*d))/2;}

bool mark(ll n){
  bool res=1;
  for(ll i=1;i*i<=n;i++){
    if(n%i)continue;
    if(i<N)res&=!used[i],used[i]=1;
    if(i!=n/i&&n/i<N)res&=!used[n/i],used[n/i]=1;
  }
  return res;
}

int main(){
  while(1){
    ll n,m,p[21];
    cin>>n>>m;
    if(!n&&!m)break;
    for(int i=0;i<m;i++)cin>>p[i];
    sort(p,p+m);

  
    ll sum=0,cnt=0;
    for(int i=0;i<m;i++){
      sum+=SumD(p[i],p[i],n/p[i]);
      cnt+=n/p[i];
      memset(used,0,sizeof(used));
      for(int j=0;j<i;j++){
	ll gcd=__gcd(p[i],p[j]);
	ll lcm=(p[i]/gcd)*p[j];
	if(!mark(lcm))continue;
	sum-=SumD(lcm,lcm,n/lcm);
	cnt-=n/lcm;
      }
    }
    double ans=1.0*(SumD(1,1,n)-sum)/max(1LL,(n-cnt));
    if(p[0]==1)ans=0;
    printf("%.8f\n",ans);
  }
  return 0;
}
accuracy: 1
time_ms: 730
memory_kb: 22664
final_rank: 15

code_snippet: #include <bits/stdc++.h>
#define N 20000000
using namespace std;
typedef long long ll;
bool used[N];

ll SumD(ll a,ll d,ll n){return (n*(2*a+(n-1)*d))/2;}

bool mark(ll n){
  bool res=1;
  for(ll i=1;i*i<=n;i++){
    if(n%i)continue;
    if(i<N)res&=!used[i],used[i]=1;
    if(i!=n/i&&n/i<N)res&=!used[n/i],used[n/i]=1;
  }
  return res;
}

int main(){
  while(1){
    ll n,m,p[21];
    cin>>n>>m;
    if(!n&&!m)break;
    for(int i=0;i<m;i++)cin>>p[i];
    sort(p,p+m);

  
    ll sum=0,cnt=0;
    for(int i=0;i<m;i++){
      sum+=SumD(p[i],p[i],n/p[i]);
      cnt+=n/p[i];
      memset(used,0,sizeof(used));
      for(int j=0;j<i;j++){
	ll gcd=__gcd(p[i],p[j]);
	ll lcm=(p[i]/gcd)*p[j];
	if(!mark(lcm))continue;
	sum-=SumD(lcm,lcm,n/lcm);
	cnt-=n/lcm;
      }
    }
    double ans=1.0*(SumD(1,1,n)-sum)/max(1,(int)(n-cnt));
    if(p[0]==1)ans=0;
    printf("%.8f\n",ans);
  }
  return 0;
}
accuracy: 1
time_ms: 730
memory_kb: 22800
final_rank: 17

code_snippet: #include <bits/stdc++.h>
#define N 20000000
using namespace std;
typedef unsigned long long ll;
bool used[N];

ll SumD(ll a,ll d,ll n){return (n*(2*a+(n-1)*d))/2;}

bool mark(ll n){
  bool res=1;
  for(ll i=1;i*i<=n;i++){
    if(n%i)continue;
    if(i<N)res&=!used[i],used[i]=1;
    if(i!=n/i&&n/i<N)res&=!used[n/i],used[n/i]=1;
  }
  return res;
}

int main(){
  while(1){
    ll n,m,p[21];
    cin>>n>>m;
    if(!n&&!m)break;
    for(int i=0;i<m;i++)cin>>p[i];
    sort(p,p+m);

  
    ll sum=0,cnt=0;
    for(int i=0;i<m;i++){
      sum+=SumD(p[i],p[i],n/p[i]);
      cnt+=n/p[i];
      memset(used,0,sizeof(used));
      for(int j=0;j<i;j++){
	ll gcd=__gcd(p[i],p[j]);
	ll lcm=(p[i]/gcd)*p[j];
	if(!mark(lcm))continue;
	sum-=SumD(lcm,lcm,n/lcm);
	cnt-=n/lcm;
      }
    }
    double ans=1.0*(SumD(1,1,n)-sum)/max(1,(int)(n-cnt));
    if(p[0]==1)ans=0;
    printf("%.8f\n",ans);
  }
  return 0;
}
accuracy: 1
time_ms: 730
memory_kb: 22660
final_rank: 14

code_snippet: #include <bits/stdc++.h>
#define N 20000000
using namespace std;
typedef long long ll;
bool used[N];

ll SumD(ll a,ll d,ll n){return (n*(2*a+(n-1)*d))/2;}

bool mark(ll n){
  int res=1;
  used[1]=0;
  for(ll i=1;i*i<=n;i++){
    if(n%i)continue;
    if(i<N)res*=!used[i],used[i]|=1;
    if(i!=n/i&&n/i<N)res*=!used[n/i],used[n/i]|=1;
  }
  return res;
}

int main(){
  while(1){
    ll n,m,p[21];
    cin>>n>>m;
    if(!n&&!m)break;
    for(int i=0;i<m;i++)cin>>p[i];
    sort(p,p+m);

  
    ll sum=0,cnt=0;
    for(int i=0;i<m;i++){
      sum+=SumD(p[i],p[i],n/p[i]);
      cnt+=n/p[i];
      memset(used,0,sizeof(used));
      for(int j=0;j<i;j++){
	ll gcd=__gcd(p[i],p[j]);
	ll lcm=(p[i]/gcd)*p[j];
	if(!mark(lcm))continue;
	sum-=SumD(lcm,lcm,n/lcm);
	cnt-=n/lcm;
      }
    }

    double ans=1.0*(SumD(1,1,n)-sum)/max(1LL,(n-cnt));
    if(p[0]==1)ans=0;
    printf("%.8f\n",ans);
  }
  return 0;
}
accuracy: 0.3333333333333333
time_ms: 740
memory_kb: 22812
final_rank: 20

code_snippet: #include <bits/stdc++.h>
#define N 20000000
using namespace std;
typedef long long ll;
bool used[N];

ll SumD(ll a,ll d,ll n){return (n*(2*a+(n-1)*d))/2;}
bool mark(ll n){
  int res=1;
  used[1]=0;
  for(ll i=1;i*i<=n;i++){
    if(n%i)continue;
    if(i<N)res*=!used[i],used[i]|=1;
    if(i!=n/i&&n/i<N)res*=!used[n/i],used[n/i]|=1;
  }
  return res;
}

int main(){
  while(1){
  ll n,m;
  cin>>n>>m;
  if(!n&&!m)break;
  int p[21];
  for(int i=0;i<m;i++)cin>>p[i];
  sort(p,p+m);

  
  ll sum=0,cnt=0;
  for(int i=0;i<m;i++){
    sum+=SumD(p[i],p[i],n/p[i]);
    cnt+=n/p[i];
    memset(used,0,sizeof(used));
    for(int j=0;j<i;j++){
      ll gcd=__gcd(p[i],p[j]);
      ll lcm=(p[i]/gcd)*p[j];
      if(!mark(lcm))continue;
      sum-=SumD(lcm,lcm,n/lcm);
      cnt-=n/lcm;
    }
  }
  double ans=1.0*(SumD(1,1,n)-sum)/max(1LL,(n-cnt));
  if(p[0]==1)ans=0;
  printf("%.8f\n",ans);
  }
  return 0;
}
accuracy: 0.3333333333333333
time_ms: 720
memory_kb: 22700
final_rank: 18

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

#define int long long
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define all(v) (v).begin(),(v).end()
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define pb push_back
#define fi first
#define se second
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}

int gcd(int a,int b){
    return b?gcd(b,a%b):a;
}
int lcm(int a,int b){
    return a/gcd(a,b)*b;
}

int N,M;
int P[20];

signed main(){
    while(cin>>N>>M,N||M){
        rep(i,M)cin>>P[i];

        int cnt=0;
        int sum=0;
        reps(i,1,1<<M){
            int a=1;
            rep(j,M)if(i>>j&1){
                a=lcm(a,P[j]);
                if(a>N)break;
            }
            int popcnt=__builtin_popcountll(i);
            int tmp=(a+N)*(N/a)/2;
            if(popcnt&1){
                sum+=tmp;
                cnt+=N/a;
            }
            else{
                sum-=tmp;
                cnt-=N/a;
            }
        }
        sum=N*(N+1)/2-sum;
        cnt=N-cnt;

        if(cnt==0)printf("%.20f\n",0.0);
        else printf("%.20f\n",1.0*sum/cnt);
    }
    return 0;
}
accuracy: 1
time_ms: 390
memory_kb: 3212
final_rank: 7

code_snippet: #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class t>
using table = vector<vector<t>>;
const ld eps = 1e-9;

//// < "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\a.txt" > "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\b.txt"
  
long long int gcd(long long int l, long long int r) {
	if (l > r)return gcd(r, l);
	else {
		if (r%l) {
			return gcd(l, r%l);

		}
		else {
			return l;
		}
	}
}

int main() {
	cout << setprecision(11) << fixed;
	while (1) {
		int N, M; cin >> N >> M;
		ld sum = 0;
		ld year = 0;
		if (!N)break;
		vector<long long int>nums(M);
		for (int i = 0; i < M; ++i)cin >> nums[i];
		for (int i = 0; i < (1 << M); ++i) {
			bitset<20>bs(i);
			long long int anum = 1;
			for (int j = 0; j < M; ++j) {
				if (bs[j]) {
					anum = anum*nums[j] / gcd(anum, nums[j]);
				}
			}
			ld asum = N / anum;
			ld ayear= (anum + N)*(N / anum) / 2;
			if (bs.count() % 2) {

				sum -= asum;
				year -= ayear;
			}
			else {

				sum += asum;
				year+= ayear;
			}
		}
		if (sum < eps)cout << 0 << endl;
		else 	cout << year/ sum << endl;
	
	}
	return 0;
}
accuracy: 1
time_ms: 430
memory_kb: 3288
final_rank: 9

code_snippet: #include<iostream>
#include<iomanip>
using namespace std;
long long n, m, a[20];
int gcd(int a, int b) {
	if (b == 0)return a;
	return gcd(b, a%b);
}
int main() {
	while (true) {
		cin >> n >> m;
		if (n == 0 && m == 0)break;
		for (int i = 0; i < m; i++)cin >> a[i];
		long long S = 0, L = 0;
		for (int i = 0; i < (1 << m); i++) {
			long long bit[20], cnt = 0, lcm = 1;
			for (int j = 0; j < m; j++) { bit[j] = (i / (1 << j)) % 2; }
			for (int j = 0; j < m; j++) { cnt += bit[j]; }
			for (int j = 0; j < m; j++) {
				if (bit[j] == 1) {
					lcm *= (a[j] / gcd(lcm, a[j]));
				}
			}
			long long K = ((n / lcm) + 1) *(n / lcm) / 2 * lcm;
			if (cnt % 2 == 0) { S += K; L += n / lcm; }
			if (cnt % 2 == 1) { S -= K; L -= n / lcm; }
		}
		if (L == 0)L = 1;
		cout << fixed << setprecision(15) << 1.0l*S / L << endl;
	}
	return 0;
}
accuracy: 1
time_ms: 420
memory_kb: 1236
final_rank: 3