CodeGraderBench/CodeGraderBench huggingface dataset:
Problem: Write a C++ program to calculate the number of possible sequences that can be formed under certain conditions using recursion. The program should define a recursive function 'combination(int n, int k)' which calculates the total number of ways to arrange 'n' and 'k' such that the count follows a specific recursive relationship.

Code must fulfil these requirements:
A. Input: Accept two integers, 'n' and 'k', from the user

B. Recursive Function Definition: Define a recursive function 'int combination(int n, int k)' that follows the rules below:

C. Base Cases:
    1. If 'n == 1' and 'k >= 1', return '1'
       (Only one way to arrange if one element is available but multiple positions exist.)
    2. If 'k == 1' and 'n >= k', return 'n'
       (If there’s only one position, the number of ways equals the number of elements available.)
    3. If either 'n < 0' or 'k < 0', return '0'
       (Negative values are invalid)

D. Recursive Relation: combination(n, k) = combination(n - 1, k) + combination(n, k - 1)

E. Function Call and Output

Student submission:
#include <iostream>
using namespace std;
int c(int n,int k){

    if (n==1){
        return 1;
    }
    if (k==1){
        return n;
    }
    return(c(n-1,k)+c(k,n-1));
}
int main(){
    int n,k,ans;
    cin>>n;
    cin>>k;
    cout<<c(n,k);
    return 0;
}

Grading criterion: Calls the funcion from the main and prints the result
Rating A: Correctly calls the function from the main

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to calculate the number of possible sequences that can be formed under certain conditions using recursion. The program should define a recursive function 'combination(int n, int k)' which calculates the total number of ways to arrange 'n' and 'k' such that the count follows a specific recursive relationship.

Code must fulfil these requirements:
A. Input: Accept two integers, 'n' and 'k', from the user

B. Recursive Function Definition: Define a recursive function 'int combination(int n, int k)' that follows the rules below:

C. Base Cases:
    1. If 'n == 1' and 'k >= 1', return '1'
       (Only one way to arrange if one element is available but multiple positions exist.)
    2. If 'k == 1' and 'n >= k', return 'n'
       (If there’s only one position, the number of ways equals the number of elements available.)
    3. If either 'n < 0' or 'k < 0', return '0'
       (Negative values are invalid)

D. Recursive Relation: combination(n, k) = combination(n - 1, k) + combination(n, k - 1)

E. Function Call and Output

Student submission:
#include<iostream>
using namespace std;
 int fun( int n,int k){
    if(n=n-2) 
     return k;
    return fun(n-1, k) + fun(n, k-1);


 }
int main(){
    int n,k;
    cin>>n>>k;
    

    cout<<fun(n,k);
}

Grading criterion: Calls the funcion from the main and prints the result
Rating A: Correctly calls the function from the main

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to calculate the number of possible sequences that can be formed under certain conditions using recursion. The program should define a recursive function 'combination(int n, int k)' which calculates the total number of ways to arrange 'n' and 'k' such that the count follows a specific recursive relationship.

Code must fulfil these requirements:
A. Input: Accept two integers, 'n' and 'k', from the user

B. Recursive Function Definition: Define a recursive function 'int combination(int n, int k)' that follows the rules below:

C. Base Cases:
    1. If 'n == 1' and 'k >= 1', return '1'
       (Only one way to arrange if one element is available but multiple positions exist.)
    2. If 'k == 1' and 'n >= k', return 'n'
       (If there’s only one position, the number of ways equals the number of elements available.)
    3. If either 'n < 0' or 'k < 0', return '0'
       (Negative values are invalid)

D. Recursive Relation: combination(n, k) = combination(n - 1, k) + combination(n, k - 1)

E. Function Call and Output

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

int count (int n, int k){
    if(n ==1){
        return 1;
    }
    if(k ==1){
        return n;
    }
    return((count((n-1),k)) + (count(n,(k-1))));
}

int main (){
    int n;
    int k;

    cin >> n;
    cin >> k;

    cout << count(n , k);

}

