SDE - 1

Convert both strings to lowercase or uppercase to ensure case insensitivity. Remove all whitespace and punctuation marks from both strings using regular expressions. Convert both strings to arrays of characters. Sort both arrays of characters in ascending order. Compare both arrays of characters. If they are equal, the original strings are anagrams of each other; otherwise, they are not.

Create a new node with the given data.

Check if the doubly linked list is empty:
a. If it is empty, set the new node as both the head and the tail of the list.
b. If it is not empty, proceed to the next step.

Set the next pointer of the new node to the current head of the list.

Set the prev pointer of the current head, if it exists, to the new node.

Set the new node as the new head of the list.

Create a function to traverse the binary tree recursively.

If the current node is None (indicating an empty subtree), return 0.

If both the left and right child nodes of the current node are None (indicating a leaf node), return 1.

Recursively traverse the left and right subtrees of the current node.

Sum up the leaf node counts obtained from the left and right subtrees and return the total count.

Create a function to invert the binary tree recursively.

If the current node is None (indicating an empty subtree), return None.

Swap the left and right child nodes of the current node.

Recursively invert the left and right subtrees of the current node.

Return the updated current node.

Create a function to validate the binary tree recursively.

Define a helper function that takes the current node, a lower bound, and an upper bound as parameters. This function will recursively validate each node's value against the bounds.

If the current node is None (indicating an empty subtree), return True as the empty subtree is considered valid.

If the current node's value is outside the lower or upper bounds, return False as it violates the BST property.

Recursively validate the left subtree, passing the updated upper bound as the current node's value and the lower bound unchanged.

Recursively validate the right subtree, passing the updated lower bound as the current node's value and the upper bound unchanged.

If both the left and right subtrees are valid (i.e., return True for both recursive calls), return True for the current node.

Initialize a semaphore variable, semaphore, with the maximum number of threads that can access the shared resource simultaneously.

When a thread wants to access the shared resource, it must acquire the semaphore. If the semaphore value is greater than 0, decrement the semaphore value by 1 and allow the thread to access the resource. If the semaphore value is 0, the thread must wait until it can acquire the semaphore. When a thread finishes accessing the shared resource, it must release the semaphore by incrementing the semaphore value by 1 to allow another waiting thread to acquire the resource.

Analyze the query execution plan:

• Check if the query is utilizing appropriate indexes on the relevant columns.
• Identify any full table scans or inefficient join operations that can be optimized.

Review the query conditions and filters:

• Ensure that the query conditions are selective enough to reduce the number of rows being processed.
• Consider adding additional indexes on the columns used in the query conditions to improve filtering.

Optimize table join operations:

• Check if the join conditions can be simplified or rewritten to reduce the number of comparisons.
• Determine if using a different join algorithm (e.g., hash join or nested loop join) can improve performance.

Consider query rewriting or subquery optimization:

• Evaluate if rewriting the query using alternative constructs can improve performance.
• Identify any subqueries within the main query and optimize them individually.