algoexpert | 100 Question from https : //www.algoexpert.io

currentLongest = [0, 1], this is the initial assumption. in this code assume that the longest palindromic substring is a string which start from 0 and end from 1.

for example:

if given string is abcdc it assume currentLongest as a (from index 0 to 1).

Then in the for loop in longestPalindromicSubstring function, it checks and increases the index by one. in even, and odd cases. it gets even length and odd length substrings to check. You can check the length by the values that pass into getLongestPalidromeFrom function. ( (i-1),(i),(i+1) length= 3 odd ).

in getLongestPalidromeFrom function it increases length by two and checks is it palindromic or not. then return the longest palindromic sub string that can generate by starting given points .

in longest it checks what is the longest substring from odd and even length strings. and then in currentLongest it compares the new longest value with the previous longest (cuurentLongest) value.

Remember indexes in currentLongest, longest are the indexes of starting and endpoints of the sub-string. So length equal to x[1]-x[0]. the lambda function.

there can be some mistakes in indexing in my explanation. but totally idea is this.

It becomes clear when you realise every execution of productSum has its own arraySum variable. Although the name is each time the same, it really is a variable that is unrelated to the other variables out there (in the recursion tree) that happen to have the same name.

Each time a recursive call is made, the caller's productSum ends up on a stack frame, from where it is restored when the recursive call returns, and then the returned value is added to its own productSum.

And so a value is accumulating while backtracking out of recursion, and all those different productSum variables each play a little role in carrying an intermediate result, until it was returned to the caller, who accumulated it further, ...etc.

Several issues:

• depthFirstSearch is a method of the Node class, not a global function, so it should be called on a node instance. So for instance, if you have a node named child it should be called like child.depthFirstSearch

• As it is a method, you should not use the function keyword (in a class construct). This was correctly removed in the last code block you have in your question.

• The argument passed to depthFirstSearch should be an array, but you pass it array[i] which is a node. It should be just array, as in the Python code.

• The loop should not be over array, but over the children of the current node, i.e. over this.children. So you would have i < this.children.length in your for loop.

Some other remarks:

• No semi-colon is needed after a for loop. Adding it actually introduces a (harmless) empty statement.
• Using a for..of instead of a plain old for loop makes the code a bit shorter and also better mimics what the Python code does.

Corrected version:

You can use Cloudinary or Imgur to upload and images through code. You can go through their Documentation. Cloudinary offer 25GB free storage in their free plan.

Documentation Cloudinary

Let N=len(arr), M=len(arr[0]). This code has O(NM^2+N^2M) complexity (or O(N^3) for square input matrix). Here's why: outer loop (while) is fully equivalent to for loop (because you increment test at the end and never change it elsewhere) and will be executed N+M times. Then you enter the second loop which is executed exactly N times. Then inner loop - M times. Inner loop will be repeated for each step of middle loop, the same with outer. So we have to multiply all this counts together. All inner operations are not atomic, of course, but for small data will be O(1) on average. If your input is large, I suggest pre-allocating out (creating it as out = [None for _ in range(N*M)]) to avoid costs of its growth and keeping current first free index as additional variable.

You can use sort with a custom key that compares each element to toMove. All the False values will be to the left, and all the True values will be to the right. Therefore all the toMove values will end up at the back of the list.

Yes, you can use only one class to implement a tree, e.g., Node class in the first snippet you present is sufficient.

That being said, if you have only one class, you would have to always keep an object referring to the root node, so you can access the tree.

The class BinaryTree (in the first snippet) could help to do that, but it is not necessary.

Example code using BinaryTree from the second snippet and declaring a tree:

Both are correct. The answer depends on the start of the sequence. If you start it with 0,1, then the 4th item will be 2 and if you start with 1,1, then the 4th item will be 3.

EDIT:

I made small changes to your code: