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>
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 of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: A
Problem: 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 of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: 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 of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: 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 of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: 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 of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: 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 of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: 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 of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: A
Problem: 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 of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: 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 of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: 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 of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: 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 of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: 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 of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: 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 of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: C
Problem: 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 of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: C
Problem: 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 of variable names
Rating A: Good variable names
Rating B: Ok Variable Names
Rating C: Poor Variable Names
Rating D: 0
Assigned grade: B
Problem: 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: 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,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: 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 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: 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;
	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: 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 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: 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 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: 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=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: 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 A,B;
	cin >> A>> B;
	cout <<A*B/ gcd (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>
main_program{
	int a,b;
	cin>>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 A,B;
	cin >>A>>B;
	int LCM(A,B);
	LCM(A,B) = A*B;
	int result;
	result = 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: 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 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: 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;
	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: 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 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: 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 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: 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 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: 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 m,int n){
	return m*n/gcd(m,n);
}
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>
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: 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 p,q,x,y,i,j;
	cin>>x>>y;
while(x*i=y*j){
	int i=1;j=1;
	x*i=p;
	y*j=q;
	i++;
	j++;}

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){
	if(a%b==0){
		cout<<a;
	}
	else if(b%a==0){
		cout<<b;
	}
	else if(a%2==1 && b%2==1){
		cout<<a*b;
	}
	else if(a%2==0 && b%2==1 &&( a%b!=0 || b%a!=0)){
		cout<<((a*b)/abs(b-a));
	}
	else if(b%2==0 && a%2==1 &&( b%a!=0 || a%b!=0)){
		cout<<((a*b)/abs(b-a));
	}

	return lcm(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: 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>

unsigned int lcm (int A, int B){
	// we find hcfand do lcm = A*B/hcf
	int r, Atemp, Btemp;
	Atemp = A;
	Btemp = B;
	while (A % B > 0){
		r = A%B;
		A = B;
		B = r;
	}	
	return (Atemp * Btemp)/B;
}

main_program{
	int a, b;
	cin >> a >> b;
	if (a >= b) cout << lcm(a, b);
	else cout << lcm(b, a);
}

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>
main_program {
	int a, b; cin >> a >> b;
	}
int gcd ( int m, int n) {
	while ( m % n != 0) {
		int remainder;
		remainder = m % n;
		m = n;
		n = remainder;
	}
	return n;
} 
int lcm ( int m, int n) {
	int lcm = m*n /  gcd ( m , n) ;
	return 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 a,int b){
    int c=a;
    a=max(a,b);
    if(a==b) b=c;
    else b=b;

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


}

int LCM(int a,int b){
    int lcm=(a*b)/gcd(a,b);



return lcm;
}



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){
	int remainder;
	while(m%n!=0){
			remainder=m%n;
			m=n;
			n=remainder;
			}
			return n;
			}
			int lcm(int c,int d){
			int lcm=c*d/gcd(c,d);
			return lcm;}

main_program{
	int a,b;
	cin >>a;
	cin>>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;
gcd(int a,int b){
if (a%b==0)
   { a=b;
     b=a%b;}
     return  b;}
     int main () {
	     int m,n;
	     cin>>m>>n;
	     cout<<gcd(int m,int n)<<endl;}
	     lcm(a,b)*gcd(a,b)=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