Tip 1: Practice coding on coding platforms, solving at least 100 questions.
Tip 2: Practice using any one automation framework that includes design patterns.
Tip 1: Restrict your resume to 1 page and include only your practical work.
Tip 2: Mention key topics such as Selenium, Rest Assured automation, and languages used (e.g., Java).



The given linked list is 1 -> 2 -> 3 -> 2-> 1-> NULL.
It is a palindrome linked list because the given linked list has the same order of elements when traversed forwards and backward.
Can you solve the problem in O(N) time complexity and O(1) space complexity iteratively?



The answer could be very large, output answer %(10 ^ 9 + 7).
There are n – 1 ways for element 0 (this explains multiplication with n – 1).
Let 0 be placed at index i. There are now two possibilities, depending on whether or not element i is placed at 0 in return.



Let S = “abdd” and X = “bd”.
The windows in S which contain all the characters in X are: 'abdd', 'abd', 'bdd', 'bd'.
Out of these, the smallest substring in S which contains all the characters present in X is 'bd'.
All the other substring have a length larger than 'bd'.
Approach 1 (Brute Force) :
1) Generate all substrings of string1.
2) For each substring, check whether the substring contains all characters of string2.
3) Finally, print the smallest substring containing all characters of string2.
TC : O(N^3), where N=length of the given string s1 and s2
SC : O(1)



1. The path does not need to start or end at the root or a leaf, but it must go downwards (traveling only from parent nodes to child nodes).
2. Output the paths in the order in which they exist in the tree from left to right. Example: In the below example, path {1,3} is followed by {3,1} and so on.
For K = 4 and tree given below:

The possible paths are:
1 3
3 1
-1 4 1
4
-1 5
The sum of values of nodes of each of the above-mentioned paths gives a sum of 4.
The idea is simple: record all prefix sums in a hash table along the path. For current prefix sum x, check if (x - target)
appears in the hash table.
Steps :
1) We will be using an unordered map which will be filled with various path sums.
2) For every node we will check if the current sum and root’s value equal to k or not. If the sum equals k then
increment the required answer by one.
3) Then we will add all those path sums in map which differs from current sum+root->data value by a constant integer
k.
4) Then we will be inserting the current sum + root->data value in the map.
5) We will recursively check for left and right subtrees of current root
6) After the right subtree is also traversed we will remove the current sum + root->data value from the map so that it
is not taken into consideration in further traversals of other nodes other than the current root’s.

Here's your problem of the day
Solving this problem will increase your chance to get selected in this company
To make an AI less repetitive in a long paragraph, you should increase: