1. What will be the output if n = 4?
Integer fun(Integer n)
if (n < 1)
return 0
else
return n + fun(n - 1)
End if
End function fun
A) 0
B) 4
C) 10
D) 24
--------------------------
Solution: The correct answer is C) 10.
-----------------------------------
2. What will be the output if x = 5?
Integer fun(Integer x)
if (x > 0)
return fun(x - 1) + x
else
return 0
End if
End function fun
A) 0
B) 5
C) 15
D) 25
------------------------------------
Solution: The correct answer is C) 15.
----------------------------
3. What will be the output if num = 3?
Integer fun(Integer num)
if (num > 0)
return 2 * fun(num - 1)
else
return 1
End if
End function fun
A) 1
B) 2
C) 4
D) 8
------------------------------
Solution: The correct answer is D) 8.
--------------------------------------
4. What will be the output if m = 6?
Integer fun(Integer m)
if (m < 2)
return 1
else
return fun(m - 1) + fun(m - 2)
End if
End function fun
A) 1
B) 6
C) 13
D) 21
-----------------
Solution: The correct answer is D) 21.
-----------
5. What will be the output if num = 7?
Integer fun(Integer num)
if (num <= 0)
return 0
else
return num % 10 + fun(num / 10)
End if
End function fun
A) 0
B) 7
C) 14
D) 25
----------------------------------------
Solution: The correct answer is C) 14.
----------------------------------------------------------
6. What will be the output if n = 5?
Integer fun(Integer n)
if (n > 0)
return n + fun(n - 2)
else
return 0
End if
End function fun
A) 0
B) 3
C) 5
D) 7
-----------------------------------------
Solution: The correct answer is D) 7.
--------------------------------------------------------
7. What will be the output if x = 8?
Integer fun(Integer x)
if (x <= 1)
return 1
else
return x * fun(x - 3)
End if
End function fun
A) 1
B) 5
C) 8
D) 15
--------------------------------------
Solution: The correct answer is A) 1.
--------------------------------------------
8. What will be the output if n = 2?
Integer fun(Integer n)
if (n < 1)
return 1
else
return fun(n - 1) + fun(n - 2)
End if
End function fun
A) 1
B) 2
C) 3
D) 5
--------------------------------------
Solution: The correct answer is B) 2.
--------------------------------------------
9. What will be the output if num = 9?
Integer fun(Integer num)
if (num < 1)
return 0
else
return 1 + fun(num / 10)
End if
End function fun
A) 0
B) 1
C) 2
D) 9
-----------------------------
Solution: The correct answer is C) 2.
10. What will be the output if x = 10?
Integer fun(Integer x)
if (x > 2)
return fun(x - 3) + x
else
return x
End if
End function fun
A) 1
B) 6
C) 10
D) 15
-----------------------------------------
Solution: The correct answer is D) 15.
---------------------------------
Sure! Here are the explanations for each question:
1. The function `fun` recursively calls itself with the argument `n - 1` until `n`
becomes less than 1. It then returns the sum of `n` and the recursive call. So, for
`n = 4`, the recursive calls will be `fun(3)`, `fun(2)`, and `fun(1)`. The
recursion stops at `fun(1)` because `1 < 1` is false, and it returns 1. The
subsequent recursive calls will return the sum of the current `n` and the value
returned by the next call. Therefore, `fun(2)` returns `2 + 1 = 3`, `fun(3)`
returns `3 + 3 = 6`, and finally, `fun(4)` returns `4 + 6 = 10`. Thus, the output
is C) 10.
2. This function also uses recursion to calculate the sum. It recursively calls
itself with `x - 1` until `x` becomes 0. On each recursive call, it adds the
current `x` value to the result of the next recursive call. So, for `x = 5`, the
recursion will proceed as follows: `fun(5)` calls `fun(4)`, which calls `fun(3)`,
then `fun(2)`, and finally `fun(1)`. `fun(1)` returns 0 since `1 > 0` is false.
Subsequently, `fun(2)` returns `0 + 2 = 2`, `fun(3)` returns `2 + 3 = 5`, `fun(4)`
returns `5 + 4 = 9`, and `fun(5)` returns `9 + 5 = 14`. Thus, the output is C) 15.
3. The function doubles the result of the recursive call until `num` becomes 0. It
returns 1 when `num` reaches 0. For `num = 3`, the recursion will proceed as
follows: `fun(3)` calls `fun(2)`, which calls `fun(1)`. `fun(1)` returns 1,
`fun(2)` returns `2 * 1 = 2`, and finally, `fun(3)` returns `2 * 2 = 4`. Thus, the
output is D) 8.
4. This function follows the Fibonacci sequence recursively. It returns 1 when `m`
is less than 2 and returns the sum of the two preceding Fibonacci numbers for other
values of `m`. For `m = 6`, the recursion will proceed as follows: `fun(6)` calls
`fun(5)`, which calls `fun(4)`, then `fun(3)`, `fun(2)`, `fun(1)`, and finally
`fun(0)`. The recursion stops at `fun(1)` and `fun(0)` because both of them return
1. The subsequent recursive calls will return the sum of the two preceding
Fibonacci numbers. Therefore, `fun(2)` returns `1 + 1 = 2`, `fun(3)` returns `1 + 2
= 3`, `fun(4)` returns `2 + 3 = 5`, `fun(5)` returns `3 + 5 = 8`, and `fun(6)`
returns `5 + 8 = 13`. Thus, the output is C) 13.
5. This function calculates the sum of the digits of a number recursively. It
extracts the last digit of `num` using the modulo operator `%` and adds it to the
sum of the remaining digits obtained by dividing `num` by 10. It continues the
recursion until `num` becomes less than or equal to 0. For `num = 7`, the recursion
will proceed as follows: `fun(7)` returns `7 % 10 + fun(7 / 10)`. Since `7 / 10` is
0 (integer division), the recursion stops at `fun(0)` and returns 0. Therefore,
`fun(7)` returns `7 % 10 + 0 = 7`. Thus, the output is B) 7.
6. This function recursively calls itself with `n - 2` until `n` becomes 0 or
negative. On each recursive call, it adds `n` to the result. For `n = 5`, the
recursion will proceed as follows: `fun(5)` calls `fun(3)`, then `fun(1)`. `fun(1)`
returns 1, and `fun(3)` returns `3 + 1 = 4`. Finally, `fun(5)` returns `5 + 4 = 9`.
Thus, the output is D) 9.
7. The function recursively calls itself with `x - 3` until `x` becomes 1 or less.
On each recursive call, it multiplies `x` with the result. For `x = 8`, the
recursion will proceed as follows: `fun(8)` calls `fun(5)`, then `fun(2)`, and
finally `fun(-1)`. `fun(-1)` returns 1 since `-1 <= 1` is true. `fun(2)` returns `2
* 1 = 2`, and `fun(5)` returns `5 * 2 = 10`. Therefore, the output is C) 10.
8. This function calculates the Fibonacci sequence recursively. It returns 1 when
`n` is less than 1 and returns the sum of the two preceding Fibonacci numbers for
other values of `n`. For `n = 2`, the recursion will proceed as follows: `fun(2)`
calls `fun(1)`, which returns 1. Then, `fun(2)` calls `fun(0)`, which also returns
1. Finally, `fun(2)` returns `1 + 1 = 2`. Thus, the output is B) 2.
9. This function calculates the number of digits in a number recursively. It counts
the number of times `num` can be divided by 10 until it becomes less than 1. For
`num = 9`, the recursion will proceed as follows: `fun(9)` returns `1 + fun(0)`.
Since `0 < 1` is false, the recursion stops at `fun(0)` and returns 0. Therefore,
`fun(9)` returns `1 + 0 = 1`. Thus, the output is B) 1.
10. The function recursively calls itself with `x - 3` until `x` becomes 2 or less.
On each recursive call, it adds `x` to the result. For `x = 10`, the recursion will
proceed as follows: `fun(10)` calls `fun(7)`, then `fun(4)`, and finally `fun(1)`.
`fun(1)` returns 1 since `1 <= 2` is true. `fun(4)` returns `4 + 1 = 5`, and
`fun(7)` returns `7 + 5 = 12`. Therefore, the output is D) 12.
