Ctrl+Solve

def add_item(item, lst=[ ]):

lst.append(item)

return lst

print(add_item(1))

print(add_item(2))

print(add_item(3, [ ]))

print(add_item(4))

What is the output?

• [1] [2] [3] [4]

• [1] [1, 2] [3] [1, 2, 4]

• [1] [2] [3] [4]

• [1] [1, 2] [3] [4]

A short snippet is displayed in a scrambled order. Which option shows the correct order for the code?

Scrambled Snippet:
printf("Result: %d", calculate(3));

int calculate(int n) {
return n > 0 ? n * calculate(n - 1) : 1;

}
Expected Output:
Result: 6

• int calculate(int n) {
  return n > 0 ? n * calculate(n - 1) : 1;
  }
  printf("Result: %d", calculate(3));

• printf("Result: %d", calculate(3));
  int calculate(int n) {
  return n > 0 ? n * calculate(n - 1) : 1;
  }

• int calculate(int n);
  printf("Result: %d", calculate(3));
  int calculate(int n) {
  return n > 0 ? n * calculate(n - 1) : 1;
  }

• int calculate(int n) {
  return n > 0 ? n + calculate(n - 1) : 1;
  }
  printf("Result: %d", calculate(3));

#include<stdio.h>

void recurse() {

int arr[1000]; // Large stack allocation

recurse();

}

int main() {

recurse();

return 0;

}

What is the error?

• No error, infinite recursion allowed

• Stack overflow due to uncontrolled recursion

• Compilation error due to large array

• Undefined behavior

x = 0 or None or [ ] or { } or 42

print(x)

What will be printed?

• 0

• None

• [ ]

• 42

Answer explanation

• The or operator returns the first truthy value or the last falsy value if all are falsy.

• 0, None, [], {} are all falsy, so Python keeps evaluating.

• 42 is truthy, so it is returned.

       x = 10

           def outer():

                x = 5  

               def inner():

                    nonlocal x

                   x += 1

                  return x

             return inner()

print(outer(), x)

What is the output?

• 6 10

• 6 6

• UnboundLocalError

• 5 10

A short snippet is displayed in a scrambled order. Which option shows the correct order for the code?

Scrambled Snippet:

printf("Value: %d", arr[2]);

arr[2] += modify(arr[1]);

int arr[ ] = {1, 2, 3, 4};

int modify(int x) {

return x * 2;

}

Expected Output:

Value: 7

• int modify(int x) {

  return x * 2;

  }

  int arr[ ] = {1, 2, 3, 4};

  arr[2] += modify(arr[1]);

  printf("Value: %d", arr[2]);

• printf("Value: %d", arr[2]);

  arr[2] += modify(arr[1]);

  int arr[ ] = {1, 2, 3, 4};

  int modify(int x) {

  return x * 2;

  }

• int arr[ ] = {1, 2, 3, 4};

  arr[2] += modify(arr[1]);

  printf("Value: %d", arr[2]);

  int modify(int x) {

  return x * 2;

  }

• int modify(int x);

  int arr[ ] = {1, 2, 3, 4};

  arr[2] += modify(arr[1]);

  printf("Value: %d", arr[2]);

  int modify(int x) {

  return x + 2;

  }

#include<stdio.h>

#include<stdlib.h>

int* createNumber() {

int num = 42;

return &num;

}

int main() {

int* ptr = createNumber();

printf("%d", *ptr);

return 0;

}

What is the error?

• No error, prints 42

• Undefined behavior due to returning a local variable's address

• Segmentation fault

• Compilation error

x = 5 & 3 | 2 ^ 1

print(x)

What will be printed?

• 0

• 2

• 3

• 7

Answer explanation

Bitwise operations are evaluated in this order: &, ^, |.

• 5 & 3 = 0b101 & 0b011 = 0b001 = 1

• 2 ^ 1 = 0b010 ^ 0b001 = 0b011 = 3

• 1 | 3 = 0b001 | 0b011 = 0b011 = 3

Which of the following C code snippets correctly creates a pointer to an integer?

• int* ptr;

• int ptr;

• int ptr = 10;

• ptr = 10;  

Which option shows the correct order for the code?

Scrambled Snippet:

printf("Result: %d", result);

result = compute(4);

int compute(int n) {

return n * fact(n - 1);

}

int fact(int n) {

return n == 0 ? 1 : n * fact(n - 1);

}

int result;

Expected Output:

Result: 24

• int fact(int n) {

  return n == 0 ? 1 : n * fact(n- 1);

  }

  int compute(int n) {

  return n * fact(n - 1);

  }

  int result;

  result = compute(4);

  printf("Result: %d", result);

• int compute(int n) {

  return n * fact(n - 1);

  }

  int fact(int n) {

  return n == 0 ? 1 : n * fact(n - 1);

  }

  printf("Result: %d", result);

  int result;

  result = compute(4);

• printf("Result: %d", result);

  result = compute(4);

  int compute(int n) {

  return n * fact(n - 1);

  }

  int fact(int n) {

  return n == 0 ? 1 : n * fact(n - 1);

  }

  int result;

• int fact(int n); int compute(int n) {

  return n * fact(n - 1);

  }

  int result;

  result = compute(4);

  printf("Result: %d", result);

  int fact(int n) {

  return n == 0 ? 1 : n * fact(n - 1);

  }