Programming Concepts

Consider this value-based function:
```
function addOne(value) {
value = value + 1;
return value;
}

let score = 4;
let updated = addOne(score);
```
What are the values of score and updated after the call?

Step 1: The argument score has the value 4 when the function is called.
Step 2: The parameter value receives that value for the call.
Step 3: Changing value to 5 changes the function's local binding, not score.
Step 4: The function returns 5, which is assigned to updated.
Answer: score remains 4 and updated becomes 5. The exact copy/reference behavior for objects is language-dependent, so always check the type being passed.

What is the output of this recursive function for factorial(4)?
```
function factorial(n) {
if (n === 0) return 1;
return n * factorial(n - 1);
}
```

Step 1: The base case is factorial(0) = 1.
Step 2: factorial(4) calls 4 × factorial(3).
Step 3: The calls continue as 4 × 3 × 2 × 1 × factorial(0).
Step 4: The base case returns 1, so the result is 4 × 3 × 2 × 1 × 1 = 24.
Answer: 24. The call argument decreases by one each time, so the recursion reaches its base case.

What is printed, and what is the time complexity?
```
for i from 1 to n:
print(i)
```

Step 1: The loop starts at 1 and visits each integer through n.
Step 2: It prints 1, 2, 3 and so on up to n.
Step 3: The body executes n times, with constant work per iteration.
Answer: It prints the integers from 1 to n, and its time complexity is O(n).

A class keeps a private balance field and exposes deposit(amount) and getBalance() methods. Which OOP principle is most directly illustrated?
A) Encapsulation
B) Inheritance
C) Recursion
D) Iteration

Step 1: The balance field is kept behind the class boundary.
Step 2: Other code uses controlled methods instead of changing the field directly.
Step 3: Bundling state with the operations that manage it is encapsulation.
Answer: A) Encapsulation.

What does this function return, and what happens to the outer total?
```
let total = 10;
function addLocal() {
let total = 3;
return total + 1;
}
```
The function is called once.

Step 1: The total declared inside addLocal has local scope.
Step 2: It shadows the outer total only while the function runs.
Step 3: The function returns the local value 3 plus 1, which is 4.
Step 4: The outer total is never assigned a new value.
Answer: The function returns 4 and the outer total remains 10.

What are the four pillars of Object-Oriented Programming?

Step 1: Recall the core OOP principles
Step 2: Encapsulation bundles data and methods
Step 3: Inheritance allows class hierarchies
Step 4: Polymorphism enables multiple forms
Step 5: Abstraction hides implementation details
Answer: Encapsulation, Inheritance, Polymorphism, Abstraction

What is encapsulation in OOP?

Step 1: Encapsulation is about data hiding and bundling
Step 2: It restricts direct access to some components
Step 3: Data is protected within the class
Step 4: Access is provided through public methods
Answer: Bundling data and methods that operate on that data within a single unit

What is inheritance in OOP?