Break A Number Up To An Array of Individual Digits

If I have the integer 123 and I want to break the digits into an array [1,2,3] what is the best way of doing this? I have messed around with this a lot and I have the following working:

var number = 123    
var digits = Array(String(number)).map{Int(strtoul((String($0)),nil,16))}

I look at it and feel there might be an better/easier way of doing this. If not then maybe it will come up on web searches. Any alternatives ideas?

Solution 1:

It is easier to work on the UTF-8 representation of the number string because the UTF-8 code unit of a decimal digit can easily be converted to the corresponding integer by subtracting a constant:

let asciiZero = UInt8(ascii: "0")
let digits = map(String(number).utf8) { Int($0 - asciiZero) }

This also turned out to be significantly faster.

If performance is the primary goal then you should restrict the method to simple integer arithmetic, without using strings or characters:

var digits : [Int] = []
while number > 0 {
    digits.insert(number % 10, atIndex: 0)
    number /= 10
}

Here is my complete test code for your convenience (compiled with Xcode 6.4 in Release mode on a MacBook Pro).

func digits1(number : Int) -> [Int] {
    let digits = Array(String(number)).map{Int(strtoul((String($0)), nil, 16))}
    return digits
}

func digits2(number : Int) -> [Int] {
    // Use a static property so that the constant is initialized only once.
    struct Statics {
        static let asciiZero = UInt8(ascii: "0")
    }

    let digits = map(String(number).utf8) { Int($0 - Statics.asciiZero) }
    return digits
}

func digits3(var number : Int) -> [Int] {
    var digits : [Int] = []
    while number > 0 {
        digits.insert(number % 10, atIndex: 0)
        number /= 10
    }
    return digits
}

func measure(converter: (Int)-> [Int]) {
    let start = NSDate()
    for n in 1 ... 1_000_000 {
        let digits = converter(n)
    }
    let end = NSDate()
    println(end.timeIntervalSinceDate(start))
}

measure(digits1) // 10.5 s
measure(digits2) // 1.5 s
measure(digits3) // 0.9 s

Update for Swift 3:

func digits(_ number: Int) -> [Int] {
    var number = number
    var digits: [Int] = []
    while number > 0 {
        digits.insert(number % 10, at: 0)
        number /= 10
    }
    return digits
}

print(digits(12345678)) // [1, 2, 3, 4, 5, 6, 7, 8]

This also turned out to be slightly faster than appending the digits to an array and reversing it at the end.

Solution 2:

My take for Swift 2:

var x = 123
var digits = String(x).characters.map { Int(String($0))! } // [1,2,3]

It is more explicit about the characters, so I think it is quite readable.

Solution 3:

Another Swift 3 alternative is making use of the global sequence(state:next:) method.

Swift 3.1

let number = 123456
let array = Array(sequence(state: number,
    next: { return $0 > 0 ? ($0 % 10, $0 = $0/10).0 : nil }
    ).reversed())

print(array) // [1, 2, 3, 4, 5, 6]

Swift 3.0

let number = 123456
let array = Array(sequence(state: number,
    next: { (num: inout Int) -> Int? in
        return num > 0 ? (num % 10, num /= 10).0 : nil
    }).reversed())

print(array) // [1, 2, 3, 4, 5, 6]

The approach above assumes a non-negative number, and will moreover return an empty array ([]) is case number is 0. To cover the full range of natural numbers as follows:

// -123 -> [1, 2, 3]
// 0    -> [0]
// 123  -> [1, 2, 3]

We can modify the above to:

// for some number ...
let number = ...

// Swift 3.1
let array: [Int]
if number == 0 { array = [0] }
else {
    array =  Array(sequence(state: abs(number),
    next: { return $0 > 0 ? ($0 % 10, $0 = $0/10).0 : nil }
    ).reversed())
}

// Swift 3.0
let array: [Int]
if number == 0 { array = [0] }
else {
    array = Array(sequence(state: number,
    next: { (num: inout Int) -> Int? in
        return num > 0 ? (num % 10, num /= 10).0 : nil
    }).reversed())
}

Some details regarding the tuple return above

In the single line return above, we've made use of the neat "()-return operation inlined as tuple member of type ()", a method that I first saw used by @MartinR in his improvement proposal to update the following answer. We use the last member of a (Int, ()) tuple to mutate the state property num; the first member of the tuple will be computed prior to the execution of the ()-return operation in "computing" the 2nd tuple member.

We can draw an analogy between this tuple method and the approach of executing a closure with a single defer and return statement. I.e., the return statement:

return num > 0 ? (num % 10, num /= 10).0 : nil

could also be accomplished by executing such a closure instead ("long form", in this context)

return num > 0 ? { defer { num /= 10 }; return num % 10 }() : nil  

I haven't benchmarked these two approaches against each other, but I have a feeling the former will be faster when repeatedly being called as in the context of sequence(state:next:) above.

Swift 3.0 vs 3.1: anonymous argument in the next closure above

Due to the now closed (Swift 3.1 and onwards) bug reported in SR-1976 (Closure signature in Swift 3 required for inout params), there's a limitation in Swift's type inference for inout parameters to closures. See e.g. the following Q&A for details:

• Global function sequence(state:next:) and type inference

This is the reason why we have to explicitly annotate the type of the state in the next closure of the Swift 3.0 solution above, whereas we can make use of anonymous arguments in the next closure for the Swift 3.1 solution.

Solution 4:

I don't know if you are new to swift but let's be clear, the method where you use the map is the best for what you want to do:) There is another approach that i don't recommend cause having a good visualisation of your code structure is really important.

import Foundation

var number2 = 123
var number3 : String = "\(number2)"
var array : [String] = []
var str2 = ""
for i in number3.characters
{
    str2.append(i)
    var string = NSString(string: "str")
    string.doubleValue
    array.append(str2)
    str2 = ""
}

cheers