PGDCA Paper-IV Model Questions

Group-A

1. Write short notes on any three of the following:

a. Operator overloading in C++

Operator overloading in C++ is a feature that allows you to redefine the behavior of operators
(such as +, -, *, /, ==, <<, >>) for user-defined data types (classes). This means you can make
these operators work with objects of your own classes in a way that is intuitive and consistent
with their behavior for built-in data types. The primary goal is to enhance code readability and
make expressions involving objects more natural. When an operator is overloaded, it is
implemented as a special function, either a member function of the class or a non-member
(friend) function. For example, you could overload the + operator to perform concatenation of
custom string objects or vector addition for a Vector class.
b. Header files
Header files in C++ are external files, typically with .h or .hpp extensions, that contain
declarations of functions, classes, variables, and macros. They serve as interfaces that
provide information to the compiler about components defined elsewhere, usually in .cpp
source files or pre-compiled libraries. By using the #include preprocessor directive, you can
incorporate the contents of a header file into your source code. This mechanism promotes
modular programming, allows for code reuse, and enables the compiler to perform type
checking and resolve references to functions and classes that might be implemented in
different compilation units. Common examples include <iostream> for standard input/output
operations, <vector> for dynamic arrays, and <cmath> for mathematical functions.
d. Virtual function
A virtual function in C++ is a member function declared within a base class that is specifically
designed to be overridden (reimplemented) by derived classes. The virtual keyword is used in
the base class declaration to signify this intent. The key concept behind virtual functions is to
achieve runtime polymorphism (also known as dynamic dispatch). When a virtual function is
called through a pointer or a reference to the base class, the C++ runtime system determines
which version of the function (from the base class or one of its derived classes) to execute
based on the actual type of the object being pointed to or referenced, rather than the type of
the pointer/reference itself. This allows for flexible and extensible object-oriented designs,
where different derived classes can provide their own specific implementations of a common
behavior defined in the base class.
2. a) What do you mean by inheritance? Explain the difference between multilevel and
multiple inheritance.

Inheritance is one of the core principles of Object-Oriented Programming (OOP), enabling a

new class, called the derived class (or subclass/child class), to acquire (inherit) the
properties (data members) and behaviors (member functions) of an existing class, known as
the base class (or superclass/parent class). This mechanism is fundamental for promoting
code reusability, reducing redundancy, and establishing an "is-a" relationship between
classes (e.g., a Dog "is a" Animal). Inheritance creates a hierarchical classification, allowing
general characteristics to be defined in base classes and more specific ones in derived
classes.

Differences between Multilevel and Multiple Inheritance:

●​ Multilevel Inheritance:
○​ Definition: In multilevel inheritance, a class is derived from another derived class,
creating a chain or hierarchy. This means Class C inherits from Class B, and Class B,
in turn, inherits from Class A. The inheritance path flows sequentially.
○​ Structure: A single inheritance path where one class extends another, which itself
extends another.
○​ Example: Class A (Grandparent) -> Class B (Parent) -> Class C (Child).
○​ Diagram: A rightarrow B rightarrow C
●​ Multiple Inheritance:
○​ Definition: In multiple inheritance, a single derived class inherits from two or more
independent base classes. This allows the derived class to combine features and
functionalities from multiple distinct sources.
○​ Structure: A derived class has direct parentage from two or more unrelated base
classes.
○​ Example: Class C inherits simultaneously from Class A and Class B.
○​ Diagram: A, B rightarrow C

b) What are the main properties involved in object-oriented programming?

The main properties, often referred to as the pillars or fundamental concepts, involved in
Object-Oriented Programming (OOP) are:
●​ Encapsulation: This principle involves bundling data (attributes) and the methods
(functions) that operate on that data within a single unit, typically a class. A key aspect
of encapsulation is data hiding, where the internal state of an object is protected from
direct external access, and interaction is controlled through public methods. This
prevents unauthorized modification of data and ensures data integrity, while also making
the code more modular and easier to maintain.
●​ Inheritance: As explained above, inheritance is the mechanism by which one class
acquires the properties and behaviors of another class. It facilitates code reuse,
establishes a hierarchical relationship (is-a), and allows for the extension of existing
 classes without modifying them.
●​ Polymorphism: Meaning "many forms," polymorphism allows objects of different classes
to be treated as objects of a common type. It enables a single interface to represent
different underlying forms or implementations. In C++, polymorphism can be achieved
through:
○​ Function Overloading: Multiple functions with the same name but different
parameter lists.
○​ Operator Overloading: Redefining operators for user-defined types.
○​ Virtual Functions: Allowing derived classes to provide their own implementations of
a base class function, executed dynamically at runtime.
●​ Abstraction: Abstraction focuses on showing only the essential features and information
to the user while hiding the complex implementation details. It concentrates on "what" an
object does rather than "how" it does it. This simplifies the view of complex systems,
improves clarity, and allows for changes in underlying implementation without affecting
the higher-level view. Abstract classes and interfaces are common ways to achieve
abstraction in OOP.

3. What are the different types of looping statements available in C++?

Looping statements in C++ are control structures that allow a block of code to be executed
repeatedly as long as a specified condition remains true, or for a predetermined number of
times. The different types provide flexibility for various iteration scenarios:
●​ for loop: This loop is typically used when the number of iterations is known or can be
easily determined before the loop begins. It combines initialization, condition checking,
and iteration (increment/decrement) into a single line, making it compact for definite
iterations.​
C++​
for (int i = 0; i < 5; i++) {​
// Code to be executed repeatedly​
}​

●​ while loop: This loop executes a block of code repeatedly as long as a specified
condition evaluates to true. The condition is checked before each iteration. If the
condition is initially false, the loop body will not execute even once. It's suitable for
indefinite loops where the number of iterations isn't known in advance, but depends on a
condition.​
C++​
int i = 0;​
while (i < 5) {​
// Code to be executed​
i++;​
}​
 ●​ do-while loop: This loop is similar to the while loop, but with one crucial difference: the
loop body is executed at least once before the condition is evaluated for the first time.
After the first execution, it continues to repeat as long as the condition remains true. This
is useful when you need to guarantee at least one execution of the loop's content.​
C++​
int i = 0;​
do {​
// Code to be executed at least once​
i++;​
} while (i < 5);​

4. What are the different branching techniques available in C++?

Branching techniques (or conditional statements) in C++ allow a program to execute different
blocks of code based on whether certain conditions are met. They control the flow of
execution, diverting it from the sequential path.
●​ if statement: This is the most basic conditional statement. It executes a block of code
only if a specified boolean condition evaluates to true. If the condition is false, the code
block is skipped.​
C++​
if (condition) {​
// Code executes if condition is true​
}​

●​ if-else statement: This statement provides two alternative paths of execution. If the
condition evaluates to true, the code block following if is executed. Otherwise (if the
condition is false), the code block following else is executed.​
C++​
if (condition) {​
// Code executes if condition is true​
} else {​
// Code executes if condition is false​
}​

●​ else-if ladder: This structure is used when there are multiple conditions to check
sequentially. The conditions are evaluated from top to bottom. As soon as a condition
evaluates to true, its corresponding block of code is executed, and the rest of the else-if
ladder (and any final else block) is skipped. If no condition is true, the final else block (if
present) is executed.​
C++​
if (condition1) {​
// Code for condition1​
 } else if (condition2) {​
// Code for condition2​
} else {​
// Default code if no conditions are true​
}​

●​ switch statement: This statement allows for multi-way branching based on the value of
a single expression (usually an integer, character, or enum). It provides an alternative to a
long if-else if ladder when you need to compare an expression against several constant
values. Each case label represents a possible value, and a default case handles values
not explicitly matched. The break keyword is essential to exit the switch block after a
match, preventing "fall-through."​
C++​
switch (expression) {​
case value1:​
// Code for value1​
break;​
case value2:​
// Code for value2​
break;​
default:​
// Default code​
}​

5. (a) Explain the concept of operator overloading in C++?

Operator overloading in C++ is a powerful feature that allows programmers to redefine the
way standard operators (like +, -, *, /, ==, <<, >>, etc.) behave when applied to user-defined
data types (objects of classes). This means that an operator can have different
implementations depending on the types of its operands. The primary goal of operator
overloading is to make user-defined types behave similarly to built-in types, thereby making
the code more intuitive, readable, and natural to write.

For example, without operator overloading, to add two Complex number objects, you might
need a method like c3 = c1.add(c2). With operator overloading, you can define the + operator
to perform addition for Complex objects, allowing a more natural syntax like c3 = c1 + c2.

When an operator is overloaded, it is implemented as a function. This function can be a

member function of the class or a non-member (friend) function. The compiler determines
which overloaded operator function to call based on the types of the operands at compile
time. Not all operators can be overloaded (e.g., . (dot operator), :: (scope resolution operator),
?: (ternary operator) cannot be overloaded).
6. (a) What are the differences between constructor and destructor in C++?

Constructors and destructors are special member functions in C++ that are automatically
invoked during the lifetime of an object. They manage the creation and destruction phases of
an object.

Feature Constructor Destructor

Purpose Initializes the object's state Cleans up resources

and its member variables allocated by the object
when an object is created. during its lifetime (e.g.,
It allocates necessary deallocating dynamically
resources. allocated memory, closing
files). It's called before the
object is destroyed.

Name Has the exact same name Has the same name as the
as the class. class, but prefixed with a
tilde (~).

Return Type Does not have a return Does not have a return
type, not even void. type.

Arguments Can take arguments. This Cannot take any

allows for different ways to arguments.
initialize objects
(constructor overloading).

Number A class can have multiple A class can have only one
constructors (overloaded destructor.
constructors) with different
parameter lists.

Invocation Automatically called when Automatically called when

an object is created (e.g., an object goes out of
when an object is declared, scope, when a
using new, or returned by new-allocated object is
value). deleted using delete, or
when the program
terminates for static/global
objects.

Overloading Can be overloaded. Cannot be overloaded.

 Virtual Cannot be virtual. Can be virtual, which is
important for proper
cleanup in class hierarchies
with polymorphism.

b) What are the differences between structures and classes in C++?

In C++, both struct and class are keywords used to define user-defined data types that can
encapsulate data members (variables) and member functions (functions). While they are very
similar in functionality in C++, a few key distinctions, primarily related to default access
specifiers, exist due to their historical origins in C.

Feature Structure (struct) Class (class)

Default Access Specifier By default, all members By default, all members

for Members (variables and functions) declared within a class are
declared within a struct are private.
public.

Default Access Specifier When inheriting from a When inheriting from a

for Base Classes base class, the default base class, the default
(Inheritance) inheritance type is public. inheritance type is private.
For example, struct Derived For example, class Derived
: Base implies public : Base implies private
inheritance. inheritance.

Primary Usage Historically, struct was class was explicitly

(Historical/Conceptual) primarily used in C for introduced in C++ to
grouping related data items implement Object-Oriented
(like records) without Programming concepts,
behavior. In C++, it was emphasizing
extended to include encapsulation, data hiding,
member functions. It's and complex behaviors. It's
often still preferred for generally preferred for
simple Plain Old Data defining full-fledged
(POD) structures. objects with methods and
controlled access.

Constructors/Destructors Can have constructors and Can have constructors and

destructors. destructors.

Member Functions Can have member Can have member

 functions. functions.

Inheritance Can participate in Can participate in

inheritance. inheritance.

7. a. What is constructor overloading? Explain with examples.

Constructor overloading is a feature in C++ that allows a class to have multiple constructors.
Each of these constructors must have a unique signature, meaning they must differ in at least
one of the following ways:
●​ The number of parameters.
●​ The data types of the parameters.
●​ The order of the data types of the parameters.

This flexibility provides multiple ways to initialize objects of a class, allowing you to create
objects with different initial states based on the arguments provided during their instantiation.
The compiler determines which constructor to call based on the arguments supplied when an
object is created.

Example:
Consider a Circle class. You might want to create a circle with a default radius, a specific
radius, or even a circle defined by its center coordinates and radius.

C++

class Circle {​
public:​
double radius;​
double centerX;​
double centerY;​
​
// 1. Default Constructor: Initializes a circle with default values (e.g., radius 1.0 at origin)​
Circle() {​
radius = 1.0;​
centerX = 0.0;​
centerY = 0.0;​
}​
​
// 2. Constructor with one argument: Initializes a circle with a specified radius at the origin​
Circle(double r) {​
 radius = r;​
centerX = 0.0;​
centerY = 0.0;​
}​
​
// 3. Constructor with three arguments: Initializes a circle with a specified radius and center
coordinates​
Circle(double r, double x, double y) {​
radius = r;​
centerX = x;​
centerY = y;​
}​
​
double getArea() {​
return 3.14159 * radius * radius; // Pi * r^2​
}​
};​
​
/*​
// Example usage in main() or another function:​
// Circle c1; // Calls the default constructor: radius 1.0 at (0,0)​
// Circle c2(5.0); // Calls constructor 2: radius 5.0 at (0,0)​
// Circle c3(10.0, 2.5, 3.5); // Calls constructor 3: radius 10.0 at (2.5, 3.5)​
*/​

In this example, the Circle class demonstrates constructor overloading, providing different
ways to construct Circle objects.

b. What is the difference between call by value and call by reference in C++?

When passing arguments to a function in C++, there are two primary mechanisms: call by
value and call by reference. These methods determine how the arguments are handled
within the function and how changes to the parameters inside the function affect the original
variables in the calling function.

Feature Call by Value Call by Reference

Mechanism A copy of the actual The memory address (or a

argument's value is passed reference, which acts as an
to the function's formal alias) of the actual
parameter. argument is passed to the
function's formal
parameter.
 Memory A separate, independent No new copy of the
copy of the argument is variable is created. The
created in the function's function directly accesses
own stack frame. The and manipulates the
function works on this original variable in the
copy. caller's memory space.

Impact of Changes Any modifications made to Any modifications made to

the parameter inside the the parameter inside the
function do not affect the function do directly affect
original argument in the the original argument in the
calling function, because calling function, because
the function is operating on the parameter refers to the
a local copy. same memory location.

Overhead Generally higher overhead, Generally lower overhead

especially for large objects, as only the
due to the cost of copying address/reference (which is
the entire value. typically small) is passed,
avoiding the cost of
copying large objects.

Use Case Used when the function Used when the function
only needs to read the needs to modify the
value of the argument and original argument's value.
should not modify the Also beneficial for passing
original data. Also good for large objects efficiently to
primitive types where avoid expensive copying.
copying is cheap.

Syntax void func(int x) (where x is void func(int &x) (for

the parameter) reference parameter) or
void func(int *x) (for
pointer parameter).

8. What is a recursive function? What are the merits and demerits of this type of
functions? How is it different from an ordinary function? What is the storage class used
in a recursive function?

A recursive function is a function that solves a problem by calling itself. It breaks down a
larger problem into smaller, identical subproblems until it reaches a base case, which is a
simple instance of the problem that can be solved directly without further recursion. The
solutions to these base cases are then combined as the recursive calls return to build the
solution for the original problem.

Merits of Recursive Functions:

●​ Code Simplicity and Elegance: For problems that have inherently recursive definitions
(e.g., calculating factorial, Fibonacci sequence, tree traversals, quicksort), recursive
solutions can be much more concise, readable, and align naturally with the problem's
mathematical or logical definition compared to their iterative counterparts.
●​ Problem Solving Paradigm: It provides a powerful and elegant way to solve problems
that can be broken down into self-similar subproblems.
●​ Reduced Code Length: In some cases, a recursive solution can lead to fewer lines of
code compared to an iterative one.

Demerits of Recursive Functions:

●​ Memory Overhead (Stack Overflow): Each time a recursive function calls itself, a new
stack frame is pushed onto the call stack. This frame stores local variables, parameters,
and the return address for that specific call. If the recursion goes too deep (many nested
calls), it can consume a large amount of stack memory, potentially leading to a stack
overflow error.
●​ Performance Overhead: Function calls, including recursive ones, incur a certain
overhead (e.g., pushing and popping data from the stack, saving/restoring registers). For
problems that can be solved efficiently iteratively, recursive solutions might be slower due
to this overhead.
●​ Debugging Difficulty: Tracing the execution flow of recursive functions can be more
challenging and complex compared to iterative functions due to the multiple nested calls
and the dynamic nature of the call stack.

How is it different from an ordinary function?

An ordinary function (or iterative function) executes its statements sequentially from start to
finish and typically completes its execution without calling itself. Its flow is linear.
A recursive function, on the other hand, is defined by the fact that it calls itself as part of its
execution. This self-referential property is its defining characteristic and allows it to solve
problems by repeating the same process on smaller inputs.
What is the storage class used in a recursive function?
The local variables and parameters of a recursive function are stored on the call stack. This
means they belong to the automatic storage class. Each time a recursive function is called, a
new, independent copy of its local variables and parameters is created and pushed onto the
call stack. When a recursive call completes and returns, its corresponding stack frame
(containing its local variables and parameters) is popped off the stack. This mechanism
ensures that each instance of the function call works with its own set of data, preventing
interference between different levels of recursion.
9. Write short notes on any three of the following:

a. Function overloading in C++

Function overloading in C++ allows you to define multiple functions with the same name within
the same scope. The key requirement for overloading is that these functions must have
different parameter lists (also known as their "signatures"). The parameter lists can differ in
the number of arguments, the data types of the arguments, or the order of the data types of
the arguments. The compiler uses this unique signature to determine which specific
overloaded function to call based on the arguments provided during the function call. This
feature enhances code readability and reusability by allowing a single, intuitive function name
to perform similar operations on different types of data or with different input configurations.
b. Library files
Library files (often simply referred to as "libraries") are collections of pre-compiled code, data,
and resources that provide reusable functionalities. In programming, libraries serve as
repositories of pre-written and tested code modules that developers can incorporate into
their own programs, rather than writing everything from scratch. This significantly speeds up
development, reduces potential errors, and promotes code standardization. In C++, libraries
can be broadly categorized into:
●​ Static Libraries (.lib on Windows, .a on Unix/Linux): Code from static libraries is
copied directly into the executable during the linking phase.
●​ Dynamic/Shared Libraries (.dll on Windows, .so on Unix/Linux): Code from dynamic
libraries is loaded into memory only when the program is executed, and multiple
programs can share a single copy of the library.​
The C++ Standard Library, which includes components like the Standard Template Library
(STL), is a prominent example of a widely used library providing fundamental
functionalities.

c. Logical operator
Logical operators in C++ are special symbols used to combine or manipulate boolean
expressions (expressions that evaluate to either true or false). They are fundamental for
constructing complex conditional statements and controlling program flow. The three primary
logical operators are:
●​ Logical AND (&&): This binary operator returns true only if both of its operands
(conditions) are true. If either operand is false, the result is false. It performs short-circuit
evaluation, meaning if the first operand is false, the second is not evaluated.
●​ Logical OR (||): This binary operator returns true if at least one of its operands
(conditions) is true. It returns false only if both operands are false. It also performs
short-circuit evaluation; if the first operand is true, the second is not evaluated.
●​ Logical NOT (!): This is a unary operator that negates (reverses) the boolean value of its
single operand. If the operand is true, ! makes it false, and if it's false, ! makes it true.

d. Pure Virtual function

A pure virtual function in C++ is a virtual function declared in a base class that has no
definition (implementation) within that base class. It is declared by assigning 0 to its
declaration, like this: virtual returnType functionName(parameters) = 0;. The presence of at
least one pure virtual function makes a class an abstract class, which means you cannot
create direct instances (objects) of that class. Derived classes that inherit from an abstract
class are required to provide an implementation for all its pure virtual functions; otherwise,
they too become abstract. Pure virtual functions serve to enforce an interface, ensuring that
all concrete (non-abstract) derived classes implement specific behaviors that are essential for
their functionality, but whose implementation details vary among derived classes.

Group - B

1. Write a program in PHP to take input roll no., name, marks of five students and
display & store their grade card in a file grade.txt.

Answer:
This PHP program will interact with the user via the command line to collect student
information. It will then calculate a grade based on the marks provided, display the formatted
grade card on the screen, and finally append this information to a text file named grade.txt.
The file will be created if it doesn't already exist.

PHP

<?php​
$filename = "grade.txt";​
$file = fopen($filename, "a");​
if ($file === false) { die("Error: Could not open " . $filename); }​
​
echo "Enter details for 5 students:\n";​
​
for ($i = 1; $i <= 5; $i++) {​
echo "\nStudent " . $i . ":\n";​
echo "Roll No: ";​
$rollNo = trim(fgets(STDIN));​
echo "Name: ";​
$name = trim(fgets(STDIN));​
echo "Marks: ";​
$marks = (int)trim(fgets(STDIN));​
​
$grade = '';​
if ($marks >= 90) { $grade = 'A'; }​
elseif ($marks >= 80) { $grade = 'B'; }​
 elseif ($marks >= 70) { $grade = 'C'; }​
elseif ($marks >= 60) { $grade = 'D'; }​
else { $grade = 'F'; }​
​
$studentData = "Roll No: " . $rollNo . ", Name: " . $name . ", Marks: " . $marks . ", Grade: " . $grade .
"\n";​
echo $studentData;​
fwrite($file, $studentData);​
}​
​
fclose($file);​
echo "\nGrade cards saved to " . $filename . "\n";​
?>​

2. Develop a program in JAVA script to take input a number and then check whether it
is even or odd.

Answer:
This JavaScript program is embedded within an HTML file, creating a simple web interface. It
allows a user to input a number through a text field. Upon clicking a button, a JavaScript
function executes to determine if the entered number is even or odd and displays the result
directly on the web page.

HTML

<!DOCTYPE html>​
<html>​
<head>​
<title>Even or Odd Checker</title>​
<style>​
body { font-family: Arial, sans-serif; margin: 20px; }​
input[type="number"] { padding: 8px; margin-right: 5px; border: 1px solid #ccc; border-radius: 4px; }​
button { padding: 10px 15px; background-color: #007bff; color: white; border: none; border-radius:
4px; cursor: pointer; }​
button:hover { background-color: #0056b3; }​
#result { margin-top: 15px; font-weight: bold; }​
.even { color: green; }​
.odd { color: blue; }​
.error { color: red; }​
</style>​
</head>​
<body>​
​
<h1>Even or Odd Checker</h1>​
​
<label for="numberInput">Enter a number:</label>​
<input type="number" id="numberInput" placeholder="e.g., 7">​
<button onclick="checkEvenOdd()">Check</button>​
​
<p id="result"></p>​
​
<script>​
function checkEvenOdd() {​
let numberString = document.getElementById("numberInput").value;​
let resultElement = document.getElementById("result");​
resultElement.className = '';​
​
if (numberString === '' || isNaN(numberString) || !Number.isInteger(Number(numberString))) {​
resultElement.textContent = "Please enter a valid integer.";​
resultElement.classList.add('error');​
return;​
}​
​
let number = parseInt(numberString);​
​
if (number % 2 === 0) {​
resultElement.textContent = number + " is an even number.";​
resultElement.classList.add('even');​
} else {​
resultElement.textContent = number + " is an odd number.";​
resultElement.classList.add('odd');​
}​
}​
</script>​
​
</body>​
</html>​

3. What is the difference between a server and a client? What are the different types of
servers used in the Internet? Explain their purpose and functionalities.

Difference between a Server and a Client:

●​ Client: A client is typically a program or a computing device (like a personal computer,
smartphone, or tablet) that requests services or resources from a server. It initiates
communication and relies on the server to provide the requested data, computations, or
functionalities. Examples include web browsers (e.g., Chrome, Firefox, Safari), email
clients (e.g., Outlook, Gmail app), and applications running on a user's device that
 connect to a backend system.
●​ Server: A server is a program or a dedicated powerful computer that provides services,
data, or resources to clients over a network. It listens for incoming client requests,
processes them, and sends back the appropriate responses. Servers are designed for
high availability, reliability, and often have significant processing power, memory, and
storage capacity to handle numerous concurrent requests.

Different types of servers used in the Internet, their purpose and functionalities:
1.​ Web Servers (e.g., Apache HTTP Server, Nginx, Microsoft IIS, Node.js with
Express):
○​ Purpose: To store, process, and deliver web pages and other web content (like
images, videos, stylesheets, JavaScript files) to clients (web browsers) over the
Hypertext Transfer Protocol (HTTP or HTTPS).
○​ Functionalities: Handles HTTP/HTTPS requests, retrieves requested files from its file
system, executes server-side scripts (like PHP, Python, Node.js) to generate dynamic
content, and sends the content back to the client. They are the backbone of the
World Wide Web.
2.​ Mail Servers (e.g., Sendmail, Postfix, Microsoft Exchange, Dovecot):
○​ Purpose: To send, receive, store, and manage email messages for users.
○​ Functionalities: Uses protocols like SMTP (Simple Mail Transfer Protocol) for
sending emails between servers and to clients, and POP3 (Post Office Protocol 3) or
IMAP (Internet Message Access Protocol) for clients to retrieve emails from their
inboxes. They act as central hubs for email communication.
3.​ Database Servers (e.g., MySQL, PostgreSQL, Oracle Database, Microsoft SQL
Server, MongoDB):
○​ Purpose: To store, organize, manage, and retrieve large amounts of data in a
structured way for various applications. They provide a centralized repository for
data accessed by web applications, desktop software, and other services.
○​ Functionalities: Processes database queries (e.g., SQL queries), ensures data
consistency and integrity, manages concurrent access from multiple clients, and
handles data transactions (ensuring Atomicity, Consistency, Isolation, Durability -
ACID properties).
4.​ DNS Servers (Domain Name System Servers):
○​ Purpose: To translate human-readable domain names (like www.example.com) into
machine-readable IP addresses (like 192.0.2.1). This translation is crucial for devices
to locate resources on the internet, as computers communicate using IP addresses.
○​ Functionalities: Maintains a distributed database of domain name to IP address
mappings, resolves domain name queries from clients (like your web browser), and
routes internet traffic to the correct servers. They are essential for internet
navigation.
5.​ FTP Servers (File Transfer Protocol Servers):
○​ Purpose: To facilitate the transfer of files between a client and a server over a
network using the File Transfer Protocol (FTP). They are commonly used for
 uploading website files, sharing large documents, or downloading software.
○​ Functionalities: Allows users to upload files to the server, download files from the
server, delete files, and list directory contents. FTP connections can be active or
passive and often require authentication (username and password).

4. Explain HTML tag to draw a table. Explain HTML tags for various components of the
table such as caption of the table, row of table and column of table.

The main HTML tag used to define a table is <table>. This tag acts as the container for all
other table-related content, structuring data into rows and columns.

Here's an explanation of the HTML tags for various components of a table:

1.​ <table> tag:
○​ Purpose: Defines the entire table structure in an HTML document. It is the root
element for all table content.
○​ Functionality: Establishes a tabular layout for data, allowing content to be organized
into rows and columns. Browsers render the content within this tag as a table.
○​ Example: <table border="1"> ... </table> (The border attribute is for visual display,
though CSS is preferred for styling).
2.​ <caption> tag:
○​ Purpose: Specifies a caption or title for the table.
○​ Functionality: Provides a brief, descriptive heading for the table's content, which is
valuable for accessibility (screen readers) and overall understanding. It is typically
displayed centered above the table by default.
○​ Placement: Must be the first child of the <table> tag.
○​ Example: <caption>Monthly Sales Report</caption>
3.​ <tr> (Table Row) tag:
○​ Purpose: Defines a row within a table.
○​ Functionality: Groups cells horizontally. Each <tr> element represents a new
horizontal division in the table, which will contain either header cells (<th>) or data
cells (<td>).
○​ Placement: Must be a child of a <table>, <thead> (table head), <tbody> (table body),
or <tfoot> (table foot) tag.
○​ Example: <tr> ... </tr>
4.​ <th> (Table Header) tag:
○​ Purpose: Defines a header cell in a table.
○​ Functionality: Represents the heading for a column or a row. Text within <th> tags is
typically rendered in bold and centered by default by browsers, signifying its role as a
heading and providing semantic meaning.
○​ Placement: Must be a child of a <tr> tag.
○​ Example: <th>Student Name</th>
5.​ <td> (Table Data) tag:
○​ Purpose: Defines a standard data cell in a table.
 ○​ Functionality: Contains the actual data content for a specific cell at the intersection
of a row and a column. This is where the individual pieces of information within the
table are placed.
○​ Placement: Must be a child of a <tr> tag.
○​ Example: <td>John Doe</td>

Example HTML Table Structure:

HTML

<table border="1">​
<caption>Employee Information</caption>​
<thead>​
<tr>​
<th>Employee ID</th>​
<th>Name</th>​
<th>Department</th>​
</tr>​
</thead>​
<tbody>​
<tr>​
<td>E001</td>​
<td>Alice Smith</td>​
<td>HR</td>​
</tr>​
<tr>​
<td>E002</td>​
<td>Bob Johnson</td>​
<td>Engineering</td>​
</tr>​
</tbody>​
</table>​

5. Write short notes:

a. Table tag of HTML

The <table> tag in HTML is the fundamental element used to create tables, which are
structured collections of data organized into rows and columns. It acts as a container for all
the elements that make up a table, including rows (<tr>), header cells (<th>), and data cells
(<td>). Its primary purpose is to present tabular data in a clear, accessible, and semantically
meaningful format.
b. JavaScript events
JavaScript events are specific actions or occurrences that happen in a web browser, often as
a result of user interaction or browser activities. These events can include a user clicking a
button (onclick), moving the mouse over an element (onmouseover), submitting a form
(onsubmit), a web page finishing loading (onload), a keyboard key being pressed
(onkeydown), or an input field losing focus (onblur). JavaScript allows developers to detect
these events and execute specific functions (known as event handlers or event listeners) in
response, enabling dynamic, interactive, and responsive web pages.
c. HTML frames
HTML frames, primarily implemented using the <frameset> and <frame> tags, were a feature
that allowed a web page to be divided into multiple independent, scrollable regions, with each
region displaying a separate HTML document. This enabled complex layouts where, for
example, a navigation menu could remain static in one frame while the main content changed
in another. However, <frameset> and <frame> are largely deprecated in HTML5 due to
numerous issues, including problems with accessibility (screen readers), difficulties with
bookmarking specific content within a frame, and challenges for search engine indexing. The
<iframe> tag, which embeds one HTML document within another as an inline frame, is still
supported and commonly used for embedding external content (like YouTube videos or maps)
securely.
d. External link in HTML
An external link in HTML is a hyperlink that directs the user to a resource (another web page, a
file, an image, etc.) located on a different website or a completely different domain on the
internet. These links are created using the <a> (anchor) tag, with the href attribute specifying
the full, absolute URL of the external resource. For example: <a
href="https://www.google.com" target="_blank" rel="noopener noreferrer">Go to Google</a>.
The target="_blank" attribute is commonly used to open external links in a new browser tab or
window, while rel="noopener noreferrer" is a security best practice for such links.
e. File handling in PHP
File handling in PHP refers to the comprehensive set of capabilities that allow PHP scripts to
interact with the file system on the server. This involves using various built-in functions to
perform common file operations such as:
●​ Opening and closing files: fopen() (to open a file in various modes like read, write,
append) and fclose() (to close an opened file).
●​ Reading from files: fread() (reads a specified number of bytes), fgets() (reads a line),
file_get_contents() (reads entire file into a string).
●​ Writing to files: fwrite() (writes to an opened file), fputs() (alias of fwrite()),
file_put_contents() (writes string to a file, creating it if needed).
●​ Checking file properties: file_exists() (checks if file exists), filesize() (gets file size),
is_readable(), is_writable() (checks permissions).
●​ Deleting files: unlink() (deletes a file).​
File handling is essential for a wide range of web application tasks, including logging
data, managing user-uploaded files, reading configuration settings, and generating
 dynamic file-based content like reports or CSV exports.

f. Error checking in JavaScript

Error checking in JavaScript involves implementing mechanisms to identify, anticipate, and
gracefully handle errors (exceptions) that might occur during script execution, rather than
allowing the script to crash and disrupt the user experience. The primary construct for
structured error handling is the try...catch statement, which allows you to "try" a block of code
and "catch" any exceptions (errors) that are thrown within it. Other common practices for
error checking include:
●​ Input Validation: Checking if user input or data from external sources is in the correct
format, type, or range before processing it.
●​ Conditional Logic: Using if/else statements to handle different scenarios or potential
issues.
●​ Defensive Programming: Writing code that anticipates unexpected conditions and
handles them explicitly.​
Robust error checking is crucial for building reliable, user-friendly, and maintainable web
applications.

g. Internal link in HTML

An internal link in HTML is a hyperlink that directs the user to a resource located within the
same website or even to a different section within the same web page. This type of link is
crucial for creating well-structured and navigable websites, improving user experience by
allowing them to move between related content efficiently without leaving the site.
●​ Linking to a section on the same page: Achieved by using the <a> (anchor) tag where
the href attribute is set to # followed by the id of the target HTML element on the same
page (e.g., <a href="#top-section">Back to Top</a> where a <div id="top-section">
exists).
●​ Linking to another page within the same website: Achieved by using the <a> tag with
a relative path in the href attribute (e.g., <a href="about.html">About Us</a> or <a
href="../products/item-detail.html">Product Detail</a>).

h. MySQL connectivity in PHP

MySQL connectivity in PHP refers to the process by which a PHP script establishes and
manages a connection to a MySQL database server to perform various database operations.
These operations typically include executing SQL queries to retrieve (SELECT), insert
(INSERT), update (UPDATE), or delete (DELETE) data. PHP provides specific extensions for this
purpose:
●​ mysqli extension (MySQL Improved Extension): This is the most widely recommended
extension for MySQL interaction in modern PHP. It offers both a procedural and an
object-oriented interface, and provides advanced features like prepared statements (for
enhanced security against SQL injection) and support for multiple statements.
●​ PDO (PHP Data Objects): This is a lightweight, consistent interface for connecting to
various databases (not just MySQL). PDO also supports prepared statements and offers a
 more generic approach to database interactions, making code more portable across
different database systems.​
The older mysql extension and its functions (like mysql_query()) are deprecated and
removed in modern PHP versions (PHP 7.0+), making mysqli or PDO the standard for
secure and efficient MySQL connectivity.

6. What is the difference between a server and a client? What are the different types of
servers used in the Internet? Explain their purpose and functionalities.
(This answer is identical to Question 3 in Group B. It is provided again for completeness as per
examination paper format.)
Difference between a Server and a Client:
●​ Client: A client is typically a program or a computing device (like a personal computer,
smartphone, or tablet) that requests services or resources from a server. It initiates
communication and relies on the server to provide the requested data, computations, or
functionalities. Examples include web browsers (e.g., Chrome, Firefox, Safari), email
clients (e.g., Outlook, Gmail app), and applications running on a user's device that
connect to a backend system.
●​ Server: A server is a program or a dedicated powerful computer that provides services,
data, or resources to clients over a network. It listens for incoming client requests,
processes them, and sends back the appropriate responses. Servers are designed for
high availability, reliability, and often have significant processing power, memory, and
storage capacity to handle numerous concurrent requests.

Different types of servers used in the Internet, their purpose and functionalities:
1.​ Web Servers (e.g., Apache HTTP Server, Nginx, Microsoft IIS, Node.js with
Express):
○​ Purpose: To store, process, and deliver web pages and other web content (like
images, videos, stylesheets, JavaScript files) to clients (web browsers) over the
Hypertext Transfer Protocol (HTTP or HTTPS).
○​ Functionalities: Handles HTTP/HTTPS requests, retrieves requested files from its file
system, executes server-side scripts (like PHP, Python, Node.js) to generate dynamic
content, and sends the content back to the client. They are the backbone of the
World Wide Web.
2.​ Mail Servers (e.g., Sendmail, Postfix, Microsoft Exchange, Dovecot):
○​ Purpose: To send, receive, store, and manage email messages for users.
○​ Functionalities: Uses protocols like SMTP (Simple Mail Transfer Protocol) for
sending emails between servers and to clients, and POP3 (Post Office Protocol 3) or
IMAP (Internet Message Access Protocol) for clients to retrieve emails from their
inboxes. They act as central hubs for email communication.
3.​ Database Servers (e.g., MySQL, PostgreSQL, Oracle Database, Microsoft SQL
Server, MongoDB):
○​ Purpose: To store, organize, manage, and retrieve large amounts of data in a
 structured way for various applications. They provide a centralized repository for
data accessed by web applications, desktop software, and other services.
○​ Functionalities: Processes database queries (e.g., SQL queries), ensures data
consistency and integrity, manages concurrent access from multiple clients, and
handles data transactions (ensuring Atomicity, Consistency, Isolation, Durability -
ACID properties).
4.​ DNS Servers (Domain Name System Servers):
○​ Purpose: To translate human-readable domain names (like www.example.com) into
machine-readable IP addresses (like 192.0.2.1). This translation is crucial for devices
to locate resources on the internet, as computers communicate using IP addresses.
○​ Functionalities: Maintains a distributed database of domain name to IP address
mappings, resolves domain name queries from clients (like your web browser), and
routes internet traffic to the correct servers. They are essential for internet
navigation.
5.​ FTP Servers (File Transfer Protocol Servers):
○​ Purpose: To facilitate the transfer of files between a client and a server over a
network using the File Transfer Protocol (FTP). They are commonly used for
uploading website files, sharing large documents, or downloading software.
○​ Functionalities: Allows users to upload files to the server, download files from the
server, delete files, and list directory contents. FTP connections can be active or
passive and often require authentication (username and password).

7. Explain the concept of frame in HTML. Also explain use of frameset and frame tags.

Concept of Frame in HTML:

The concept of frames in HTML refers to the ability to divide a single browser window into
multiple, independent regions, with each region displaying a separate HTML document. This
allowed for a composite layout where different parts of the screen could show different
content that could be scrolled or updated independently. For instance, one frame could
contain a static navigation bar, while another frame displays the dynamic content based on
user selections, creating a multi-pane interface.
Use of frameset and frame tags:
1.​ <frameset> tag:
○​ Purpose: The <frameset> tag was used in an HTML document to define how the
browser window was to be divided into multiple frames. It replaced the <body> tag in
documents that used frames, as it's not meant to contain visible document content
directly.
○​ Functionality: It specified the number and size of the frames using attributes like
rows (for horizontal division) or cols (for vertical division). For example, <frameset
rows="25%,*"> would create two horizontal frames: the top one taking 25% of the
window height, and the bottom one taking the remaining space.
○​ Example:​
HTML​
 <frameset cols="25%,*">​
</frameset>​

2.​ <frame> tag:

○​ Purpose: The <frame> tag defined a single frame within a <frameset>. It specified
which HTML document should be displayed inside that particular frame.
○​ Functionality: Its primary attribute was src, which pointed to the URL of the HTML
document to be loaded into the frame. Other attributes included name (to allow links
to target a specific frame), scrolling (to control whether scrollbars appear), and
noresize (to prevent users from resizing the frame).
○​ Placement: Must be placed directly inside a <frameset> tag.
○​ Example:​
HTML​
<frameset cols="25%,*">​
<frame src="navigation.html" name="navFrame">​
<frame src="main_content.html" name="contentFrame">​
</frameset>​

Note: While frames provided a way to structure complex layouts, the <frameset> and <frame>
tags are considered deprecated in modern HTML (HTML5) due to several significant
drawbacks, including issues with accessibility (screen readers often struggle with frames),
difficulties with bookmarking specific content within a frame, challenges for search engine
indexing, and generally poorer user experience. Modern web development primarily relies on
CSS for layout (e.g., Flexbox, Grid) and the <iframe> tag for embedding external content.

8. Develop a program in JAVA script to take input a number and then check whether it
is prime or not.

Answer:
This JavaScript program is integrated into an HTML file to create a web-based utility. It
prompts the user to enter an integer. When the user clicks the "Check" button, a JavaScript
function will evaluate whether the entered number is a prime number (a natural number
greater than 1 that has no positive divisors other than 1 and itself) and display the result on
the page.

HTML

<!DOCTYPE html>​
<html>​
<head>​
<title>Prime Number Checker</title>​
<style>​
body { font-family: Arial, sans-serif; margin: 20px; }​
input[type="number"] { padding: 8px; margin-right: 5px; border: 1px solid #ccc; border-radius: 4px; }​
button { padding: 10px 15px; background-color: #28a745; color: white; border: none; border-radius:
4px; cursor: pointer; }​
button:hover { background-color: #218838; }​
#primeResult { margin-top: 15px; font-weight: bold; }​
.prime { color: green; }​
.not-prime { color: blue; }​
.error { color: red; }​
</style>​
</head>​
<body>​
​
<h1>Prime Number Checker</h1>​
​
<label for="primeNumberInput">Enter a positive integer:</label>​
<input type="number" id="primeNumberInput" placeholder="e.g., 17">​
<button onclick="checkPrime()">Check</button>​
​
<p id="primeResult"></p>​
​
<script>​
function checkPrime() {​
let numberString = document.getElementById("primeNumberInput").value;​
let resultElement = document.getElementById("primeResult");​
resultElement.className = '';​
​
if (numberString === '' || isNaN(numberString) || !Number.isInteger(Number(numberString)) ||
Number(numberString) < 1) {​
resultElement.textContent = "Please enter a valid positive integer.";​
resultElement.classList.add('error');​
return;​
}​
​
let number = parseInt(numberString);​
​
if (number <= 1) {​
resultElement.textContent = number + " is not a prime number.";​
resultElement.classList.add('not-prime');​
return;​
}​
​
for (let i = 2; i * i <= number; i++) {​
if (number % i === 0) {​
resultElement.textContent = number + " is not a prime number (divisible by " + i + ").";​
resultElement.classList.add('not-prime');​
 return;​
}​
}​
​
resultElement.textContent = number + " is a prime number.";​
resultElement.classList.add('prime');​
}​
</script>​
​
</body>​
</html>​

9. Explain the following terms in respect to PHP:

a. foreach
The foreach loop is a control structure in PHP specifically designed for iterating over elements
of arrays and properties of objects. It provides a clean, concise, and convenient way to loop
through each item in a collection without the need to manage an explicit counter variable. The
foreach loop can operate in two primary modes: one that retrieves only the value of each
element (foreach ($array as $value)), and another that retrieves both the key (or index) and
the value (foreach ($array as $key => $value)). It is widely used for traversing arrays,
processing form submissions, and iterating over database query results.
b. array
An array in PHP is a special variable that can hold more than one value under a single name,
allowing you to store a collection of data elements. Unlike scalar variables that can only hold a
single value, arrays enable you to group related pieces of data. PHP arrays are exceptionally
flexible and versatile, capable of functioning as:
●​ Indexed arrays: Using numeric keys (e.g., [0], [1], [2]), similar to lists in other languages.
●​ Associative arrays: Using named string keys (e.g., ["name"], ["age"]), similar to
dictionaries or hash maps.
●​ Multidimensional arrays: Arrays containing other arrays, enabling the representation of
complex data structures like matrices or tables.​
Arrays are fundamental data structures for organizing and manipulating data in almost
any PHP application.

c. explode
The explode() function in PHP is a powerful string function used to divide (or "explode") a
string into an ordered array of substrings. The division is performed based on a specified
delimiter string. Essentially, the function searches for occurrences of the delimiter within the
input string and breaks the string into pieces at each delimiter's position, placing these pieces
into a new array.
●​ Syntax: explode(string $delimiter, string $string, int $limit = PHP_INT_MAX): array
●​ $delimiter: The string that marks the boundary for splitting (e.g., a comma, a space, a
hyphen).
 ●​ $string: The input string to be split.
●​ $limit: An optional integer specifying the maximum number of elements the returned
array can contain. If limit is set, the last array element will contain the rest of the string.​
It is commonly used for parsing data from files, URLs, or user input that is structured with
specific separators (e.g., parsing a CSV line into individual values).

d. mysql_query
mysql_query() was a function belonging to the original MySQL extension in PHP, which was
widely used to send a SQL query (like SELECT, INSERT, UPDATE, DELETE) to the currently
active MySQL database connection on the server. It would execute the query and return a
result resource (for SELECT queries) or a boolean value indicating success/failure.
Important Note: The mysql_query() function and the entire mysql extension are officially
deprecated as of PHP 5.5.0 and were completely removed in PHP 7.0.0 and subsequent
versions. This deprecation and removal were due to several reasons, including security
vulnerabilities (prone to SQL injection without careful handling), lack of support for newer
MySQL features, and the availability of superior alternatives. Modern PHP applications must
use more secure and feature-rich extensions like mysqli (MySQL Improved Extension) or PDO
(PHP Data Objects) for interacting with MySQL databases.
e. file handling
File handling in PHP refers to the comprehensive set of capabilities that allow PHP scripts to
interact with the server's file system. This includes a variety of built-in functions that enable
scripts to perform fundamental operations on files and directories. Key aspects of file
handling include:
●​ Opening and closing files: fopen() to open a file (specifying read, write, append, etc.,
modes) and fclose() to release the file handle.
●​ Reading from files: Functions like fread() (reads a specified number of bytes), fgets()
(reads a single line), and file_get_contents() (reads the entire file into a string).
●​ Writing to files: Functions like fwrite() (writes content to an opened file) and
file_put_contents() (writes a string to a file, creating or overwriting it).
●​ Checking file properties: Functions like file_exists() (checks if a file exists), filesize()
(gets the size of a file), is_readable(), is_writable() (checks file permissions).
●​ Deleting files: unlink() to remove a file from the filesystem.
●​ Directory operations: Functions like mkdir() (create directory), rmdir() (remove directory),
opendir(), readdir() (for iterating directory contents).​
File handling is essential for diverse web application tasks such as logging data,
managing user uploads, reading configuration files, generating reports, and manipulating
server-side data.

f. do-while
The do-while loop is a control flow statement in PHP that executes a block of code at least
once, and then repeatedly executes the block as long as a specified condition evaluates to
true. The distinguishing characteristic of the do-while loop is that its condition is tested after
each iteration, rather than before (as in a while loop). This guarantees that the loop body will
always run at least one time, regardless of the initial state of the condition.
●​ Syntax:​
PHP​
do {​
// Code to be executed at least once​
} while (condition);​

This type of loop is particularly useful in scenarios where you need to perform an action at
least once before evaluating whether further repetitions are necessary (e.g., prompting a user
for input until valid data is entered).

g. implode
The implode() function in PHP is a string function that is used to join elements of an array into
a single string. It acts as the inverse of the explode() function. It takes a "glue" string (or
separator) and an array as arguments, and it returns a string where all the array elements are
concatenated together, with the specified separator string inserted between each element.
●​ Syntax: implode(string $separator, array $array): string
●​ $separator: The string to use as the "glue" or delimiter between the array elements in the
resulting string (e.g., a comma, a space, a hyphen). If an empty string is used, the
elements are concatenated directly.
●​ $array: The array whose elements are to be joined.​
It is commonly used for converting array data into a string format that is suitable for
display (e.g., creating a comma-separated list for output) or for storing in a single
database field.