Grading criterion: Calls the funcion from the main and prints the result
Rating A: Correctly calls the function from the main

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to calculate the number of possible sequences that can be formed under certain conditions using recursion. The program should define a recursive function 'combination(int n, int k)' which calculates the total number of ways to arrange 'n' and 'k' such that the count follows a specific recursive relationship.

Code must fulfil these requirements:
A. Input: Accept two integers, 'n' and 'k', from the user

B. Recursive Function Definition: Define a recursive function 'int combination(int n, int k)' that follows the rules below:

C. Base Cases:
    1. If 'n == 1' and 'k >= 1', return '1'
       (Only one way to arrange if one element is available but multiple positions exist.)
    2. If 'k == 1' and 'n >= k', return 'n'
       (If there’s only one position, the number of ways equals the number of elements available.)
    3. If either 'n < 0' or 'k < 0', return '0'
       (Negative values are invalid)

D. Recursive Relation: combination(n, k) = combination(n - 1, k) + combination(n, k - 1)

E. Function Call and Output

Student submission:
#include<iostream>
using namespace std;
int func(int n, int k){
    if(k==0) return 0;
    if(n==1) return 1;
    if(k==1) return n;
    return func(n-1,k) + func(n,k-1);
}

int main(){
    int n,k;
    cin>>n>>k;
    cout<<func(n,k);
	return 0;
}

Grading criterion: Calls the funcion from the main and prints the result
Rating A: Correctly calls the function from the main

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to calculate the number of possible sequences that can be formed under certain conditions using recursion. The program should define a recursive function 'combination(int n, int k)' which calculates the total number of ways to arrange 'n' and 'k' such that the count follows a specific recursive relationship.

Code must fulfil these requirements:
A. Input: Accept two integers, 'n' and 'k', from the user

B. Recursive Function Definition: Define a recursive function 'int combination(int n, int k)' that follows the rules below:

C. Base Cases:
    1. If 'n == 1' and 'k >= 1', return '1'
       (Only one way to arrange if one element is available but multiple positions exist.)
    2. If 'k == 1' and 'n >= k', return 'n'
       (If there’s only one position, the number of ways equals the number of elements available.)
    3. If either 'n < 0' or 'k < 0', return '0'
       (Negative values are invalid)

D. Recursive Relation: combination(n, k) = combination(n - 1, k) + combination(n, k - 1)

E. Function Call and Output

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

int func(int n,int k){
    if (n ==0){return 0;}
    if (k ==0){return 0;}
    if (n ==1){return 1;}
    if (k ==1){return n;}
  return func(n-1,k)+ func(n,k-1);
}





int main(){

    int n,k;
    cin>>n>>k;

   cout<< func(n,k)<<endl;
}

Grading criterion: Calls the funcion from the main and prints the result
Rating A: Correctly calls the function from the main

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to calculate the number of possible sequences that can be formed under certain conditions using recursion. The program should define a recursive function 'combination(int n, int k)' which calculates the total number of ways to arrange 'n' and 'k' such that the count follows a specific recursive relationship.

Code must fulfil these requirements:
A. Input: Accept two integers, 'n' and 'k', from the user

B. Recursive Function Definition: Define a recursive function 'int combination(int n, int k)' that follows the rules below:

C. Base Cases:
    1. If 'n == 1' and 'k >= 1', return '1'
       (Only one way to arrange if one element is available but multiple positions exist.)
    2. If 'k == 1' and 'n >= k', return 'n'
       (If there’s only one position, the number of ways equals the number of elements available.)
    3. If either 'n < 0' or 'k < 0', return '0'
       (Negative values are invalid)

D. Recursive Relation: combination(n, k) = combination(n - 1, k) + combination(n, k - 1)

E. Function Call and Output

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

int c(int n, int k){
    if (k == 0) return 1;
    if (n ==1) return 1;
    
    return c(n-1,k)+c(n,k-1);
}

int main(){
    int n, k;
    cin>>n>>k;
    cout << c(n,k);
}

Grading criterion: Calls the funcion from the main and prints the result
Rating A: Correctly calls the function from the main

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to calculate the number of possible sequences that can be formed under certain conditions using recursion. The program should define a recursive function 'combination(int n, int k)' which calculates the total number of ways to arrange 'n' and 'k' such that the count follows a specific recursive relationship.

