CodeGraderBench/CodeGraderBench huggingface dataset:
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
main_program{
	int a,b;
	cin>>a>>b;
	int i=1;
	while(i*a%b!=0){
		i++;
	}
	int n=i*a;
	cout<<n<<endl;
}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int n1,n2;
int func(int n1 , int n2)
if(n1>n2){
	n1=n1-n2;
}
if(n2>n1){n2=n2-n1;}
if(n1=n2) break;

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int gcd(int &n , int &m){while (m%n!=0){ int remainder = m%n;
	                 m=n;
			 n=remainder;}
			 return(n);}
int lcm(int &n , int &m){int l = m*n/gcd(n,m);
	                 return l;}
main_program{
	int n,m; cin>>n>>m;
	cout<<lcm(n,m);}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int lcm(int m, int n){
	int remainder;
	if(m>n && m%n==0){
		return m;}
        if(n>m && n%m==0){
		return n;}
        if(m>n && m%n!=0){
		while( m%n!=0){
			remainder = m%n;
			m=n;
			n=remainder;
		
	 return (m*n)/remainder;}
	}
		 if(n>m && n%m!=0){
			while( n%m!=0){
		        remainder = n%m;
			n=m;
			m=remainder;
			
		      	return (m*n)/remainder;}
		 }
}
		
main_program{
	int A,B,l;
	cin>>A>>B;
	l = lcm(A,B);
	cout<<l<<endl;
}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int LCM(int a,int b){
	int c=b;
	while(a%b!=0){
		int t;
		t=a%b;
		a=b;
		b=t;}
	b=a*c/b;
	return(b);
}
main_program{
	int m,l;
	cin>>m>>l;
	cout<<LCM(m,l);
}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int gcd(int m,int n){
	int remainder;
	while(m%n!=0){
		remainder=(m%n);
		m=n;
		n=remainder;}
	return n;}
main_program
{int m,n;
	cin>>m>>n;
        int lcm;
	lcm=m*n/gcd(m,n);
	cout<<lcm;}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>

int gcd(int m , int n)
{
	int remainder;
	while(m%n !=0)
	{
		remainder = m%n;
		m=n;
		n=remainder;
	}
	return n;
}

int lcm(int a, int b)
{

	return (a*b)/gcd(a,b) ;
}
main_program{

	int a,b;
	cin>>a>>b;

	cout<<lcm(a,b)<<endl;
}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
void gcd(int m, int n)
{
	while(m%n!=0)
	{
		int r=m%n;
		m=n;
		n=r;
	}
	return n;

	lcm(int m,int n)= m*n/gcd(int m, int n)
}
main_program
{
	int x,y;
	cin>>x>>y;
	lcm(x,y);

}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int lcm(int a,int b)
{
	int rem, result;
	result = a*b;
	while(b%a!=0)
 {
  rem=b%a;
  b=a;
  a=rem;
 }
	result = result/a;
	return result;
}
main_program
{
 int num1, num2;
 cin>>num1>>num2;
 cout<<lcm(num1,num2)<<endl;
}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include <simplecpp>
main_program{
	int a,b,x,y;
	cin>>a>>b;
	int rem;
	a=x;
	b=y;
	while(rem!=0){
		rem=y%x;
		y=x;
		x=rem;
	}
	cout<<(a*b)/rem;
}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int lcm(int a,int b)
{int number;
       	if(b>a)
	 number=b;
		else number=a;
	while(true)
	
	if (number%a==0 && number%b==0)
		break;
		else ++number;
		return number;

}
main_program{
	int c,d;
	cin>>c>>d;
	lcm(c,d);
	cout<<lcm(c,d);
}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int LCM(int p,int q){
	int x=p;
	int y=q;
	int rem;
	while(p%q!=0){
	rem=p%q;
	p=q;
	q=rem;}
	return (x*y)/q;}
