.

It fails since digitize(0L) will return an empty array instead of returning {0}

bro, hi. I want to improve my skills in OOP programming. Can you give me some tips on what to read and where to practice?

• You should never check for cycle in (1), as you are at best removing dependencies from the graph.
• Instead of keeping track of current dependencies and formula in (2) and rolling back to it when a cycle is found, another option is to verify for a pending cyclic graph upfront.

you need to filter the children based on if a child is in santas list or not.

Additionally, the problem statement says that it must be case sensitive i think

Im a begginer but in my opinion its a great solution

@dinglemouse raised this already, Thanks for pointing it anyway )

In the real world, we make all kinds of assumptions, we just don't even recognise them anymore.

"Start with the initial value; apply f for every value in the list" relies on the assumption that applying zero times is valid. Which it is. This is not even an edge case, it's a base case. null means empty; it definitely is data - all of none of it. Zero has been invented for a while.

It might be easier to reason about [] then about null.

If your Strings have a length of Integer.MAX_VALUE, you really will have other problems with this code.

In the worse case, this algorithm makes k iteration and creates k brand new string objects. Not the most efficient approach.

Multiline lambdas with curly braces and functions that aren't pure (i.e. functions that cause side-effects) are not considered a good practice.

To begin with, I didn't tell that any method must have exactly one return statement.
For maintainability reasons method has to have AS FEWER RETURN STATEMENTS as possible.

'Object.equals() method uses multiple return statements'

equals method in the Object class has only one line that checks reference equality. Basically, it is entry-level information that you should know by hard.
Most of the classes in the JDK and different frameworks override default implementations of the equals method to define equality based on an object's state.

For the purpose of explanation, I think equals probably is not the best illustration because it is short and simple.
To describe a method that has more than one exit point but still remains to be well-readable let's consider a method, which implements some intricate algorithm, and may be it's a relatively long one. And it has the following structure:
{
if (eliminate one case) throw ... // that's the early kill and that's great
if (eliminate another case) retrurn ... // and that's the early kill as well

// MAIN LOGIC

return ...
}

To conclude, in general, return statements in the middle of a method has to be avoided where it's possible.
Because it can create confusion when return inclosed by multiple loops and conditions, as well as when return statements are present in both try and catch blocks.

DISCLAIMER: I don't say no one writes like that. I say it is considered to be undesirable nowadays.

Quick digression. If you think that JDK is written by the Gods and there are no pitfalls in Java you have a lot to discover.

'how you would solve problems of that kind in general'
In terms of clean coding, it's a naive way of thinking that there's some kind of uniform recipe that can be applied anywhere.
Clean code - is a code that is EASY to read, but difficult to write.
There are tons of books on this topic and if you expect to receive an exhaustive unambiguous answer in this comment then I'll say:
Sorry silver bullets are out of stock))

If you want to see how to solve this kata in an imperative way without exiting in the middle of the loop take a look at my fork.
That's doable with a help of break statement or labels. Caution, both of them can make the code cluttered, and labels are actually discouraged to use for that reason.

By the way, your dubious attitude to streams is still unclear to me.
Streams are effective, lazily evaluated, very nice in terms of readability, and capable to solve most of the problems which traditionally were implemented using loops.
If you are striving to write clean then code functional style is more preferable over imperative. And that is the strongest suggestion in my answer.

Now you are free to ignore this information or explore it father on your own. I hardly can add anything.
Good luck.

Single exit strategy is a controversial discussed dogma. For instance the Object.equals() method uses multiple return statements. Just have a look at the source code. Perhaps you shall advise Oracle that you think they're using bad pracice and improve the Java code base with a better solution. Your approach may be good for these concrete kata, but it is indeed not a general valid way, to solve all problems of that type, as you can see.

Hence, my question was not about linking connections to anything, but wanting to know, how you would solve problems of that kind in general, if something like IntStream was not accessible. Since clairvoyance does not exist, nobody can elaborate how your solution would look like. This is just a red herring argument. I would be grateful, if you could take two minutes to show a good way that works even for cases when Streams don't work, with a single exit point. And of course, without a break in the loop, because it violates your choosen strategy.