Code must fulfil these requirements:
A. Input: Accept two integers, 'n' and 'k', from the user

B. Recursive Function Definition: Define a recursive function 'int combination(int n, int k)' that follows the rules below:

C. Base Cases:
    1. If 'n == 1' and 'k >= 1', return '1'
       (Only one way to arrange if one element is available but multiple positions exist.)
    2. If 'k == 1' and 'n >= k', return 'n'
       (If there’s only one position, the number of ways equals the number of elements available.)
    3. If either 'n < 0' or 'k < 0', return '0'
       (Negative values are invalid)

D. Recursive Relation: combination(n, k) = combination(n - 1, k) + combination(n, k - 1)

E. Function Call and Output

Student submission:
#include<iostream>
using namespace std;
int sequences(int n, int k)
{
    if(n==1)
    {
        return 1;
    }
    if(k==1)
    {
        return n;
    }
    return (sequences(n-1,k) + sequences(n,k-1));
}
int main()
{
    int n,k;
    cin>>n>>k;
    int res=sequences(n,k);
    cout<<res<<endl;
}

Grading criterion: Calls the funcion from the main and prints the result
Rating A: Correctly calls the function from the main

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to calculate the number of possible sequences that can be formed under certain conditions using recursion. The program should define a recursive function 'combination(int n, int k)' which calculates the total number of ways to arrange 'n' and 'k' such that the count follows a specific recursive relationship.

Code must fulfil these requirements:
A. Input: Accept two integers, 'n' and 'k', from the user

B. Recursive Function Definition: Define a recursive function 'int combination(int n, int k)' that follows the rules below:

C. Base Cases:
    1. If 'n == 1' and 'k >= 1', return '1'
       (Only one way to arrange if one element is available but multiple positions exist.)
    2. If 'k == 1' and 'n >= k', return 'n'
       (If there’s only one position, the number of ways equals the number of elements available.)
    3. If either 'n < 0' or 'k < 0', return '0'
       (Negative values are invalid)

D. Recursive Relation: combination(n, k) = combination(n - 1, k) + combination(n, k - 1)

E. Function Call and Output

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

int rec(int n ,k){
    for(n=0;)
}
int main(){
    cin >>n,k;
    
}

Grading criterion: Calls the funcion from the main and prints the result
Rating A: Correctly calls the function from the main

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: C
Problem: Write a C++ program to calculate the number of possible sequences that can be formed under certain conditions using recursion. The program should define a recursive function 'combination(int n, int k)' which calculates the total number of ways to arrange 'n' and 'k' such that the count follows a specific recursive relationship.

Code must fulfil these requirements:
A. Input: Accept two integers, 'n' and 'k', from the user

B. Recursive Function Definition: Define a recursive function 'int combination(int n, int k)' that follows the rules below:

C. Base Cases:
    1. If 'n == 1' and 'k >= 1', return '1'
       (Only one way to arrange if one element is available but multiple positions exist.)
    2. If 'k == 1' and 'n >= k', return 'n'
       (If there’s only one position, the number of ways equals the number of elements available.)
    3. If either 'n < 0' or 'k < 0', return '0'
       (Negative values are invalid)

D. Recursive Relation: combination(n, k) = combination(n - 1, k) + combination(n, k - 1)

E. Function Call and Output

Student submission:
#include<iostream>
using namespace std;
int recurse(int n,int k){
    if(k==0){
        return 1;
    }
    if(n==0){
        return 0;
    }

    return (recurse(n-1,k)+recurse(n,k-1));
    
}
int main(){
    int n;
    int k;
    cin>>n;
    cin>>k;
    int y=recurse(n,k);
    cout<<y;
}

Grading criterion: Calls the funcion from the main and prints the result
Rating A: Correctly calls the function from the main

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to calculate the number of possible sequences that can be formed under certain conditions using recursion. The program should define a recursive function 'combination(int n, int k)' which calculates the total number of ways to arrange 'n' and 'k' such that the count follows a specific recursive relationship.

Code must fulfil these requirements:
A. Input: Accept two integers, 'n' and 'k', from the user

