One-liner to generate Powerball picks in Swift?

Question

With the U.S.'s large $1.5 Billion lottery this week, I wrote a function in Ruby to make Powerball picks. In Powerball, you choose 5 numbers from the range 1..69 (with no duplicates) and 1 number from the range 1..26.

This is what I came up with:

def pball
    Array(1..69).shuffle[0..4].sort + [rand(1..26)]
end

It works by creating an array of integers from 1 to 69, shuffling that array, choosing the first 5 numbers, sorting those, and finally adding on a number from 1 to 26.

To do this in Swift takes a bit more work since Swift doesn't have the built-in shuffle method on Array.

This was my attempt:

func pball() -> [Int] {
    let arr = Array(1...69).map{($0, drand48())}.sort{$0.1 < $1.1}.map{$0.0}[0...4].sort()
    return arr + [Int(arc4random_uniform(26) + 1)]
}

Since there is no shuffle method, it works by creating an [Int] with values in the range 1...69. It then uses map to create [(Int, Double)], an array of tuple pairs that contain the numbers and a random Double in the range 0.0 ..< 1.0. It then sorts this array using the Double values and uses a second map to return to [Int] and then uses the slice [0...4] to extract the first 5 numbers and sort() to sort them.

In the second line, it appends a number in the range 1...26. I tried adding this to the first line, but Swift gave the error:

Expression was too complex to be solved in reasonable time; consider breaking up the expression into distinct sub-expressions.

Can anyone suggest how to turn this into a 1-line function? Perhaps there is a better way to choose the 5 numbers from 1...69.

Answer 1

Xcode 8.3 • Swift 3.1

import GameKit 

var powerballNumbers: [Int] {
    return (GKRandomSource.sharedRandom().arrayByShufflingObjects(in: Array(1...69)) as! [Int])[0..<5].sorted() + [Int(arc4random_uniform(26) + 1)]
}

powerballNumbers   // [5, 9, 62, 65, 69, 2]

---

Swift 2.x

import GameKit 

var powerballNumbers: [Int] {
    return (GKRandomSource.sharedRandom().arrayByShufflingObjectsInArray(Array(1...69)) as! [Int])[0...4].sort() + [Int(arc4random_uniform(26).successor())]
}

powerballNumbers   // [21, 37, 39, 42, 65, 23]

Answer 2

I don't find the "one-liner" concept very compelling. Some languages lend themselves to it; others don't. I would suggest giving Swift a shuffle method to start with:

extension Array {
    mutating func shuffle () {
        for var i = self.count - 1; i != 0; i-- {
            let ix1 = i
            let ix2 = Int(arc4random_uniform(UInt32(i+1)))
            (self[ix1], self[ix2]) = (self[ix2], self[ix1])
        }
    }
}

But since I made this mutating, we still need more than one line to express the entire operation because we have to have a var reference to our starting array:

var arr = Array(1...69)
(1...4).forEach {_ in arr.shuffle()}
let result = Array(arr[0..<5]) + [Int(arc4random_uniform(26)) + 1]

If you really insist on the one-liner, and you don't count the code needed to implement shuffle, then you can do it, though less efficiently, by defining shuffle more like this:

extension Array {
    func shuffle () -> [Element] {
        var arr = self
        for var i = arr.count - 1; i != 0; i-- {
            let ix1 = i
            let ix2 = Int(arc4random_uniform(UInt32(i+1)))
            (arr[ix1], arr[ix2]) = (arr[ix2], arr[ix1])
        }
        return arr
    }
}

And here's your one-liner:

let result = Array(1...69).shuffle().shuffle().shuffle().shuffle()[0..<5] + [Int(arc4random_uniform(26)) + 1]

But oops, I omitted your sort. I don't see how to do that without getting the "too complex" error; to work around that, I had to split it into two lines:

var result = Array(1...69).shuffle().shuffle().shuffle().shuffle()[0..<5].sort(<)
result.append(Int(arc4random_uniform(26)) + 1)

Answer 3

Xcode 10 • Swift 4.2

Swift now has added shuffled() to ClosedRange and random(in:) to Int which now makes this easily accomplished in one line:

func pball() -> [Int] {
    return (1...69).shuffled().prefix(5).sorted() + [Int.random(in: 1...26)]
}

Further trimmings:

Because of the return type of pball(), the Int can be inferred in the random method call. Also, .prefix(5) can be replaced with [...4]. Finally, return can be omitted from the one-line function:

func pball() -> [Int] {
    (1...69).shuffled()[...4].sorted() + [.random(in: 1...26)]
}

Answer 4

How about this:

let winningDraw = (1...69).sort{ _ in arc4random_uniform(2) > 0}[0...4].sort() + [Int(arc4random_uniform(26)+1)]

[edit] above formula wasn't random. but this one will be

(1...69).map({Int(rand()%1000*70+$0)}).sort().map({$0%70})[0...4].sort() + [Int(rand()%26+1)]

Answer 5

For the fun of it, a non-GameplayKit (long) one-liner for Swift 3, using the global sequence(state:next:) function to generate random elements from the mutable state array rather than shuffling the array (although mutating the value array 5 times, so some extra copy operations here...)

let powerballNumbers = Array(sequence(state: Array(1...69), next: { 
    (s: inout [Int]) -> Int? in s.remove(at: Int(arc4random_uniform(UInt32(s.count))))})
    .prefix(5).sorted()) + [Int(arc4random_uniform(26) + 1)]

... broken down for readability.

---

(Possible in future Swift version)

If the type inference weren't broken inout closure parameters (as arguments to closures), we could reduce the above to:

let powerballNumbers = Array(sequence(state: Array(1...69), next: {
    $0.remove(at: Int(arc4random_uniform(UInt32($0.count)))) })
    .prefix(5).sorted()) + [Int(arc4random_uniform(26) + 1)]

If we'd also allow the following extension

extension Int {
    var rand: Int { return Int(arc4random_uniform(UInt32(exactly: self) ?? 0)) }
}

Then, we could go on to reduce the one-line to:

let powerballNumbers = Array(sequence(state: Array(1...69), next: { $0.remove(at: $0.count.rand) }).prefix(5).sorted()) + [26.rand + 1]