This is by far the most performant and elegant solution.

Horrible solution. Perfect example of how to kill performance by making code shorter. Solutions here are expected to have O(n) and compete only in number of passes through the list, but this one manages to get to O(n^2).

I don't think modular arithmetics is basic math, but I guess that is a matter of perceptioin.

That kata now already has a Java translation. Also this kata requires to merge the frequency count and prime factors in string format, so technically not an exact duplicate.

Also, duplicates of Prime Factorization katas has been mentioned here and will be handled sooner or later.

Corrected!
Thanks for the feedback!

There is an issue for original kata and you better not inherit it. There really should be explicit tests with repeating minimum in the array. For example [3, 4, 3, 5] should produce 6, not 7. I guess, single fixed test is ok.

The solution is incorrect. It fails if the minimum element repeats anywhere in the array.

I dont know why Swift translator added it here, but other translators have not. Its been reported before too.

why there is no this check in python?
swift can't pass

It feeds your solution with an infinite sequence and checks if it stops as soon as the answer is known, without evaluating the whole input.

Swift:
what is Laziness Tests?

Ants NEVER collide more than 2 at once in one place. In this case particularly the middle one first collides with the right one and then (after changing direction) with the left one:
(time goes from top to bottom)

.R..R..L.
..R..RL.. <- first collision
...R.LR..
....!..R. <- second collision
...L.R..R

There is a harder version of this kata. https://www.codewars.com/kata/65e4b8877e8acd0dbae9a14f

There is wider kata about computing regular expressions for divisibility tests. https://www.codewars.com/kata/5993c1d917bc97d05d000068