CodeGraderBench/CodeGraderBench huggingface dataset:
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>
main_program
{
    	long double n,r,c,x;
	cin>>n>>r;
	c=n-r;
	if(n>r && n>=1 && r>=1 && n<=35000)
	{
		long double d,a,b,j=1,i=1,k=1;
		a=n;b=r;d=n-r;
		while(a>i)
		{
			n=n*i;
			i=i+1;
		}
		while(b>j)
		{
			r=r*j;
			j=j+1;
		}
		while(d>k)
		{
			c=c*k;
			k=k+1;
		}
		x=n/(r*c);
		cout<<x;
		

	}
}

Grading criterion: Quality and number of comments
Rating A: Well Commented
Rating B: Ok Commented
Rating C: Poor or No Comments
Rating D: 0
Assigned grade: C
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>
main_program{
    long long int n,r,k=1,l;
    long double s=1.0;
    cin>>n>>r;
    l=n-r;
    if(l<r){
        r=l;
    }
    repeat(r){
        s=s*n/k;
        n--;k++;
    }
    cout<<s;
}

Grading criterion: Quality and number of comments
Rating A: Well Commented
Rating B: Ok Commented
Rating C: Poor or No Comments
Rating D: 0
Assigned grade: C
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>
main_program[
float n,r;
cin<<n<<r;
for(int num=1; num<=n; num++){
num *=num;
cout<<num;


}

Grading criterion: Quality and number of comments
Rating A: Well Commented
Rating B: Ok Commented
Rating C: Poor or No Comments
Rating D: 0
Assigned grade: C
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>
main_program{
	int n, r;
	long double a=1, b=1, c=1;
	cin>>n>>r;
	int i=1, j=1, k=1;
	repeat(n){
		a=a*i;
		i++;
	}
	repeat(r){
		b=b*j;
		j++;
	}
	
	repeat(n-r){
		c=c*k;
		k++;
	}
	  long double result=(a/b);
	  long double sum=result/c;
	cout<<sum<<endl;



}

Grading criterion: Quality and number of comments
Rating A: Well Commented
Rating B: Ok Commented
Rating C: Poor or No Comments
Rating D: 0
Assigned grade: C
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>
main_program{

	int n,r;
	cin>>n;
	cin>>r;

	if(r>=1 && r<=n && n>=1 && n<=35000){
		long double a=1;
		for(int i=1; i<=r; i++){
	    a=a*(n+1-i)/i;} 
                     cout<<a;
	}}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>
main_program{
long double ncr,n,r,x;
cin>>n>>r;
x=2;
ncr=n;
while(x<r+1){
ncr=ncr*((n+1-x)/x);
x=x+1;
}
cout<<ncr;

}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include <simplecpp>
main_program
{
    int n; int r; int a; long double nca;
    cin >> n >>  r;
    nca = 1;
    if (r<=(n/2))
    {
    for (a=1; a<=r; a++)
    {
        nca = ((nca)*(n-a+1))/a ;
    }
    cout << nca;
    }
    else 
    {
       for (a=n; a>r; a--)
    {
        nca = ((nca)*a)/(n-a+1) ;  //cout << nca << endl;
    }
    cout << nca; 
    }
}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<iostream>
using namespace std;

int main(){
	long long n, r, fact = 1.0;
	cin >> n >> r;
	for ( int i = n; i >= r;i--){
		long long mulli = n/(r*(n - r));
		fact *= mulli;
		n -= 1;
		r -= 1;}
	cout << fact << endl;
	//next i am going to do the calculation for n-r to 1 and then multiply both
}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>

main_program{

	long n, r;
	cin>>n;
	cin>>r;
	long a=n; 
	long b=r;
	double long adi=1;
	double long adi2=1;

	repeat(r){

		adi=adi*a*1.0/(b);
		a--;
		b--;
	}

	b=r;

	repeat(n-r){

		adi2=adi2*a*1.0/(n-b);
		a--;
		b++;
	}

	cout<<adi*adi2;
}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>
main_program
{
	long double n,r;
	cin>>n>>r;
	long double b=n;
	long double d=n-r;
	long double a=1;
	long double c=1;
	for(int i=1; i<=n-r; i++)
	{
		a=a*b;
		--b;
		c=c*d;
		--d;
	}
	long double ans=(a/c);
	cout<<ans;
}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>
main_program{
long double c=1;
long double n,r;
int t=1;
while(t==r){
c*=(n-t+1)/t;
t=t+1
}
}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: C
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>
main_program{
	long double  n,r;
	long double output=1;
	cin>>n>>r;
	long double a=n-r;

	while(n!=r){
	output*=(n/a);
	n--;
	a--;
	}
	cout<<output;
}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>

main_program{
	int n,r;
	cin>>n>>r;
	 long double binom=1;
	
	if(r<n/2)
		r=n-r;
	
	int i=n-r;
	while(i>0){
		binom*=(n-i);
		binom/=(i);
		
		i--;
	}
	binom=(binom*n)/r;

	cout<<binom;// this code can only handle a difference in inputs of about // 3600 or so,after that it overflows into inf.
}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>
main_program{
long double a,b=1,r,n;
	cin>>n>>r;
	while(b<r){
		n=n*(n-b);
		b++;}
	b=r-1;
a=r;
	while(b>0&&b<=r-1){
		a=a*b;
		b--;}
	cout<<n/a;
}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>
long double c=1 ;
int n,r,a ;

main_program{
	cin>>n >>r ;
	for(a=1;a<=r;a++){
	        c=c/a;
		c=sqrt(c*(n-a+1));
//did this to keep c minimum

	        c=c*c;}
		cout<<c;



}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>
main_program{
 long long unsigned  int n,r,k=1;

 cin>>n>>r;
if(1<=n && n<=3500 & 1<=r && r<=n){
while(r>0){
k=(k*(n-r+1)/r);
r--;


}
cout<<k;}






}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include <simplecpp>

main_program{
long double n, r, j =1;
long double result = 1;

cin >> n >> r;

while(j <= r){
result = result * ((n - r + j)/j);
j++;
}
cout << result;


}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: A
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>
main_program{
	long double n,r;
	cin>>n>>r;
	long double a=n-r;
	long double b=1;
	while(n!=r){
		b=b*n;
		n--;
	}
	long double c=1;
	while(a!=1){
		c=c*a;
		a--;
	}
	cout<<(b/c);
}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include <simplecpp>
main_program{
	double n,r;
	cin>>n>>r;
	long double show=1;
	if(r<=n/2){
	for(int i=0;i<r;i++){
		long double div=(n-i)/(i+1);
		show=show*div;}}
	else{
	for(int i=0;i<n-r;i++){
		long double div=(n-i)/(i+1);
		show=show*div;}}
	
	
	
	cout<<show;
}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: C
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>

main_program{
	long long unsigned int n;
	long long unsigned int r;
	cin >> n >> r;
	long double num = 1;
	long double denom = 1;
	if(r>=n/2){
		r = n-r;
	}
	for(long long unsigned int i=n;i>=n-r+1;i--){
		num *= i;
	}
	for(long long unsigned int i=1;i<=r;i++){
		denom *= i;
	}
	long double ncr =num/denom;
	cout << ncr;
}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include <simplecpp>
main_program{
	long double n,r,p=1;
	cin>>n>>r;
	int t=n-r;
	repeat(t){
		p=n/t*p;
		n--;
		t--;
	}
	cout<<p;
}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>


main_program
{
	long double mult=1 ,fac=1,r ,n,ncr;
	cin>>n>>r;
	long double a=n,diff=(n-r);
	repeat(n-r)
	{
		mult=mult*a;
		a--;
	}

	repeat(n-r)
	{
		fac=fac*diff;
		diff--;
	}

	ncr= mult/fac;
	cout<<ncr;
}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include <simplecpp>

main_program{
    int n, r;
    cin>>n>>r;
    long double ans = 1.0;
    if(r>n-r) {
        r = n-r;
    }

    for (int i = 0; i < r; i++){
        ans *= 1.0*(n-i)/(i+1);
    }
    cout<<ans;
}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>
main_program{
	long double x=1,n,r,i=0;
	cin>>n>>r;
	repeat(r){
		x=x*(n-i)/(r-i);
		i=i+1;
	}
	cout<<x;
}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B
Problem: accept n and r from the user, compute nCr, and print the result. A naive approach would be to calculate the factorial of n, factorial of r, and factorial of n-r and then finally compute the result as given in the formulae above. However, calculating the factorial of a large number can be tricky, and the result may overflow due to the limitation of the size of data type. you are free to use other data types, including long double. you are free to use other data types, including long double.

Constraints:1 <= r <= n1 <= n <= 35000

Student submission:
#include<simplecpp>
main_program{
    long double n, r;
    cin>>n>>r;

    long double nCr=1;

    for( int i=0 ; i<=r-1 ; i++ ){

        nCr=nCr*(1+((n-r)/(r-i)));
    }
    cout<<nCr;

}

Grading criterion: Quality of variable names
Rating A: Good Variable Names
Rating B: Ok variable names
Rating C: poor variable names
Rating D: 0
Assigned grade: B