C++ choose函数代码示例

static int key(W_Event *data)
{
  if (data->y == (metaHeight-B_ADD)) return add_key(data);
  if (data->key == 113 || data->key == 196) { /* q or ^d */
    metadone();
    terminate(0);
  } else if (data->key == 114 || data->key == 210) { /* r or ^r */
    refresh();
  } else if (data->key == W_Key_Up) {
    choose(-1);
  } else if (data->key == W_Key_Down) {
    choose(1);
  } else if (data->key == '\r' || data->key == ' ') { /* enter or space */
    if (chosen != -1) return chose(chosen, W_LBUTTON);
  } else if (data->key == 'g') { /* g, for guest */
    if (chosen != -1) return chose(chosen, W_MBUTTON);
  } else if (data->key == 'o') { /* o, for observe */
    if (chosen != -1) return chose(chosen, W_RBUTTON);
  } else if (data->key == 'h') {
    toggle_help();
  } else {
    return button(data);
  }
  return 0;
}

int main()
{
	int caseNumber = 1;
	scanf("%d", &numOfCases);
	while(numOfCases--)
	{
		memset(dp, -1, sizeof dp);
		scanf("%lld %lld", &N, &K);
		long long array[N];
		for(long long i = 0; i < N; i++)	scanf("%lld", &array[i]);
		std::sort(array, array + sizeof(array)/sizeof(array[0]));
		//for(int i = 0; i < N; i++)	printf("%d ", array[i]);
		//printf("\n"); 
		long long num = choose(N, K);
		long long sum = 0;
		while(num--)
		{
			sum += choose(N-1, K-1);
		}
		printf("case #%d: %lld\n", caseNumber, sum);
		caseNumber++;
		return 0;
	}	
	return 0;
}

/**
 * Description not yet available.
 * \param
 */
void lvector::fill_multinomial(const int& seed, const dvector& p)
  // Fils a dvector with random numbers drawn from a multinomial distribution
  {
    double sum=mean(p)*p.size();
    int pmin=p.indexmin();
    int pmax=p.indexmax();
    dvector tmp(pmin,pmax);
    dvector tmp1(pmin,pmax);
    dvector choose(indexmin(),indexmax());
    choose.fill_randu(seed);
    tmp=p/sum;
    tmp1(pmin)=tmp(pmin);
    for (int j=pmin+1;j<=pmax-1;j++)
    {
      tmp1(j)=tmp1(j-1)+tmp(j);
    }
    tmp1(pmax)=1.0;

    for (int i=indexmin();i<=indexmax();i++)
    {
      int j=pmin;
      while (choose(i)>tmp1(j))
      {
        j++;
      }
      (*this)(i)=j;
    }
  }

real
choose(int n, int k) {
	if (n <= 0)
		return 1;
	if (k <= 0)
		return 1;
	if (n < k)
		return n;
	// Recurse if n is too high
	if ( (fact(n) == 0.) || isinf(fact(n)) )
		return choose(n-1, k-1)+choose(n-1, k);
	return fact(n)/(fact(k)*fact(n-k));
}

long long choose(long long n, long long k)
{
	if(dp[n][k] != -1)	return dp[n][k];
	if(n < k)	return 0;
	if(n == 0)	return 0;
	if(k == 0)	return 1;
	if(n == k)	return 1;
	if(1 == k)	return n;
	else return (choose(n-1, k-1) + choose(n-1, k));	
}

//computes n choose m
mwSize choose(mwSize m, mwSize n)
{
   if(m > n) return 0;
   if(m == 0) return 1;
   if(m == 1) return n;
   if(m == n) return 1;
   if(m == (n-1)) return n;

   return(choose(m, n-1) + choose(m-1, n-1));
}

int choose(int n, int r)
{
	static int memo[100][100];

	if(memo[n][r] != 0 )
		return memo[n][r];

	if(r == 0 || n ==r)
		return memo[n][r] = 1;
	else
		return memo[n][r] = choose(n-1, r-1) + choose(n-1, r);
}

void Login_3()//教室登陆验证函数
{

	FILE *fp_1;
	FILE *fp_2;
	int find = 0;
	char Userstrcat[22] = { 0 };
	char Userdata[22] = { 0 };
	fp_1 = fopen("dataT.dat", "rb");
	fp_2 = fopen("dataL.dat", "wb");
	printf("================================================================================");
	printf("\n  Teacher,Please enter the information of yourself to register11\n ");
	/*
	printf("  ID :");
	fflush(stdin);
	gets(INPUT);
	printf("\n");
	printf("   Password :");
	fflush(stdin);
	gets((*Input).Password);
	*/
	scanf("%s %s", INPUT_1[IN].ID, INPUT_1[IN].Password);
	fwrite(&INPUT_1[IN], sizeof(struct Login_1), 1, fp_2);
	printf("\n                                                              Logining..........");
	printf("\n                                                              Please wait.......\n");


	while (!feof(fp_1))
	{
		fread(Userdata, sizeof(struct Login_1), 1, fp_1);
		if (strcmp(Userstrcat, Userdata) == 0)
		{
			getchar();
			printf("\n                                                              Login Successful!\n");
			printf("                                                             %s,Welcome back!\n", INPUT_1[IN].ID);
			find = 1;
			printf("===============================================================================");
			printf("\n\n                                                               Enter to next ");
			getchar();
			system("cls");
			choose();
			break;
		}
	}
	if (!find)
	{
		choose();
		//printf("\n  Login failed! Pleas try again!\n");
	}
	fclose(fp_1);
	fclose(fp_2);
}

