Datasets:
Dataset Viewer
question
string | choices
sequence | answer
int64 | answer_label
string | split
string | subcategories
string | lang
string | second_lang
string | coding_lang
string | notes
string | id
string | set_id
float64 | variation_id
string |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
What will this code output?
```
def mystery(n):
if n <= 0:
return 0
if n == 1:
return 1
return mystery(n-1) + mystery(n-2)
print(mystery(6))
``` | [
"5",
"8",
"6",
"13"
] | 1 | B | dev | Cannonical | eng_Latn | python | The function outputs the n-th Fibonacci number | 65-1.0 | 65 | 1.0 |
|
What will this code output?
```
def mystery(n):
if n <= 0:
return 0
if n == 2:
return 1
return mystery(n-1) + mystery(n-2)
print(mystery(6))
``` | [
"5",
"8",
"6",
"13"
] | 0 | A | test | Buggy code | eng_Latn | python | Fibonacci series, off by one | 65-1.1 | 65 | 1.1 |
|
What will this code output?
```
def mystery(input_num):
if input_num <= 0:
return 0
if input_num == 1:
return 1
return mystery(input_num-1) + mystery(input_num-2)
print(mystery(6))
``` | [
"5",
"6",
"13",
"8"
] | 3 | D | test | Variable naming conventions | eng_Latn | python | Fibonacci series, snake_case naming convention | 65-1.10 | 65 | 1.10 |
|
What will this code output?
```
def mystery_func(input_num):
if input_num <= 0:
return 0
if input_num == 1:
return 1
return mystery_func(input_num-1) + mystery_func(input_num-2)
print(mystery_func(6))
``` | [
"8",
"5",
"6",
"13"
] | 0 | A | test | Variable naming conventions | eng_Latn | python | Fibonacci series, snake_case naming convention | 65-1.11 | 65 | 1.11 |
|
What will this code output?
```
def mystery(n):
return mystery(n-1) + mystery(n-2)
print(mystery(6))
``` | [
"8",
"6",
"13",
"RecursionError: maximum recursion depth exceeded"
] | 3 | D | test | Buggy code | eng_Latn | python | Fibonacci series with infinite loop | 65-1.12 | 65 | 1.12 |
|
What will this code output?
```
def mystery(n):
if n <= 0:
return 0
if n == 1:
return 1
return mystery(n-1) + mystery(n-2)
print(mystery(6))
``` | [
"SyntaxError: invalid syntax",
"8",
"6",
"13"
] | 0 | A | test | Buggy code | eng_Latn | python | Fibonacci series with wrong syntax | 65-1.13 | 65 | 1.13 |
|
What will this code output?
```
def mystery(n):
if n <= 0:
return 0
if n == 1:
return 1
return mystery(n-1) + mystery(n-2)
print(mystery(6))
``` | [
"8",
"6",
"13",
"IndentationError: unexpected indent"
] | 3 | D | test | Buggy code | eng_Latn | python | Fibonacci series with wrong indentation | 65-1.14 | 65 | 1.14 |
|
What will this code output?
```
def mystery(n):
if n <= 0:
return 0,
if n == 1:
return 1
return mystery(n-1) + mystery(n-2)
print(mystery(6))
``` | [
"8",
"TypeError: unsupported operand type(s) for +: 'int' and 'tuple'",
"6",
"13"
] | 1 | B | test | Buggy code | eng_Latn | python | Fibonacci series with bug in the base case | 65-1.15 | 65 | 1.15 |
|
What will this code output?
```
def mystery(n):
if n <= 0: # base case
return 0
if n == 1:
return 1
return mystery(n-1) + mystery(n-2)
print(mystery(6))
``` | [
"5",
"6",
"13",
"8"
] | 3 | D | test | Comments across languages | eng_Latn | python | Fibonacci, commented | 65-1.16 | 65 | 1.16 |
|
What will this code output?
```
def mystery(n):
if n <= 0: ##### base case
return 0
if n == 1:
return 1
return mystery(n-1) + mystery(n-2)
print(mystery(6))
``` | [
"5",
"6",
"13",
"8"
] | 3 | D | test | Comments across languages | eng_Latn | python | Fibonacci, commented | 65-1.17 | 65 | 1.17 |
|
What will this code output?
```
def mystery(n):
# base case
if n <= 0:
return 0
if n == 1:
return 1
return mystery(n-1) + mystery(n-2)
print(mystery(6))
``` | [
"8",
"5",
"6",
"13"
] | 0 | A | test | Comments across languages | eng_Latn | python | Fibonacci, commented | 65-1.18 | 65 | 1.18 |
|
What will this code output?
```
def mystery(n):
""" base case """
if n <= 0:
return 0
if n == 1:
return 1
return mystery(n-1) + mystery(n-2)
print(mystery(6))
``` | [
"5",
"8",
"6",
"13"
] | 1 | B | test | Comments across languages | eng_Latn | python | Fibonacci, comments with double quotes | 65-1.19 | 65 | 1.19 |
|
What will this code output?
```
def mystery( n ):
if n <= 0 :
return 0
if n == 1 :
return 1
return mystery( n - 1 ) + mystery( n - 2 )
``` | [
"8",
"5",
"6",
"13"
] | 0 | A | test | Whitespace variations | eng_Latn | python | Additional spaces | 65-1.2 | 65 | 1.2 |
|
What will this code output?
```
def mystery(n):
''' base case """
if n <= 0:
return 0
if n == 1:
return 1
return mystery(n-1) + mystery(n-2)
print(mystery(6))
``` | [
"8",
"SyntaxError",
"Never terminates",
"TypeError"
] | 2 | C | test | Comments across languages | eng_Latn | python | Fibonacci, mismatched comment quotes, code never executes | 65-1.20 | 65 | 1.20 |
|
What will this code output?
```
def mystery(n):
''' base case '''
if n <= 0:
return 0
if n == 1:
return 1
return mystery(n-1) + mystery(n-2)
print(mystery(6))
``` | [
"8",
"5",
"6",
"13"
] | 0 | A | test | Comments across languages | eng_Latn | python | Fibonacci, comments with single quotes | 65-1.21 | 65 | 1.21 |
|
What will this code output?
```
def mystery(n):
if n<=0 :
return 0
if n==1 :
return 1
return mystery(n-1)+mystery(n-2)
``` | [
"8",
"6",
"5",
"13"
] | 2 | C | test | Whitespace variations | eng_Latn | python | No space at all | 65-1.3 | 65 | 1.3 |
|
What will this code output?
```
def mystery(n):
if n <= 0:
return 0
if n == 2:
return 1
return mystery(n-1) + mystery(n-2)
print(f"Result: {mystery(6)}")
``` | [
"Result: 8",
"8",
"Result: 6",
"Result: 13"
] | 0 | A | test | String literals | eng_Latn | python | String literals - f-string output | 65-1.4 | 65 | 1.4 |
|
What will this code output?
```
def mystery(n):
if n <= 0:
return 0
if n == 2:
return 1
return mystery(n-1) + mystery(n-2)
print(f"{mystery(6)}")
``` | [
"6",
"8",
"\"8\"",
"13"
] | 1 | B | test | String literals | eng_Latn | python | String literals - f-string output | 65-1.5 | 65 | 1.5 |
|
What will this code output?
```
def mystery(n):
if n <= 0:return 0
if n == 1:return 1
return mystery(n-1) + mystery(n-2)
print(mystery(6))
``` | [
"8",
"5",
"6",
"13"
] | 0 | A | test | Whitespace variations | eng_Latn | python | No line break and additional spaces | 65-1.6 | 65 | 1.6 |
|
What will this code output?
```
def mystery(n):
if n <= 0: return 0
if n == 1: return 1
return mystery(n-1) + mystery(n-2)
print(mystery(6))
``` | [
"8",
"5",
"6",
"13"
] | 0 | A | test | Whitespace variations | eng_Latn | python | No line break | 65-1.7 | 65 | 1.7 |
|
What will this code output?
```
def mystery(inputNum):
if inputNum <= 0:
return 0
if inputNum == 1:
return 1
return mystery(inputNum-1) + mystery(inputNum-2)
print(mystery(6))
``` | [
"5",
"6",
"13",
"8"
] | 3 | D | test | Variable naming conventions | eng_Latn | python | Fibonacci series, camelCase naming convention | 65-1.8 | 65 | 1.8 |
|
What will this code output?
```
def mysteryFunc(inputNum):
if inputNum <= 0:
return 0
if inputNum == 1:
return 1
return mysteryFunc(inputNum-1) + mysteryFunc(inputNum-2)
print(mysteryFunc(6))
``` | [
"8",
"5",
"6",
"13"
] | 0 | A | test | Variable naming conventions | eng_Latn | python | Fibonacci series, camelCase naming convention | 65-1.9 | 65 | 1.9 |
|
What will this code output?
```
public class Test {
public static void main(String[] args) {
int[] arr = {3, 1, 4, 1, 5};
int sum = 0;
for (int i = 0; i < arr.length; i += 2) {
sum += arr[i];
}
System.out.println(sum);
}
}
``` | [
"12",
"14",
"9",
"5"
] | 0 | A | dev | Cannonical | eng_Latn | java | The function sums elements at even indices | 66-1.0 | 66 | 1.0 |
|
What will this code output?
```
public class Test {
public static void main( String[] args ) {
int[] arr = { 3, 1, 4, 1, 5 };
int sum = 0;
for ( int i = 0; i < arr.length; i += 2 ) {
sum += arr[ i ];
}
System.out.println( sum );
}
}
``` | [
"14",
"12",
"9",
"5"
] | 1 | B | test | Whitespace variations | eng_Latn | java | Whitespace variations - extra spaces: | 66-1.1 | 66 | 1.1 |
|
What will this code output?
```
public class Test {
public static void main(String[] args) {
int[] arr = {3, 1, 4, 1, 5}; // array initialization
int sum = 0;
for (int i = 0; i < arr.length; i += 2) { // step by 2
sum += arr[i];
}
System.out.println(sum);
}
}
``` | [
"14",
"12",
"9",
"5"
] | 1 | B | test | Comments across languages | eng_Latn | java | Comments - single line | 66-1.10 | 66 | 1.10 |
|
What will this code output?
```
public class Test {
public static void main(String[] args) {
/* Initialize array */
int[] arr = {3, 1, 4, 1, 5};
int sum = 0;
/* Loop through every other element */
for (int i = 0; i < arr.length; i += 2) {
sum += arr[i];
}
System.out.println(sum);
}
}
``` | [
"14",
"12",
"9",
"5"
] | 1 | B | test | Comments across languages | eng_Latn | java | Comments - block comments | 66-1.11 | 66 | 1.11 |
|
What will this code output?
```
public class Test {
/**
* Main method
*/
public static void main(String[] args) {
int[] arr = {3, 1, 4, 1, 5};
int sum = 0;
for (int i = 0; i < arr.length; i += 2) {
sum += arr[i];
}
System.out.println(sum);
}
}
``` | [
"14",
"9",
"12",
"5"
] | 2 | C | test | Comments across languages | eng_Latn | java | Comments - javadoc style | 66-1.12 | 66 | 1.12 |
|
What will this code output?
```
public class Test {
public static void main(String[] args) {
/* Initialize array
int[] arr = {3, 1, 4, 1, 5};
int sum = 0;
for (int i = 0; i < arr.length; i += 2) {
sum += arr[i];
}
System.out.println(sum);
}
}
``` | [
"12",
"9",
"5",
"Compilation error"
] | 3 | D | test | Buggy code, Comments across languages | eng_Latn | java | Comments - mismatched block comment | 66-1.13 | 66 | 1.13 |
|
What will this code output?
```
public class Test {public static void main(String[] args) {int[] arr = {3, 1, 4, 1, 5};int sum = 0;for (int i = 0; i < arr.length; i += 2) {sum += arr[i];}System.out.println(sum);}}
``` | [
"14",
"9",
"5",
"12"
] | 3 | D | test | Whitespace variations | eng_Latn | java | No whitespace/formatting | 66-1.14 | 66 | 1.14 |
|
What will this code output?
```
public class Test {
public static void main(String[] args) {
int[] arr = {3, 1, 4, 1, 5};
int sum = 0;
for (int i = 0; i < arr.length; i += 2) {
sum += arr[i];
}
System.out.println(sum);
}
}
``` | [
"14",
"12",
"9",
"5"
] | 1 | B | test | Whitespace variations | eng_Latn | java | No tabs | 66-1.15 | 66 | 1.15 |
|
What will this code output?
```
public class Test {
public static void main(String[] args) {
int[] arr = {3, 1, 4, 1, 5};
int sum = 0;
for (int i = 0; i < arr.length; i += 2) {
sum += arr[i];;
;;
}
System.out.println(sum);
}
}
``` | [
"Compilation error",
"9",
"5",
"12"
] | 3 | D | test | Syntax and punctuation variations | eng_Latn | java | Double semicolons | 66-1.16 | 66 | 1.16 |
|
What will this code output?
```
public class Test {
public static void main(String[] args) {
int[] arr = {3, 1, 4, 1, 5}
int sum = 0;
for (int i = 0; i < arr.length; i += 2) {
sum += arr[i];
}
System.out.println(sum);
}
}
``` | [
"12",
"9",
"5",
"Compilation error"
] | 3 | D | test | Buggy code | eng_Latn | java | Missing semicolon | 66-1.17 | 66 | 1.17 |
|
What will this code output?
```
public class Test {
public static void main(String[] args) {
int[] arr = {3, 1, 4, 1, 5}
;
int sum = 0;
for (int i = 0; i < arr.length; i += 2) {
sum += arr[i];
}
System.out.println(sum);
}
}
``` | [
"14",
"9",
"5",
"12"
] | 3 | D | test | Syntax and punctuation variations, Whitespace variations | eng_Latn | java | Semicolon at next line | 66-1.18 | 66 | 1.18 |
|
What will this code output?
```
public class Test{
public static void main(String[]args){
int[]arr={3,1,4,1,5};
int sum=0;
for(int i=0;i<arr.length;i+=2){
sum+=arr[i];
}
System.out.println(sum);
}
}
``` | [
"14",
"12",
"9",
"5"
] | 1 | B | test | Whitespace variations | eng_Latn | java | No spaces | 66-1.2 | 66 | 1.2 |
|
What will this code output?
```
public class Test {
public static void main(String[] args) {
int[] arr = {3, 1, 4, 1, 5};
int sum = 0;
for (int i = 0; i < arr.length; i += 2) {
sum += arr[i];
}
System.out.println("Result: " + sum);
}
}
``` | [
"Result: 12",
"12",
"Result: 9",
"Result: 5"
] | 0 | A | test | String literals | eng_Latn | java | String literals - formatted output | 66-1.3 | 66 | 1.3 |
|
What will this code output?
```
public class Test {
public static void main(String[] args) {
int[] arr = {3, 1, 4, 1, 5};
int sum = 0;
for (int i = 0; i < arr.length; i += 2) {
sum += arr[i];
}
System.out.printf("%d", sum);
}
}
``` | [
"14",
"9",
"12",
"5"
] | 2 | C | test | String literals | eng_Latn | java | String literals - printf format | 66-1.4 | 66 | 1.4 |
|
What will this code output?
```
public class Test {
public static void main(String[] args) {
int[] arrayValues = {3, 1, 4, 1, 5};
int totalSum = 0;
for (int currentIndex = 0; currentIndex < arrayValues.length; currentIndex += 2) {
totalSum += arrayValues[currentIndex];
}
System.out.println(totalSum);
}
}
``` | [
"14",
"9",
"5",
"12"
] | 3 | D | test | Variable naming conventions | eng_Latn | java | Variable naming conventions - camelCase | 66-1.5 | 66 | 1.5 |
|
What will this code output?
```
public class Test {
public static void main(String[] args) {
int[] array_values = {3, 1, 4, 1, 5};
int total_sum = 0;
for (int current_index = 0; current_index < array_values.length; current_index += 2) {
total_sum += array_values[current_index];
}
System.out.println(total_sum);
}
}
``` | [
"14",
"9",
"5",
"12"
] | 3 | D | test | Variable naming conventions | eng_Latn | java | Variable naming conventions - snake_case style | 66-1.6 | 66 | 1.6 |
|
What will this code output?
```
public class Test {
public static void main(String[] args) {
int[] arr = {3, 1, 4, 1, 5};
int sum = 0;
for (int i = 0; i < arr.length; i -= 2) {
sum += arr[i];
}
System.out.println(sum);
}
}
``` | [
"12",
"9",
"5",
"Never terminates"
] | 3 | D | test | Buggy code | eng_Latn | java | Infinite loop | 66-1.7 | 66 | 1.7 |
|
What will this code output?
```
public class Test {
public static void main(String[] args) {
int[] arr = {3, 1, 4, 1, 5};
int sum = 0;
for (int i = 0; i < arr.length; i += 2)
sum += arr[i];
System.out.println(sum);
}
}
``` | [
"12",
"9",
"Compilation error",
"5"
] | 2 | C | test | Buggy code | eng_Latn | java | Syntax error | 66-1.8 | 66 | 1.8 |
|
What will this code output?
```
public class Test {
public static void main(String[] args) {
int[] arr = {3, 1, 4, 1, 5};
int sum = 0;
for (int i = 0; i <= arr.length; i += 2) {
sum += arr[i];
}
System.out.println(sum);
}
}
``` | [
"12",
"9",
"5",
"ArrayIndexOutOfBoundsException"
] | 3 | D | test | Buggy code | eng_Latn | java | Array bounds | 66-1.9 | 66 | 1.9 |
|
What will this code output?
```
#include <stdio.h>
int main() {
int x = 10;
int *ptr = &x;
*ptr = *ptr + 5;
printf("%d", x);
return 0;
}
``` | [
"15",
"10",
"5",
"20"
] | 0 | A | test | Cannonical | eng_Latn | C | 67-1.0 | 67 | 1.0 |
||
What will this code output?
```
#include <stdio.h>
int main() {
int x = 10;
int *ptr = NULL;
*ptr = *ptr + 5;
printf("%d", x);
return 0;
}
``` | [
"15",
"Segmentation fault",
"10",
"5"
] | 1 | B | test | Buggy code | eng_Latn | C | Buggy code - null pointer | 67-1.1 | 67 | 1.1 |
|
What will this code output?
```
#include <stdio.h>
int main() {
int initial_value = 10;
int *value_ptr = &initial_value;
*value_ptr = *value_ptr + 5;
printf("%d", initial_value);
return 0;
}
``` | [
"15",
"15",
"10",
"5"
] | 1 | B | test | Variable naming conventions | eng_Latn | C | Variable naming conventions - snake_case | 67-1.10 | 67 | 1.10 |
|
What will this code output?
```
#include <stdio.h>
int main() {
int x = 10;;
int *ptr = &x;;
*ptr = *ptr + 5;;
printf("%d", x);;
return 0;;
}
``` | [
"10",
"Compilation error",
"5",
"15"
] | 3 | D | test | Syntax and punctuation variations | eng_Latn | C | Extra semicolons: | 67-1.11 | 67 | 1.11 |
|
What will this code output?
```
#include <stdio.h>
int main() {
int x = 10;
int *ptr = &x;
(*ptr) = (*ptr) + 5;
printf("%d", x);
return 0;
}
``` | [
"10",
"5",
"15",
"20"
] | 2 | C | test | Syntax and punctuation variations | eng_Latn | C | Extra parentheses | 67-1.12 | 67 | 1.12 |
|
What will this code output?
```
#include <stdio.h>
int main() {
int x = 10;
int *ptr = &x;
*ptr = *ptr + 5 * 2;
printf("%d", x);
return 0;
}
``` | [
"15",
"20",
"10",
"25"
] | 1 | B | test | Syntax and punctuation variations | eng_Latn | C | Operator precedence | 67-1.13 | 67 | 1.13 |
|
What will this code output?
```
#include <stdio.h>
int main() {
int x = 10;
/* outer comment /* inner comment */ still commenting */
int *ptr = &x;
*ptr = *ptr + 5;
printf("%d", x);
return 0;
}
``` | [
"15",
"Compilation error",
"10",
"5"
] | 1 | B | test | Buggy code | eng_Latn | C | Comments across languages - nested comments (error) | 67-1.14 | 67 | 1.14 |
|
What will this code output?
```
#include <stdio.h>
int main() {
int x = 10;
int *ptr;
*ptr = *ptr + 5;
printf("%d", x);
return 0;
}
``` | [
"15",
"10",
"5",
"Segmentation fault"
] | 3 | D | test | Buggy code | eng_Latn | C | Buggy code - uninitialized pointer | 67-1.2 | 67 | 1.2 |
|
What will this code output?
```
#include <stdio.h>
int main( ) {
int x = 10;
int * ptr = & x;
* ptr = * ptr + 5;
printf( "%d", x );
return 0;
}
``` | [
"10",
"5",
"15",
"20"
] | 2 | C | test | Whitespace variations | eng_Latn | C | Whitespace variations - extra spaces | 67-1.3 | 67 | 1.3 |
|
What will this code output?
```
#include<stdio.h>
int main(){
int x=10;
int*ptr=&x;
*ptr=*ptr+5;
printf("%d",x);
return 0;
}
``` | [
"10",
"5",
"20",
"15"
] | 3 | D | test | Whitespace variations | eng_Latn | C | Whitespace variations - no spaces | 67-1.4 | 67 | 1.4 |
|
What will this code output?
```
#include <stdio.h>
int main() {
int x = 10;
int *ptr = &x;
*ptr = *ptr + 5;
printf("Result: %d\n", x);
return 0;
}
``` | [
"15",
"Result: 15",
"Result: 10",
"Result: 5"
] | 1 | B | test | String literals | eng_Latn | C | String literals - different format | 67-1.5 | 67 | 1.5 |
|
What will this code output?
```
#include <stdio.h>
int main() {
int x = 10;
int *ptr = &x;
*ptr = *ptr + 5;
printf("%d", x);
printf(".");
return 0;
}
``` | [
"15",
"15",
"10",
"5"
] | 0 | A | test | String literals | eng_Latn | C | String literals - multiple printf | 67-1.6 | 67 | 1.6 |
|
What will this code output?
```
#include <stdio.h>
int main() {
int x = 10; // initialize variable
int *ptr = &x; // pointer to x
*ptr = *ptr + 5; // modify through pointer
printf("%d", x);
return 0;
}
``` | [
"15",
"10",
"5",
"15"
] | 3 | D | test | Comments across languages | eng_Latn | C | Comments across languages - single line | 67-1.7 | 67 | 1.7 |
|
What will this code output?
```
#include <stdio.h>
int main() {
int x = 10;
int *ptr = &x;
/* modify value through pointer */
*ptr = *ptr + 5;
printf("%d", x);
return 0;
}
``` | [
"15",
"15",
"10",
"5"
] | 1 | B | test | Comments across languages | eng_Latn | C | Comments across languages - block comments | 67-1.8 | 67 | 1.8 |
|
What will this code output?
```
#include <stdio.h>
int main() {
int initialValue = 10;
int *valuePtr = &initialValue;
*valuePtr = *valuePtr + 5;
printf("%d", initialValue);
return 0;
}
``` | [
"15",
"15",
"10",
"5"
] | 0 | A | test | Variable naming conventions | eng_Latn | C | Variable naming conventions - camelCase: | 67-1.9 | 67 | 1.9 |
|
What will this code output?
```
#include <iostream>
using namespace std;
int main() {
int x = 10;
int *ptr = &x;
*ptr = *ptr + 5;
cout << x;
return 0;
}
``` | [
"10",
"5",
"20",
"15"
] | 3 | D | dev | Cannonical | eng_Latn | C++ | 68-1.0 | 68 | 1.0 |
||
What will this code output?
```
#include <iostream>
using namespace std;
int main() {
int x = 10;
int *ptr = nullptr;
*ptr = *ptr + 5;
cout << x;
return 0;
}
``` | [
"15",
"10",
"Segmentation fault",
"5"
] | 2 | C | test | Buggy code | eng_Latn | C++ | Buggy code - null pointer | 68-1.1 | 68 | 1.1 |
|
What will this code output?
```
#include <iostream>
using namespace std;
int main() {
int x = 10;
int *ptr = &x;
*ptr = *ptr + 5;
cout << "Result: " << x;
return 0;
}
``` | [
"Result: 15",
"15",
"Result: 10",
"Result: 5"
] | 0 | A | test | String literals | eng_Latn | C++ | String literals - different output | 68-1.10 | 68 | 1.10 |
|
What will this code output?
```
#include <iostream>
using namespace std;
int main() {
int x = 10; // initialize variable
int *ptr = &x; // pointer to x
*ptr = *ptr + 5; // modify through pointer
cout << x;
return 0;
}
``` | [
"10",
"5",
"20",
"15"
] | 3 | D | test | Comments across languages | eng_Latn | C++ | Comments across languages - single line | 68-1.11 | 68 | 1.11 |
|
What will this code output?
```
#include <iostream>
using namespace std;
int main() {
int x = 10;
int *ptr = &x;
/* modify value through pointer */
*ptr = *ptr + 5;
cout << x;
return 0;
}
``` | [
"10",
"15",
"5",
"20"
] | 1 | B | test | Comments across languages | eng_Latn | C++ | Comments across languages - block comments | 68-1.12 | 68 | 1.12 |
|
What will this code output?
```
#include <iostream>
using namespace std;
int main() {
int initialValue = 10;
int *valuePtr = &initialValue;
*valuePtr = *valuePtr + 5;
cout << initialValue;
return 0;
}
``` | [
"10",
"15",
"5",
"20"
] | 1 | B | test | Variable naming conventions | eng_Latn | C++ | Variable naming conventions - camelCase | 68-1.13 | 68 | 1.13 |
|
What will this code output?
```
#include <iostream>
using namespace std;
int main() {
int initial_value = 10;
int *value_ptr = &initial_value;
*value_ptr = *value_ptr + 5;
cout << initial_value;
return 0;
}
``` | [
"10",
"5",
"15",
"20"
] | 2 | C | test | Variable naming conventions | eng_Latn | C++ | Variable naming conventions - snake_case | 68-1.14 | 68 | 1.14 |
|
What will this code output?
```
#include <iostream>
using namespace std;
int main() {
int x = 10;;
int *ptr = &x;;
*ptr = *ptr + 5;;
cout << x;;
return 0;;
}
``` | [
"10",
"5",
"20",
"15"
] | 3 | D | test | Syntax and punctuation variations | eng_Latn | C++ | Extra semicolons | 68-1.15 | 68 | 1.15 |
|
What will this code output?
```
#include <iostream>
using namespace std;
int main() {
int x = 10;
int *ptr = &x;
*ptr = *ptr + 5;
::std::cout << x;
return 0;
}
``` | [
"10",
"5",
"20",
"15"
] | 3 | D | test | Syntax and punctuation variations | eng_Latn | C++ | Scope resolution | 68-1.16 | 68 | 1.16 |
|
What will this code output?
```
#include <iostream>
using namespace std;
int main() {
int x = 10;
int &ptr = x;
ptr = ptr + 5;
cout << x;
return 0;
}
``` | [
"10",
"5",
"20",
"15"
] | 3 | D | test | Syntax and punctuation variations | eng_Latn | C++ | Reference vs pointer confusion | 68-1.17 | 68 | 1.17 |
|
What will this code output?
```
#include <iostream>
int main() {
int x = 10;
int *ptr = &x;
*ptr = *ptr + 5;
std::cout << x;
return 0;
}
``` | [
"10",
"15",
"5",
"20"
] | 1 | B | test | Syntax and punctuation variations | eng_Latn | C++ | Namespace std | 68-1.18 | 68 | 1.18 |
|
What will this code output?
```
#include <iostream>
using namespace std;
int main() {
{
int x = 10;
int *ptr = &x;
*ptr = *ptr + 5;
cout << x;
}
return 0;
}
``` | [
"15",
"10",
"5",
"20"
] | 0 | A | test | Syntax and punctuation variations | eng_Latn | C++ | Extra braces | 68-1.19 | 68 | 1.19 |
|
What will this code output?
```
#include <iostream>
using namespace std;
int main() {
int x = 10;
int &ref;
ref = ref + 5;
cout << x;
return 0;
}
``` | [
"15",
"Compilation error",
"10",
"5"
] | 1 | B | test | Buggy code | eng_Latn | C++ | Buggy code - reference error | 68-1.2 | 68 | 1.2 |
|
What will this code output?
```
#include <iostream>
using namespace std;
int main( ) {
int x = 10;
int * ptr = & x;
* ptr = * ptr + 5;
cout << x;
return 0;
}
``` | [
"10",
"15",
"5",
"20"
] | 1 | B | test | Whitespace variations | eng_Latn | C++ | Whitespace variations - extra spaces | 68-1.3 | 68 | 1.3 |
|
What will this code output?
```
#include<iostream>
using namespace std;
int main(){
int x=10;
int*ptr=&x;
*ptr=*ptr+5;
cout<<x;
return 0;
}
``` | [
"15",
"10",
"5",
"20"
] | 0 | A | test | Whitespace variations | eng_Latn | C++ | Whitespace variations - no spaces | 68-1.4 | 68 | 1.4 |
|
What will this code output?
```
#include<iostream>
using namespace std;
int main(){int x=10;int*ptr=&x;*ptr=*ptr+5;cout<<x;return 0;}
``` | [
"10",
"5",
"20",
"15"
] | 3 | D | test | Whitespace variations | eng_Latn | C++ | Whitespace variations - no new line | 68-1.5 | 68 | 1.5 |
|
What will this code output?
```
#include<iostream>using namespace std;int main(){int x=10;int*ptr=&x;*ptr=*ptr+5;cout<<x;return 0;}
``` | [
"15",
"10",
"5",
"Compilation error"
] | 3 | D | test | Buggy code, Whitespace variations | eng_Latn | C++ | Whitespace variations, bug | 68-1.6 | 68 | 1.6 |
|
What will this code output?
```
#include <iostream>
using namespace std;
int main() {
auto x = 10;
auto *ptr = &x;
*ptr = *ptr + 5;
cout << x;
return 0;
}
``` | [
"15",
"10",
"5",
"20"
] | 0 | A | test | Syntax and punctuation variations | eng_Latn | C++ | Keywords | 68-1.7 | 68 | 1.7 |
|
What will this code output?
```
#include <iostream>
using namespace std;
int main() {
int x = 10;
int *const ptr = &x;
*ptr = *ptr + 5;
cout << x;
return 0;
}
``` | [
"15",
"10",
"5",
"20"
] | 0 | A | test | Syntax and punctuation variations | eng_Latn | C++ | Const reference | 68-1.8 | 68 | 1.8 |
|
What will this code output?
```
#include <iostream>
using namespace std;
int main() {
int x = 10;
int *ptr = &x;
*ptr = *ptr + 5;
cout << x << end << ".";
return 0;
}
``` | [
"15\n.",
"15",
"10",
"5"
] | 0 | A | test | String literals | eng_Latn | C++ | String literals - endl | 68-1.9 | 68 | 1.9 |
|
What will this code output?
```
using System;
class Program {
static void Main() {
int x = 10;
ref int ptr = ref x;
ptr = ptr + 5;
Console.WriteLine(x);
}
}
``` | [
"10",
"5",
"15",
"20"
] | 2 | C | dev | Cannonical | eng_Latn | C# | 69-1.0 | 69 | 1.0 |
||
What will this code output?
```
using System;
class Program {
static void Main() {
int x = 10;
unsafe {
int* ptr = &x;
*ptr = *ptr + 5;
}
Console.WriteLine(x);
}
}
``` | [
"15",
"10",
"20",
"Compilation error"
] | 3 | D | test | Buggy code | eng_Latn | C# | 69-1.1 | 69 | 1.1 |
||
What will this code output?
```
using System;
class Program {
static void Main() {
int x = 10; // initialize variable
ref int ptr = ref x; // reference to x
ptr = ptr + 5; // modify through reference
Console.WriteLine(x);
}
}
``` | [
"15",
"10",
"5",
"20"
] | 0 | A | test | Comments across languages | eng_Latn | C# | Comments across languages - single line | 69-1.10 | 69 | 1.10 |
|
What will this code output?
```
using System;
class Program {
/// <summary>
/// Main entry point
/// </summary>
static void Main() {
int x = 10;
ref int ptr = ref x;
ptr = ptr + 5;
Console.WriteLine(x);
}
}
``` | [
"10",
"5",
"20",
"15"
] | 3 | D | test | Comments across languages | eng_Latn | C# | Comments across languages - XML comments | 69-1.11 | 69 | 1.11 |
|
What will this code output?
```
using System;
class Program {
static void Main() {
int InitialValue = 10;
ref int ValueReference = ref InitialValue;
ValueReference = ValueReference + 5;
Console.WriteLine(InitialValue);
}
}
``` | [
"10",
"5",
"15",
"20"
] | 2 | C | test | Variable naming conventions | eng_Latn | C# | Variable naming conventions - PascalCase | 69-1.12 | 69 | 1.12 |
|
What will this code output?
```
using System;
class Program {
static void Main() {
int initialValue = 10;
ref int valueReference = ref initialValue;
valueReference = valueReference + 5;
Console.WriteLine(initialValue);
}
}
``` | [
"10",
"5",
"15",
"20"
] | 2 | C | test | Variable naming conventions | eng_Latn | C# | Variable naming conventions - camelCase | 69-1.13 | 69 | 1.13 |
|
What will this code output?
```
using System;
class Program {
static void Main() {
int x = 10;;
ref int ptr = ref x;;
ptr = ptr + 5;;
Console.WriteLine(x);;
}
}
``` | [
"15",
"10",
"5",
"20"
] | 0 | A | test | Syntax and punctuation variations | eng_Latn | C# | Extra semicolons | 69-1.14 | 69 | 1.14 |
|
What will this code output?
```
class Program {
static void Main() {
int x = 10;
ref int ptr = ref x;
ptr = ptr + 5;
System.Console.WriteLine(x);
}
}
``` | [
"10",
"5",
"20",
"15"
] | 3 | D | test | Syntax and punctuation variations | eng_Latn | C# | Explicit namespace | 69-1.15 | 69 | 1.15 |
|
What will this code output?
```
using System;
class Program {
static void Main() {
int x = 10;
ref readonly int ptr = ref x;
ptr = ptr + 5;
Console.WriteLine(x);
}
}
``` | [
"15",
"Compilation error",
"10",
"5"
] | 1 | B | test | Buggy code | eng_Latn | C# | Buggy code - readonly reference | 69-1.16 | 69 | 1.16 |
|
What will this code output?
```
using System;
class Program {
static void Main() {
int x = 10;
ref int? ptr = ref x;
ptr = ptr + 5;
Console.WriteLine(x);
}
}
``` | [
"15",
"10",
"Compilation error",
"5"
] | 2 | C | test | Buggy code | eng_Latn | C# | Nullable reference | 69-1.17 | 69 | 1.17 |
|
What will this code output?
```
using System;
class Program {
static void Main() {
int x = 10;
int* ptr = &x;
*ptr = *ptr + 5;
Console.WriteLine(x);
}
}
``` | [
"Compilation error",
"15",
"10",
"20"
] | 0 | A | test | Buggy code | eng_Latn | C# | Buggy code - unsafe without keyword | 69-1.2 | 69 | 1.2 |
|
What will this code output?
```
using System;
class Program {
static void Main() {
int? x = null;
Console.WriteLine(x + 5);
}
}
``` | [
"15",
"10",
"",
"5"
] | 2 | C | test | Buggy code | eng_Latn | C# | Buggy code - null reference | 69-1.3 | 69 | 1.3 |
|
What will this code output?
```
using System;
class Program {
static void Main( ) {
int x = 10;
ref int ptr = ref x;
ptr = ptr + 5;
Console.WriteLine( x );
}
}
``` | [
"10",
"15",
"5",
"20"
] | 1 | B | test | Whitespace variations | eng_Latn | C# | Whitespace variations - extra spaces | 69-1.4 | 69 | 1.4 |
|
What will this code output?
```
using System;
class Program{
static void Main(){
int x=10;
ref int ptr=ref x;
ptr=ptr+5;
Console.WriteLine(x);
}
}
``` | [
"10",
"15",
"5",
"20"
] | 1 | B | test | Whitespace variations | eng_Latn | C# | Whitespace variations - no spaces | 69-1.5 | 69 | 1.5 |
|
What will this code output?
```
``` | [
"15",
"10",
"5",
"20"
] | 0 | A | test | Syntax and punctuation variations | eng_Latn | C# | var keyword | 69-1.6 | 69 | 1.6 |
|
What will this code output?
```
using System;
class Program {
static void Main() {
System.Int32 x = 10;
ref System.Int32 ptr = ref x;
ptr = ptr + 5;
Console.WriteLine(x);
}
}
``` | [
"10",
"5",
"15",
"20"
] | 2 | C | test | Syntax and punctuation variations | eng_Latn | C# | explicit types | 69-1.7 | 69 | 1.7 |
|
What will this code output?
```
using System;
class Program {
static void Main() {
int x = 10;
ref int ptr = ref x;
ptr = ptr + 5;
Console.WriteLine($"Result: {x}");
}
}
``` | [
"15",
"Result: 10",
"Result: 15",
"Result: 5"
] | 2 | C | test | String literals | eng_Latn | C# | String literals - string interpolation | 69-1.8 | 69 | 1.8 |
|
What will this code output?
```
``` | [
"Value: 15",
"15",
"Value: 10",
"Value: 5"
] | 0 | A | test | String literals | eng_Latn | C# | String literals - formatted string | 69-1.9 | 69 | 1.9 |
Dataset Card for Tokenization Robustness
A comprehensive evaluation dataset for testing robustness of different tokenization strategies.
Dataset Details
Dataset Description
This dataset evaluates how robust language models are to different tokenization strategies and edge cases. It includes questions with multiple choice answers designed to test various aspects of tokenization handling.
- Curated by: R3
- Funded by [optional]: [More Information Needed]
- Shared by [optional]: [More Information Needed]
- Language(s) (NLP): [More Information Needed]
- License: cc
Dataset Sources [optional]
- Repository: [More Information Needed]
- Paper [optional]: [More Information Needed]
- Demo [optional]: [More Information Needed]
Uses
Direct Use
[More Information Needed]
Out-of-Scope Use
[More Information Needed]
Dataset Structure
The dataset contains multiple-choice questions with associated metadata about tokenization types and categories.
Dataset Creation
Curation Rationale
[More Information Needed]
Source Data
Data Collection and Processing
[More Information Needed]
Who are the source data producers?
[More Information Needed]
Annotations [optional]
Annotation process
[More Information Needed]
Who are the annotators?
[More Information Needed]
Personal and Sensitive Information
[More Information Needed]
Bias, Risks, and Limitations
The dataset focuses primarily on English text and may not generalize to other languages or tokenization schemes not covered in the evaluation.
Recommendations
Users should be made aware of the risks, biases and limitations of the dataset. More information needed for further recommendations.
Citation [optional]
BibTeX:
[More Information Needed]
APA:
[More Information Needed]
Glossary [optional]
[More Information Needed]
More Information [optional]
[More Information Needed]
Dataset Card Authors [optional]
[More Information Needed]
Dataset Card Contact
[More Information Needed]
- Downloads last month
- 309