CodeGraderBench/CodeGraderBench huggingface dataset:
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
double x1,x2;
cin>>x1>>x2;
if (x1<=1 && x2>1 && x2<2)
cout<< "1.000"<< endl;
if (x1<=1 && x2==1)
cout << "1.000"<<endl;
if (x1<=2&& x1>1 && x2>2 && x2<3)
cout<< "2.000"<<endl;
if (x1<=2&& x2==2)
cout<< "2.000"<<endl;
if ( x1>2 && x1<=3 && x2>=3)
cout<< "3.000"<<endl;}

Grading criterion: Is the loop used for iterations correctly breaking after a threshold
Rating A: The loop breaks after a certain threshold where no further iterations are required for the root calculation
Rating B: Wrong loop is used which continues infinitely or no loop is used
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
int_main {
int n;
cout<<"enter any number"<<endl;
cin>>"n">> endl;
int x,y;
cout<<"enter positive inegers"<<endl;
cin>>x,y">>endl;

    if(x%=0) {
 cout<<"x is lcm of n"<<;
 }

Grading criterion: Is the loop used for iterations correctly breaking after a threshold
Rating A: The loop breaks after a certain threshold where no further iterations are required for the root calculation
Rating B: Wrong loop is used which continues infinitely or no loop is used
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
double f(double x)
{
	double ans= x*x*x-6*x*x+11*x-6;
	return ans;
}
main_program
{
	double x1,x2;
	cin>>x1>>x2;
	double epsilon = 1.0E-5;
	double xm;
	while(abs(x1-x2)>epsilon)
	{
		xm= (x1+x2)/2.0;
		if(f(xm)*f(x1)>0)
			x1=xm;
		else
			x2=xm;
	}
	cout<<fixed;
	cout.precision(3);
	cout<<x1<<endl;
}

Grading criterion: Is the loop used for iterations correctly breaking after a threshold
Rating A: The loop breaks after a certain threshold where no further iterations are required for the root calculation
Rating B: Wrong loop is used which continues infinitely or no loop is used
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{

}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	int a=1,b=2,c=3,x1,x2;
cin>>x1>>x2;
if(a>x1 && a<x2){
	cout<<a<<endl;}
else{cout<<" "<<endl;}
if(b>x1 && b<x2){
        cout<<b<<endl;}
else{cout<<" "<<endl;}
if(c>x1 && c<x2){
        cout<<c<<endl;}
else{cout<<" "<<endl;}
}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	double x1 , x2, xM ;
	cin>>x1>>x2;

	if(x1>=-100 && x2<=100 && x2>x1){
	repeat(10000){
		xM=( x1+ x2)/2.0;
		double p = xM*xM*xM - 6*xM*xM + 11*xM - 6 ;
		double q = x1*x1*x1 - 6*x1*x1 + 11*x1 -6 ;
		double r = x2*x2*x2 - 6*x2*x2 + 11*x2 - 6;

		if((p>0 && q>0) || (p<0 && q<0))
			x1=xM;

		else if ((p>0 && r>0) || (p<0 && r<0))
			x2=xM;

	}
        cout<<fixed;
	cout.precision(3);
	cout<<xM;
}

