Convert Subnet Mask to Binary: The subnet mask 255.255.255.240 can be written in binary as:

11111111.11111111.11111111.11110000

Determine the Number of Hosts: The number of host bits is 4, so we use the formula: 2⁴ – 2 =14

Therefore, there are 14 valid hosts in this subnet.

Calculate the Network Address: Perform a bitwise AND between the IP address and subnet mask:

IP Address (192.168.1.50): 11000000.10101000.00000001.00110010

Subnet Mask (255.255.255.240): 11111111.11111111.11111111.11110000

The result is the network address in binary:

11000000.10101000.00000001.00110000

When converted back to decimal, the network address is: 192.168.1.48

Calculate the Broadcast Address: The broadcast address is obtained by setting all host bits to 1 in the network address:

• Network Address: 11000000.10101000.00000001.00110000
• Host bits set to 1: 11000000.10101000.00000001.00111111

The result is the broadcast address: 192.168.1.63

Determine the Valid Host Range: The valid host range is the IP addresses between the network address and the broadcast address, excluding those two addresses:

• The first valid host is 192.168.1.49 (Network Address + 1).
• The last valid host is 192.168.1.62 (Broadcast Address – 1).

• Network Address: 192.168.1.48
• Broadcast Address: 192.168.1.63
• Valid Host Range: 192.168.1.49 to 192.168.1.62
• Number of Hosts: 14

SELECT e.first name, d.dept_name
FROM employees e
JOIN department d ON e.dept_id = d.dept_id
ORDER BY e.salary DESC
LIMIT 1;

#include <stdio.h>

int main() {
int rows;

printf("Enter number of rows: ");
scanf("%d", &rows);

int maxWidth = 2 * rows - 1;

for (int i = 0; i < rows; i++) {
int numbers = 2 * i + 1;
int spaces = (maxWidth - numbers) / 2;

// print leading spaces
for (int s = 0; s < spaces; s++) {
printf(" ");
}

// print 0 and 1 pattern
for (int j = 0; j < numbers; j++) {
printf("%d", j % 2);
}

printf("\n");
}

return 0;
}

    Sample I/O:
Enter number of rows: 5
    0
   010
  01010
 0101010
010101010

=== Code Execution Successful ===

        

Merge Sort Example: Sorting Array [11, 6, 3, 24, 46, 22, 7]

Step 1: Initial Array

A = [11, 6, 3, 24, 46, 22, 7]

Step 2: Divide the Array

We divide the array into two halves:

A1 = [11, 6, 3, 24] and A2 = [46, 22, 7]

Step 3: Recursively Divide Each Half

For A1 = [11, 6, 3, 24], we divide it into:

A1.1 = [11, 6] and A1.2 = [3, 24]

For A1.1 = [11, 6], divide it into:

A1.1.1 = [11] and A1.1.2 = [6]

For A1.2 = [3, 24], divide it into:

A1.2.1 = [3] and A1.2.2 = [24]

For A2 = [46, 22, 7], we divide it into:

A2.1 = [46, 22] and A2.2 = [7]

For A2.1 = [46, 22], divide it into:

A2.1.1 = [46] and A2.1.2 = [22]

Step 4: Merge Subarrays

Now, we begin merging the subarrays:

Merge [11] and [6] → [6, 11]

Merge [3] and [24] → [3, 24]

Merge [46] and [22] → [22, 46]

Merge [22, 46] and [7] → [7, 22, 46]

Step 5: Final Merge

Finally, merge the two sorted halves:

[6, 11, 3, 24] and [7, 22, 46]

After merging, the sorted array is:

[3, 6, 7, 11, 22, 24, 46]

Time Complexity

Best Case Time Complexity: O(n log n)

Worst Case Time Complexity: O(n log n)

To design a 6-to-1 multiplexer (MUX) using 2-to-1 multiplexers, we can break it down into smaller parts. A 6-to-1 MUX has 6 data inputs, 1 output, and 3 selection bits (since 2^3 = 8 and we need 3 bits to select one of the 6 inputs). A 2-to-1 MUX has 2 inputs, 1 output, and 1 selection bit.