B. Recursive Function Definition: Define a recursive function 'int combination(int n, int k)' that follows the rules below:

C. Base Cases:
    1. If 'n == 1' and 'k >= 1', return '1'
       (Only one way to arrange if one element is available but multiple positions exist.)
    2. If 'k == 1' and 'n >= k', return 'n'
       (If there’s only one position, the number of ways equals the number of elements available.)
    3. If either 'n < 0' or 'k < 0', return '0'
       (Negative values are invalid)

D. Recursive Relation: combination(n, k) = combination(n - 1, k) + combination(n, k - 1)

E. Function Call and Output

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

int sequence(int n, int k){
    if(n == 1){
        return 1;
    }
    if(n== 2 && k == 2){
        return 3;
    }
    if(n>k && k == 1){
        return n;
    }
    return (sequence(n-1,k)+ sequence(n,k-1));

}
int main(){
    int n,k;
    cin>>n>>k;
    cout<<sequence(n,k);
}

Grading criterion: Calls the funcion from the main and prints the result
Rating A: Correctly calls the function from the main

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to calculate the number of possible sequences that can be formed under certain conditions using recursion. The program should define a recursive function 'combination(int n, int k)' which calculates the total number of ways to arrange 'n' and 'k' such that the count follows a specific recursive relationship.

Code must fulfil these requirements:
A. Input: Accept two integers, 'n' and 'k', from the user

B. Recursive Function Definition: Define a recursive function 'int combination(int n, int k)' that follows the rules below:

C. Base Cases:
    1. If 'n == 1' and 'k >= 1', return '1'
       (Only one way to arrange if one element is available but multiple positions exist.)
    2. If 'k == 1' and 'n >= k', return 'n'
       (If there’s only one position, the number of ways equals the number of elements available.)
    3. If either 'n < 0' or 'k < 0', return '0'
       (Negative values are invalid)

D. Recursive Relation: combination(n, k) = combination(n - 1, k) + combination(n, k - 1)

E. Function Call and Output

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

int seq( int n , int k ) {

        if ( n==1 ) {
                return 1;
        }
        if ( k==1 ) {
                return n;
        }

        return seq(n-1 , k) + seq(n , k-1);
}

int main() {

        int n,k;
        cin >> n >> k;

        cout << seq(n,k);
}

Grading criterion: Base case Identification
Rating A: Correctly returns 0 or 1 when n or k become 0

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to calculate the number of possible sequences that can be formed under certain conditions using recursion. The program should define a recursive function 'combination(int n, int k)' which calculates the total number of ways to arrange 'n' and 'k' such that the count follows a specific recursive relationship.

Code must fulfil these requirements:
A. Input: Accept two integers, 'n' and 'k', from the user

B. Recursive Function Definition: Define a recursive function 'int combination(int n, int k)' that follows the rules below:

C. Base Cases:
    1. If 'n == 1' and 'k >= 1', return '1'
       (Only one way to arrange if one element is available but multiple positions exist.)
    2. If 'k == 1' and 'n >= k', return 'n'
       (If there’s only one position, the number of ways equals the number of elements available.)
    3. If either 'n < 0' or 'k < 0', return '0'
       (Negative values are invalid)

D. Recursive Relation: combination(n, k) = combination(n - 1, k) + combination(n, k - 1)

E. Function Call and Output

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

int count(int n, int k){
    if(k==0) return 0;
    if(k==1) return n;
    if(n==0) return 0;
    if(n==1) return 1;

    return count(n-1, k)+ count (n, k-1);

}

int main(){
    int n,k;
    cin>>n>>k;
    cout<<count(n,k)<<endl;
}

Grading criterion: Base case Identification
Rating A: Correctly returns 0 or 1 when n or k become 0

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to calculate the number of possible sequences that can be formed under certain conditions using recursion. The program should define a recursive function 'combination(int n, int k)' which calculates the total number of ways to arrange 'n' and 'k' such that the count follows a specific recursive relationship.

Code must fulfil these requirements:
A. Input: Accept two integers, 'n' and 'k', from the user

B. Recursive Function Definition: Define a recursive function 'int combination(int n, int k)' that follows the rules below:

