leetcode | Java engineer LeetCode

Some issues in your code (as it was first posted):

• return skipper(prev,curr) is going to exit the loop, but there might be more nodes to be removed further down the list. skipper only takes care of a sub sequence consisting of the same value, but it will not look beyond that. The list is not necessarily sorted, so the occurrences of the value are not necessarily grouped together.

• Be aware that the variable prev in skipper is not the same variable as the other, outer prev. So the assignment prev=curr in skipper is quite useless

• Unless the list starts with the searched value, dummy.next will always remain None, which is what the function returns. You should initialise dummy so it links to head as its next node. In your updated code you took care of this, but it is done in an obscure way (in the else part). dummy should just be initialised as the head of the whole list, so it is like any other node.

In your updated code, there some other problems as well:

• while prev.next: risks to be an infinite loop, because it continues while prev is not the very last node, but it also doesn't move forward in that list if its value is not equal to the searched value.

I would suggest doing this without the skipper function. Your main loop can just deal with the cases where current.val == val, one by one.

Here is the corrected code:

This will work:

Let's take a look at a worst case scenario, i.e. the palindrome check will not allow us to have an early out.

For writing down the recurrence relation, let's say n = end - start, so that n is the length of the sequence to be processed. I'll assume the indexed array accesses are constant time.

is_palindrome will check for palindromity in O(end - start) = O(n) steps.

dfs_helper for a subsequence of length n, calls is_palindrome once and then has 2n recursive calls of lengths 0 through n - 1, each being called two times, plus the usual constant overhead that I will leave out for simplicity.

So, we have

I have ran it through gdb. After a bit of digging, the error is this:

The main thing you want to check for overflow is this:

A point to remember: Servers present inside runningServers heap have higher priority than the servers that are present in the pool serverId waiting for some task.

Now, assume that we have 3 servers s1, s2, s3 having priority order s1 > s2 > s3, and 4 tasks t1, t2, t3, t4 with arrival time in increasing order. Also, assume that when we were about to allocate a server for t4, then by that time s2 and s3 got free.

Now, ideally, we should choose server s2 for task t4 but the above-given algorithm is going to choose s3 for t4 because it's maintaining a min-heap property on the finish time of the servers. So it's important to first free all the servers that have finish time <= currTime, and then choose a new server for t4 from the pool.

Now, what would happen if no server can be chosen from runningServer and we don't even have any server available in the pool serverId?

solution: We'll have to wait for some time for one of the servers to get free. let's say a server is going to get free at time = x ms, and it is also possible that there are multiple servers that are going to get free at time = x ms.

So, the final solution for the problem statement is:

you have a typo in these code block:

The shadowing is defined by the C++ standard, and must work on all conforming compilers.

Your code prints garbage, because carry in carry + 1 reads the new variable (which isn't initialized at that point yet, causing UB), not the old one.

Assuming your system is using ASCII or UTF-8 or something like that, 'a' == 97.

So, this is equivalent to chars[97]++.