Software Development

I used the c++ stl gcd function to solve the problem

Now the question is how to rob a circular row of houses. It is a bit complicated to solve like the simpler question. It is because in the simpler question whether to rob num[lo] is entirely our choice. But, it is now constrained by whether num[hi] is robbed.

However, since we already have a nice solution to the simpler problem. We do not want to throw it away. Then, it becomes how can we reduce this problem to the simpler one. Actually, extending from the logic that if house i is not robbed, then you are free to choose whether to rob house i + 1, you can break the circle by assuming a house is not robbed.

For example, 1 -> 2 -> 3 -> 1 becomes 2 -> 3 if 1 is not robbed.

Since every house is either robbed or not robbed and at least half of the houses are not robbed, the solution is simply the larger of two cases with consecutive houses, i.e. house i not robbed, break the circle, solve it, or house i + 1 not robbed. Hence, the following solution. I chose i = n and i + 1 = 0 for simpler coding. But, you can choose whichever two consecutive ones.

Here we’re dividing the string into substrings and checking if it’s palindrome or not.
We’re storing all the palindromic substrings into a temp vector, using the help function to divide them into substrings.
In our help function our base condition if the checking index is equal to string size, that means we are at last index, so simply push back temp to our ans vector.
Else we’ll check palindrome for the rest of the string & take a loop, divide index by index and check for palindrome.
If it’s a palindrome substring then we’ll push it to ans & then we’ll call again the help function for the rest.
After the function returns we’ll pop back the element from temp, which means there is another substring that is not a palindrome.
Time complexity: O(n*2^n)

step 1 - i told the brute force approach - At each index, if the element is less than target, then we can always form a combination by picking the current element. The brute force is just based on this idea -
step 2 - i told the dp top down approach 
By drawing the recursion tree, we can see that for a target, we do the same calculations over and over again. This could be avoided by storing the number of combination obtained for a given target so that we don't waste time recalculating it at each recursion.

This can be done by maintain a dp array where dp[i] will denote the number of combinations possible with target = i. Initially, all elements in dp will be initialized to -1 denoting that the number of combinations for those target aren't calculated yet.

Once the number of combinations for subtarget = i (where 0I also took some help in between wherever i got stuck

Tip 1: be confident
Tip 2: always sound positive
Tip 3: make sure that you have eye contact and don't ever portray someone as negative person in any situation you are given.

Tip 1: Don't think a lot, they just want your honesty
Tip 2: might be a deciding factor, that whether you will be in testing or development
Tip 3: dont panic.