Associate Software Developer

Tip 1: Learn JavaScript concepts.

Tip 1: Focus on JS concepts.
Tip 2: Basic JS questions.

Initialize a HashMap:

Create a HashMap called map where each integer in the array nums will be a key, and the value will initially be true (indicating that this number could potentially start a sequence).

Populate the HashMap:

For each integer num in the array nums: Set map[num] = true.

Initialize max for the longest sequence:

Set max to 0. This will keep track of the maximum length of consecutive sequences.

Loop through each key in the HashMap:

For each key key in the HashMap: Check if there’s a number just before key (i.e., key - 1) in the map. If key - 1 exists in the map, mark map[key] as false because key cannot start a new sequence. Otherwise, if key - 1 is not in the map, key is the start of a new sequence.

Count the length of the sequence starting from key:

Initialize len to 1 (since key is the first number in the sequence). While there are consecutive numbers after key (i.e., while the map contains key + len): Increment len by 1.

Update the maximum length:

Update max to be the larger of the current max or the len just calculated.

Return the result:

After all keys are processed, return max, which represents the length of the longest consecutive sequence.

Mark Out-of-Range Numbers:

1. Get the length of the array, n.
2. For each element in nums, if the value is not a candidate for the smallest missing positive integer (i.e., if nums[i] <= 0 or nums[i] > n), replace nums[i] with n + 1, an out-of-range value. This transformation helps ignore irrelevant numbers during subsequent steps.

Mark Indices of Found Numbers as Negative:

1. For each element in nums, calculate its absolute value, val.
2. If val is within the range [1, n], mark the index val - 1 as negative to indicate that val exists in the array.
3. If nums[val - 1] is already negative, it has already been marked, so leave it as is.

Identify the First Positive Index:

1. Traverse nums again.
2. If nums[i] is positive, then i + 1 is the smallest positive integer missing from the array (since the array indices are zero-based).
3. If all indices are marked as negative, all numbers from 1 to n are present, so return n + 1 as the smallest missing positive integer.

The approach is to recursively call the function for X and N - 1, and then multiply the value returned by the recursive function with X.

Since X ^ N is the same as X * (X ^ (N - 1)).

Approach:

First, let's say the recursive function is ‘POW(X, N)’, with ‘X’ and ‘N’ as arguments. The base case for the recursive function will be when N = 0, in which case it will return the value 1 (since X ^ 0 = 1), and when X = 0, it will return the value 0.

Next, the function is called recursively with ‘X’ and ‘N - 1’ as arguments, and the value is returned by multiplying it with ‘X’. The function call will return X * POW(X, N - 1).

Tip 1: In questions like relational and non-relational, do not give one answer; it depends on the use case.
Tip 2: Revise thoroughly before the interview on DBMS.

Tip 1: revise evrything u have on resume
Tip 2: give proper ans to what you did in last company/internship
Tip 3: understand you project strngly