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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.