CodeGraderBench/CodeGraderBench huggingface dataset:
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

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

int main()
{
	int n,m=0,digit; cin>> n;
	int n1 = n;
	while (n1!=0){
		digit = n1%10;
		n1 = n1/10;
		m += digit;
		m *= 10;
	}	
	m = m/10;
	cout<< m;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include <iostream>
using namespace std;
int main(){
int n,r,y=0;
cin >> n;
if (n>0) {
while(n>0 ) {
r = n%10;
n = n/10;
if (r == 0) {continue;}
y = 10*y + r;
}
}
cout << y;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main(){
int n;
cin>>n;
int r=0;
int rev=0;
if (n==0) cout<<0;
while(n!=0){
r=n%10;
n=n/10;
rev=(rev*10)+r;
}
cout<<rev;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main()
{
int n,m=0;
cin>>n;
while(n%10==0){
n=n/10;}
while(n>0)
{m=m*10+n%10;
n=n/10;}
cout<<m;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

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

int main(){
int n,m=0;
cin >> n;
while (n%10==0) n=n/10;

while (n>0){
m=m+n%10;
n=n/10;
m=m*10;
}

m=m/10;

cout<<m;

return 0;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main()
{
 int n,a=0;
 cin>>n;
 for (int i = 1 ; i < 10*n; i++)
 {
  if ((n>0) && (n<10)) a = 10*a + n;
  else a = 10*a + (n%10);
  n = n/10;
 }
 cout<<a;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main(){
int a,b,c,e,n;
cin>>n;
a=n%10;
e=n/10;
b=e%10;
c=n/100;
cout<<a<<b<<c;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
	int main()
	{int n,m,r;
	cin>>n;
	while(n!=0)
	{r=n%10;
	
	n=n/10;
	cout<<r;
	
	
	
	
	
	}
	
	
	
	
	
	
	
	
	
	
	
	}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main(){
int n,d;
cin>>n;
d=n%10;
while(d==0 && n>0){
n=n/10;
d=n%10;}
while( n>0){
cout<<d;
n=n/10;
d=n%10;}
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include <iostream>
using namespace std;
int main(){
long long int n,x;
cin>>n;
for(long long int i=10;i<=10*n;i*=10)
{
   if(n%i==0)
   continue;
   x=i;
   break;
}
for(long long int p=x;p<=10*n;p*=10)
{
    cout<<(((n%p)-(n%(p/10)))/(p/10));
}
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
#include<cmath>
using namespace std;
int main(){
int n,l,m;
cin>>n;
m=(n%10);
n=((n-(n%10))/10);
while(n>=1){
l=n%10;
m=m*10+l;
n=((n-(n%10))/10);}
cout<<m;}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

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

int main()
{

int n,m, num=0,digit,sum=0;
bool flag=0;
cin>>n;
m=n;


while(m>0)
{
m=m/10;
num += 1;
}

m=n;

for(int i=num-1;i>=0;i--)
{
digit=m%10;
m=m/10;
if(digit==0 && flag==0) continue;
else
{
if(digit!=0 && flag==0) {flag=1;}
int prod=1;
for(int l=1;l<=i;l++)
{prod*=10;}
sum+=digit*prod;
}}

cout<<sum;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main(){
	long long int n,ans;int digit,prev=0;
	cin>>n;
	for(n>0;n>0;n=n/10){digit=n%10;
		ans=10*prev+digit;
		prev=ans;}
	cout<<ans;
	return 0;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

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

int main(){
	int n; cin>>n;
	bool end = true;
	int m = 0;
	while (n!=0){
		int r = n%10;
		int q = n/10;
		n=q;
		if(r==0 && end){
			continue;
		}
		else{
			m = m*10+r;
			end = true;
		}
		
	}
	cout<<m;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main(){
int num,rev,c;
rev=0;
cin>>num;
while(num>0)
{c=num%10;
rev=rev*10+c;
num=num/10;
}
cout<<rev;
return 0;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main(){
int n,m=0;
cin>>n;
while(n!=0){
int remainder=n%10;
m=10*m+remainder;
n=n/10;

}
cout<<m;}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main()
{ int n,m=0;
  cin>>n;
  while(n%10==0)
  {n=n/10;}
  while(n>0)
  {m=m*10+n%10;
   n=n/10;}
   cout<<m;}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

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

int main()
{
	int n,p=0;
	cin >> n;
	for(int m=n;m>0;m/=10)
	{
		int d=m%10;
		p=p*10+d;
	}
	cout << p;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main ()
{
	unsigned long long int n;
	cin >> n;
	
	unsigned long long int t = n, m = 0;

	while (t!=0)
	{
		unsigned long long int d = t % 10;
		
		m = m*10 + d;
		t = t/10;
	}
	cout << m;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
int n,a,c,d,m=0,b=0;cin>>n;
a=n%10;
while(a=0)
{
n/=10;a=n%10;b+=1;
}
c=d=n/pow(10,b);
while(d>0)
{
b+=1;d/=10;
}
a=c%10;
while(c>0)
{
m+=a*pow(10,b-1);
c/=10;a=c%10;b--;
}
cout<<m;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

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

int main()
{

int n,m= 0;
cin >> n;
while(n > 0)
{
int d = n % 10;
m = m*10 + d;
n = n /10;
}

cout << m;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include <iostream>
using namespace std;
int main()
{
long long int n,a,m=0;
cout<<"";
cin >> n;
while(n>0)
{
a=n%10;
m=m*10+a;
n=n/10;
}
cout<< m;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main(){
int n;
cin>>n;
if (n==9870){cout<<789;}
else if (n==789){cout<<987;}
else if (n==919){cout<<919;}
else if (n==6){cout<<6;}
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main(){
	int n;
	cin>>n;
	int m = 0, digit;
	while(n>0){
		digit = n%10;
		n = n/10;
		m *= 10;
		m += digit;
	}
	cout<<m;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main(){
int n,m=0,l=-1,p;cin>>n;
for(int k=1;n>=1;k++){
p=m;m=n%10;
if(k==1 && m==0) { n=n/10;continue;}
n=(n-m)/10;
if(l+1<k && m==0 && p==0) continue;
l=k;cout<<m;}
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main()
{ 
int n,m=0,l;
cin>>n;
while(n>0){
	l=n%10;
	m=(m+l)*10;
	n=n/10;
	}
cout<<m/10;	
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include <iostream>

using namespace std;
int main()
{
unsigned int n,m=0;
cin >> n;

while(n!=0)
{
m=(m*10)+(n%10);
n=n/10;
}

cout << m;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
#include<cmath>
int main() {
	int n, m, rem=0;
	while(n!=0) {
		m=m%10;
	    m += m*10 + rem;
	    m /= 10;
	    cout << m 
	}
	return 0;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main(){
int n;cin>>n;
for (int m=n;m>0;m=m/10) {
int i=m%10;
if (i==0) continue;
cout<<i;}
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<simplecpp>
main_program{
int n;
cin>>n;
int rev=0,rem;

while(n!=0)
{
	rem=n%10;
	rev=(rev*10)+rem;
	n/=10;
}
cout<<rev;

}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main(){
int n,k;
cin>>n;
for(int i=1;true;i++){
if(n%10==0) {n=n/10;}
else break;}
for(int i=1;n!=0 ;i++){
k=n%10;cout<<k;
n=(n-k)/10;}
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main(){
int n;

cin>>n;
if(n>0){
int rev=0;int rem;
while(n>0){
	rem=n%10;
	rev=rev+rem;
	n=n/10;
	rev*=10;}
rev/=10;
cout<<rev;
}
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program that takes a positive integer n as input from the user and prints a number m whose digits are in reverse order as compared to n. If the number ends in one or more zeroes, then those zeroes should be ignored while printing the reverse.

Student submission:
#include<iostream>
using namespace std;
int main(){
	int n,m=0,rem;
	cin>>n;
	while(n!=0){rem=n%10;
	m=m*10+rem;
	n /= 10;}
		cout<<m;
}

Grading criterion: Storing the reverse of number in a variable
Rating A: Correct output stored
Rating B: No output or wrong output stored
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program to accept two numbers from the user start and end and print the Pythagorean triplets within the range of start to end, both inclusive, but the triplets should not have any common factor. If no such triplets exist, then print 0. The triplets should be in increasing order.

Student submission:
#include<simplecpp>

main_program
{
int i = 0;
int a,b;
int m = 3;
cin>>a>>b;
if(a>3 || b<5){
while(a<((m*m)-1) && a<2*m && ((m*m)+1)<b)
{
cout<<2*m<<" "<<(m*m)-1<<" "<<((m*m)+1)<<endl;
m++;
i++;
}}
if(a<3 && b>5)
{
	cout<<3<<" "<<4<<" "<<5<<endl;
while(a<((m*m)-1) && a<2*m && ((m*m)+1)<b)
{
cout<<2*m<<" "<<(m*m)-1<<" "<<((m*m)+1)<<endl;
m++;
i++;
}
}

if(i == 0)
{
	cout<<0;
}
}

Grading criterion: Check whether the common factors are calculated correctly
Rating A: correct
Rating B: incorrect
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program to accept two numbers from the user start and end and print the Pythagorean triplets within the range of start to end, both inclusive, but the triplets should not have any common factor. If no such triplets exist, then print 0. The triplets should be in increasing order.

Student submission:
#include<simplecpp>
main_program{
             int start;
	     int end;
	     cin>>start;
	     cin>>end;
	     int a;int b; int c;
	     
	     a=start;b=a+1;
	    
	     
	     
             while(start<=a && a<=end){
		     while(start<=b && b<=end){c=pow(((a*a)+(b*b)),0.5);
			     
			     if(start<=c && c<=end )
			     
			     {
				     cout<<a<<" "<<b<<" "<<c<<endl;}
			     b++;} 
		     a++;}


}
















































/*	int m,n;
	cin>>m;
	cin>>n;
	int small;
	int large;
	large=m;
	small=n;
	if(n>m){large=n;
		small=m;}
	for(int i=1;i<=small;i++){
	   if(large%i==0 && small%i==0){cout<<i<<endl;}}*/

Grading criterion: Check whether the common factors are calculated correctly
Rating A: correct
Rating B: incorrect
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program to accept two numbers from the user start and end and print the Pythagorean triplets within the range of start to end, both inclusive, but the triplets should not have any common factor. If no such triplets exist, then print 0. The triplets should be in increasing order.

Student submission:
#include<simplecpp>
main_program{
   int start,end;
   cin >> start >> end;
  int flag=0;
   while(start<end){
         int a,b,c;
	 float d;
	 a=start;
	
	   for(b=a+1;b<end;b++){
          c=sqrt(a*a + b*b);
	  d=sqrt(a*a + b*b);
	      if (c==d && c<=end){
		    /*     
		      int e;
		      for(e=2; e<a; e++){
			      if(a%e==0 && b%e==0 && c%e==0  ){
	                              flag=1;     
			      }
		   }
		        
                            if (flag=0){*/
			       cout << a << " "<< b << " " << c<< endl;
			      }
	      }
	
	   start++;
	      
           }
       
   
   }

  
 /* 
   if (flag==0){
     cout<<"0"<< endl;
   }
*/

Grading criterion: Check whether the common factors are calculated correctly
Rating A: correct
Rating B: incorrect
Rating C: 0
Rating D: 0
Assigned grade: B