else
cout<<"Invalid input";

}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	double x1,x2;
	cin>>x1>>x2;
	if (x1>=-100 && x2<=100 && x2>x1){
	        if(x1<1 && x2>1 && x2<2) cout<<"1.000"<<endl;
		if(x1>1 && x1<2 && x2>2 && x2<3) cout<<"2.000"<<endl;
		if(x1>2 && x1<3 && x2>3) cout<<"3.000"<<endl;
		if(x1<1 && x2>2 && x2<3) cout<<"1.000"<<"and"<<"2.000"<<endl;
                if(x1<1 && x2>3) cout<<"1.000"<<","<<"2.000"<<"and"<<"3.000";
               
	}
}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
float f(float x){
	return (pow(x,3)-(6*pow(x,2))+ 11*x -6);
}
main_program{
	float x1, x2, xm;
	cin>>x1>>x2;
repeat(1000){
		xm=(x1+x2)/2.00;
		if(f(xm)>0) x1=xm;
		else if(f(xm)<0) x2=xm;
		else { break;
		 }}
		cout<<xm<<endl;
	
}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include <simplecpp>
main_program{
   float x1,x2;
	cin >> x1 >> x2;
       float sum = 1;
      
       if(x1<=0){
	if(x2<2)  { cout  << sum<< endl;
	}
       }
      
       if(x1>0){
	       if(x2<2){
		      
		       cout << sum << endl;}
	       if (   x2>2 && x2<3){
		      
		      sum=sum+1; cout << sum <<endl;}
	       if (x2>3) {
		      
		      sum = sum+2; cout  << sum  << endl;}
       }

       
}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{double x1,x2;
	float xm;
	cin>>x1>>x2;
	
	while(x2-x1>=0.0001){xm=(x1+x2)/2;
		if((pow(x1,3)-6*pow(x1,2)+11*x1-6>=0 && pow(xm,3)-6*pow(xm,2)+11*xm-6>=0) ||( pow(x1,3)-6*pow(x1,2)+11*x1-6<=0 && pow(xm,3)-6*pow(xm,2)+11*xm-6<=0)){x1=xm;}
		else if((pow(x2,3)-6*pow(x2,2)+11*x2-6>=0 && pow(xm,3)-6*pow(xm,2)+11*xm-6>=0) ||( pow(x2,3)-6*pow(x2,2)+11*x2-6<=0 && pow(xm,3)-6*pow(xm,2)+11*xm-6<=0))x2=xm;	
	}
	cout<<fixed;
	cout.precision(3);
	cout<<x1<<endl;
}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include <simplecpp>
main_program{
	float x1,x2;
	cin>>x1>>x2;
	if (x1<x2){
	if (x1<1 && x2<2) cout<<1.000<<endl;
	if (x1>1 && x2<3) cout<<2.000<<endl;
	if (x1>2 && x2<3 && x2>3) cout<<3.000<<endl;
	}
}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	double xl,xr;
	cin>>xl>>xr;
	double xm,epsilon=0.000001;
	bool xl_is_positive;
xl_is_positive=(pow(xl,3)-6*pow(xl,2)+11*xl-6)>0;
while((xr-xl)>epsilon){
	xm=(xr+xl)/2;
	bool xm_is_positive=(pow(xm,3)-6*pow(xm,2)+11*xm-6)>0;
	if(xm_is_positive==xl_is_positive)
	{xl=xm;}
	else
	{xr=xm;}
}
cout<<xm<<endl;
}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include <simplecpp>

bool sign_check(double a){
	if ((pow(a, 3) - 6 * pow(a, 2) + 11 * a - 6) >= 0) return true;
	else return false;
}

