CodeGraderBench/CodeGraderBench huggingface dataset:
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include<iostream>
using namespace std;

int indexf(int *a,int n,int k);
void swap(int *(a+i),int *(a+m));
int main()
{
	int n;
	cin>>n;
	int a[n];
	for(int i=0;i<n;i++)
	{
		cin>>a[i];
	}

	for(int i=0;i<n;i++)
	{
      
      int m=indexf(a,n,i)

      swap(a[i],a[m]);


	}

	for(int i=0;i<n;i++)
	{
     cout<<a[i];


	}


}



	

	int indexf(int *a,int n,int k)
	{
	int min=10000,index=0;
	for(int i=k;i<n;i++)
	{
     if(a[i]<min)
     {
      index=i;


     }


	}

	return index;

	void swap(int *(a+i),int *(a+m))
	{
	int temp=a[i];
	a[i]=a[index];
	a[index]=a[i];



	}




}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include <iostream>
using namespace std;
int main()
{
	int n; cin>>n;
	if(n<25)
	{
	int A[n];int x,temp;
	for (int i=0;i<n;i++)
	{
		cin>>x;
		A[i]=x;
	}
	for(int i=0;i<n-1;i++)
	{
		for(int j=i+1;j<n;j++)
		{
			if(A[i]>A[j])
			{
				temp=A[i];
			    A[i]=A[j];
			    A[j]=temp;
			}
		}
	}
	for(int i=0;i<n;i++)
	{
		cout<<A[i]<<" ";
	}
	}
}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include<iostream>
using namespace std;

void swap(int &a,int &b)
{
	int temp=a;a=b;temp=b;
	return;
}

int func(int a[],int n)
{
	int i,j;
   for(int i=0;i<n;i++)
   {
   	cin>>a[i];
   }
   for(i=1;i<n;i++)
   {
   	for(j=0;j<n;j++)
   	{
   	if(a[j]>a[i])
   		swap(a[j],a[i]);

   	}	

   }
   return a[j];
}

int main()
{
	int n;
	cin>>n;
	int arr[n];

	cout<<func(arr,n);

}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include <simplecpp>

void swap (float *a, float *b)
{ float temp;
temp= *a;
*a = *b;
*b = temp;
}

int argmin( float *elements, int n)
{
int minindex=0;
for(int j=1;j<n;j++)
{ if(elements[minindex] > elements[j] ) minindex = j;
}
return minindex;
}

void selection_sort (float *data, int n)
{ for(int i=1;i<n;i++)
{ int minindex = argmin(data,i);
swap(&data[minindex],&data[i-1]);
}
}

main_program{
float A[25];
int i,n;
cin>>n;
for (i=0;i<n;i++)
{ 
cin>>A[i];}

selection_sort(A,n);
for(i=0;i<n;i++)
{
cout << A[i]<<" ";
}}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include<iostream>
using namespace std;
void swap(int* a, int* b)
{
int temp;
temp=*a;
*a=*b;
*b=temp;
}
int main()
{
int n,i,j,k,min=0;
cin>>n;
int a[n];
for(j=0;j<n;j++)
{
cin>>a[j];
}
for(i=0;i<n;i++)
{
for(k=i;k<n;k++)
{
if(a[k]<a[min])
min=k;
else 
continue;
}
swap(&(a[i]),&(a[min]));
}
for(int i=0;i<n;i++)
cout<<a[i]<<" ";
}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include<iostream>
using namespace std;
 
int main(){
	int n;
	cin>>n;
	int A[n];
	for(int i=0;i<n;i++){
		cin>>A[i];
	}
	for(int i=0;i<n;i++){
	  for(int j=i;j<n;j++){
	    if(A[i]>=A[j]){
	      int temp;
	      temp = A[i];
	      A[i] = A[j];
	      A[j] = temp;
	    }
	  }
	}
      
	
	for(int i=0;i<n;i++){
		cout<<A[i]<<" ";
	}
	
	
	return 0;
}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include<iostream>

using namespace std;

