SDET-Intern

Create two arrays:

left[i] = product of all elements to the left of index i.

right[i] = product of all elements to the right of index i.

Calculate left array:

Start with left[0] = 1 (no elements to the left).

Then for each i, left[i] = left[i-1] * nums[i-1].

Calculate right array:

Start with right[n-1] = 1 (no elements to the right).

Then for each i from n-2 to 0, right[i] = right[i+1] * nums[i+1].

Final Answer: 

For each index i, answer[i] = left[i] * right[i].

The first missing positive must be in the range [1, len(nums)+1].

Use the array itself to mark numbers present (mark nums[i] index negative).

Scan the array: the first positive index + 1 is the missing number.

Step 1: Normalize the string.

Remove all non-alphanumeric characters.

Convert all characters to lowercase.

Step 2: Use two pointers.

Start one pointer at the beginning (left) and one at the end (right) of the string.

Compare characters at left and right.

If they are different, return false.

Move left forward and right backward.

Repeat until they meet.

Step 3: If the loop completes without mismatches, return true.

Step 1: Understand the property- Since the array is sorted, we can use binary search to minimize time complexity to O(log n).

Step 2: Initialize two pointers

left = 0 (start of the array)

right = len(nums) - 1 (end of the array)

Step 3: Loop until pointers meet

While left <= right:

Find the middle index: mid = (left + right) // 2

Compare nums[mid] with target

If nums[mid] == target, return mid

If nums[mid] < target, move left = mid + 1

If nums[mid] > target, move right = mid - 1

Step 1: Understand Merge Sort
Merge Sort is a Divide and Conquer algorithm.

Divide: Split the array into two halves recursively until each subarray has one element.

Conquer: Merge the sorted subarrays back together.

Step 2: Base Condition
If the array has 0 or 1 element, it is already sorted → return it.

Step 3: Recursive Splitting

Find the middle index: mid = len(nums) // 2

Recursively call merge sort on left half nums[:mid] and right half nums[mid:].

Step 4: Merge Two Sorted Halves

Compare elements from both halves one by one.

Place the smaller element into a new array.

Merge until all elements are sorted.