tail | Go package for reading from continously updated files

The primary optimization you should use here is common subexpression elimination. Consider your first piece of code:

As I understood, in the tail recursion the base method shouldn't be waiting for the recursive method to finish executing and shouldn't be dependent on its output

That is not quite correct. Tail recursion mostly enables the compiler to apply tail call optimization (if supported), i.e. to rewrite the recursion to a regular loop instead. This has the advantage not reduced memory usage in the stack. It has nothing to do with 'not waiting'.

In the first example it has to keep one stack frame for each item in the list, and if you have a long list there is a chance you will run out of stack memory and get a stackoverflow.

In the tail recursive case the current stack frame is no longer needed when it reaches the tail-call, so the same stack frame can be re-used for each call, and that should result in code sort of equivalent to a regular loop.

Is this implementation the right way to achieve that?

It looks fine to me. But that does not necessarily mean that the optimization will be applied, it seem to depend on the compiler version, and may have other requirements. See Why doesn't .NET/C# optimize for tail-call recursion? In general I would recommend relying on the language specification and not compiler optimization for correct function of your program.

Note that recursion is often not the ideal approach in c#. For something simple as a sum it is easier, faster, and more readable to use a regular loop. For more complicated cases, like iterating over trees, recursion can be appropriate, but then tail-call optimization will not help very much in that case.

I've commented where I've made changes and why.

The key points are that since you are counting 2 values, you can just store the count of each value in an index of an array, rather than fill an array with a new value each time one of 2 options happen.

This lets you cut out the counting loop, making your program much more efficient, always try to count as you add rather than add then count at the end.

Also, you need to refresh the rng value each time the method is called, so I moved it into the top of the function.

Give it ago!

I think you over thought this.

The predicate lastElement(Stack). will match on everything. You just want the last element of the list.

Try this:

I would guess that you have an input that specifies the maximum flow through each edge.

The algorithm is then:

1. Because edges with a common source must have same actual, final flow the first step must be a little pre-processing to reduce the max flow at each edge to the minimum flow from the common source.

2. apply the standard maximum flow algorithm.

3. do a depth first search from the flow origin ( I assume there is just one ) until you find a node with unequal outflows. Reduce the max flows on all edges from this node to the minimum flow assigned by the algorithm. Re-apply the algorithm.

Repeat step 3 until no uneven flows remain.

=====================

Second algorithm:

1. Adjust capacity of every out edge to be equal to the minimum capacity of all out edges from the common vertex

2. Perform breadth first search through graph. When an edge is added, set the flow through the edge the minimum of

• the flow into the source node divided by the number of exiting edges
• the edge capacity

1. When search is complete sum flows into destination node.

For reference, here is the C++ code I use for depth first searching using recursion

The problem seems to be in this line

I managed to solve this issue by using this solution:

gcloud-command-not-found-while-installing-google-cloud-sdk

I included this 2 line into my gitlab-ci.yml before using the gsutil command.

You can refer to this simple program.

You can store the output in a list -