main_program{
	int A,B;
	cin>>A>>B;
	if (A<B){
	cout<<LCM(A,B)<<endl;
	}
	else if(A>B){
		cout<<LCM(B,A)<<endl;
	}
}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int hcf(int n1,int n2){
	int r;
	while(n1%n2>0){
		r=n1%n2;
		n1=n2;
		n2=r;
	}
	return n2;
}

int lcm(int m1,int m2){
 	return (m1*m2)/hcf(m1,m2);
}
main_program{
	int a,b;
	cin>>a>>b;
	cout<<lcm(a,b);
}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int gcd(int m,int n)
{while(m%n!=0){ 
int remainder=m%n;
m=n;
n=remainder;}
return n;}
main_program{
int lcm,a,b;
cin>>a>>b;
lcm=a*b/gcd(a,b);
cout<< lcm<< endl;}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
int_main {
float x,y;
cout<<"enter two numbers"<<endl;
  cin>>"x,y">>;
x=(2^-2)+(2^-1)+(2^0);
if(x=y) {
cout<<"y is decmal form of x"<<endl;
}
}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int gcd(double a,double b){
	double m;
	if(b/a!=0){
	m=b-a;
	b=a;}
	else if(b/a==0){ m=a;}
	return m;
	}

main_program{
	int x,y,p,q,w;
	cin>>x>>y;
	p = gcd(x,y);
	q = x*y;
	w= q/p;
	cout<<w<<endl;
}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int lcm(int x,int y)
{
	int ans=0;
	if(x>y)
	{
	for(int i=x;i<=(x*y);i++)
	{
		if(i%x==0 && i%y==0)
		{
			ans=i;
			break;
		}
	}
	}
	else 
	{
		for(int i=y;i<=(x*y);i++)
        {
                if(i%x==0 && i%y==0)
                {
                        ans=i;
                        break;
                }
        }

	}
	return ans;
}
main_program
{
	int a,b;
	cin>>a>>b;
	cout<<lcm(a,b);
}

