kata | Repository template for katas in Go and VS Code

I understand that the same string[] that comes as an argument is refilled with elements and returned.

No, absolutely not. A new sequence of strings is returned based on the input array. The input array is not modified or changed in any way.

But how does the program know that each element of the array is called “name”, as it’s never mentioned before?

name is a parameter to an anonymous function. The name parameter is a string based on context. This could be x or ASDASDASD or whatever you want, but here we use name since we have, on each call, one "name" from names.

Thus,

• names is an array of strings passed into the function
• the .Where returns a new IEnumerable from the current array based on a predicate function (e.g. returns true for a match, false to omit)
• The predicate name => name.Length == 4 takes a string and returns true if the string is length 4
• The return from the function is the strings from names that are exactly 4 characters in length

After doing some testing, I noticed that the a string is not the same in both cases (With the if __name__ == "__main__" and without it). The problem is that when you use if __name__ == "__main__" you indent the a string once to put it inside the if statement. It might seem like you indented the code block, but you actually put spaces inside the string itself.

With the if __name__ == "__main__":

Your problem is that your code don't uses Async all the way up.

Your Account class has the method Open, Close, Balance and Transaction and you use a AsyncReplyChannel but you use PostAndReply to send the message. This means: You send a message to the MailboxProcessor with a channel to reply. But, at this point, the method waits Synchronously to finish.

Even with Async.Parallel and multiple threads it can mean a lot of threads lock themsels. If you change all your Methods to use PostAndAsyncReply then your problem goes away.

There are two other performance optimization that can speed up performance, but are not critical in your example.

1. Calling the Length of a list is bad. To calculate the length of a list, you must go through the whole list. You only use this in Transaction to print the length, but consider if the transaction list becomes longer. You alway must go through the whole list, whenever you add a transaction. This will be O(N) of your transaction list.

2. The same goes for calling (List.sum). You have to calculate the current Balance whenever you call Balance. Also O(N).

As you have a MailboxProcessor, you also could calculate those two values instead of completly recalculating those values again and again.Thus, they become O(1) operations.

On top, i would change the Open, Close and Transaction messages to return nothing, as in my Opinion, it doesn't make sense that they return anything. Your examples even makes me confused of what the bool return values even mean.

In the Close message you return state.Opened before you set it to false. Why?

In the Open message you return the negated state.Opened. How you use it later it just looks wrong.

If there is more meaning behind the bool please make a distinct Discriminated Union out of it, that describes the purpose of what it returns.

You used an option throughout your code, i removed it, as i don't see any purpose of it.

Anyway, here is a full example, of how i would write your code that don't have the speed problems.

You might update your function to:

it seems your error is coming from this line:

You solution is too slow effectively, as it is related to the range of data, which may be huge.

If n is the number of intervals, here is a O(n logn) solution.

1. Sort the intervals according to the start of them, and if equal to the end of them

2. Perform an iterative linear examination of the intervals as follows:

   • sum = 0
   • current_start = interval[0].first
   • current_end = interval[0].second
   • Do i = 1 to n-1
     • if (interval[i].first > current_end) then
       • sum += current_end - current_start
       • current_start = interval[i].first
       • current_end = interval[i].second
     • else
       • current_end = max (current_end, interval[i].second)
   • sum += current_end - current_start

You can use a dictionary to achieve the behavior you want

Here's a small code snippet -

Some issues:

• There is no reason why base should not be allowed to be 10 or more
• Trying with upperPower at each increment is taking too many iterations. The distance to the next power might be rather big.

I would suggest the following algorithm:

Let the exponent to try with start at 2, and then increment by 1. Calculate which could be the corresponding base. The real base can be found by raising n to the inverse exponent (i.e. 1/exp). Then there are only 2 interesting integer bases to consider: by rounding downwards and upwards.

Here is an implementation:

This can be done by utilizing the prototype method to extend the String class. This probably isn't the most efficient way of doing this, but it can be achieved with something like this: