← Junior Engineer
Past Questions
In analysis of algorithm, approximate relationship between the size of the job and the amount of work required to do is expressed by using _________
A)
Central tendency
B)
Differential equation
C)
Order of execution
D)
Order of magnitude
In the analysis of algorithms, we are interested in how the resource requirements (time or space) grow as the input size (n) increases. This relationship is described using Asymptotic Notation (such as Big O, Omega, and Theta). These notations describe the 'Order of Magnitude' of the growth rate. For example, if an algorithm's work increases quadratically with the input size, we say it is of the order of magnitude O(n²).
Why other options are incorrect:
- a. Central tendency: This is a statistical term (mean, median, mode) used to describe the center of a data distribution, not algorithmic growth.
- b. Differential equation: While used in calculus to describe rates of change, they are not the standard way to express the approximate relationship between job size and work in algorithm analysis.
- c. Order of execution: This typically refers to the sequence in which instructions are processed (e.g., sequential vs. parallel), not the growth of work relative to input size.
Block or Buffer caches are used
A)
to improve disk performance
B)
to handle interrupts
C)
to increase the capacity of main memory
D)
to speed up main memory read operation
Block or buffer caches are used to improve disk performance by temporarily storing frequently accessed disk blocks in faster memory, reducing the number of slow disk I/O operations. This speeds up repeated reads/writes to disk data. Option b is incorrect because interrupts are handled by the CPU/interrupt controller, not by caches. Option c is incorrect because caches do not increase the actual capacity of main memory; they only improve access speed. Option d is incorrect because main memory read speed is improved by cache memory in general, but the term "block/buffer cache" specifically refers to caching disk blocks to improve disk performance.
What is the correct syntax in HTML for creating a link on a webpage?
A)
<LINK SRC= “abc.html”>
B)
<BODY LINK = “abc.html”>
C)
<A SRC = “def.html” >
D)
< A HREF = “def.html”>
In HTML, hyperlinks are created using the anchor tag <a>. The most critical attribute for this tag is 'href' (Hypertext Reference), which specifies the destination URL or file path of the link.
Analysis of options:
- Option (a) <LINK SRC= “abc.html”>: The <link> tag is used to define relationships between the current document and an external resource (most commonly used to link CSS stylesheets in the <head> section), not for creating clickable hyperlinks on a page.
- Option (b) <BODY LINK = “abc.html”>: The <body> tag defines the document body. While 'link' was an old attribute of the <body> tag used to specify the color of unvisited links, it cannot be used to create a hyperlink to another page.
- Option (c) <A SRC = “def.html”>: While this uses the correct anchor tag <a>, the 'src' (source) attribute is used for embedding media (like <img> or <script>), not for defining the destination of a hyperlink.
- Option (d) < A HREF = “def.html”>: This is the correct syntax. The <a> tag combined with the 'href' attribute correctly defines a hyperlink to the specified destination.
The constraint that specifies whether the existence of an entity depends on its being related to another entity via relationship type.
A)
Participation constraint
B)
Primary key constraint
C)
Entity types
D)
Data model
In Database Management Systems (DBMS), specifically within Entity-Relationship (ER) modeling, the Participation Constraint determines whether the existence of an entity depends on its being related to another entity. There are two types of participation:
1. Total Participation (Existence Dependency): Every entity in the entity set must participate in at least one relationship instance. This is often represented by a double line in ER diagrams. For example, every 'Employee' must work for a 'Department'.
2. Partial Participation: Some entities in the set may not participate in the relationship. This is represented by a single line. For example, not every 'Employee' is a 'Manager'.
Why other options are incorrect:
- b. Primary key constraint: This ensures that each record in a table is uniquely identifiable and that the key is not null; it does not define existence dependency between entities.
- c. Entity types: This refers to the category or definition of an entity (e.g., 'Student' or 'Course'), not a constraint on its relationship.
- d. Data model: This is a high-level conceptual framework (like the Relational Model or ER Model) used to describe the structure of a database, not a specific constraint.
For the quick sort algorithm, what is the time complexity of the best/worst case?
A)
best case: O(n) worst case: O(n*n)
B)
best case: O(n) worst case: O(n*log(n))
C)
best case: O(n*log(n)) worst case: O(n*log(n))
D)
best case: O(n*log(n)) worst case: O(n*n)
Quick Sort is a divide-and-conquer algorithm. Its time complexity depends on the choice of the pivot element:
1. **Best Case Complexity**: The best case occurs when the pivot element always divides the array into two nearly equal halves. In this scenario, the recurrence relation is T(n) = 2T(n/2) + Θ(n). According to the Master Theorem, this results in a time complexity of O(n log n).
2. **Worst Case Complexity**: The worst case occurs when the pivot is consistently the smallest or largest element of the array (which often happens if the input array is already sorted or reverse-sorted and the first or last element is chosen as the pivot). In this case, the partition is highly unbalanced, creating one subarray of size 0 and another of size n-1. The recurrence relation becomes T(n) = T(n-1) + Θ(n), which simplifies to O(n²).
Comparing this to the options:
- Option (a) is incorrect because the best case is not O(n).
- Option (b) is incorrect because the best case is not O(n) and the worst case is not O(n log n).
- Option (c) is incorrect because the worst case is O(n²), not O(n log n).
- Option (d) correctly identifies both the best case O(n log n) and the worst case O(n²).
The number of interchanges required to sort 5, 1, 6, 2, 4 in ascending order using Bubble Sort is
A)
6
B)
5
C)
7
D)
8
Bubble-sort swaps are 5 in total: three in the first pass and two in the second.
Which scheduling policy is most suitable for a time-shared operating system
A)
Shortest-job First
B)
Elevator
C)
Round-Robin
D)
First-Come-First-Serve
A time-shared operating system is designed to allow multiple users to share the CPU simultaneously, providing a fast response time for each user. To achieve this, the system must ensure that no single process monopolizes the CPU for too long.
1. **Round-Robin (RR)**: This policy assigns a small unit of time called a 'time quantum' or 'time slice' to each process. Once the time slice expires, the process is preempted and moved to the back of the ready queue, and the next process is given its turn. This ensures fairness and provides the low response time required for interactive/time-sharing environments.
2. **Shortest-Job First (SJF)**: This is an optimal algorithm for minimizing average waiting time, but it is not suitable for time-sharing because it can lead to 'starvation' of longer processes and requires knowing the length of the next CPU burst in advance.
3. **Elevator (SCAN)**: This is a disk scheduling algorithm, not a CPU scheduling algorithm. It is used to manage the movement of the disk arm to service I/O requests.
4. **First-Come-First-Serve (FCFS)**: This is a non-preemptive algorithm. If a long process arrives first, all subsequent short processes are blocked (the 'convoy effect'), leading to poor response times, which is unacceptable in a time-shared system.
The removal of process from active contention of CPU and reintroduce them into memory later is known as ____________.
A)
Interrupt
B)
Swapping
C)
Signal
D)
Thread
Step-by-step reasoning:
1. **Definition of Swapping**: In operating systems, swapping is a memory management technique where a process is temporarily removed from the main memory (RAM) and moved to secondary storage (usually a disk area called the swap space) to free up memory for other processes. Later, the process is brought back (swapped in) from the disk to the main memory to continue its execution.
2. **Analyzing the Question**: The question describes the 'removal of process from active contention of CPU' (which implies moving it out of the executable memory space) and 'reintroducing them into memory later'. This is the exact definition of swapping.
3. **Evaluating Other Options**:
- **a. Interrupt**: An interrupt is a signal to the processor emitted by hardware or software indicating an event that needs immediate attention. It does not involve moving processes between memory and disk.
- **c. Signal**: A signal is a software interrupt sent to a process to notify it of a specific event (e.g., SIGKILL or SIGINT). It is a communication mechanism, not a memory management technique.
- **d. Thread**: A thread is the smallest unit of execution within a process. While threads compete for CPU time, the act of moving them out of memory and back in is not called 'threading'.
Therefore, the correct term for this operation is Swapping.
A protocol is a set of rules governing the communication that take place ____
A)
between an interface
B)
between peers
C)
between modems
D)
across an interface
In computer networking, a protocol is defined as a set of rules and conventions that govern how two or more entities communicate. Specifically, in the context of layered network architectures (like the OSI or TCP/IP models), communication occurs horizontally between the same layer on different devices. These corresponding layers on different systems are referred to as 'peers'. Peer-to-peer communication is governed by peer protocols to ensure that data sent by a layer on one machine is correctly interpreted by the same layer on the receiving machine.
Why other options are incorrect:
- Option (a) and (d): An 'interface' is the boundary between two adjacent layers on the same machine (vertical communication). Rules governing the interface are usually internal API specifications, not network protocols.
- Option (c): While modems use protocols, a protocol is a general concept that applies to all communicating entities (software, hardware, servers, clients), not just modems specifically.
Which of the following is contained in Process Control Block (PCB)?
A)
Process Number
B)
List of Open files
C)
Memory Limits
D)
All of these
A Process Control Block (PCB), also known as a Task Control Block, is a data structure used by the operating system to store all the information needed to manage a specific process. It allows the OS to perform context switching by saving the state of a process before pausing it and restoring it later.
1. **Process Number (PID):** Every process is assigned a unique identifier called the Process ID (PID) to distinguish it from other processes. This is a fundamental part of the PCB.
2. **List of Open Files:** The OS needs to keep track of which files the process has opened and the current seek position within those files. This information is stored in the PCB (often as a table of file descriptors).
3. **Memory Limits:** To ensure memory protection and prevent a process from accessing memory belonging to another process or the kernel, the PCB stores memory management information, such as base and limit registers or page tables.
Since all three components (Process Number, List of Open files, and Memory Limits) are essential parts of the PCB, the correct option is 'All of these'.
The statement which is used to end a successful transaction is
A)
COMMIT
B)
DONE
C)
END
D)
QUIT
In SQL, a transaction is a sequence of one or more SQL operations treated as a single logical unit of work. To ensure data integrity, SQL uses Transaction Control Language (TCL) commands.
1. **COMMIT**: This command is used to permanently save all changes made during the current transaction to the database. Once a COMMIT is executed, the changes become visible to other users and cannot be undone using a ROLLBACK. Therefore, it is the statement used to end a successful transaction.
2. **DONE**: This is not a standard SQL command for transaction control. It is often used in programming languages or as a status indicator, but not as a TCL statement.
3. **END**: While 'END' is used in PL/SQL or T-SQL to mark the end of a block of code (like a BEGIN...END block), it is not the command used to commit a transaction to the database.
4. **QUIT**: This is typically a command used to exit a command-line interface (CLI) or a database shell (like the mysql monitor), not a command to finalize a database transaction.
Which of the following is not a recovery technique?
A)
Deferred update
B)
Immediate update
C)
Two-phase commit
D)
Shadow paging
In Database Management Systems (DBMS), recovery techniques are used to restore the database to a consistent state after a failure.
1. **Deferred Update (Option a):** This is a recovery technique where updates are not physically applied to the database until the transaction reaches its commit point. If a failure occurs before commit, no changes were made to the disk, so no 'undo' is needed.
2. **Immediate Update (Option b):** This is a recovery technique where updates are applied to the database immediately. If a failure occurs, the system uses logs to 'undo' uncommitted transactions and 'redo' committed ones.
3. **Shadow Paging (Option d):** This is a recovery technique that avoids the use of logs by maintaining two page tables: a current page table and a shadow page table. During a crash, the system simply reverts to the shadow page table.
**Two-phase commit (2PC) (Option c)** is NOT a recovery technique; rather, it is a **distributed atomic commitment protocol**. It is used in distributed databases to ensure that all participating nodes either commit the transaction or abort it, ensuring atomicity across multiple servers. While it helps prevent inconsistency, it is a concurrency/transaction management protocol, not a mechanism for recovering data from a system crash.
<TD> … </TD> tag is used for ________
A)
Table heading
B)
Table Records
C)
Table row
D)
None of these
In HTML, the <table> element is used to create a table. Within a table, the <tr> tag defines a table row, and the <td> tag (Table Data) is used to define a standard data cell within that row. These cells contain the actual data or 'records' of the table.
Breakdown of options:
- Option (a) Table heading: This is defined by the <th> (Table Header) tag, which typically renders text as bold and centered.
- Option (b) Table Records: This is correct. <td> stands for 'Table Data', which represents the individual records/cells of the table.
- Option (c) Table row: This is defined by the <tr> (Table Row) tag.
- Option (d) None of these: Incorrect, as option (b) accurately describes the purpose of the <td> tag.
Finding the max element in an unordered stack would require
A)
O(1) operations
B)
O(log n) operations
C)
O(n) operations
D)
None of these
1. **Understanding the Stack Data Structure**: A stack is a Last-In-First-Out (LIFO) data structure. The only element that can be accessed directly without removing others is the top element.
2. **Analyzing the Problem**: We are asked to find the maximum element in an 'unordered' stack. Because the stack is unordered, there is no inherent property (like in a Max-Heap or a Sorted Array) that tells us where the maximum value is located.
3. **The Process**: To find the maximum element, we must examine every single element in the stack. Since we can only access the top, we must pop each element one by one, compare it with a running 'max' variable, and potentially store the popped elements in a temporary stack to restore the original stack later.
4. **Complexity Analysis**: If there are 'n' elements in the stack, we must perform the pop and comparison operation 'n' times. This results in a time complexity of O(n).
5. **Evaluating Options**:
- **O(1)**: This would only be possible if we maintained an auxiliary variable that tracked the maximum during every push/pop operation, but the question asks about finding it in a standard unordered stack.
- **O(log n)**: This complexity is typical for binary search in sorted arrays or operations in balanced trees, neither of which apply to a standard stack.
- **O(n)**: This is the correct complexity as every element must be visited once.
Which of the transport layer protocols is connectionless oriented protocol?
A)
UDP
B)
TCP
C)
FTP
D)
None of these
UDP is the transport layer protocol that is connectionless oriented. It sends datagrams without establishing a session or performing connection setup/teardown, so it has lower overhead than TCP. TCP is incorrect because it is connection-oriented and requires a handshake before data transfer. FTP is incorrect because it is an application layer protocol, not a transport layer protocol. 'None of these' is incorrect because UDP is the correct connectionless transport protocol.
It distributes a relation into sets of tuples (rows)
A)
Vertical fragmentation
B)
Horizontal fragmentation
C)
Replication fragmentation
D)
Diagonal fragmentation
In a Distributed Database Management System (DDBMS), fragmentation is the process of dividing a relation (table) into smaller parts to be stored at different sites.
1. **Horizontal Fragmentation**: This process divides a relation into sets of tuples (rows). It is essentially equivalent to selecting a subset of rows using a 'WHERE' clause in SQL. For example, if a 'Customer' table is split so that customers from 'New York' are stored on one server and customers from 'London' on another, it is horizontal fragmentation.
2. **Vertical Fragmentation**: This process divides a relation into sets of attributes (columns). It splits the table by columns, ensuring that the primary key is present in each fragment to allow for reconstruction.
3. **Replication**: This is not a form of fragmentation but a strategy where the same data (or fragments) are copied and stored at multiple sites to increase availability and reliability.
4. **Diagonal Fragmentation**: This is a hybrid approach that combines both horizontal and vertical fragmentation, but it is not the standard term for distributing a relation specifically into sets of tuples.
Therefore, since the question specifically mentions distributing a relation into sets of tuples (rows), the correct answer is Horizontal fragmentation.
The set of operations or language that the DBMS provides for retrieval, insertion, deletion and modification of data is called
A)
View definition language
B)
Storage definition language
C)
Data definition language
D)
Data manipulation language
In a Database Management System (DBMS), languages are categorized based on their functionality:
1. **Data Manipulation Language (DML)**: This is the set of operations used to manage and manipulate data within existing schema objects. It specifically provides the commands for:
- **Retrieval** (e.g., SELECT in SQL)
- **Insertion** (e.g., INSERT in SQL)
- **Deletion** (e.g., DELETE in SQL)
- **Modification** (e.g., UPDATE in SQL)
2. **Data Definition Language (DDL)**: This is used to define the database structure or schema. It deals with creating, altering, and dropping tables, indexes, and constraints (e.g., CREATE, ALTER, DROP). It does not manipulate the data records themselves.
3. **Storage Definition Language (SDL)**: This is used to specify the internal schema, defining how data is physically stored on the disk. In most modern relational DBMS, this is handled internally by the system rather than a user-facing language.
4. **View Definition Language**: This is a subset of DDL used specifically to define virtual tables (views) that do not store data themselves but provide a way to look at data from one or more tables.
Since the question specifically asks for the language used for retrieval, insertion, deletion, and modification of data, the correct answer is Data Manipulation Language.
To avoid race condition, the number of processes that may be simultaneously inside their critical condition is:
A)
0
B)
1
C)
2
D)
4
A race condition occurs when multiple processes access and manipulate shared data concurrently, and the final outcome depends on the particular order in which the access takes place. To prevent this, the 'Critical Section' problem must be solved. The critical section is the part of the program where shared resources are accessed. To avoid race conditions, the system must ensure 'Mutual Exclusion'. Mutual Exclusion is a property that guarantees that if one process is executing in its critical section, no other process is allowed to execute in its critical section at the same time. Therefore, the maximum number of processes allowed inside their critical section simultaneously must be exactly 1. If 0 processes were inside, no work would be done; if 2 or more were inside, a race condition could occur.
Which of the following plays a major role in order to deliver a message to the correct application program running on a host?
A)
Port
B)
IP
C)
physical
D)
tunnel
To understand why 'Port' is the correct answer, we must look at the layers of the TCP/IP networking model:
1. **IP (Internet Protocol) Address**: The IP address is used to identify a specific device (host) on a network. It ensures that a packet reaches the correct physical or virtual machine, but it does not know which specific software or service on that machine should receive the data.
2. **Port Number**: Once a packet arrives at the correct host (via the IP address), the operating system looks at the 'Port Number' in the Transport Layer header (TCP or UDP). A port is a logical construct that identifies a specific process or application running on the host. For example, HTTP traffic typically goes to port 80, and HTTPS to port 443. Therefore, the port is what delivers the message to the correct application program.
3. **Physical**: This refers to the Physical Layer (Layer 1), which deals with the actual hardware, cables, and bit-stream transmission. It cannot distinguish between different applications.
4. **Tunnel**: Tunneling is a method of transporting an encapsulated protocol across a network (e.g., VPNs). It is a mechanism for connectivity, not a mechanism for application-level delivery on a host.
Conclusion: While the IP address gets the data to the 'house' (the host), the Port number gets the data to the 'person' (the application) inside that house.
How can you make a bulleted list?
A)
<list>
B)
<nl>
C)
<ul>
D)
<ol>
In HTML (HyperText Markup Language), lists are used to group a set of related items. There are two primary types of lists:
1. **Unordered List (<ul>):** This tag is used to create a bulleted list. The items are not numbered, and by default, they are marked with small black circles (bullets).
2. **Ordered List (<ol>):** This tag is used to create a numbered list (1, 2, 3... or a, b, c...), where the sequence of items is important.
Analysis of options:
- **a. <list>**: This is not a valid HTML tag.
- **b. <nl>**: This is not a valid HTML tag.
- **c. <ul>**: Correct. It stands for 'Unordered List' and produces a bulleted list.
- **d. <ol>**: Incorrect. It stands for 'Ordered List' and produces a numbered list.
Program ‘preemption’ is
A)
forced de allocation of the CPU from a program which is executing on the CPU.
B)
release of CPU by the program after completing its task.
C)
forced allotment of CPU by a program to itself.
D)
a program terminating itself due to detection of an error.
In Operating Systems, 'preemption' refers to the act of temporarily interrupting a task being carried out by a processor, without its cooperation, and with the intention of resuming the task at a later time.
1. **Why Option (a) is correct**: Preemptive scheduling allows the OS kernel to forcibly remove a running process from the CPU (de-allocation) to allocate the CPU to another process (usually one with higher priority or based on a time slice/quantum). This is a 'forced' action taken by the scheduler.
2. **Why Option (b) is incorrect**: This describes 'Non-preemptive' or 'Cooperative' scheduling, where a process voluntarily yields the CPU only after it finishes its execution or enters a waiting state.
3. **Why Option (c) is incorrect**: A program cannot 'force' the CPU to allot itself; the CPU allocation is managed exclusively by the Operating System's scheduler to ensure system stability and fairness.
4. **Why Option (d) is incorrect**: This describes a 'crash' or 'abnormal termination' due to a runtime error (like a segmentation fault), which is unrelated to the scheduling mechanism of preemption.
.................. is simply the use of electronic means to transfer funds directly from one account to another, rather than by cheque or cash.
A)
M-Banking
B)
O-Banking
C)
E-Banking
D)
D-Banking
Step-by-step reasoning:
1. Analysis of the definition: The question describes the process of transferring funds electronically from one account to another, bypassing traditional physical methods like cash or paper cheques. This is the fundamental definition of Electronic Banking.
2. Evaluating Option (c) E-Banking: 'E-Banking' (Electronic Banking) is an umbrella term that encompasses all banking transactions conducted via electronic platforms (internet, ATMs, etc.). It specifically allows for the direct transfer of funds (Electronic Funds Transfer - EFT) between accounts.
3. Evaluating Option (a) M-Banking: 'M-Banking' (Mobile Banking) is a subset of E-Banking. While it allows fund transfers, it is specifically limited to mobile devices. The definition provided in the question is more general and describes the broader concept of electronic banking.
4. Evaluating Options (b) and (d): 'O-Banking' and 'D-Banking' are not standard industry terms used to describe the electronic transfer of funds in the context of E-Commerce or Finance.
5. Conclusion: Since the description refers to the general use of electronic means for fund transfers, E-Banking is the most accurate and comprehensive term.
Which of the following address use 7 bits for the <network> and 24 bits for the <host> portion of the IP address.
A)
Class A
B)
Class B
C)
Class C
D)
Class D
In IPv4 classful addressing, the address space is divided into five classes (A, B, C, D, and E). The class is determined by the leading bits of the first octet:
1. **Class A**: The first bit is always '0'. This leaves 7 bits for the network portion (totaling 8 bits for the first octet) and 24 bits for the host portion (the remaining three octets). This allows for a small number of networks (128) but a very large number of hosts per network (2^24 - 2).
2. **Class B**: The first two bits are always '10'. This uses 14 bits for the network and 16 bits for the host.
3. **Class C**: The first three bits are always '110'. This uses 24 bits for the network and 8 bits for the host.
4. **Class D**: The first four bits are '1110'. This class is reserved for Multicasting and does not have a traditional network/host division.
Since the question specifies 7 bits for the network (excluding the identifying leading bit) and 24 bits for the host, it refers to Class A.
If timestamp (TS) TS(Ti)<TS(Tj), then (Ti older than Tj) Ti is allowed to wait; otherwise (Ti younger than Tj) abort Ti (Ti dies) and restart it later with the same timestamp. The rules mentioned above belong to which scheme.
A)
Wait-die
B)
Wound-wait
C)
Cautious waiting
D)
Wait-for graph
The question describes a deadlock prevention scheme based on timestamps. In DBMS, there are two primary timestamp-based deadlock prevention schemes: Wait-Die and Wound-Wait.
1. **Wait-Die Scheme (Non-preemptive):**
- If $T_i$ requests a lock held by $T_j$:
- If $TS(T_i) < TS(T_j)$ ($T_i$ is older), $T_i$ is allowed to **wait**.
- If $TS(T_i) > TS(T_j)$ ($T_i$ is younger), $T_i$ must **die** (abort and restart).
- This matches the logic provided in the question exactly.
2. **Wound-Wait Scheme (Preemptive):**
- If $T_i$ requests a lock held by $T_j$:
- If $TS(T_i) < TS(T_j)$ ($T_i$ is older), $T_i$ **wounds** $T_j$ (forces $T_j$ to abort).
- If $TS(T_i) > TS(T_j)$ ($T_i$ is younger), $T_i$ is allowed to **wait**.
3. **Cautious Waiting:** This is a technique used in distributed systems to avoid phantom deadlocks, not a standard timestamp-based deadlock prevention rule like Wait-Die.
4. **Wait-for Graph:** This is a deadlock **detection** mechanism, not a prevention scheme. It represents transactions as nodes and requests as edges to find cycles.
Since the rule states that the older transaction waits and the younger transaction dies, it is the Wait-Die scheme.
Process is ........................
A)
A program in execution
B)
An instance of a program running on a computer
C)
The entity that can be assigned to and executed
D)
All of these
In Operating Systems, a 'Process' is defined as a program in execution. To understand why all options are correct, we must look at the different perspectives of a process:
1. Option (a) 'A program in execution': This is the classic textbook definition. A program is a passive entity (like a file stored on a disk), whereas a process is an active entity that is currently being executed by the CPU.
2. Option (b) 'An instance of a program running on a computer': This is technically accurate because a single program (e.g., a web browser) can be launched multiple times. Each time it is launched, a new 'instance' or process is created with its own unique Process ID (PID) and memory space.
3. Option (c) 'The entity that can be assigned to and executed': A process is the unit of work in a modern operating system. The OS scheduler assigns CPU time, memory, and resources to this entity to allow it to execute its instructions.
Since all three descriptions accurately define a process from different technical angles, the correct answer is 'All of these'.