lol, yes

It works. But the question is what you aim for:

• least lines of code
• most robust solution that you can easily reason about
• efficiency in terms of intervals
• efficiency in terms of the total length of intervals

I'm not saying one is definitely better than the other, especially since this is not a code for production, but for practice. For this reason it could also make sense to supply several implementations for each of the above goals.

Or a single very long interval

map(x->parse(Int64, x), something) is the same as

parse.(Int64,something)

Do you mean that the timer will reset after a malformed message and messages to the Parent will not be sent?

So every 1000ms you send self() the {awake} signal which triggers another send_after function.
So does it mean that after a couple of seconds it will not receive only one {awake} signal per second, but many of them?

I like this kata, I learned a lot from it.
But I'm not sure whether the tests cover all cases. In many solutions I found (including mine) the timer resets after a malformed message was received.
But my understanding is that messages to server should arrive every 1000ms, regardless of malformed messages.

You're right! The factorization process takes care of that automatically. I realized that shortly after hitting submit, so I don't use it in my later solutions requiring prime factorization. Here's a fun example https://www.codewars.com/kata/54d496788776e49e6b00052f/julia Cheers!

I think this would work equally well without the is_prime function.

map(c1 -> length(c1), a1)
can simply be written as
map(length, a1)
or even as
length.(a1)

Sorting seems to be a bit of an overkill ...

This runs in n * m time (where n and m are the length of the inputs), while other solutions run in n+m or maybe 2*(n+m)