---

Solution

Let the boxes be $B_1, B_2, B_3$ and event $E$ be drawing $1$ white and $1$ red ball.

Since one box is chosen randomly,

$P(B_1)=P(B_2)=P(B_3)=\frac{1}{3}$

For first box,

$P(E|B_1)=\frac{\binom{2}{1}\binom{4}{1}}{\binom{9}{2}}=\frac{8}{36}=\frac{2}{9}$

For second box,

$P(E|B_2)=\frac{\binom{3}{1}\binom{2}{1}}{\binom{7}{2}}=\frac{6}{21}=\frac{2}{7}$

For third box,

$P(E|B_3)=\frac{\binom{4}{1}\binom{3}{1}}{\binom{8}{2}}=\frac{12}{28}=\frac{3}{7}$

Using Bayes theorem,

$P(B_1|E)=\frac{P(B_1)P(E|B_1)}{P(B_1)P(E|B_1)+P(B_2)P(E|B_2)+P(B_3)P(E|B_3)}$

$P(B_1|E)=\frac{\frac{1}{3}\times\frac{2}{9}}{\frac{1}{3}\times\frac{2}{9}+\frac{1}{3}\times\frac{2}{7}+\frac{1}{3}\times\frac{3}{7}}$

$P(B_1|E)=\frac{\frac{2}{9}}{\frac{2}{9}+\frac{2}{7}+\frac{3}{7}}$

$P(B_1|E)=\frac{\frac{2}{9}}{\frac{59}{63}}=\frac{14}{59}=0.237$

---

Solution

Here, the class has a method

$equals(Good\ n)$

This method does not override the original $equals(Object)$ method of Java because the parameter type is $Good$, not $Object$.

For Line 1:

$m1.equals(m2)$

Here both are objects of class $Good$, so $equals(Good\ n)$ is called.

Both values are $22$, so output is

$True$

For Line 2:

$s1.equals(s2)$

Here $s1$ and $s2$ are declared as $Object$ type.

So, Java calls $Object$ class $equals()$ method, which compares references.

Since both are different objects, output is

$False$

For Line 3:

$m1.equals(s2)$

Here $s2$ is of type $Object$, so $equals(Good\ n)$ is not called.

It calls $equals(Object)$, so reference comparison is done.

Output is

$False$

For Line 4:

$s1.equals(m2)$

Here $s1$ is of type $Object$, so again $Object$ class $equals()$ method is called.

Output is

$False$

Therefore, output is:

$True,\ False,\ False,\ False$

---

Solution

Python → OOP

Smalltalk → pure OOP

Perl → supports OOP

SQL Plus → database query interface.

---

Solution

---

Solution

In protected inheritance:

Public members of base class become protected members in derived class.

Protected members of base class also remain protected in derived class.

Private members of base class are not directly accessible in derived class.

So, member functions of class $B$ can access public and protected members of class $A$.

But object of class $B$ cannot access public base class data directly, because it becomes protected after protected inheritance.

---

Solution

---

Solution

JVM executes Java bytecode.

For execution, JVM mainly needs:

Class loader to load the class files

Java Interpreter to interpret and execute bytecode

So, JVM needs class loader and Java interpreter.

---

Solution

We have to match each concept with its correct meaning.

First, consider Localization.

Localization means related information or functionality is concentrated in one place or module.

So, it matches with:

III. Characteristic of software that indicates in a manner which information is concentrated in the program.

Therefore,

$(A)-(III)$

Now, consider Packaging or binding of a collection of items.

This is the definition of Encapsulation.

Encapsulation means wrapping data and related operations together in one unit.

Therefore,

$(B)-(I)$

Now, consider the mechanism that enables a designer to focus on essential details of a program component.

This is the definition of Abstraction.

Abstraction hides unnecessary details and shows only essential features.

Therefore,

$(C)-(II)$

Now, consider Information hiding.

Information hiding means hiding or suppressing internal operational details of a program component.

Therefore,

$(D)-(IV)$

Final matching is:

$(A)-(III), (B)-(I), (C)-(II), (D)-(IV)$

