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,num,rem,m=0;
cin>>n;
num=n;
while(num>0){
rem=num%10;
num=num/10;
m=10*m+rem;
}
cout<<m;
return 0;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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()
{
long long int n;
cin>>n;
long long int nn=n;
int c=-1;
long long int d=0;
while (n!=0)
{n=n/10;
c++;
}
while(nn!=0)
{d=d+(nn%10)*pow(10,c);
c--;
nn=nn/10;
}
cout<<d;;
return 0;

}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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;
int  x1,x2,x3,x4;
cin>>n;
x1=(n%10);
x2=(n%100)/10;
x3=(n%1000)/100;
int y1=floor(x1),y2=floor(x2),y3=floor(x3),y4=floor(x4);
cout<<y1<<y2<<y3<<y4;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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){
		m=m*10+n%10;
		n=n/10;
	}
	cout<<m;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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=0,t;
cin>>n;
while(n>0){
t=n%10;
m=m*10+t;
n=n/10;}
cout<<m;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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 power (int d){
	int j=1;
	for (int i=0; i<d;i++)
	  j=j*10;
	
	return j;
}
int main ()
{
	int n,a,b,c;
	cin >> n;
	a=1;
	b=0;
	c=1;
	while (n/a>0)
	{
		a=a*10;
		b++;
	}

	while (c<=b)
	{  
		if (c==1&& (n%power(c))*10/power(c)==0)
		{ while ((n%power(c))*10/power(c)==0){
			c++; 
		}
		}
		cout<< (n%power(c))*10/power(c);
		c++;
	
	}
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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=0;
 cin >> n;
 while(n!=0)
 {
  m=m*10+n%10;
  n/=10;
 }
 cout << m;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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 digits=1,n;
	cin >> n;
	int n1;
	n1=n;
	while((n/10)!=0){
		digits++;
		n=n/10;
	}
	int ans=0;
	while(n1!=0){
		int q=0;
		q=n1%10;
		for(int i=0;i<digits-1;i++){q=q*10;}
		digits--;
		ans=ans+q;
		n1=n1/10;
	}
	cout << ans;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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,mn=0;
cin>>n;
while(n>0){
m=n%10;
n=n/10;
mn=mn*10+m;
}
cout<<mn;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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;
while(n%10==0){n=n/10;}
while(n>0){
cout<< n%10;
n=n/10;
}

}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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;
cin>>n;
m=n;
int i,d,j,s;
s=0;
for(j=0;m>0;j++){m=m/10;}
int l;
l=j;
for(i=0;i<l;n/=10,i++,j--)
{d=n%10;
s=s+d*pow(10,(j-1));}
cout<<s;}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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 number,remainder,reverse=0;
cin>>number;
while(number>0) {
 remainder=number % 10;
 reverse=reverse*10+remainder;
number=number/10;
}
cout<<"reverse="<<endl;
return 0;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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,m=0;
cin>>n;
while(n>0)
{
int a=(n%10);
m=m*10+a;
n=((n-a)/10);
}
cout<<m;
return 0;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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,rem = 0,m = 0;
	cin>>n;
	while(n%10!=n){
		rem =  n%10;
		m = m + rem;
		m = m*10;
		n = n/10;
	}
	m = m + n;
	cout<<m;
	
	return 0;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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 m,a=0,b;