int main() {
	int n;
	
	cin>>n;
	
	int A[n];
	
	for(int i = 0; i<n; i++)
	{
		cin>>A[i];
	}
	
	
	for(int i = 0; i<n; i++)
	{
		int min = A[i];
		
		for(int j = 0; j<n; j++)
		{
			if(A[j] < min)
			{
				min = A[j];
				
				int temp = A[i];
				A[i] = A[j];
				A[j] = temp;
			}
		
		}
	
		
	}
	
	for(int k = (n-1); k>=0; k--)
	{
		cout<<A[k]<<" ";
	}
	
	return 0;
}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include <iostream>
using namespace std;
int main ()
{
	let;
    int ("any number")
	"take number n and an array A";
	int ( "a to i" );
	make a formet (A1 , A2, A3, ----------- An);
	int ("A1>A2>A3>--------->An");
	it should find the element with minimum value;
	int "somthing";
	make an array;
	cin <A1, A2, A3, --------- An>
		cout make an array;
	cin < "1 to infinite" >;
	cout ("very least number");
	return 0;
}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;

int main() {
int n ; cin >> n; //Taking the array size
int a[1000];
for(int l=0; l<n;l++){cin >> a[l];}; //Taking the array elements

int m=10000;
int i =0;
while (i<n-3){
for (;i<n-3;i++) // for loop for getting the minimum element
	{
int temp1 = min(a[i],a[i+1]);
int temp2 = min(a[i+2],a[i+3]);
if (m > temp1 ||  m > temp2){m = min(temp1,temp2);};
	
for(int j =0;j<n;j++)
        {
swap(a[j],m);
       	
	}
	}
i++;
}
for(int z =0;z<n;z++) cout << a[z] << " ";
}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include<iostream>
using namespace std;
void swap(float *a,float *b)
{
	float * temp=0;
	temp=a;
	a=b;
	b=temp;
}

void  accendingorder(float a[],int n)
{
	for (int i=0;i<n;i++)
	{
		for (int j=i+1;j<n;j++)
		{
 			if(a[i]>a[j]) swap(a[i],a[j]);
		}
	}



}
int main()
{
	int n;
	cin>>n;
	float a[n];
	for (int i=0;i<n;i++)
	{
		cin>>a[i];
	}
	accendingorder(a,n);
	for(int i=0;i<n;i++)
	{
		cout<<a[i]<<" ";
	}
}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include<simplecpp>
main_program{
	int n,i,k=0,j=0;
	cin>>n;
	int A[n];
	for(i=0;i<n;i++){
		cin>>A[i];
	}
	while(j<n){
		i=j;
	for(i=i;i<n;i++){
		if(A[i]<=A[i-1] && A[i]<=A[i+1] && A[i]<=A[k]) {
			k=i; 
		}
		
	}
		if(k!=j) {swap(A[j],A[k]); }
		j++; k=j;
	}
	cout<<A[0];
	for(i=1;i<n;i++){
		cout<<" "<<A[i];
	}
}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include<iostream>
using namespace std;
void Swap(int &a, int &b)
{int temp;
temp=a;
a=b;
b=temp;}
int findLi(int arr[],int left,int n)
{int minIndex=left;
for(left=left+1;left<n;left++)
{if(arr[minIndex]>arr[left])
{minIndex=left;}
}
return minIndex;
}
void SelectionSort(int arr[],int n)
{for(int i=0;i<n;i++)
{int minIndex=findLi(arr,i,n);
    Swap(arr[i],arr[minIndex]);
}
}
int main()
{int n;
	cin>>n;
	int arr[n];
	for(int i=0;i<n;i++)
		{cin>>arr[i];}
	SelectionSort(arr,n);
 for(int i=0;i<n;i++)
		{cout<<arr[i]<<" ";}
	return 0;
}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include <iostream>
using namespace std;

