conversion to string and lookup in it can't be efficient

looks like String(bool) comparison against "true"

Yes, it's elegant. But at the same time, it needs to iterate all the range from zero to n. I think this way wastes a lot of time when n is a big number.

Really nice! Very elegant.

Whew. How does this work?

Please can anyone explain me the logic here?

thanks for the reply. I tend to write code as clean as possible so that it is understandable. I haven't had a case where I needed to optimize my code, but this should help when that day comes.

In general, less code is always better. Less to maintain, less to go wrong. Also, the compiler does some optimisation when it sees these patterns to run them in the most efficient way.

There are some rare cases where you will need to write optimised code yourself because the compiler doesn't know how to optimise them. One example I can think of is nested loops.

clever. I'm curious in general, is code more efficient during runtime when it is coded like this as opposed to a more verbose method?

either way, nice solution

You are welcome :)

thanks again for your time, i think i got it, really appreciate.

Well, no. $N values are values inside the closure. To access start or end just use start and end inside the closure.

If there are a single parameter inside the closure, only $0 will be available. As an example - .filter(...) could be written as:

return (start...end).filter { item in !String(item).contains("5") }.count

With this you can't access parameters with $0, but can with it's name - item.

For example .sort(...) method uses 2 parameters inside, so this:

(start...end).sorted { $0 > $1 }

Is the same as this:

(start...end).sorted { left, right in left > right }

I guess it will be easier to understand if you read about Shorthand Argument Names at: Swift Book

thanks for answering, just to be sure, the filter method itself is what $0 represents here, right? and paramater start would be $1, and parameter end will be $2?