cin>>m;
while(m!=0){
b=m%10;
a=a*10+b;
m=m/10;
}
cout<<a;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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=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: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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>
int main()
{
int a, b, c, d; 
cin>>a>>b>>c>>d;
a=d;
b=c;
c=b;
d=a;	
cout<<a<<b<<c<<d;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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;
int m=0;
cin>>n;
if(n>0){
int i;
int k;
for(i=1;;i++){
k=n%10;
m=10*m+k;
n=n/10;
if(n==0){break;}
}
cout<<m;
}
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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;
#include<cmath>
int main(){
int m,l,avg=0,q,k,j,i,p,n,o;
cin>>m;
n=((log(m))/(log(10)))+1;
p=1;
while(p<=m){
 j=(m/p)%10;
if(j!=0)cout<<j;
p*=10;} }

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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;
#include<cmath>

int main()
{
int n,a=1;
cin >> n;
int m =n;
while(m/10 !=0 )
{
m=m/10;
a++;
}
int j= a-1;
int d= n/(pow(10,j));
int k=0,i=0;
while(i<j)
{
int c =n/(pow(10,i));
int num = (c%10)*(pow(10,j-i)); 
k += num;
i++;
}
cout << k+d;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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{
long long int n, reverse=0,length,i=0,remainder;
cin>>n;

length=to_string(n).length();
while(i<length){
reverse=reverse*10;
remainder=n%10;
reverse=remainder+reverse;
n=n/10;
i+=1;
};
cout<<reverse;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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;
while(n>0)
{
int m=n%10;
  n=n/10;
  if(m==0) continue;
  cout<<m;
}
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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 x=0;
int ans=0,n,b,i=0;
cin>>n;
while(true){
i++;int q=pow(10,i);b=n%q;
		if(b==n)break;}

for(int j=1;j<i+1;j++){
int q=pow(10,j);
int digit;
int l=pow(10,j-1);
int x=n%l;
digit=(n%q)-x;
digit=digit/l;
int d=i-j;
int w=pow(10,d);
ans=ans+(digit*w);
}
cout<<ans;}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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,digit,reverse=0,temp;
	temp=n;
	cin>>n;
	while(n>0){
		digit=n%10;
		reverse=reverse*10+digit;
		n=n/10;
	}
	cout<<reverse;
	
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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;
while (n != 0)
{
m = m*10 + (n%10);
n/=10;
}
cout<<m;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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 a,num_of_digits=0,i=1,n,j=0;
cin >>n;
while (n>=i){
i*=10;
num_of_digits++;
}
for (j=0;j<num_of_digits;j++)
{
a=n%10;
n/=10;
cout<<a;
}
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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;
int k;
k=n%10;
int j;
m=m+k;
n=n-k;
for(int i=10;n-(n%i)!=0;){
j=n/i;
k=j%10;
m=m*10+k;
j=j-k;
n=j;
}
cout<<m;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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,m=0,flag=1;
cin>>n;
if (n==n%10){
	 m=n;
	 flag=0;}
 while (flag){
	 m=m*10+n%10;
	 n=n-n%10;
	 n=n/10;
	 if (n==n%10){
		 m=m*10+n%10;
		 break;}
 }	
cout<<m;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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;
	cin>>n;
	int m=0;
	while(n>0){
	int remainder = n%10;
	n=n/10;
	m =m*10+remainder;
	}
cout<<m;}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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 m=0,n,c,d1=0,d2;//Extra variables for copying values for further calculation
cin>> n;
c=n;//c is equivalent to n.Next step is for number of digits calculation.
for(d1=0;n>0;d1++){
n=n/10;
}
d2=d1;//d2 is made equivalent to d1,because for FOR condition d1 is needed and d2 is needed in body which will decrease periodically
//By the following loop the remainder c%10 will go to the equivalent position from left side.
//Like in case of 1234 its reverse 4321 can be written as 4321=4*(10^(4-1))+3*(10^(3-1))+2(10^(2-1))+1*(10^(1-1)).
// In first case 4 being 1234%10 and d2=4.Then int c=(1234/10)=123 and d2=d2-1=3
for(int a=0;a<d1;a++){
m=m+(c%10)*(pow(10,d2-1));
c=c/10;
d2--;
}
cout<<m;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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=0;
	int k;
	
	cin >>k;
	int x = k;
	
	while(x>0)
	{
		x = x/10;
		n++;
	}
	int ans = 0;
	while(n>0)
	{
		int d = k - (k/10)*10;
		ans = ans + d*pow(10, n-1);
		k = k/10;
		n--;
	}
	cout << ans<<endl;
	
	return 0;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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,m,b,c;
cin>>n;
b=n;
m=0;
while(b!=0)
	{
	c=b%10;
	b=b/10;
	m=m*10;
	m=m+c;
	}
cout<<m;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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 x=0;
while(n!=0)
{
int r=n%10;
n=n/10;
x=x*10+r;
}
cout<<x;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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,p=0,m=0,d=0; cin>>n;
p = n;

	while (p!=0) {
	p /= 10;
	d++;
	}

	for (int j=(d-1); j>=0; j--) {
		int l = 1;
		for (int k=1; k<=j; k++) l *= 10;
	m += (n - (n/10)*10)*l;
	n /= 10;
	}

cout<<(m);
return 0;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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 nod(int x){
	int j=1;
	for(;x!=0;j++){
		x=(x/10);
	}
	return (j-1);
}

int main(){
	int n;
	cin>>n;
	int N=nod(n);
	int new_n=0;
	for(int j=1;j<=N;j++){
		int R=(n%10);
		new_n=new_n+(R*(pow(10,(N-j))));
		n=(n/10);
	}
	cout<<new_n;
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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 z=0;

while (n%10==0)
{
n=n/10;

}


int t;

while(t!=0)
{
t=n%10;
n=n/10;


if (t==0)
{
if (n%10 != 0) {cout<<t; t=1;}
}
else cout<<t;


}
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
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;
int digit;
int m=0;
cin>>n;
if(n>0)
{
do
{
digit=n%10;
m=(m*10) + digit;
n= n/10;
}
while(n!=0);
cout<<m;
}
}

Grading criterion: Placeholder for penalty to be given for any reason
Rating A: Maximum penalty
Rating B: no penalty
Rating C: 0
Rating D: 0
Assigned grade: B