climb | A Composer version manager tool | Build Tool library

A friend helped me to solve.

I had these lines of code in my server, but had a small typo and also needed to rearrange the locations they were in.

Beggining of server app: app.use(express.static(path.join(__dirname, "build")));

End of server app:

There are some issues in your code:

• Base case (condition that terminates the recursion) is incorrect. Every branch of recursive calls spawn new branches when it hits the condition if (sumNeeded == currentSum) is meat instead of returning the number of combinations. You created an infinite recursion that inevitably leads to a StackOverflowError. You have to place a return statement inside the curly braces after the first if in your code. And comment out the first recursive call (with 0 sum passed as an argument) you'll face the second problem: for any input, your code will yield 0.
• Results returned by recursive calls of your method countWaysToClimbHelper() are omitted. Variable possibleCombos isn't affected by these calls. Each method call allocates its own copy of this variable possibleCombos on the stack (a memory aria where JVM stores data for each method call), and their values are not related anyhow.
• you actually don't need to pass the number of combinations as a parameter, instead you have to return it.

Before moving further, let me recap the basics of recursion.

Every recursive method should contain two parts:

• base case - that represents a simple edge-case for which the outcome is known in advance. For this problem, there are two edge-cases:
  • sumNeeded == currentSum - the return value is 1, i.e. one combination was found;
  • sumNeeded > currentSum - the return value is 0.
• recursive case - a part of a solution where recursive calls a made and when the main logic resides. In your recursive case you need to accumulate the value of the number of combination, which will be the sum of values returned be two branches of execution: take 1 step or 2 steps.

So the fixed code might look like that:

The catch is that CheckNumber exists in the parent frame (from where little_fun is called) but not in the parent environment (where little_fun is defined).

test with additional code in little_fun:

Java is pass-by-value. That means your that your cnt variable in your climbStairs method is not shared; it is unique to you. When you invoke climb, you pass the value it holds (0 every time here), and climb has its own variable (also called cnt). It modifies its own cnt value which is tossed in the garbage when that method ends (all parameters and all local variables are always tossed in the garbage when a method ends).

You want to return cnt:

For a give node X, we want to know u(X) - the number of unique delete sequences.

Assume this node has two children A, B with sizes |A|, |B| and known u(A) and u(B).

How many delete sequences can you construct for X? You could take any two sequences from u(A) and u(B) and root and combine them together. The result will be a valid delete sequence for X if the following holds:

• The root X must be deleted last.
• Order of deletion of any two nodes from different subtrees is arbitrary.
• Order of deletion of any two nodes from the same subtree is fixed given its chosen delete sequence.

This means you want to find out the number of ways you can interleave both sequences (and append X).

Notice that the length of a delete sequence is the size of the tree, that's kind of trivial if you think about it.

Also give some though to the fact that this way we can generate all the delete sequences for X, that might not be so trivial.

So if I'm counting correctly, the formula you are looking for is u(X)= [|A|+|B| choose |A|] * u(A) * u(B).

It holds for empty children too if we define u(empty)=1.

Just be careful about overflow, the number of combinations will explode quite quickly.

Since you are using a internal dictionary, you can try something like this:

You are building a list of candidates, what is a good start I think. It doesn't really matter whether you white- or blacklist the result is the list of candidates. The only concern is that you could get the solution faster or more reliably by guessing words that are not on the candidates list. Why? Because that way you can introduce more new letters at once to check if the word contains them. Maybe a mix between the two strategies is best, hard to tell without testing it first.

• "green" is OK.
• "black" needs to count the number of non-black appearances of the letter in the guess and all words that not contain that exact amount of that letter can be eliminated (and also those that have the letter at a black position).
• "orange" is OK but can be improved: you can count the number of non-black appearances of the letter in the guess and eliminate all words that contain the letter fewer times (checking for minimal appearance and not just at least once) and also what you already have applies: the letter cannot be at an orange position.

There are a lot of ideas for improvements. First I would create the filter before going through the words. Using similar logic as above you would get a collection of four different rule types: A letter has to be or cannot be at a specific position or a letter has to appear exactly (possibly 0) or at least a specific number of times. Then you go through the words and filter using those rules. Otherwise some work might be done multiple times. It is easiest to create such a filter by collecting the same letters in the guess first. If there is an exact number of appearence rule then you can obviously drop a minimal number of appearance rule for the same letter.

To guess the word fast I would create an evaluation function to find the most promising next guess among the candidates. Possible values to score:

• How many new letters are introduced (letters that were not guessed yet).
• Also the probabilites of the new letters could be taken into account. E.g. how likely is it that a word contains a specific letter. Or even look at correlations between letters: like if I have a Q then I probably also have a U or if the last letter is D then the likelyhood of the 2nd last being E is very high.
• You could even go through all the possible answers for every candidate and see which guess eliminates the most words on average or something similar. Although this probably takes too long unless somehow approximated.

The answer is no, when the problem is specified like this. However, we could maybe change the problem statement a bit. If you run multiple independent solvers and, at the end, pick the best result, you can then pass that to a new solver which will start from there. This would be a variant of multi-bet solving. It is not supported out of the box, but would be relatively easy to code yourself, using either the Solver or SolverManager APIs.

That said, your entire approach is very unconventional. Custom construction heuristic is understandable, as are custom moves. But the fact that you feel the need to separate the moves into different phases makes me curious. Have you benchmarked this to be the best possible approach?

I would think that using the default local search (late acceptance), with your custom moves and our generic moves all thrown into the mix, would yield decent results already. If that fails to happen, then generally either your constraints need to be faster, or the solver needs to run for longer. For large problems, multi-threaded solving can help, too.