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>=-100 && x2<1)
		cout<< " "; 

     if( x1>=0.000 && x2<1.000)
                cout<< " ";

    else if( x1>1.000 && x2<=2.000)
                cout<< "2.000";
          else if( x1>1.000 && x2<=3.000)
                cout<< "2.000 3.000";
	 

           else if( x1>2.000 && x2<=3.000)
                cout<< "3.000";





      else if( x1>=0.000 && x2<2.000)
                cout<< "1.000";
     else if( x1>=0.000 && x2<3.000)
                cout<< "2.000";

     else if( x1>=0.000 && x2<100.000)
                cout<< "1.000 2.000 3.000";
   
     else if( x1>1.000 && x2<100.000)
                cout<< "1.000 2.000 3.000";
     
     else if( x1>=2.000 && x2<100.000)
                cout<< "2.000 3.000";
  else if( x1>=-100.000 && x2<2.000)
                cout<< "1.000";
     else if( x1>=-100.000 && x2<3.000)
                cout<< "2.000";
     else if( x1>=1.000 && x2<2.000)
                cout<< "1.000";
     else if( x1>=-100.000 && x2<100.000)
                cout<< "1.000 2.000 3.000";



     
     else if( x1>=1.000 && x2<2.000)
		cout<< "1.000";
	else if( x1>=1 && x2<3)
		cout<< "2.000";
       else if( x1>=2 && x2<=3)
		cout<< "2.000 3.000";
       else if( x1>=3 && x2<=100)
		cout << "3.000";
}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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,mid;
	cin>>x1>>x2;
	double a=2,b=3;
	double eps=1e-6;
	while((b-a)>eps){
		mid=(x1+x2)/2;
		double a=x1*x1*x1-6*x1*x1+11*x1-6;
		double b=x2*x2*x2-6*x2*x2+11*x2-6;
		if (a<0 && b>0){
			double c=mid*mid*mid-6*mid*mid+11*mid-6;
			if (c>0){
				x2=mid;
			}
			else{x1=mid;}
			}

		if(a>0 && b<0){
			double c=mid*mid*mid-6*mid*mid+11*mid-6;
			if (c>0){x1=mid;}
			else{x2=mid;}
		}
	}
	cout<<mid;
}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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 xl , xm, xr;
	cin>>xl>>xr;
	bool xl_pos, xm_pos;
	xl_pos=( pow(xl,3)-6*pow(xl,2)+11*xl -6)>0;
	while(xr-xl >0.00001){
		 xm=(xl+xr)/2;
		 xm_pos=( pow(xm,3)-6*pow(xm,2)+11*xm -6)>0;
		 if(xl_pos==xm_pos){
 			xl=xm;
		 }
		 else{
			xr=xm;
		 }
	}
	cout<<fixed;
	cout.precision(3);
	cout<<xl<<endl;
}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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>
int f(double x){
	double i= (x*x*x-6*x*x+11*x-6);
	return i;
}
main_program{
	double x1,x2;
	cin>>x1>>x2;
	if(x1>=-100 && x2<=100 && x1<x2 && (f(x1)<0 || f(x2)<0) && (f(x1)>0||f(x2)>0)) {
		double xm=(x1+x2)/2, epsilon=0.01;
		bool x1_pos=(f(x1)>0), x2_pos=(f(x2)>0);
		while((x2-x1)>=epsilon) {
			if((f(xm)>0)&&x1_pos){
				x1=xm;
				xm=(x1+x2)/2;
			}
			else if((f(xm)>0)&&x2_pos){
				x2=xm;
				xm=(x1+x2)/2;
			}
		}
		cout<<fixed;
		cout.precision(3);
		cout<<xm;
	}
}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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 x,x1,x2;
	cin>>x1>>x2;
	bool a=((pow(x1,3)-6*pow(x1,2)+11*x1-6)>0);
	while ((abs(x1-x2)>0.0001)){
		x=(x1+x2)/2;
		bool b=((pow(x,3)-6*pow(x,2)+11*x-6)>0);
		if (a==b) x1=x;
		else x2=x;
	}
	cout<<fixed;
	cout.precision(3);
	cout<<x;
}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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 bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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>
bool pos_sig(float x)
{
	if ((x*x*x - 6*x*x +11*x - 6) < 0) return false;
	else return true;
}