int main(void)
{
  int n = 2, m = 3;

  f(&a, &b);
  f(&c, &d);

  b = choose (0, n, m);
  a += choose (1, n, m);

  a += fs163_main (10);

  return a;
}

int main(void) {
    printf("Starting.\n");
    int count = 0;
    int n=0;
    int r=0;
    /* printf("upper int limit %d\n", INT_MAX); */
    /* printf("factorial(23) %d\n", factorial(23)); */
    /* printf("choose(23, 10) %d\n", choose(23,10)); */

    for(n=1; n <= N; n++) {
        for(r=0; r <= n; r++) {
        /* for(r=0; r <= n/2 + 1; r++) { */
            /* printf("%d choose %d\n", n, r); */
            mpz_t ans;
            choose(ans, n, r);
            gmp_printf("%d choose %d is %Zd\n", n, r, ans);
            if (mpz_cmp_ui(ans , 1000000) > 0) {
                count++;
            }
        }
    }

    printf("Answer %d\n", count);

    return 0;
}

constraint mk_class_instance_cnstr(std::shared_ptr<class_instance_context> const & C, local_context const & ctx, expr const & m, unsigned depth) {
    environment const & env = C->env();
    justification j         = mk_failed_to_synthesize_jst(env, m);
    auto choice_fn = [=](expr const & meta, expr const & meta_type, substitution const &, name_generator const &) {
        if (auto cls_name_it = is_ext_class(C->tc(), meta_type)) {
            name cls_name = *cls_name_it;
            list<expr> const & ctx_lst = ctx.get_data();
            list<expr> local_insts;
            if (C->use_local_instances())
                local_insts = get_local_instances(C->tc(), ctx_lst, cls_name);
            list<name>  insts = get_class_instances(env, cls_name);
            if (empty(local_insts) && empty(insts))
                return lazy_list<constraints>(); // nothing to be done
            // we are always strict with placeholders associated with classes
            return choose(std::make_shared<class_instance_elaborator>(C, ctx, meta, meta_type, local_insts, insts, j, depth));
        } else {
            // do nothing, type is not a class...
            return lazy_list<constraints>(constraints());
        }
    };
    bool owner      = false;
    bool relax      = C->m_relax;
    return mk_choice_cnstr(m, choice_fn, to_delay_factor(cnstr_group::Basic),
                           owner, j, relax);
}

 long long int choose(int n,int k)
 {
         if(k>n)
             return 0;
     if(n<=1)
         return 1;
     if(k==0)
         return 1;
  
         if(nck[n][k]!=-1)
             return nck[n][k];
         long long int answer = choose(n-1,k-1) + choose(n-1,k);
         answer%=MOD;
         nck[n][k] = answer;
         return answer;
 }

void KDTree<Dim>::buildKDTree(int dimension, int bottom, int top)
{
    if(top == bottom)
    {
        return; //"base case"
    }

    int middle = (top+bottom)/2;//declare middle

    //call the "choose" helper function to sort of split this thing
    choose(middle, bottom, top, dimension);



    if(top > middle) //check upper end
    {
        //make recursive call
        buildKDTree((dimension+1)%Dim, middle+1, top); //call this thing on the upper end
    }

    if(bottom < middle) //check lower end
    {
        //make recursive call
        buildKDTree((dimension+1)%Dim, bottom, middle-1); //call this thing on the lower end
    }



}

double dwilcox(double x, double m, double n, int give_log)
{
    double d;

#ifdef IEEE_754
    /* NaNs propagated correctly */
    if (ISNAN(x) || ISNAN(m) || ISNAN(n))
	return(x + m + n);
#endif
    m = R_forceint(m);
    n = R_forceint(n);
    if (m <= 0 || n <= 0)
	ML_ERR_return_NAN;

    if (fabs(x - R_forceint(x)) > 1e-7)
	return(R_D__0);
    x = R_forceint(x);
    if ((x < 0) || (x > m * n))
	return(R_D__0);

    int mm = (int) m, nn = (int) n, xx = (int) x;
    w_init_maybe(mm, nn);
    d = give_log ?
	log(cwilcox(xx, mm, nn)) - lchoose(m + n, n) :
	    cwilcox(xx, mm, nn)  /  choose(m + n, n);

    return(d);
}

int main( int argc,char **argv )
{
  int arg = argc>1 ? atoi( argv[1] ) : 0;
  choose( arg );

  return( arg );
}