Ministry of Power, Energy and Mineral Resources
Post: Assistant Maintenance Engineer;
Exam Date: 30 May, 2025 Exam Taker: BPSC
The minimum spanning tree value is: 410+612+310+200=1532
Heap Sort is a comparison-based sorting algorithm that uses a binary heap data structure.
It first builds a heap (usually a Max Heap) from the input data, and then repeatedly
removes the largest element from the heap and rebuilds the heap until the list is sorted.
Steps of Heap Sort:
1. Build a Max Heap from the given data.
2. Swap the root (largest element) with the last element.
3. Reduce the heap size by one.
4. Heapify the root again.
5. Repeat until the heap size becomes 1.
Build a Max Heap from the list:
[44, 30, 50, 22, 60, 55, 70, 55]
Step 1: Insert elements and adjust to maintain Max Heap property.
Final Max Heap (array form):
[70, 60, 55, 55, 30, 50, 44, 22]
Heap Tree Representation:
70
/ \
60 55
/ \ / \
55 30 50 44
/
22
1234
234
34
4
#include<stdio.h>
#include <string.h>
int main() {
char num[50];
printf("Enter an integer: ");
scanf("%s", num);
int len = strlen(num);
for(int i = 0; i < len; i++) {
// print spaces
for(int s = 0; s < i; s++) {
printf(" ");
}
// print remaining digits
for(int j = i; j < len; j++) {
printf("%c", num[j]);
}
printf("\n");
}
return 0;
}
Sample Input: Enter an integer: 1234 Sample Output: 1234 234 34 4
A friend function is a function that is not a member of a class but is allowed to access the private and protected members of the class. It is declared inside the class using the friend keyword.
Friend Function on given Class:
#include <iostream>
using namespace std;
class myclass {
int num;
public:
myclass(int i) {
num = i;
}
// friend function declaration
friend bool isneg(myclass obj);
};
// friend function definition
bool isneg(myclass obj) {
if (obj.num < 0)
return true;
else
return false;
}
int main() {
myclass a(-10);
if (isneg(a))
cout << "Number is negative";
else
cout << "Number is positive";
return 0;
}
(i) Supervised learning
True Positive (TP) = 560
True Negative (TN) = 330
False Positive (FP) = 60
False Negative (FN) = 50
Calculate the following:
(i) Accuracy (ii) Precision (iii) Recall (iv) F1 Score
Given:
TP = 560
TN = 330
FP = 60
FN = 50
(i) Accuracy
Accuracy = (TP + TN) / (TP + TN + FP + FN)
= (560 + 330) / (560 + 330 + 60 + 50)
= 890 / 1000
= 0.89 (89%)
(ii) Precision
Precision = TP / (TP + FP)
= 560 / (560 + 60)
= 560 / 620
= 0.9032 (≈ 90.32%)
(iii) Recall
Recall = TP / (TP + FN)
= 560 / (560 + 50)
= 560 / 610
= 0.9180 (≈ 91.80%)
(iv) F1 Score
F1 Score = 2 × (Precision × Recall) / (Precision + Recall)
= 2 × (0.9032 × 0.9180) / (0.9032 + 0.9180)
= 2 × (0.8290) / 1.8212
= 0.910 (≈ 91.0%)
Final Results:
Accuracy = 89%
Precision = 90.32%
Recall = 91.80%
F1 Score = 91.0%
Determine the following for each subnet:
(i) Total number of IP addresses
(ii) Range of usable IP addresses
(iii) Network address
(iv) Direct broadcast address
(v) Limited broadcast address.
Given: Network = 200.1.2.0/24, required subnets = 3
Step 1: Find new subnet mask
To create at least 3 subnets from a /24 network, we borrow 2 bits from the host part.
New subnet mask = /26
This gives 22 = 4 subnets, which is enough for 3 subnets.
Step 2: Addresses per subnet
A /26 subnet has 32 – 26 = 6 host bits.
So, total IP addresses per subnet = 26 = 64
Usable IP addresses per subnet = 64 – 2 = 62
Subnet details
6. (a) Consider a computer system with the following specifications: 2+2=4 Physical memory (RAM): 4 GB, Page size: 4 KB, Virtual address space: 32 bit Page table entry size: 8 bytes, Answer the following:
Number of pages in the virtual address space
Virtual address space for a 32-bit system: 232 bytes
Page size: 4 KB = 212 bytes
Number of pages = Virtual address space / Page size
= 232 / 212
= 220
= 1,048,576 pages
Size of the page table
Number of pages = 220
Page table entry size = 8 bytes = 23 bytes
Page table size:
= Number of pages × Size of each entry
= 220 × 23
= 223 bytes
= 8 MB