C. Base Cases:
    1. If 'n == 1' and 'k >= 1', return '1'
       (Only one way to arrange if one element is available but multiple positions exist.)
    2. If 'k == 1' and 'n >= k', return 'n'
       (If there’s only one position, the number of ways equals the number of elements available.)
    3. If either 'n < 0' or 'k < 0', return '0'
       (Negative values are invalid)

D. Recursive Relation: combination(n, k) = combination(n - 1, k) + combination(n, k - 1)

E. Function Call and Output

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

int main() {
    vector<int> b,c,d;
    b ={1,2}
    c ={1, b[0]+ b[1],2(b[0]+b[1])}
    d ={1,c[0]+c[1], c[0]+c[1]+c[2],2(c[0]+c[1]+c[2])}
    cin>> n >> k;
    if(n=1){
        cout<<1 <<endl;
    if(n=2){
        cout << b[0]+b[1]<< endl;
    if (n=3){
        cout << c[0]+c[1]+c[2]<< endl;
    if (n=4){
        cout << d[0]+d[1]+d[2]+d[3]<< endl;
    }    
    }    
    }    
    }
    return 0;
}

Grading criterion: Base case Identification
Rating A: Correctly returns 0 or 1 when n or k become 0

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: C
Problem: Write a C++ program to calculate the number of possible sequences that can be formed under certain conditions using recursion. The program should define a recursive function 'combination(int n, int k)' which calculates the total number of ways to arrange 'n' and 'k' such that the count follows a specific recursive relationship.

Code must fulfil these requirements:
A. Input: Accept two integers, 'n' and 'k', from the user

B. Recursive Function Definition: Define a recursive function 'int combination(int n, int k)' that follows the rules below:

C. Base Cases:
    1. If 'n == 1' and 'k >= 1', return '1'
       (Only one way to arrange if one element is available but multiple positions exist.)
    2. If 'k == 1' and 'n >= k', return 'n'
       (If there’s only one position, the number of ways equals the number of elements available.)
    3. If either 'n < 0' or 'k < 0', return '0'
       (Negative values are invalid)

D. Recursive Relation: combination(n, k) = combination(n - 1, k) + combination(n, k - 1)

E. Function Call and Output

Student submission:
#include<iostream>
using namespace std;
int count(int n,int k){
    if(n==1){
        return 1;
    }
    if(k==1){
        return n;
    }
    return count(n-1,k)+count(n,k-1);
}
int main(){
    int n,k;
    cin>>n>>k;
    cout<<count(n,k);
    return 0;
}

Grading criterion: Base case Identification
Rating A: Correctly returns 0 or 1 when n or k become 0

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: A
Problem: Write a C++ program to calculate the number of possible sequences that can be formed under certain conditions using recursion. The program should define a recursive function 'combination(int n, int k)' which calculates the total number of ways to arrange 'n' and 'k' such that the count follows a specific recursive relationship.

Code must fulfil these requirements:
A. Input: Accept two integers, 'n' and 'k', from the user

B. Recursive Function Definition: Define a recursive function 'int combination(int n, int k)' that follows the rules below:

C. Base Cases:
    1. If 'n == 1' and 'k >= 1', return '1'
       (Only one way to arrange if one element is available but multiple positions exist.)
    2. If 'k == 1' and 'n >= k', return 'n'
       (If there’s only one position, the number of ways equals the number of elements available.)
    3. If either 'n < 0' or 'k < 0', return '0'
       (Negative values are invalid)

D. Recursive Relation: combination(n, k) = combination(n - 1, k) + combination(n, k - 1)

E. Function Call and Output

Student submission:
#include<iostream>

using namespace std;

int count(int n, int k){
    int sum,a=0,b=0,c=0,total;
    if (n==1&&k==1)return 1;
    else if(n==1&&k!=1)return 1;
    else if(n!=1&&k==1)return n;
    else return count(n-1,k)+count(n,k-1);
    }

    int main(){
        int n,k;
        cin >> n >> k;
        cout<<count(n,k);
    }

Grading criterion: Base case Identification
Rating A: Correctly returns 0 or 1 when n or k become 0

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: A