dog | Full repository for the Dog gateway

This problem should be solved easily using a trie.

The trie node should basically keep a track of 2 things:

1. Child nodes
2. Count of prefixes ending at current node

Insert all strings in the trie, which will be done in O(string length * number of strings). After that, simply traversing the trie, you can hash the prefixes based on the count as per your use case. For suffixes, you can use the same approach, just start traversing the strings in reverse order.

Edit:
On second thought, trie might be the most efficient way, but a simple hashmap implementation should also work here. Here's an example to generate all prefixes with count > 1.

Your logic is correct. Just syntax is wrong.

() => T is not Function1[Unit, T]. It is actually a syntax for lambda with no argument which results in Function0[T]. The parenthesis here is not Unit. It's a syntax to denote zero arguments

The correct way to construct a Unit => Unit is:

The blind-signature library used in the NodeJS code for blind signing implements the process described here:

• BlindSignature.blind() generates the SHA256 hash of the message and determines the blind message m' = m * r^e mod N.
• BlindSignature.sign() calculates the blind signature s' = (m')^d mod N.
• BlindSignature.unblind() determines the unblind signature s = s' * r^-1 mod N.
• BlindSignature.verify() decrypts the unblind signature (s^e) and compares the result with the hashed message. If both are the same, the verification is successful.

No padding takes place in this process.

In the Java code, the implementation of signing the blind message in signConcealedMessage() is functionally identical to BlindSignature.sign().
In contrast, the verification in the Java code is incompatible with the above process because the Java code uses PSS as padding during verification.
A compatible Java code would be for instance:

It may be faster with a join

Maybe consider a simple recursive function like this

We could use match with sort

We may use read.dcf from base R

This is a very common mistake: overlooking the direction of the polymorphism.

In short: it's the caller of the function that gets to choose type parameters, not the implementer of the function.

Slightly longer: when you give your function a signature like Animal a => a, you're making a promise to any caller of your function, and that promise reads something like this: "Pick a type. Any type. Whatever type you want. Let's call it a. Now make sure there is an instance Animal a. Now I can return you a value of type a"

So you see, when you write such function, you don't get to return a specific type that you choose. You have to return whatever type the caller of your function will choose later when they call it.

To drive it home with a specific example, imagine that your getA' function is possible, and then consider this code:

Something like