SDE - 1

Initialize three pointers: previous (initialized as None), current (initialized as the head of the linked list), and next_node (initialized as None).
Iterate through the linked list while the current pointer is not None:
a. Store the next node of the current node in the next_node pointer.
b. Point the next reference of the current node to the previous node.
c. Move the previous pointer to the current node.
d. Move the current pointer to the next node (stored in next_node).
After the iteration, update the head of the linked list to the current node (which is the last node of the original list).
Return the new head of the reversed linked list.

Initialize two variables, largest and second_largest, both set to negative infinity.
Iterate through the array:
a. If the current element is greater than the largest value, update second_largest to hold the previous value of largest, and update largest with the current element.
b. If the current element is greater than the second_largest value but smaller than largest, update second_largest with the current element.
After iterating through the array, the second_largest variable will hold the second largest element.
Return the value of second_largest.

Let's label the four people as A, B, C, and D, with their respective crossing times: 1 minute, 2 minutes, 5 minutes, and 10 minutes.

To minimize the time, we need to pair the two fastest people (A and B) to cross the bridge together first. They take 2 minutes to cross (as B is slower).

After A and B cross, A will return with the torch, which takes 1 minute.

Now, the two slowest people (C and D) need to cross the bridge. D is the slowest, so both C and D will take 10 minutes to cross.

Finally, B (who has already crossed) needs to go back to get the torch. This takes 2 minutes.

The total time taken for all four people to cross the bridge is 2 + 1 + 10 + 2 = 15 minutes.

Create an empty set to keep track of visited numbers.
Iterate through the array:
a. Check if the current number is already in the set. If it is, return the current number as the duplicate.
b. If the current number is not in the set, add it to the set.
If no duplicate is found, return -1 or any appropriate value to indicate the absence of a duplicate.

Remove any spaces, punctuation, and convert the string to lowercase to ignore case sensitivity.
Initialize two pointers, left and right, pointing to the start and end of the string, respectively.
Iterate until the left pointer is less than the right pointer:
a. Compare the characters at the left and right pointers.
b. If they are not equal, return False as it is not a palindrome.
c. Move the left pointer one step forward and the right pointer one step backward.
If the loop completes without any mismatched characters, return True as it is a palindrome.

Definition: Virtual memory is a memory management technique used by operating systems to provide an illusion of a larger memory space than physically available in the system. It allows programs to operate as if they have access to a large contiguous memory space, even if the physical memory is limited.

Virtual Address Space: The virtual memory is divided into a virtual address space, which is typically larger than the physical memory. Each process has its own virtual address space, which is divided into fixed-sized pages.

Paging: The virtual memory is implemented using a technique called paging. The virtual address space is divided into fixed-sized pages, and the physical memory is divided into fixed-sized page frames. The pages of the virtual address space are mapped to the page frames of the physical memory.

Definition: Normalization is a process in database design that organizes tables and their attributes to reduce data redundancy and dependency. It ensures that the database is structured efficiently, minimizes data anomalies, and improves data integrity.

Purpose of Normalization: The main purpose of normalization is to eliminate data redundancy and prevent inconsistencies, anomalies, and update anomalies that can occur when data is duplicated across multiple tables.

Normal Forms: Normalization is typically achieved through a series of normal forms, each building on the previous one.