Tip 1 : Start from basic, don't jump to advanced topics
Tip 2 : Revise regularly.
Tip 3 : Make handwritten notes.
Tip 1 : Make a single-page resume
Tip 2 : Use formal font and font color should be black
Psychometric Test: Psychometric Test is basically Expedia’s version of the Workstyle assessment. The duration of this round was 45 minutes, and scenario-based questions were asked. I would recommend going through Expedia Worklife principles and answering accordingly. This was also an elimination round and 83 students were selected for the next round.
Moving on to the coding round. This round was based on the HackerRank platform. The test contained 6 MCQ Questions and 2 DSA Based Questions.
MCQs were on the Core Subjects like OS and OOPs. DSA Questions were pretty easy, I’d say Easy-Medium of LeetCode.
After this round 12 Students were selected for the Offline Technical Interviews.



‘word1’ = [“exceptional”, “coding”, “skills”]
‘word2’ = [“great”, “coding”, “talent”]
‘pairs’ = [ [“exceptional”, “good”], [“great”, “good”], [“skills”, “talent”] ]
For each word in ‘word1’, we have:
1. “exceptional” = “great”, because “exceptional” = “good” and “good” = “great”
2. “coding” = “coding”, as every word is identical to itself.
3. “skills” = “talent”, because [“skills”, “talent”] is present in ‘pairs’.
As every word in ‘word1’ is identical to the corresponding word in ‘word2’, the given sentences are identical.
1. The array ‘pairs’ can have words that are not present in ‘word1’ and ‘word2’.
2. Each pair ‘[u, v]’ in ‘pairs’ is unique, and if a pair ‘[u, v]’ is present, then there will never be a pair ‘[v, u]’.
3. You do not need to print anything; it has already been taken care of. Just implement the function.
Every uncommon word occurs exactly once in total. We can count the number of occurrences of every word, then return the ones that occur exactly once.



1. If 'X' is not found in the array, return 0.
2. The given array is sorted in non-decreasing order.
-HashTable + Sort: We use HashTable to count the occurrence and sort the entries based on the occurrence, then build the string.
-HashTable + Heap(Maxheap): We use HashTable to count the occurrence and build the heap based on the occurrence, then build the string.
The Interviews were conducted in offline mode. Both Interviews were conducted for all 12 students. Both the interviews were based on DSA and Behavioural questions.
Interview Round 1: The interviewer(SDE 2) asked me to introduce myself, and after that, he introduced himself as well. After a casual chat about his work at Expedia, he asked me about my projects, not very technical just an overview. He also asked about the time complexities of various sorting algorithms(Insertion sort, Heap sort, quick sort, merge sort) and also some Data Structures(Heap, Map, BST, LL, BT). Later, he started with the DSA part.
Interview Round 2: This round was taken by a senior SDE at Expedia. After the introduction, he asked me about the projects and what type of difficulties I faced during the projects and the position of responsibilities. Later on, he asked me about some DSA problems.



The idea is to scan the string from left to right, keep track of the maximum length Non-Repeating Character Substring seen so far in res. When we traverse the string, to know the length of current window we need two indexes.
1) Ending index ( j ) : We consider current index as ending index.
2) Starting index ( i ) : It is same as previous window if current character was not present in the previous window. To check if the current character was present in the previous window or not, we store last index of every character in an array lasIndex[]. If lastIndex[str[j]] + 1 is more than previous start, then we updated the start index i. Else we keep same i.



You can only move down or right at any point in time.
There are two ways to reach the solution :
1. Memoization – Starting from the top node, traverse recursively with each node, till the pathsum of that node is calculated. And then store the result in an array. But this will take O(N^2) space to maintain the array.
2. Bottom up – Start from the nodes on the bottom row; the min pathsum for these nodes are the values of the nodes themselves. And after that, minimum pathsum at the ith node of kth row would be the minimum of the pathsum of its two children + the node’s value, i.e.:
memo[k][i] = min( memo[k+1][i], memo[k+1][i+1]) + A[k][i];



Input:
'num1' : 1 -> 2 -> 3 -> NULL
'num2' : 4 -> 5 -> 6 -> NULL
Output: 5 -> 7 -> 9 -> NULL
Explanation: 'num1' represents the number 321 and 'num2' represents 654. Their sum is 975.
Traverse both lists to the end and add preceding zeros in the list with lesser digits. Then call a recursive function on the start nodes of both lists which calls itself for the next nodes of both lists till it gets to the end. This function creates a node for the sum of the current digits and returns the carry.



The given linked lists may or may not be null.
If the first list is: 1 -> 4 -> 5 -> NULL and the second list is: 2 -> 3 -> 5 -> NULL
The final list would be: 1 -> 2 -> 3 -> 4 -> 5 -> 5 -> NULL
The strategy here uses a temporary dummy node as the start of the result list. The pointer Tail always points to the last node in the result list, so appending new nodes is easy.
The dummy node gives the tail something to point to initially when the result list is empty. This dummy node is efficient, since it is only temporary, and it is allocated in the stack. The loop proceeds, removing one node from either ‘a’ or ‘b’, and adding it to the tail. When
We are done, the result is in dummy.next.

Here's your problem of the day
Solving this problem will increase your chance to get selected in this company
How do you remove whitespace from the start of a string?