main_program{
	double x1, x2, xM;
	cin >> x1 >> x2;
	if (x1 <= 2 && x2 >= 2){
		repeat(500){
			xM = (x1 + x2)/2;
			if (sign_check(xM)) x1 = xM;
			else x2 = xM;
		}
	}
	else{
		repeat(500){
			xM = (x1 + x2)/2;
			if (sign_check(xM)) x2 = xM;
			else x1 = xM;
		}
	}
	cout << fixed;
	cout.precision(3);
	cout << xM;
}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include <simplecpp>
main_program {
	float x1, x2;
}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	float x1,x2;
	cin>> x1;
	cin>>x2;
	int a=0;
	int b=0;
	float xm,xl=x1,xr=x2;
	while((xr-xl)>=0.001){
		xm=(xl+xr)/2;

		if((pow(xl,3)-6*pow(xl,2)+11*xl-6)<=0){a=1;}
		if((pow(xm,3)-6*pow(xm,2)+11*xm-6)<=0){b=1;}
		if (a==b){xl=xm;
			}
		if(a!=b){xr=xm;}
	}
		cout<<xm<<endl;
	
}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	float x1,x2;
		cin >> x1 >> x2;
		if ((x1 < 1 < x2);cout << "1.000";)
		else if( (x1 < 2 < x2);cout << "2.000";)
		else ((x1< 3 <x2);cout << "3.000";)
}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	double x1,x2;
	cin>>x1>>x2;
	double i=x1;
	double b;
	while(i<=x2){
		b=(i*i*i)-(6.0*i*i)+(11.0*i)-6.0;
		if(b==0.000){
			cout<<fixed;
			cout.precision(3);
			cout<<i<<endl;
			break;
		}
		else i++;

	}
}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include <simplecpp>

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>

	
	double equation (float x) {
		double value = pow(x, 3) - 6*pow(x,2) + 11*x - 6;
		return value;
	}

	main_program {
	float x1, x2; 
	cin >> x1; cin >> x2;
	float x0 = 0;
	do
       	{
		x0 = (x1 + x2)/2;
	 if (equation(x1)*equation(x0) <= 0) {x2 = x0;}
	 else  {x1 = x0;};
 	} while (equation(x0) !=0);
	
	cout << fixed; cout.precision(3);
	cout << x0;
 }

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program
{
	double x1,x2;

	cin>>x1>>x2;

	double  xm;

	while(x2-x1 > 0.000001){
		bool x1chk = (pow(x1,3) - 6*pow(x1,2) + (11*x1) - 6) < 0;
		
		xm = (x1 + x2) / 2.0;
		
		bool xmchk = (pow(xm,3) - 6*pow(xm,2) + (11*xm) - 6) < 0 ;
		
		
		if(x1chk  == xmchk)

		{
		
			x1 = xm;
		}

		else
		{
			x2 = xm;
		}
	}

	
	cout<<fixed;
	cout.precision(3);

	cout<<xm;
}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	float x1,x2,x3;
	cout<<"x1:";
	cin>>x1;
	cout<<"x2:";
	cin>>x2;

	
	while(x2-x1<=0.001){
		x3=(x1+x2)/2;
		float c=pow(x1,3) -(6*pow(x1,2))+(11*x1)-6;
		float d=pow(x2,3)-(6*pow(x2,2))+(11*x2)-6;
	        float e=pow(x3,3)-6*pow(x3,2)+(11*x3)-6;
		if((c>0 && e<0) || (c<0 && e>0)){
			    
			x2=x3;
		}
		else if ((d>0 && e<0 ) ||(d<0 && e>0) ) {
		x1=x3;
		
		}
		
		}
		cout<<x3<<endl;
		}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program{
	double x1 , x2;
	cin >> x1 >> x2 ;
	if(x1 <1 && x2 >1) cout << "1.000" << endl;
	else if(x1 <2 && x2 >2 ) cout << "2.000" << endl;
	else if(x1 <3 && x2 >2) cout << "3.000" << endl;
}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: The problem statement is to find the root of the equation f(x) = x3 - 6x2 + 11x - 6 between x1 and x2 using the bisection method. The input is two high-precision floating-point values of type double representing x1 and x2 respectively. The output is the root of the equation correct up to 3 decimal places. The constraints are that -100 <= x1, x2 <= 100, and x1 < x2. The program should not print any general messages, but only the root of the equation correct up to 3 decimal places.

Student submission:
#include<simplecpp>
main_program {
	double xL,xR;cin>>xL>>xR;
	double xM=(xL+xR)/2;
        int m=xM;
	cout<<m+1;
	cout.precision(3);
}

Grading criterion: Is the root getting correctly extracted from the final iteration of the loop
Rating A: The root is Correctly identified
Rating B: The root isn't correctly calculated or stored in a variable
Rating C: 0
Rating D: 0
Assigned grade: B