← MES Jr. Grade
Past Questions
What is true about a class and a structure?
A)
A class contains both variables and functions but a structure can contain variables only.
B)
The data items inside a structure are private by default but inside a class pubic by default.
C)
A class and structure are not similar at all.
D)
None of the above
To determine the correct answer, we must analyze the properties of classes and structures, specifically in the context of C++ (where both exist and are most frequently compared in CSE exams):
1. Analysis of Option (a): 'A class contains both variables and functions but a structure can contain variables only.' This is FALSE. In C++, a `struct` is almost identical to a `class`; it can contain both member variables (data members) and member functions (methods).
2. Analysis of Option (b): 'The data items inside a structure are private by default but inside a class public by default.' This is FALSE. It is actually the opposite: in a `struct`, members are **public** by default, whereas in a `class`, members are **private** by default.
3. Analysis of Option (c): 'A class and structure are not similar at all.' This is FALSE. They are very similar; the primary difference is the default access specifier (public for struct, private for class).
Since options (a), (b), and (c) are all technically incorrect, the correct choice is (d) None of the above.
Identify the way to create a dynamic array of pointers (to integers) of size 10 in C++?
A)
int *arr = new int *[10];
B)
int **arr = new int *[10];
C)
int *arr = new int [10];
D)
Not Possible
To create a dynamic array of pointers, we must understand the types involved:
1. The target elements of the array are 'pointers to integers', which have the type `int*`.
2. When we use the `new` operator to allocate an array of a certain type, it returns a pointer to the first element of that array.
3. Therefore, if we allocate an array of `int*`, the return type must be a pointer to an `int*`, which is a double pointer: `int**`.
Breaking down Option (b): `int **arr = new int *[10];`
- `new int *[10]` allocates memory for 10 pointers to integers on the heap.
- `int **arr` declares a pointer to a pointer to an integer, which correctly stores the address of the first element of the allocated array.
Why other options are incorrect:
- Option (a): `int *arr = new int *[10];` is incorrect because it attempts to assign a pointer-to-pointer (`int**`) to a single pointer (`int*`), causing a type mismatch error.
- Option (c): `int *arr = new int [10];` creates a dynamic array of integers, not an array of pointers to integers.
- Option (d): This is possible in C++ using the logic described above.
After invoking the destructor of an object
A)
The members of that object cannot be accessed
B)
The members of that object can be accessed only if the object is const
C)
The members of that object can be accessed without problem
D)
All the previous answers are incorrect
In Object-Oriented Programming (specifically C++), a destructor is a special member function that is called when an object goes out of scope or is explicitly deleted. The primary purpose of the destructor is to release resources (like memory or file handles) that the object acquired during its lifetime. Once the destructor has finished executing, the object's lifetime officially ends, and the memory it occupied is considered 'deallocated' or 'invalid'. Attempting to access the members of an object after its destructor has been invoked results in 'Undefined Behavior' (UB). In a logical and architectural sense, the object no longer exists; therefore, its members cannot be accessed.
- Option (b) is incorrect because 'const' qualifiers affect whether a member can be modified, not whether the object exists in memory.
- Option (c) is incorrect because accessing a destroyed object leads to memory corruption or segmentation faults.
- Option (d) is incorrect because option (a) is the logically correct answer in the context of object lifecycles.
What will be output if you will execute following c code? int main(){ char arr[20]="MysticRiver"; cout<<sizeof(arr); return 0; }
A)
20
B)
11
C)
12
D)
22
1. The code declares a character array `arr` with a fixed size of 20: `char arr[20]`.
2. The array is initialized with the string "MysticRiver". While the string "MysticRiver" contains 11 characters (including the null terminator '\0'), the size of the array is explicitly defined as 20.
3. The `sizeof` operator in C++ returns the total size of the object in bytes.
4. Since `arr` is an array of 20 characters and the size of a `char` is always 1 byte, `sizeof(arr)` evaluates to 20 * 1 = 20.
5. Option (b) 11 would be the result of `strlen(arr)`, which counts characters until the null terminator, but not the total allocated size of the array.
6. Options (c) and (d) are mathematically unrelated to the array declaration.
Which key do you need to press in order to access the system boot menu?
A)
F4
B)
F7
C)
F8
D)
F5
In the context of traditional PC hardware and legacy BIOS/Windows environments (which are typically the basis for these technical competitive exams), the F8 key is the standard key used to access the Advanced Boot Options menu (Safe Mode, Last Known Good Configuration, etc.) during the system startup process. While modern UEFI systems and Windows 10/11 have moved toward software-based recovery menus, F8 remains the textbook answer for 'system boot menu' in computer hardware fundamentals.
Breakdown of other options:
- F4: Generally used for application-specific shortcuts or system recovery in some specific OEM brands, but not a universal boot menu key.
- F7: Often used for 'Advanced Startup' in some specific laptop brands or for spell-check in software, but not the standard boot menu key.
- F5: Often used for refreshing pages or specific diagnostic tools in some BIOS versions, but not the primary boot menu key.
What is the output of the below program? #include<iostream> using namespace std; int main() { enum {red, blue=5, GREEN}; cout<<red<<“ “<<GREEN; }
A)
0 3
B)
0 8
C)
0 6
D)
0 2
In C++, an enumeration (enum) assigns integer constants to names. The rules for assignment are as follows:
1. If the first element of an enum is not explicitly initialized, it is assigned the value 0. Therefore, 'red' = 0.
2. If an element is explicitly initialized, it takes that specific value. Therefore, 'blue' = 5.
3. If an element follows another element and is not explicitly initialized, it is assigned the value of the previous element plus one. Therefore, 'GREEN' = blue + 1 = 5 + 1 = 6.
The program outputs 'red' and 'GREEN', which results in '0 6'.
Comparing with options:
- Option a (0 3) is incorrect because it assumes GREEN is the 3rd element (index 2) without considering the explicit value of blue.
- Option b (0 8) is incorrect as there is no logic leading to 8.
- Option d (0 2) is incorrect as it assumes a simple 0, 1, 2 sequence.
What does an operating system do
A)
An interface that regulates hardware and software programs
B)
A hardware device
C)
A program that operates the hardware devices
D)
A program that operates the software devices
An Operating System (OS) is a system software that acts as an intermediary or interface between the computer user/application software and the computer hardware. Its primary roles include resource management (CPU, memory, I/O devices) and providing a platform for application software to run.
Analysis of options:
- Option (a) is correct because the OS regulates how software programs access hardware resources, ensuring efficiency and preventing conflicts.
- Option (b) is incorrect because an OS is software, not a physical hardware device.
- Option (c) is partially true in a narrow sense, but 'operates the hardware devices' is an incomplete description; the OS manages them rather than just 'operating' them, and it must also manage software.
- Option (d) is incorrect because 'software devices' is a technically inaccurate term; software consists of programs and data, not 'devices'.
In C++, what is the default return value of the functions?
A)
float
B)
int
C)
char
D)
void
In early versions of C (K&R C) and inherited by some legacy C++ contexts, if a function's return type was not explicitly specified, the compiler would assume by default that the function returned an 'int'. However, it is important to note that in modern C++ (standardized since C++98 and onwards), this 'implicit int' rule was removed. Every function must have an explicitly declared return type. Despite this change in the modern standard, in the context of technical competitive examinations based on classic C/C++ fundamentals, 'int' is the recognized answer for the historical default return type.
- Option (a) float: Never a default return type.
- Option (c) char: Never a default return type.
- Option (d) void: This must be explicitly declared to indicate the function returns nothing; it is not a default.
The shape of the Bezier curve is controlled by.
A)
Control points
B)
Knots
C)
End points
D)
All of the mentioned
A Bézier curve is a parametric curve used in computer graphics that is defined by a set of control points. The shape of the curve is determined by these points: the curve starts at the first control point, ends at the last control point, and is 'pulled' toward the intermediate control points without necessarily passing through them.
Why other options are incorrect:
- b. Knots: Knots are used in B-Splines and NURBS (Non-Uniform Rational B-Splines) to determine where the control points influence the curve, but they are not a feature of standard Bézier curves.
- c. End points: While the end points are technically a subset of the control points (the first and last ones), they only define the start and end of the curve, not its overall shape or curvature.
- d. All of the mentioned: Since knots are not applicable to Bézier curves, this option is incorrect.
Which of the following are the states of process model? (i) Running (ii) Ready (iii) New (iv) Exit (v) Destroy
A)
i, ii, iii and v only
B)
i, ii, iv and v only
C)
i, ii, iii, and iv only
D)
i, ii, iii, iv and v
In Operating Systems, the Process State Model (specifically the 5-state process model) describes the lifecycle of a process. The standard states are:
1. New: The process is being created.
2. Ready: The process is waiting to be assigned to a processor.
3. Running: Instructions are being executed.
4. Waiting/Blocked: The process is waiting for some event to occur (such as I/O completion).
5. Terminated/Exit: The process has finished execution.
Analyzing the given list:
(i) Running - Valid state.
(ii) Ready - Valid state.
(iii) New - Valid state.
(iv) Exit - Valid state (also known as Terminated).
(v) Destroy - Not a standard process state. 'Destroy' is an action or a result of termination, but it is not a state in the process state transition diagram.
Therefore, states (i), (ii), (iii), and (iv) are correct, making option 'c' the right choice.
In normalization transformation for window to viewport, window is lower left corner (1,1) and upper right corner at (3,5) to a view point with lower left corner at (0,0) and upper right corner at(1,1). Find out the Scaling factor (Sx, Sy)
A)
0.5,0.5
B)
0.25,0.5
C)
0.25,0.25
D)
0.5,0.25
Based on established principles in Computer Science & Engineering, the correct and most appropriate choice is '0.25,0.25' (Option C).
Predict the output of following program. #include <iostream> using namespace std; class A { protected: int x; public: A() {x = 0;} friend void show(); }; class B: public A { public: B() : y (0) {} private: int y; }; void show() { A a; B b; cout << “The default value of A::x = “ << a.x << “ “; cout << “The default value of B::y = “ << b.y; }
A)
Compiler Error in show() because x is protected in class A
B)
Compiler Error in show() because y is private in class b
C)
The default value of A::x = 0 The default value of B::y = 0
D)
Compiler Dependent
Let's analyze the code step-by-step:
1. **Class A**: It has a protected member `x`. It declares `friend void show();`. This means the function `show()` has permission to access all members of class A, including the protected member `x`.
2. **Class B**: It inherits from class A. It has a private member `y`. Crucially, class B does NOT declare `show()` as a friend function.
3. **Function show()**:
- It creates an object `a` of class A. The line `cout << a.x` is valid because `show()` is a friend of class A.
- It creates an object `b` of class B. The line `cout << b.y` attempts to access the private member `y` of class B.
4. **The Error**: Since `show()` is not a friend of class B, it cannot access the private member `y`. In C++, private members are inaccessible to any function outside the class unless that function is explicitly declared as a friend within that specific class. Therefore, the compiler will throw an error at the line `cout << "The default value of B::y = " << b.y;`.
**Analysis of Options:**
- Option (a) is incorrect because `show()` is a friend of A, so it can access `x`.
- Option (b) is correct because `show()` is not a friend of B, so it cannot access the private member `y`.
- Option (c) is incorrect because the code will not compile.
- Option (d) is incorrect because access modifiers (private/protected) are strictly enforced by the C++ standard across all compliant compilers.
In raster scan display, a special area of memory is dedicated to graphics only. This memory area is called __________ and it hold the set of __________ value for all screen points.
A)
Frame Buffer, Intensity
B)
LUT, Canvas
C)
Canvas, Output
D)
None of the above
In a raster scan display system, the image is represented as a grid of pixels. To store the image data, a dedicated area of memory is used called the 'Frame Buffer' (also known as a refresh buffer). Each memory location in the frame buffer corresponds to a specific pixel on the screen. The value stored at each location represents the 'Intensity' (or color) of that pixel. During the refresh cycle, the display controller reads these intensity values from the frame buffer and converts them into electrical signals to control the electron beam (in CRTs) or light emission (in LCDs/LEDs) to produce the image on the screen.
Why other options are incorrect:
- Option b: LUT (Look-Up Table) is used for color mapping (indexing), but it is not the primary memory area that holds the set of values for all screen points; the frame buffer is. 'Canvas' is a conceptual drawing area, not a memory structure.
- Option c: 'Canvas' is a software abstraction, and 'Output' is a general term, not a specific memory value type.
Which of the following is not a type of constructor?
A)
Copy constructor
B)
Friend constructor
C)
Default constructor
D)
Parameterized constructor
In Object-Oriented Programming (specifically in C++), a constructor is a special member function that is automatically called when an object of a class is created.
1. **Default Constructor (Option c):** A constructor that accepts no arguments. If no constructor is defined, the compiler provides one automatically.
2. **Parameterized Constructor (Option d):** A constructor that accepts arguments to initialize an object with specific values.
3. **Copy Constructor (Option a):** A constructor used to create a new object as a copy of an existing object of the same class.
**Why 'Friend constructor' is incorrect:** In C++, a 'friend' is a keyword used to grant a non-member function or another class access to the private and protected members of a class. While you can have 'friend functions' or 'friend classes', there is no such concept as a 'friend constructor'. A constructor must be a member of the class it initializes; it cannot be a 'friend' because its primary purpose is to initialize the internal state of the object from within the class scope.
Predict the output? #include <iostream> using namespace std; class Test { int x; Test() { x = 5;} }; int main() { Test *t = new Test; cout << t->x; }
A)
Compiler Error
B)
5
C)
Garbage value
D)
0
The provided C++ code will result in a compiler error due to two primary reasons related to access modifiers:
1. **Private Constructor**: In C++, members of a class (including constructors) are private by default. In the class `Test`, the constructor `Test()` is declared without an access specifier, making it private. In the `main()` function, the statement `new Test` attempts to call this constructor from outside the class. Since the constructor is private, the compiler will throw an error stating that the constructor is inaccessible.
2. **Private Data Member**: The integer variable `x` is also private by default. The statement `cout << t->x;` attempts to access a private member of the class from the `main()` function, which is not permitted in C++ and will trigger another compiler error.
Because the code cannot be compiled, it will never reach the execution stage to print '5', '0', or a 'Garbage value'.
If we want to resize a 1024 × 768 pixels image to one that is 720 pixels wide with the same aspect ratio, what would be the height of the resized image?
A)
420 Pixels
B)
460 Pixels
C)
480 Pixels
D)
540 Pixels
To maintain the aspect ratio of an image during resizing, the ratio of the width to the height must remain constant.
1. **Identify the original dimensions:**
Original Width ($W_1$) = 1024 pixels
Original Height ($H_1$) = 768 pixels
2. **Calculate the Aspect Ratio:**
Aspect Ratio = $W_1 / H_1 = 1024 / 768$
Simplifying the fraction: $1024 / 768 = 4 / 3$ (or approximately 1.333)
3. **Set up the equation for the resized image:**
Let the new width ($W_2$) = 720 pixels
Let the new height be $H_2$
Since the aspect ratio is the same: $W_1 / H_1 = W_2 / H_2$
$1024 / 768 = 720 / H_2$
4. **Solve for $H_2$:**
$H_2 = (720 \times 768) / 1024$
$H_2 = 552960 / 1024$
$H_2 = 540$
Therefore, the height of the resized image is 540 pixels.
Comparing this to the options:
- a. 420 Pixels: Incorrect
- b. 460 Pixels: Incorrect
- c. 480 Pixels: Incorrect
- d. 540 Pixels: Correct
Converting a primitive type data into its corresponding wrapper class object instance is called
A)
Boxing
B)
Wrapping
C)
Instantiation
D)
Autoboxing
In Java and similar object-oriented languages, primitive types (like int, double, boolean) are not objects. To use them in collections (like ArrayList) or with generics, they must be converted into their corresponding wrapper classes (like Integer, Double, Boolean).
1. **Autoboxing**: This is the automatic conversion that the Java compiler makes between the primitive types and their corresponding object wrapper classes. For example, assigning an 'int' to an 'Integer' object is called autoboxing.
2. **Boxing**: While 'boxing' is the general term for converting a primitive to a wrapper, the specific mechanism provided by the language to do this automatically is called 'Autoboxing'. In the context of standard programming exams, 'Autoboxing' is the precise technical term for this process.
3. **Wrapping**: This is a general descriptive term but not a formal programming keyword or operation name for this specific type conversion.
4. **Instantiation**: This refers to the creation of a new instance of a class using the 'new' keyword, which is a broader concept than the specific conversion of a primitive to a wrapper.
Which of the following statements is/are not correct with reference to curve generation? I. Hermite curves are generated using the concepts of interpolation II. Bezier curves are generated using the concepts of approximation III. The Bezier curve lies entirely within the convex hull of its control points IV. The degree of Bezier curve does not depend on the number of control points
A)
I and IV only
B)
II and III only
C)
II and III only
D)
IV only
Let's evaluate each statement based on the principles of Computer Graphics and Curve Generation:
1. **Statement I: Hermite curves are generated using the concepts of interpolation.**
- **Correct.** Hermite curves are interpolating curves because they are guaranteed to pass through their two endpoints. The shape is determined by the positions and the tangents (slopes) at those endpoints.
2. **Statement II: Bezier curves are generated using the concepts of approximation.**n
- **Correct.** Bezier curves are approximating curves. While they interpolate the first and last control points, they do not generally pass through the intermediate control points; instead, the curve is 'pulled' toward them, approximating their positions.
3. **Statement III: The Bezier curve lies entirely within the convex hull of its control points.**
- **Correct.** This is a fundamental property of Bezier curves known as the 'Convex Hull Property.' The curve is always contained within the smallest convex polygon that encloses all its control points.
4. **Statement IV: The degree of Bezier curve does not depend on the number of control points.**
- **Incorrect.** The degree of a Bezier curve is directly dependent on the number of control points. Specifically, if there are $n+1$ control points, the resulting Bezier curve is a polynomial of degree $n$. For example, 3 control points produce a quadratic (degree 2) curve, and 4 control points produce a cubic (degree 3) curve.
Since the question asks for the statement(s) that are **NOT correct**, only Statement IV is incorrect.
A point P(5,1) is rotated by 90 degree about a pivot point (2,2). What is the coordinate of new transformed point P’?
A)
(3,5)
B)
(5,3)
C)
(2,4)
D)
(1,5)
To rotate a point P(x, y) about a pivot point (cx, cy) by an angle θ, we follow these three steps:
1. **Translate the pivot point to the origin**: Subtract the pivot coordinates from the point P.
x' = x - cx = 5 - 2 = 3
y' = y - cy = 1 - 2 = -1
The translated point is (3, -1).
2. **Rotate the point about the origin**: For a 90-degree counter-clockwise rotation, the transformation rule is (x', y') → (-y', x').
New x'' = -(-1) = 1
New y'' = 3
The rotated point is (1, 3).
3. **Translate the pivot point back**: Add the pivot coordinates back to the rotated point.
Final x = x'' + cx = 1 + 2 = 3
Final y = y'' + cy = 3 + 2 = 5
Therefore, the new transformed point P' is (3, 5).
Verification of options:
- Option (a) (3, 5) matches our calculation.
- Option (b) (5, 3) would result from a different rotation or reflection.
- Option (c) (2, 4) is incorrect.
- Option (d) (1, 5) is incorrect.
Which of the following is used to return the number of characters in a string?
A)
size()
B)
length()
C)
length
D)
both (a) & (b)
In C++, the std::string class provides two member functions to determine the number of characters in a string: size() and length().
1. size(): This is a member function inherited from the standard container requirements. It returns the number of characters currently in the string.
2. length(): This is a member function that provides the exact same functionality as size(). It was included in the string class to be more intuitive for those coming from other programming languages where 'length' is the standard term for string size.
Both functions return a value of type size_t and are functionally identical in their implementation and return value.
Option (c) 'length' is incorrect because it lacks the parentheses '()', meaning it refers to a variable or property rather than a member function call, which would result in a compilation error in C++.
Which specific function enables the provision of a communication facility between client programs?
A)
Monolithic kernel
B)
Microkernel
C)
Hybrid Kernels
D)
Nano Kernels
In a Microkernel architecture, the kernel is stripped of all non-essential components. Most OS services (such as file systems, device drivers, and network stacks) are moved out of the kernel space and into the user space as 'server' programs. Because these services now reside in separate address spaces, they cannot communicate via simple function calls. Therefore, the primary and specific function of a Microkernel is to provide a mechanism for Inter-Process Communication (IPC), which enables the communication facility between client programs and these service providers (servers).
Comparison with other options:
- Monolithic kernel (a): All OS services run in the same kernel address space; they communicate via direct function calls rather than a specialized communication facility.
- Hybrid Kernels (c): A combination of both, but the 'specific function' of providing a communication facility as a core architectural requirement is the defining characteristic of the Microkernel approach.
- Nano Kernels (d): Even smaller than microkernels, focusing on basic hardware abstraction, but the standard academic answer for the provision of communication facilities between user-space services is the Microkernel.
Semaphore functions as a __________ and aids in resolving the problem of __________.
A)
integer variable, critical section
B)
atomic, critical section
C)
integer variable, memory error
D)
atomic, memory error
1. Definition of a Semaphore: A semaphore is a synchronization tool introduced by Edsger Dijkstra. Technically, it is an integer variable that is accessed only through two standard atomic operations: wait() (also known as P) and signal() (also known as V).
2. Functionality: The integer value of the semaphore represents the number of available resources. If the value is 1, it acts as a binary semaphore (mutex); if it is greater than 1, it acts as a counting semaphore.
3. Purpose: Semaphores are primarily used to manage concurrent access to a shared resource. The region of code where shared resources are accessed is called the 'Critical Section'. By using semaphores, the OS ensures that only one process (or a limited number of processes) enters the critical section at a time, thereby preventing race conditions.
4. Analysis of Options:
- Option (a) is correct because a semaphore is an integer variable used to resolve critical section problems.
- Option (b) is incorrect because 'atomic' describes the operations performed on the semaphore, not the semaphore itself (which is a variable).
- Options (c) and (d) are incorrect because semaphores are not used to resolve 'memory errors' (which refer to segmentation faults or leaks), but rather synchronization issues.
When was the first operating system built?
A)
1956
B)
1950
C)
1952
D)
1960
The concept of an operating system evolved from simple monitors to complex systems. The first recognized operating system was developed by General Motors (GM) in collaboration with North American Aviation for the IBM 704 mainframe computer. This system, created in 1956, was designed to automate the transition between jobs (batch processing), which previously had to be handled manually by operators. This eliminated the idle time between programs and is widely cited in computer science history as the birth of the first operating system. Options b, c, and d are incorrect as they do not align with the historical development of the GM-NAA I/O system.
Which of the following is true in case of Oblique Projections? I. Parallel projection rays are not perpendicular to the viewing plane. II. Parallel lines in space appear parallel on the final projected image. III. Used exclusively for pictorial purposes rather than formal working drawings. IV. Projectors are always perpendicular to the plane of projection.
A)
I and IV only
B)
I, II and III only
C)
II and III only
D)
IV only
Let's analyze each statement regarding Oblique Projections:
1. **Statement I: Parallel projection rays are not perpendicular to the viewing plane.** This is TRUE. By definition, an oblique projection is a type of parallel projection where the projectors (projection rays) strike the projection plane at an angle other than 90 degrees. If they were perpendicular, it would be an Orthographic projection.
2. **Statement II: Parallel lines in space appear parallel on the final projected image.** This is TRUE. Oblique projection is a subset of Parallel Projection. A fundamental property of all parallel projections is that parallel lines in 3D space remain parallel in the 2D projection.
3. **Statement III: Used exclusively for pictorial purposes rather than formal working drawings.** This is TRUE. Because oblique projections distort the depth (the receding axis is scaled), they are not suitable for precise engineering measurements or formal working drawings (which use Orthographic projections). They are used for quick sketches or pictorial representations (like Cavalier or Cabinet projections).
4. **Statement IV: Projectors are always perpendicular to the plane of projection.** This is FALSE. This is the definition of Orthographic projection. In Oblique projection, projectors are specifically NOT perpendicular to the plane.
Since statements I, II, and III are correct and statement IV is incorrect, the correct option is 'b'.
Which option represents an instance of a Real Time Operating System?
A)
MAC
B)
MS-DOS
C)
Windows 10
D)
Process Control
A Real-Time Operating System (RTOS) is designed to process data and respond to events within a strict, predefined time constraint (deadline).
1. **Option d (Process Control):** In industrial automation and engineering, 'Process Control' systems (such as those used in chemical plants, robotics, or aircraft control) require deterministic behavior where a failure to respond within a specific timeframe could lead to system failure or catastrophe. These are the primary use cases for RTOS.
2. **Option a (MAC):** macOS is a General Purpose Operating System (GPOS) designed for user experience, multitasking, and versatility, not for strict real-time guarantees.
3. **Option b (MS-DOS):** MS-DOS is a single-tasking, command-line operating system. While it is simple, it is not a real-time system designed for deterministic scheduling.
4. **Option c (Windows 10):** Windows 10 is a GPOS. While it can be modified with real-time extensions, the standard version prioritizes throughput and fairness over strict timing deadlines.
Therefore, 'Process Control' is the only option that represents a functional instance/application of a Real-Time Operating System.