SDE - Intern

1) I first thought of checking all subarrays using two loops, but that was too slow (O(N²)).
2) Then I used a better way with prefix sum and HashMap.
3) I kept a running sum of elements. For every new sum, I checked if (sum - K) already appeared before — that means a subarray ending here has sum K.
4) Stored counts of each prefix sum in a map to handle multiple cases.
5)This made the code run in O(N) time.

1) I used a stack to keep track of opening brackets.
2) For every character
>If it was an opening bracket, I pushed it to the stack.
>If it was a closing bracket, I checked if the top of the stack had the matching opening one.
3) If not matching, it’s invalid; otherwise, I popped it.
4) In the end, if the stack was empty, the string was valid.
5) The solution worked in O(N) time.

Create a dummy node dummy and a pointer tail pointing to dummy.
Use two pointers p1 = head1 and p2 = head2.
While both p1 and p2 are not null:
Compare p1->val and p2->val.
Append the smaller node to tail->next and advance that pointer (p1 or p2).
Move tail = tail->next.
After the loop, attach the non-empty remainder: if p1 not null then tail->next = p1 else tail->next = p2.
Return dummy->next as the head of the merged list.

Initialize count = 0 and a set vowels = {'a','e','i','o','u'}.
Iterate each character ch in S.
Convert ch to lowercase for case-insensitive check.
If ch is in vowels, count += 1.
After iteration return count.

Delete command removes specific rows from a table using a WHERE clause, can be rolled back.
Truncate command deletes all rows from a table instantly; cannot be rolled back in most databases.
Drop command Completely removes the table structure and data from the database.

I first thought of using any sorting algorithm like bubble sort, but that would take O(n²).
Then I realized we can solve this in O(n) by counting the number of 0s and 1s.
Count total 0s in the array fill that many 0s from the start and remaining 1s afterward.
Another optimal approach is to use the two-pointer method:
Keep left = 0 and right = n-1.
Move left forward until it finds 1, and right backward until it finds 0.
Swap them and continue until left >= right.

I first thought of checking every character using two loops (O(n²)), but that’s inefficient.
I optimized it using a HashMap (or array of size 26) to count the frequency of each character.
After counting, I iterated over the string again and returned the first character with count = 1.
If no such character found, return “-1”.

I explained that Abstraction means hiding complex details and showing only the necessary information to the user. I gave the example of Paytm, where the user only sees a simple interface to send or receive money, while all the backend processes like API calls, authentication, and transaction handling are hidden.

Understand that the Critical Section is the part of code where shared resources are accessed, and mutual exclusion must be ensured to prevent race conditions. A Deadlock occurs when two or more processes wait indefinitely for resources held by each other. Revise deadlock prevention, avoidance, and detection methods like the Banker’s Algorithm.

Revise these topics from Computer Networks especially the chapters on Error Detection/Correction and Network Security.