void myswap (int *a, int *b)
{
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

int argmax (int *scores, int L){
int minindex = L-1;
for(int j=(L-1); j>0; j--){
if(scores[minindex] > scores[j]) minindex = j;
}
return minindex;
}

void selection_sort (int *data, int n){
for(int i=n; i>1;i--){
int minindex = argmax(data,i); 
myswap (&data[minindex],&data[n-i]); 
}
}

int main(){
int i,n;
cin>>n;
int A[n];

for (i=0;i<n;i++){
cin>>A[i];
}
selection_sort(A,n);
for (i=0; i<n; i++){
cout<<A[i]<<" ";
}
}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include<simplecpp>
main_program{
int n;
cin>>n;
int a[n];
for(int i=0;i<n;i++)
{cin>>a[i];}


for(int i=0;i<n-1;i++)
{int temp;
 for(int j=i+1;j<n;j++)
 
 {if( a[i]>a[j])
 {int temp=a[j];
 a[j]=a[i];
 a[i]=temp;
 
 
 }
 
 
 }
 
 
 }cout<<temp;
 }

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include<iostream>
using namespce std;
int sort(int *A,int n){
int A[n];
for(int i=0;i<n;i++)
{
for(int j=i;j<n;j++)
{ 
if(A[i]<=A[j])

return A[i];
}
}
}

intmain()
{
int n;
cin>>n;
int A[n];
for(int i=0;i<n;i++)
{
cin>>A[i];
}
cout<<sort(int *A , n)<<" "<<endl;

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include<iostream>
using namespace std;
void swap (int &a , int &b)
{
	int =t;
	t=a;
	a=b;
	b=t;

}

int find Minindex (int arr [ ], int left, int n)


{
	int minIndex =left;
	for (left=left+1;left<n; left + +)
	{
	if (arr [minIndex] > arr [left])
	{
	minIndex = left;

	}
	}
	return minIndex;
}
void selectionsort (int arr [ ], int left, int n)
{
	for (int i=0; i<n-1,i++)
	{
	int minIndex = find MinIndex (arr,i,n);
	swap (arr[i],arr [minIndex]);
}
}
int main();
{
	int n;
	cin >> n;
	int arr [n];
	for (int i=0;i<n;i++)
	{
	cin >> arr [i];
	}
	SelectionSort (arr,n);
	for (int i=0;i<n;i++)
	{
	cout << arr [i];
	}
}
return 0;

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include<iostream>
using namespace std;
int main(){
int n;
cin>>n;
int A[n];
for(int i=0;i<n;i++)
cin>>A[i];
for(int i=0;i<n;i++){
for(int j=i;j<n;j++)
if(A[j]<A[i]){int temp=A[i]; A[i]=A[j];A[j]=temp;}
}
for(int i=0;i<n;i++)
cout<<A[i]<<" ";
return 0;
}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include<simplecpp>
  int k,m;
  void swap (int *A) {
  int temp = A[k];
  A[k]=A[m];
  A[m]=temp;
  return;
  }
main_program {
  int n,i,j,k=0; cin>>n;
  int A[n] ;
  for (i=0;i<n;i++) {cin>>A[i] ;}
    int temp_min=A[0];

  while (k<n-1) {
                for (j=0;j<n-k;j++) {
                    if (A[j]<=temp_min ) { temp_min= A[j] ;}}
                for (j=0;j<n;j++) {
                    if (temp_min == A[j] ) { m=j ;} } 
                swap (A);
k++;
  }
 for (i=0;i<n;i++) {
                  cout<<A[i]; }
}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: B
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include<simplecpp>
void swap (float *a, float *b)
{
    float temp;
    temp = *a;
    *a = *b;
    *b = temp;
}
int argmin (float *marks, int L, int n)
{
	int minindex = L;
	for(int j=L+1; j<n; j++){
		if(marks[minindex] > marks[j]) minindex = j;	//Update the minindex
	}
	return minindex;
}
void desired_sort (float *data, int n)
{
    for(int i=0;i<n-1;i++)
    {
        int minindex = argmin(data,i,n); //Call the argmin to find min from A[i] to A[n-1].
        swap(&data[minindex],&data[i]);  //swap the values A[i] and A[minindex] using call by refrence.
		//Now the first i+1 elements are in exact position as in sorted array.
   	}
}
main_program
{
    float A[30];
    int i,n;
	cin >> n;
    for (i= 0; i < n; i++)
    {
        cin >> A[i];
    }
    desired_sort(A,n);
    for (i= 0; i < n-1; i++)
    {
        cout << A[i] << " ";
    }
	cout << A[n-1];
}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to sort an array A of n numbers strictly using the given algorithm:

1. Find the minimum element in the array.
2. Swap the minimum element with the first element of the array.
3. Find the minimum element in the remaining array.
4. Swap the minimum element with the second element of the array.
5. Repeat steps 3 and 4 until the entire array is sorted.

Constraints:

* n < 25

Input Format:

* Non-negative integer n
* Array A of n elements

Output Format:

* Print the sorted array with a space between adjacent elements.

Student submission:
#include<simplecpp>
void swap(int &x,int &y){
int q=x;
x=y;
y=q;
}
main_program{
int n;
cin>>n;
int x[25];
for(int i=0;i<n;i++){
 cin>>x[i];
 }
for(int i=0;i<n;i++){
 int r=i;
 for(int j=i;j<n;j++){
  if (x[j]<x[r]) {r=j;}
 }
 swap(x[i],x[r]);
 cout<<x[i]<<" ";
}
}

Grading criterion: Correctness of swapping minimum value and first element of array
Rating A: Swapping is correct
Rating B: Wrong swapping
Rating C: 0
Rating D: 0
Assigned grade: B