Grading criterion: Quality and number of Comments
Rating A: Well Commented and Formatted
Rating B: Ok Commented or Ok Formatted
Rating C: Poor Comments and Formatting
Rating D: 0
Assigned grade: C
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
main_program{
	int LCM(int n, int m)
	{
	intx;
	if(m>n)
		x=n;
	int gcd;
	}

}

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
main_program{
	int a,b,i,j;
	cin>>a>>b;
	for(i>0,i<a,i++){
		if(a%i=0){
                cout<<i;}
	}
	for(j>0,j<b,j++){
		if(b%j=0{
		cout<<j;}
		}
		int g;
		if(i<j){
		i=g};
		else{j=g};
		
cout<<a*b/g<<endl;

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int lcm(int m, int n){
	int k = m*n;
	while(m%n!=0){
		int temp = m%n;
		m = n;
		n = temp;
	}
	return k/n;
}
main_program{
	int A,B;
	cin>>A>>B;
	cout<<lcm(A,B);
}

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include <simplecpp>
main_program{
	int a,b;
	cin>>a>>b;
	int p=a,q=b;
	while (b%a!=0){
		int r=b%a;
		b=a;
		a=r;
	}
	int lcm=(p*q)/a;

	cout<<lcm;
}

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include <simplecpp>
int gcd(int a,int b) {
	while (a%b > 0) {
	int remainder = a%b;
	a=b;
	b= remainder;
	}
	return b;
}
int lcm(int a,int b) {
	int x = (a*b)/gcd(a,b);
	return x;
}
main_program {
	int a,b;
	cin >>a >>b;
	cout <<lcm(a,b) <<endl;
}

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>

int lcm(int a , int b){
	int product= a*b;
	int c =b;
	if(a<b){
		b=a;
		a=c;
	}

	while(a%b!=0){
		int r = a%b;
		a=b;
		b=r;
	}

	int hcf = b ;
	int x = product/hcf;

	return x;
}

main_program{
	int a , b;
	cin>>a>>b;
        cout<<lcm(a,b)<<endl;
}

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int gcd (int m , int n ) {
	int remainder=n%m;
      
	      if(n%m !=0) {
		n=m;
	 
		m=remainder;
	     }
   
	return m;
	}
int lcm (int m , int n) {
int 	lcm_nu=(m*n)/gcd(m,n);
	return lcm_nu;
}
main_program {
	int A, B;
	cin>>A>>B;
	cout<<lcm(A,B);
}

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int gcd (int m,int n){
	int Remainder;
	while (m%n !=0){
		Remainder = m %n;
		m =n;
		n = Remainder;
	}
	return n;
}
main_program{

	int A,B;
	cin >> A>> B;
	cout <<A*B/ gcd (A,B) << endl;
}

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
main_program{
	int a,b;
	cin>>a>>b;

}

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include <simplecpp>
main_program{
	int A,B;
	cin >>A>>B;
	int LCM(A,B);
	LCM(A,B) = A*B;
	int result;
	result = LCM(A,B);
}

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int lcm(int a, int b){
int i,c;	for(i=1; (a*i)%b!=0;i++){c=a*(i+1);}
	return c;
}
main_program{
	int A,B;
	cin>>A>>B;
	cout<<lcm(A,B)<<endl;
}

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
main_program{
	int a,b;
	cin>>a;
	cin>>b;
	b>=a;
	int i;

	for( i<=a; a%i!=0; b%i!=0; i++)
	       int z;
	z=a*b;
	cout<<z;
}

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>

	int gcd(int m,int n);
    {
	while(m % n != 0)
	{
		int r = m % n;
		m=n;
		n=r;
	}
	return n;
    }
	int lcm(int m,int n);
	{
	return m*n/gcd(m,n);
        }
main_program
   {
	int m,n;
	cin>>m>>n;
	cout<<lcm(m,n)<<endl;
   }

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int lcm(int a,int b)
{
        int hcf=1;
        for(int i=2;i<=a;i++)
        {
                if(a%i==0 && b%i==0)
                        hcf=i;

        }
        return (a*b)/hcf;

}

main_program
{
	int a,b;
	cin>>a>>b;
	if(b<a)
	{
		int temp=a;
		a=b;
		b=temp;
	}

	int c=lcm(a,b);
	cout<<c;
}

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int main()
int A,B,r;
int	B>A
	int gcd(A,B);
	while(A%B=0)
	return B;
	while(A%B!=0)
int remainder=r;
A=B;
B=r
return r;


main_program{
int main()

int A,B;
int lcm=A*B/gcd(A,B)
cin>>A>>B;
cout<<lcm<<endl;

}

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include <simplecpp>
int gcd(int n,int m){
	while (m%n!=0){
		int remainder=m%n;
		m=n;
		n=remainder;
	}
	return n;
}
int lcm(int m,int n){
	return m*n/gcd(m,n);
}
main_program{
	int a,b;
	cin>>a>>b;
	cout<<lcm(a,b)<<endl;
}

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a program that takes two positive integers A and B as input, passes them to a function that computes the LCM, and finally prints the result in the main function.

Student submission:
#include<simplecpp>
int gcd
(int m,int n){
	while(m%n!=0)
	{		int r=m%n;
	m=n;
	n=r;
}
return n;
}
int lcm
(int m, int n)
{ return (m*n)/gcd(m,n);
}
int main(){
	int A,B;
	cin>>A>>B;
	cout<<lcm(A,B)<<endl;
}

Grading criterion: Overall program correctness
Rating A: "Common requirements  of a Program are correct - i.e.
 
- header (includes, using namespace, etc)
- main syntax
- variables declaration
- overall syntax"
Rating B: Problems are present in the code(eg: printing unnecessary strings, missing semicolons & braces, wrong/missing declarations, wrong header files)
Rating C: 0
Rating D: 0
Assigned grade: A