int main()
{
	float x1, x2;
	cin >> x1 >> x2;
	float x = (x1+x2)/2;
	while (abs(x*x*x - 6*x*x + 11*x - 6) >= 0.001)
	{
		if ((!(pos_sig(x)) && (!pos_sig(x1))) || (pos_sig(x) && pos_sig(x1))) x1 = x;
		else x2 = x;
		x = (x1+x2)/2;
	}
	cout <<  fixed;
	cout.precision(3);
	cout << x;
}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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>
double f(double x)
{
	return (x*x*x-6*x*x+11*x-6);
}
main_program
{
	double x1,x2,xm;
	cin>>x1>>x2;
	bool sofx1=(f(x1)>=0),sofxm;
	while(abs(x1-x2)>0.0001)
	{
		xm=(x1+x2)/2;
		sofxm=(f(xm)>=0);
		if(sofx1==sofxm)
		{
			x1=xm;
		}
		else x2=xm;
		sofx1=(f(x1)>=0);
		
	}
	cout<<fixed;
	cout.precision(3);
	cout<<xm;
}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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, xm, fxm;
	cin >> x1 >> x2;
	int v1, v2, vm;

	double fx1 = (x1*x1*x1) - (6*x1*x1) + (11*x1) - 6;
	double fx2 = (x2*x2*x2) - (6*x2*x2) + (11*x2) - 6;

	if (fx1>0) v1=1;
	else v1=0;
	if ( fx2>0) v2=1;
	else v2=0;

	while ( x2-x1 > 0.0001 )
	{
		xm = (x1+x2)/2;
		fxm =  (xm*xm*xm) - (6*xm*xm) + (11*xm) - 6;

		if ( fxm>0) vm=1;
       		else vm=0;

		if ( vm == v1) x1=xm;
		if ( vm == v2) x2=xm;
		
	}

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

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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 L , R , M , l , r ;
	cin>>L>>R;
	l = L;
	r = R;
	for ( int i = 1 ; i<=1000 ; i++){
		M= (L+R)/2;
		if (M*M*M-6*M*M+11*M-6 > 0 ){
			R = M;}
		if ( M*M*M - 6*M*M + 11*M - 6 < 0){
			L = M ;} 
		if (M*M*M - 6*M*M + 11*M -6 == 0){
			cout<<M;
			break;}}

        for ( int j = 1 ; j<=1000 ; j++){
                M= (l+r)/2;
                if (M*M*M-6*M*M+11*M-6 < 0 ){
                        r = M;}
                if ( M*M*M - 6*M*M + 11*M - 6 > 0){
                        l = M ;}
                if (M*M*M - 6*M*M + 11*M -6 == 0){
                        cout<<M;
                        break;}}
	
}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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;
	bool is_x2_pos = ((x2 - 1)*(x2 - 2)*(x2 - 3) > 0);
	bool is_x1_pos = ((x1 - 1)*(x1 - 2)*(x1 - 3) > 0);
	while(abs(x2 - x1) >= 0.00001){
		double xm = (x1 + x2)/2;		
		bool is_xm_pos = ((xm - 1)*(xm - 2)*(xm - 3) > 0);
		if( is_xm_pos == is_x1_pos){
			x1 = xm;
		}
		else{
			x2 = xm;
		}
	}
	cout << fixed;
	cout.precision(3);
	cout << x1;
}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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 a,b;
	cin>>a>>b;
	if(a<1&&b>1) 
	cout<<"1.000";             //we know that the roots are 1,2 and 3
	if(a<2&&b>2)
		cout<<"2.000";
	if(a<3&&b>3)
	cout<<"3.000";
}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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;

   
	if ((x1 == -1) && (x2 == 1.8)) {cout <<"1.000";}
	else{cout << "";}

		 if ((x1 == 1.1) && (x2 == 2.3)) {cout << "2.000";}
		 else {cout << "";}

		 if ((x2 == 2.34) && (x2 == 3.89)) {cout << "3.000";}
		 else {cout << "";}
}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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, xm;
	cin>>x1>>x2;
	//xL = pow(x1, 3) - 6*pow(x1, 2) + 11*x1 - 6;
	//xR = pow(x2, 3) - 6*pow(x2, 2) + 11*x2 - 6;	
	while(x2 - x1 > 0.0001)
	{
		xm = (x1 + x2)/2;
		xM = pow(xm, 3) - 6*pow(xm, 2) + 11*xm - 6;
		if(xM > 0)
		{
			x2 = xm;
		}
		else if(xM < 0)
		{
			x1 = xm;
		}
		else if(xM == 0)
		{
			break;
		}
	}
	if(2.1 > xm && xm > 1.9)
	{
		cout<<"2.000";
	}
	else if(1.1 > xm && xm > 0.9)
	{
		cout<<"1.000";
	}
	else if(3.1 > xm && xm > 2.9)
	{
		cout<<"3.000";
	}
}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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 xa=x1,xb=x2;
if(x1>=-100&&x2<=100&&x1<x2)
{
	double x =0.0;
	while(true)
	{
		if((pow(x,3)-6*x*x+11*x-6)<=0.00001)
		{
			break;
		}
		x = x1-(pow(x1,3)-6*x1*x1+11*x1-6)*(pow(x2,3)-6*x2*x2+11*x2-6-(pow(x1,3)-6*x1*x1+11*x1-6))/(x2-x1);
		if(x>=1) x2=x;
			if(x<=1) x1=x;
			}
	if(xa<1&&xb>1&&xb<2)
		x=1;
	else if(xa<2&&xb>2&&xb<3)
		x=2;
	else
		x=3;

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

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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 a1,b1,c1,d1,d,a,b,c,m,n,n1,n2,n3;
	cin>> n>>n1>>n2>>n3;
	if(n1>n2){
		a=n1;
		n1=n2;
		n2=a;
	}
	if(n2>n3){
		b=n2;
		n2=n3;
		n3=b;
	}
	if (n1>n3){
		c=n1;
		n1=n3;
		n3=c;
	}
	if(n1>n2){
		d=n1;
		n1=n2;
		n2=d;
	}


	repeat(n-3){
		cin >>m;
		if(n1>m){n3=m;}
		else if(n2>m){n3=m;}
		else if(n3>m){n3=m;}
	
	}
	if(n1>n2){
		a1=n1;
		n1=n2;
		n2=a1;
	}
	if(n2>n3){
		b1=n2;
		n2=n3;
		n3=b1;
	}
	if(n1>n3){
		c1=n1;
		n1=n3;
		n3=c1;}
	if(n1>n2){d1=n1;
		n1=n2;
		n2=d1;}


	cout << n1 <<" "<< n2 <<" "<< n3;
}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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(-100<=x1 &&  x2<=100)
	     {while(x1 <  x2) { xm = (x1+x2)/2;
		               if ((x1>=0 && xm>=0) || (x1<=0 && xm<=0)){x1 = xm;}
		               else x2 = xm;}}cout<<x1;}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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;
        {
		if(x1<1.0 && x2>1.0) cout<<" 1.000";
		if(x1<2.0 && x2>2.0) cout<<" 2.000";
		if(x1<3.0 && x2>3.0) cout<<" 3.000";
	}
}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
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;

while(x2-x1 >= 0.000000001)
{
	double xm;
	xm = (x1+x2)/2.0 ;

	if((x1*x1*x1 - 6*x1*x1 + 11* x1 -6>0 && xm*xm*xm - 6*xm*xm + 11*xm -6>0) ||( x1*x1*x1 - 6*x1*x1 + 11*x1 -6 <0 && xm*xm*xm -6*xm*xm +11*xm -6 <0))
		x1 = xm;
	else
		x2 = xm;
}

cout<<fixed;

cout.precision(3);

cout<<x1<<endl;
}

Grading criterion: Is the bisection interval calculated between the correct numbers after each iteration
Rating A: The code identifies the correct interval where the root lies and iterates through that interval
Rating B: The code fails to identify the correct interval where the root lies
Rating C: 0
Rating D: 0
Assigned grade: A