DXC Technology Interview Preparation and Recruitment Process

inline void multiplyNums(int x,  int y)
{
   int answer = x * y;
   printf("Product of the two numbers given is: %d", answer);
}

int i = 20;
int j = 40;
multiplyNums(i, j);

int i = 20;
int j = 40;
int answer = i * j;
printf("Product of the two numbers given is: %d", answer);

In SQL, DESC stands for "descending" and is used primarily in the ORDER BY clause to sort the result set in descending order.

* Usage

SELECT * FROM employees
ORDER BY salary DESC;

* This query will return all employees sorted by their salary, from highest to lowest.

* Common Use Cases

1. Sorting numbers from largest to smallest:

   SELECT * FROM products ORDER BY price DESC;
   

2. Sorting dates from newest to oldest:

   SELECT * FROM orders ORDER BY order_date DESC;
   

3. Alphabetical order reversed (Z to A):

   SELECT * FROM customers ORDER BY last_name DESC;
   

* Contrast with ASC:

• ASC = ascending order (default)

• DESC = descending order

In SQL, the LIKE operator is used to perform pattern matching in WHERE clauses.

* Syntax

SELECT * FROM table_name
WHERE column_name LIKE 'pattern';

* Pattern Wildcards

* Examples

1. Find names starting with "A":

   SELECT * FROM employees
   WHERE name LIKE 'A%';
   

2. Find names ending with "son":

   SELECT * FROM employees
   WHERE name LIKE '%son';
   

3. Find names containing "ann":

   SELECT * FROM employees
   WHERE name LIKE '%ann%';
   

4. Find 5-letter names where the second letter is "a":

   SELECT * FROM employees
   WHERE name LIKE '_a___';
   

* Case Sensitivity

• In SQL Server: LIKE is case-insensitive by default.

• In PostgreSQL/MySQL: It may be case-sensitive depending on collation/settings.

For more advanced pattern matching, SQL also supports regular expressions using REGEXP or SIMILAR TO (depending on the database system).

Great question! Let's break it down:

What is DNS (Domain Name System)?

DNS is like the phonebook of the internet. It translates human-readable domain names (like www.google.com) into IP addresses (like 142.250.190.68) that computers use to identify each other on the network.

How Does DNS Work? (Step-by-Step)

Here’s what happens when you type a website into your browser:

1. User types a URL (e.g., www.example.com)

Your browser checks if it already has the IP address cached.

2. Check Local DNS Cache

If the address is in your local system's DNS cache, it’s used immediately.

3. Query Sent to Recursive DNS Resolver

If not cached, your request goes to your ISP's recursive DNS resolver (or a custom one like Google's 8.8.8.8).

4. Resolver contacts Root DNS Server

The resolver asks a Root DNS server:

“Where can I find .com domains?”

The root server responds with the address of a Top-Level Domain (TLD) server for .com.

5. Resolver contacts TLD DNS Server

Next, the resolver asks the .com TLD server:

“Where is example.com?”

The TLD server responds with the address of the Authoritative DNS server for example.com.

6. Resolver contacts Authoritative DNS Server

The resolver then asks:

“What’s the IP for www.example.com?”

The Authoritative DNS server responds with the actual IP address.

7. Return IP to Browser

The IP is passed back through the resolver to your browser, which then connects to the website's server using that IP.

8. Website Loads

Your browser now knows where to go, and the page begins loading.

Summary :

What are Scheduling Algorithms?

Scheduling algorithms are methods used by operating systems to decide the order in which processes are executed on the CPU. Since the CPU can only handle one process at a time (in a single-core system), the OS must schedule multiple processes in a fair and efficient way.

These algorithms are crucial in managing:

• CPU utilization

• Throughput

• Waiting time

• Response time

• Fairness

Types of Scheduling Algorithms (Briefly)

1. FCFS (First-Come, First-Served)

2. SJF (Shortest Job First)

