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>
#include<cmath>
using namespace std;
int main()
{
int N,p=0;
cin>>N;
for(int m=N;m>0;m=floor(m/10))
{
p=10*p+m%10;
}
cout<<p<<endl;
}

Grading criterion: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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 m=0, n, d;
cin >> n;
while(n>0)
{
d=n%10;
n=n/10;
m=m*10+d;
}
cout << m;
}

Grading criterion: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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 int n,m=0;
cin >>n;
while(n!=0){
	m=m*10;
	m+=n%10;
	n=n/10;
	
	}
cout<<m;
}

Grading criterion: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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,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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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;
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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,r;
	cin>>n;
	while(n!=0)
	{r=n%10;
	
	n=n/10;
	cout<<r;
	
	
	
	
	
	}
	
	
	
	
	
	
	
	
	
	
	
	}

Grading criterion: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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,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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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,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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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,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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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 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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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;
	int m = 0, digit;
	while(n>0){
		digit = n%10;
		n = n/10;
		m *= 10;
		m += digit;
	}
	cout<<m;
}

Grading criterion: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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<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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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: Reading Input datatype
Rating A: Correctly Reads an integer as input
Rating B: Fails To Read Input or reads a different datatype
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,cn,rev=0,d;
cin>>n;



if(n/10!=0){
cn=n;
rev=0;
while(cn>0){
d=cn%10;
rev=rev*10+d;
cn=cn/10;
//cout<<rev<<endl;
}
cout<<rev;}
else if(n/10==0){
cout<<n;}
return 0;}

Grading criterion: Placeholder for extra marks to be given for any reason
Rating A: Modularity, Extra Functions Defined, some corrective marks for failed testcases
Rating B: No reason for extra marks
Rating C: 0
Rating D: 0
Assigned grade: B