---

Solution

---

Solution

---

Solution

Initial values

$a = 5,; b = 10$

First call

swap(a,b)

$a = 10,; b = 5$

Second call

swap(a,b)

$a = 5,; b = 10$

Thus final output

5 10

---

Solution

Given function is $F(N)=F(N-3)+N+F(N-2)+N$ and if $N\le 0$, then $F(N)=-$.
Now,
$F(1)=F(-2)+1+F(-1)+1=-1-1$
$F(2)=F(-1)+2+F(0)+2=-2-2$
$F(3)=F(0)+3+F(1)+3=-3-1-13$
Now find $F(5)$:
$F(5)=F(2)+5+F(3)+5$
$F(5)=(-2-2)+5+(-3-1-13)+5$
$F(5)=-2-25-3-1-135$

---

Solution

JNDI means Java Naming and Directory Interface. It provides API support for naming and directory services. So, $A-II$.
RMI means Remote Method Invocation. It supports calling methods on remote objects. So, $B-III$.
JDK means Java Development Kit. It contains compiler and class libraries to develop Java applications. So, $C-IV$.
JRE means Java Runtime Environment. It provides runtime support for running Java programs. So, $D-I$.
Final matching is $A-II,\ B-III,\ C-IV,\ D-I$.

---

Solution

Imperative programming is command-based and procedural, so $A-IV$.
Object-oriented programming is based on objects, classes and abstract data types, so $B-III$.
Logic programming is declarative and uses clausal representation and theorem proving, so $C-I$.
Functional programming is side-effect-free and based on expression evaluation, so $D-II$.
Final matching is $A-IV,\ B-III,\ C-I,\ D-II$.

---

Solution

Statement (a) is true.

Operator overloading allows an existing operator to work with user-defined or other data types.

Statement (b) is true.

Inheritance supports code reusability in object oriented programming.

Statement (c) is false.

When an object of derived class is created, the base class constructor is executed first, then derived class constructor is executed.

Statement (d) is true.

Overloading is a form of compile-time polymorphism.

So, correct statements are:

(a), (b) and (d)

---

Solution

(A) True

Constructors can be overloaded.

(B) True

Constructors do not have return type.

(C) False

Constructors are member functions, not friend functions.

(D) False

Destructor is called when object is destroyed.

Thus correct statements:

(A) and (B)

---

Solution

Step-1: Object creation

Base *b = new Derived();

Constructor order in inheritance:

Base constructor

Derived constructor

Output:

Base Const

Derived Const

Step-2: Deleting object

Base destructor is virtual, so destructors call in reverse order:

Derived destructor

Base destructor

Output:

Derived dest

Base dest

Final Output:

Base Const Derived Const Derived dest Base dest

---

Solution

In C++, the keyword $\text{explicit}$ is used only while declaring the constructor inside the class.

When the constructor is defined outside the class, $\text{explicit}$ is not written again.

So, the correct definition is:

$ \text{Date::Date(int dd) { /* ... */ }} $

---

Solution

• Overloading → Compile-time polymorphism (III)
• Early Binding → Done at compile time (II)
• Overriding → Run-time binding; slower (I)
• Late Binding → Supports run-time polymorphism (IV)

---

Solution

For a:

If implementation differs only through a parameter, templates are useful.

So,

a → III

For b:

If actual object types are not known at compile time, class hierarchy and runtime polymorphism are used.

So,

b → I

For c:

Templates allow inline operations and can improve run-time efficiency.

So,

c → II

For d:

To access derived class instances through base class reference or pointer, explicit casting may be used.

So,

d → IV

Correct matching:

a-III, b-I, c-II, d-IV

---

Solution

C++ → supports multiple inheritance directly ✔

• Java → does not support multiple inheritance with classes (only interfaces) ✘

• Python → supports multiple inheritance ✔

• VB.NET → supports multiple inheritance through interfaces only ✘

• BASIC → does not support multiple inheritance ✘

Thus the languages that directly support multiple inheritance are:

C++ and Python