3. Round Robin

4. Priority Scheduling

5. Multilevel Queue Scheduling

6. Multilevel Feedback Queue

FCFS (First-Come, First-Served) Scheduling

Definition :

FCFS is the simplest scheduling algorithm. The process that arrives first gets executed first, just like standing in a queue.

How FCFS Works :

• The CPU keeps a queue of processes.

• Each process is executed to completion in the order of arrival.

• Non-preemptive: Once a process starts running, it cannot be interrupted.

Example :

Execution Order: P1 → P2 → P3

Gantt Chart :

| P1 |     P2     |       P3       |
0    5           8                16

Key Metrics :

• Waiting Time (WT) = Time spent waiting in the queue

• Turnaround Time (TAT) = Completion Time – Arrival Time

Advantages of FCFS :

• Simple to understand and implement.

• Fair in the sense that each process gets a turn.

Disadvantages :

• Convoy effect: A long process can delay all others.

• Not optimal in terms of average waiting time.

• No consideration for priority or burst time.

Great question! Real-Time Operating Systems (RTOS) are specialized OSes designed to run applications with precise timing and high reliability. They're often used in embedded systems, robotics, automotive systems, medical devices, and industrial automation.

What is an RTOS?

An RTOS ensures that critical tasks are executed within a predictable time frame. The key feature is determinism—knowing that something will happen at the exact time it's supposed to.

Types of Real-Time Operating Systems

There are three main types of RTOS based on how they handle tasks and timing:

1. Hard Real-Time Systems :

• Strict timing constraints: Missing a deadline is considered a system failure.

• Used in critical systems like:

  • Pacemakers

  • Flight control systems

  • Nuclear plant control

* Pros: Highly reliable
* Cons: Expensive and complex to design

2. Soft Real-Time Systems :

• Deadlines are important but not absolutely mandatory.

• Occasional deadline misses are tolerated, but performance should degrade gracefully.

• Used in:

  • Online video streaming

  • VoIP

  • Multimedia systems

* Pros: Easier to develop, more flexible
* Cons: Not suitable for mission-critical applications

3. Firm Real-Time Systems :

• Similar to soft real-time, but missing a deadline renders the result useless (though the system won’t crash).

• Missed deadlines are not catastrophic, but are not acceptable either.

• Used in:

  • Industrial automation

  • Control systems where occasional failures can be tolerated

* Pros: Balance between strictness and practicality
* Cons: Harder to balance scheduling and load

Comparison Table :

Servlet collaboration is an important concept in Java-based web applications, especially when multiple servlets need to work together to process a single client request or share data. It’s all about enabling communication between servlets to build modular, maintainable, and efficient web applications.

What is Servlet Collaboration?

Servlet collaboration refers to interaction between two or more servlets in a web application. It allows servlets to:

• Share data

• Forward requests

• Include responses

Why is it Useful?

• Promotes modularity (each servlet handles a specific task)

• Improves code reuse

• Helps in building layered architectures (e.g., input validation, processing, and display handled by separate servlets)

Techniques for Servlet Collaboration

1. Request Dispatching

Uses the RequestDispatcher interface to:

• forward(): Transfers control to another servlet or JSP

• include(): Includes output of another resource in the response

RequestDispatcher rd = request.getRequestDispatcher("SecondServlet");
rd.forward(request, response);  // or rd.include(request, response);

2. Using Shared Data (Request/Session/Application scope)

• Request scope: For short-lived data (current request only)

• Session scope: For user-specific data across multiple requests

• Application scope: For global data shared by all servlets

request.setAttribute("name", "Alice");

Then another servlet can access:

String name = (String) request.getAttribute("name");

Advantages :

• Cleaner separation of concerns

• Easier maintenance and testing

• Promotes reusability of servlet logic

Potential Downsides

• Over-collaboration can lead to tight coupling

• Requires good design discipline to avoid spaghetti-like dependencies