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 count(int n, int k){
    if(n == 0){ 
        return 0;
    } 
    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);
}

Grading criterion: Declarations of variable, taking input, and final output
Rating A: Correctly declares and reads two integers as input and cout for final output

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;
    else if(k==1) return n;
    else if(k==0) return 0;
    else return count(n-1,k)+count(n,k-1);
}

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

Grading criterion: Declarations of variable, taking input, and final output
Rating A: Correctly declares and reads two integers as input and cout for final output

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(n==1 || k==0) return 1;
    return (c(n,k-1)+c(n-1,k));
}
int main(){
    int k,n;
    cin >> n>>k;
    int sum=c(n,k);
    cout<<sum<<endl;
}

Grading criterion: Declarations of variable, taking input, and final output
Rating A: Correctly declares and reads two integers as input and cout for final output

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 counting(int n, int k) {
    if(k==0) return 0;
    if(n==1 && k!=0) return 1;
    else return counting(n-1,k) + counting(n,k-1);

}

int main(){
    int n,k;
    cin>>n>>k;
    cout<< counting(n,k+1);
}

Grading criterion: Declarations of variable, taking input, and final output
Rating A: Correctly declares and reads two integers as input and cout for final output

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(n!=1&&k==1){
                return n;
            }
           
            
            
        
        int c;
        c=count(n-1,k)+count(n,k-1);
        k--;n--;
        return c;
        }
    


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

}

Grading criterion: Declarations of variable, taking input, and final output
Rating A: Correctly declares and reads two integers as input and cout for final output

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(n==1 && k>0) return 1;
    if(n>1 && k==1) return n;
    else {
        return C(n-1, k) + C(n, k-1);
    }

}


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

Grading criterion: Declarations of variable, taking input, and final output
Rating A: Correctly declares and reads two integers as input and cout for final output

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(n==0)return 0;
    if(n==1)return 1;
    if(n==2 && k==2)return 3;
    if(k==1)return n;
    return C(n-1,k)+C(n,k-1);
    
}
int main(){
    int n , k ;
    cin>>n>>k;
    cout<<C(n,k);
}

Grading criterion: Declarations of variable, taking input, and final output
Rating A: Correctly declares and reads two integers as input and cout for final output

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;

void seq(vector<int>& arr ,vector<int>& curr, int i , vector<int> &ans , int k){
    if(curr.size() == k ){
        ans.push_back(1);
        return ;
    }
    if(i == arr.size()){
        return ;
    }
    curr.push_back(arr[i]);
    seq(arr , curr , i , ans ,k);
    curr.pop_back();
    seq(arr , curr , i+1 , ans , k);
}
int main(){
    int n , k;
    cin>>n>>k;
    vector<int> arr(n,0);
    vector<int> curr;
    vector<int> ans;
    for(int i = 0 ; i<n ; i++){
        arr[i] = 1+i;
    }

    seq(arr ,curr , 0 , ans , k );
    int count = ans.size();
    cout<<count;
return 0;
}

Grading criterion: Declarations of variable, taking input, and final output
Rating A: Correctly declares and reads two integers as input and cout for final output

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 counting(int n, int k){
    if (n==1 || k==0)
        return 1;

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

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

    cout<<counting(n, k);
}

Grading criterion: Declarations of variable, taking input, and final output
Rating A: Correctly declares and reads two integers as input and cout for final output

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 m){
    if(m>n) return 0;
    if(n==m) return 1;
    if(m==1) return n;
    return c(n-1,m) +c(n,m-1);
}
int count(int n,int m){
    if(m==0) return 0;
    return count(n,m-1) +c(n,m);
}
int main(){
    int n , m;
    cin>> n >> m;
    cout<<count(n,m);
}

Grading criterion: Declarations of variable, taking input, and final output
Rating A: Correctly declares and reads two integers as input and cout for final output

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(n==0 || k==0){
        return 0;
    }else if(n==1 && k==2){
        return 1;
    }else if(n>0 && k<0){
        return 0;
    }else if(n==1 && k==3){
        return 1;
    }else if(k==1){
        return n;
    }
    
    else return  C(n-1,k) + C(n,k-1);

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

    cout<<C(n,k);
}

Grading criterion: Declarations of variable, taking input, and final output
Rating A: Correctly declares and reads two integers as input and cout for final output

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 comb(int n, int k){
     int ans;
    if(k==0 ){
        
        return 0;
    }
    if(n==0){
        
        return 0;
    }
     
    ans = comb(n-1,k) + comb(n,k-1); 
    return ans;
    
    
}
int main(){
    int n,k;
    cin >> n;
    cin>> k;
    comb(n,k);
}

Grading criterion: Declarations of variable, taking input, and final output
Rating A: Correctly declares and reads two integers as input and cout for final output

Rating B: some issue
Rating C: major issue
Rating D: 0
Assigned grade: B
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==1){return 1;}
    if(n==1&&k!=1){return k;}
    return c(n-1,k)+c(n,k-1);
}
int main(){
    int n,k;
    cin>>n>>k;
    cout<<c(n,k);
}

Grading criterion: Declarations of variable, taking input, and final output
Rating A: Correctly declares and reads two integers as input and cout for final output

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;
    
}

Grading criterion: Declarations of variable, taking input, and final output
Rating A: Correctly declares and reads two integers as input and cout for final output

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 c(int n,int k){
    if(n==0) return 1;
    if(k==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: Declarations of variable, taking input, and final output
Rating A: Correctly declares and reads two integers as input and cout for final output

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