Wie randomisiere oder mische ich die Elemente in einem Array in Swift? Zum Beispiel, wenn mein Array aus 52 Karten besteht, mag ich mische das Array , um das Deck zu mischen.

Diese Antwort beschreibt, wie Sie mit einem schnellen und einheitlichen Algorithmus (Fisher-Yates) in Swift 4.2+ mischen und wie Sie dieselbe Funktion in den verschiedenen früheren Versionen von Swift hinzufügen. Die Benennung und das Verhalten für jede Swift-Version stimmen mit den mutierenden und nicht mutierenden Sortiermethoden für diese Version überein.

Swift 4.2+

shuffleund shuffledsind native ab Swift 4.2. Anwendungsbeispiel:

let x = [1, 2, 3].shuffled()
// x == [2, 3, 1]

let fiveStrings = stride(from: 0, through: 100, by: 5).map(String.init).shuffled()
// fiveStrings == ["20", "45", "70", "30", ...]

var numbers = [1, 2, 3, 4]
numbers.shuffle()
// numbers == [3, 2, 1, 4]

Swift 4.0 und 4.1

Diese Erweiterungen fügen shuffle()jeder veränderlichen Sammlung (Arrays und unsichere veränderbare Puffer) eine shuffled()Methode und jeder Sequenz eine Methode hinzu:

extension MutableCollection {
    /// Shuffles the contents of this collection.
    mutating func shuffle() {
        let c = count
        guard c > 1 else { return }

        for (firstUnshuffled, unshuffledCount) in zip(indices, stride(from: c, to: 1, by: -1)) {
            // Change `Int` in the next line to `IndexDistance` in < Swift 4.1
            let d: Int = numericCast(arc4random_uniform(numericCast(unshuffledCount)))
            let i = index(firstUnshuffled, offsetBy: d)
            swapAt(firstUnshuffled, i)
        }
    }
}

extension Sequence {
    /// Returns an array with the contents of this sequence, shuffled.
    func shuffled() -> [Element] {
        var result = Array(self)
        result.shuffle()
        return result
    }
}

Gleiche Verwendung wie in den obigen Swift 4.2-Beispielen.

Swift 3

Diese Erweiterungen fügen shuffle()jeder veränderlichen Sammlung eine shuffled()Methode und jeder Sequenz eine Methode hinzu:

extension MutableCollection where Indices.Iterator.Element == Index {
    /// Shuffles the contents of this collection.
    mutating func shuffle() {
        let c = count
        guard c > 1 else { return }

        for (firstUnshuffled , unshuffledCount) in zip(indices, stride(from: c, to: 1, by: -1)) {
            // Change `Int` in the next line to `IndexDistance` in < Swift 3.2
            let d: Int = numericCast(arc4random_uniform(numericCast(unshuffledCount)))
            guard d != 0 else { continue }
            let i = index(firstUnshuffled, offsetBy: d)
            self.swapAt(firstUnshuffled, i)
        }
    }
}

extension Sequence {
    /// Returns an array with the contents of this sequence, shuffled.
    func shuffled() -> [Iterator.Element] {
        var result = Array(self)
        result.shuffle()
        return result
    }
}

Gleiche Verwendung wie in den obigen Swift 4.2-Beispielen.

Swift 2

(veraltete Sprache: Sie können Swift 2.x nicht verwenden, um ab Juli 2018 auf iTunes Connect zu veröffentlichen.)

extension MutableCollectionType where Index == Int {
    /// Shuffle the elements of `self` in-place.
    mutating func shuffleInPlace() {
        // empty and single-element collections don't shuffle
        if count < 2 { return }

        for i in startIndex ..< endIndex - 1 {
            let j = Int(arc4random_uniform(UInt32(count - i))) + i
            guard i != j else { continue }
            swap(&self[i], &self[j])
        }
    }
}

extension CollectionType {
    /// Return a copy of `self` with its elements shuffled.
    func shuffle() -> [Generator.Element] {
        var list = Array(self)
        list.shuffleInPlace()
        return list
    }
}

Verwendungszweck:

[1, 2, 3].shuffle()
// [2, 3, 1]

let fiveStrings = 0.stride(through: 100, by: 5).map(String.init).shuffle()
// ["20", "45", "70", "30", ...]

var numbers = [1, 2, 3, 4]
numbers.shuffleInPlace()
// [3, 2, 1, 4]

Swift 1.2

(veraltete Sprache: Sie können Swift 1.x nicht verwenden, um ab Juli 2018 auf iTunes Connect zu veröffentlichen.)

shuffle als mutierende Array-Methode

Mit dieser Erweiterung können Sie eine veränderbare ArrayInstanz an Ort und Stelle mischen :

extension Array {
    mutating func shuffle() {
        if count < 2 { return }
        for i in 0..<(count - 1) {
            let j = Int(arc4random_uniform(UInt32(count - i))) + i
            swap(&self[i], &self[j])
        }
    }
}
var numbers = [1, 2, 3, 4, 5, 6, 7, 8]
numbers.shuffle()                     // e.g., numbers == [6, 1, 8, 3, 2, 4, 7, 5]

shuffled als nicht mutierende Array-Methode

Mit dieser Erweiterung können Sie eine gemischte Kopie einer ArrayInstanz abrufen :

extension Array {
    func shuffled() -> [T] {
        if count < 2 { return self }
        var list = self
        for i in 0..<(list.count - 1) {
            let j = Int(arc4random_uniform(UInt32(list.count - i))) + i
            swap(&list[i], &list[j])
        }
        return list
    }
}
let numbers = [1, 2, 3, 4, 5, 6, 7, 8]
let mixedup = numbers.shuffled()     // e.g., mixedup == [6, 1, 8, 3, 2, 4, 7, 5]

Bearbeiten: Wie in anderen Antworten erwähnt, fügt Swift 4.2 der Standardbibliothek schließlich eine Zufallszahlengenerierung hinzu, einschließlich Array-Shuffling.

Die GKRandom/ GKRandomDistributionsuite in GameplayKit kann jedoch mit dem neuen RandomNumberGeneratorProtokoll weiterhin nützlich sein. Wenn Sie den GameplayKit-RNGs Erweiterungen hinzufügen, um sie an das neue Standardbibliotheksprotokoll anzupassen, erhalten Sie auf einfache Weise:

• sendbare RNGs (die eine "zufällige" Sequenz reproduzieren können, wenn sie zum Testen benötigt werden)
• RNGs, die Robustheit für Geschwindigkeit opfern
• RNGs, die ungleichmäßige Verteilungen erzeugen

... und nutzen Sie trotzdem die netten neuen "nativen" Zufalls-APIs in Swift.

Der Rest dieser Antwort betrifft solche RNGs und / oder ihre Verwendung in älteren Swift-Compilern.

Hier gibt es bereits einige gute Antworten sowie einige gute Beispiele dafür, warum das Schreiben eines eigenen Shuffle fehleranfällig sein kann, wenn Sie nicht vorsichtig sind.

In iOS 9, macOS 10.11 und tvOS 9 (oder höher) müssen Sie keine eigenen schreiben. Es gibt eine effiziente, korrekte Implementierung von Fisher-Yates in GameplayKit (das trotz des Namens nicht nur für Spiele gedacht ist).

Wenn Sie nur ein einzigartiges Shuffle möchten:

let shuffled = GKRandomSource.sharedRandom().arrayByShufflingObjects(in: array)

Wenn Sie in der Lage sein möchten, ein Mischen oder eine Reihe von Mischen zu replizieren, wählen Sie eine bestimmte zufällige Quelle aus und setzen Sie sie. z.B

let lcg = GKLinearCongruentialRandomSource(seed: mySeedValue)
let shuffled = lcg.arrayByShufflingObjects(in: array)

In iOS 10 / macOS 10.12 / tvOS 10 gibt es auch eine praktische Syntax zum Mischen über eine Erweiterung NSArray. Das ist natürlich etwas umständlich, wenn Sie einen Swift verwenden Array(und er verliert seinen Elementtyp, wenn Sie zu Swift zurückkehren):

let shuffled1 = (array as NSArray).shuffled(using: random) // -> [Any]
let shuffled2 = (array as NSArray).shuffled() // use default random source

Aber es ist ziemlich einfach, einen typerhaltenden Swift-Wrapper dafür zu erstellen:

extension Array {
    func shuffled(using source: GKRandomSource) -> [Element] {
        return (self as NSArray).shuffled(using: source) as! [Element]
    }
    func shuffled() -> [Element] {
        return (self as NSArray).shuffled() as! [Element]
    }
}
let shuffled3 = array.shuffled(using: random)
let shuffled4 = array.shuffled()

In Swift 2.0 kann GameplayKit Abhilfe schaffen! (unterstützt von iOS9 oder höher)

import GameplayKit

func shuffle() {
    array = GKRandomSource.sharedRandom().arrayByShufflingObjectsInArray(array)
}

Hier ist etwas möglicherweise etwas kürzer:

sorted(a) {_, _ in arc4random() % 2 == 0}

Mit dem Algorithmus von Nate wollte ich sehen, wie dies mit Swift 2 und Protokollerweiterungen aussehen würde.

Das habe ich mir ausgedacht.

extension MutableCollectionType where Self.Index == Int {
    mutating func shuffleInPlace() {
        let c = self.count
        for i in 0..<(c - 1) {
            let j = Int(arc4random_uniform(UInt32(c - i))) + i
            swap(&self[i], &self[j])
        }
    }
}

extension MutableCollectionType where Self.Index == Int {
    func shuffle() -> Self {
        var r = self
        let c = self.count
        for i in 0..<(c - 1) {
            let j = Int(arc4random_uniform(UInt32(c - i))) + i
            swap(&r[i], &r[j])
        }
        return r
    }
}

Jetzt kann jeder MutableCollectionTypediese Methoden verwenden, vorausgesetzt, er verwendet IntalsIndex

In meinem Fall hatte ich einige Probleme beim Austauschen von Objekten in Array. Dann kratzte ich mich am Kopf und erfand das Rad neu.

// swift 3.0 ready
extension Array {

    func shuffled() -> [Element] {
        var results = [Element]()
        var indexes = (0 ..< count).map { $0 }
        while indexes.count > 0 {
            let indexOfIndexes = Int(arc4random_uniform(UInt32(indexes.count)))
            let index = indexes[indexOfIndexes]
            results.append(self[index])
            indexes.remove(at: indexOfIndexes)
        }
        return results
    }

}

Dies ist eine Version von Nates Implementierung des Fisher-Yates-Shuffle für Swift 4 (Xcode 9).

extension MutableCollection {
    /// Shuffle the elements of `self` in-place.
    mutating func shuffle() {
        for i in indices.dropLast() {
            let diff = distance(from: i, to: endIndex)
            let j = index(i, offsetBy: numericCast(arc4random_uniform(numericCast(diff))))
            swapAt(i, j)
        }
    }
}

extension Collection {
    /// Return a copy of `self` with its elements shuffled
    func shuffled() -> [Element] {
        var list = Array(self)
        list.shuffle()
        return list
    }
}

Die Änderungen sind:

• Die Einschränkung Indices.Iterator.Element == Indexist jetzt Teil des CollectionProtokolls und muss der Erweiterung nicht mehr auferlegt werden.
• Der Austausch von Elementen muss durch Aufrufen swapAt()der Sammlung erfolgen, vergleiche SE-0173 HinzufügenMutableCollection.swapAt(_:_:) .
• Elementist ein Alias ​​für Iterator.Element.

Das benutze ich:

func newShuffledArray(array:NSArray) -> NSArray {
    var mutableArray = array.mutableCopy() as! NSMutableArray
    var count = mutableArray.count
    if count>1 {
        for var i=count-1;i>0;--i{
            mutableArray.exchangeObjectAtIndex(i, withObjectAtIndex: Int(arc4random_uniform(UInt32(i+1))))
        }
    }
    return mutableArray as NSArray
}

Swift 4 Mische die Elemente eines Arrays in einer for-Schleife, wobei i das Mischungsverhältnis ist

var cards = [Int]() //Some Array
let i = 4 // is the mixing ratio
func shuffleCards() {
    for _ in 0 ..< cards.count * i {
        let card = cards.remove(at: Int(arc4random_uniform(UInt32(cards.count))))
        cards.insert(card, at: Int(arc4random_uniform(UInt32(cards.count))))
    }
}

Oder mit der Erweiterung Int

func shuffleCards() {
    for _ in 0 ..< cards.count * i {
        let card = cards.remove(at: cards.count.arc4random)
        cards.insert(card, at: cards.count.arc4random)
    }
}
extension Int {
    var arc4random: Int {
        if self > 0 {
            print("Arc for random positiv self \(Int(arc4random_uniform(UInt32(self))))")
        return Int(arc4random_uniform(UInt32(self)))
        } else if self < 0 {
            print("Arc for random negotiv self \(-Int(arc4random_uniform(UInt32(abs(self)))))")
            return -Int(arc4random_uniform(UInt32(abs(self))))
        } else {
            print("Arc for random equal 0")
            return 0
        }
    }
}

Swift 3-Lösung, folgende Antwort von @Nate Cook: (Arbeiten, wenn der Index mit 0 beginnt, siehe Kommentare unten)

extension Collection {
    /// Return a copy of `self` with its elements shuffled
    func shuffle() -> [Generator.Element] {
        var list = Array(self)
        list.shuffleInPlace()
        return list
    } }

extension MutableCollection where Index == Int {
    /// Shuffle the elements of `self` in-place.
    mutating func shuffleInPlace() {
        // empty and single-element collections don't shuffle
        if count < 2 { return }
        let countInt = count as! Int

    for i in 0..<countInt - 1 {
        let j = Int(arc4random_uniform(UInt32(countInt - i))) + i
            guard i != j else { continue }
            swap(&self[i], &self[j])
        }
    }
}

So wird es auf einfachste Weise gemacht. import Gamplaykitzu Ihrem VC und verwenden Sie den folgenden Code. Getestet in Xcode 8.

 import GameplayKit

 let array: NSArray = ["Jock", "Ellie", "Sue Ellen", "Bobby", "JR", "Pamela"]

 override func viewDidLoad() {
    super.viewDidLoad()

    print(array.shuffled())  
}

Wenn Sie einen gemischten String aus einem Array erhalten möchten, können Sie den folgenden Code verwenden.

func suffleString() {

    let ShuffleArray = array.shuffled()

    suffleString.text = ShuffleArray.first as? String

    print(suffleString.text!)

}

Wenn Sie mit Swift 3 ein Array an Ort und Stelle mischen oder ein neues gemischtes Array aus einem Array abrufen möchten, AnyIteratorkann dies hilfreich sein. Die Idee ist, ein Array von Indizes aus Ihrem Array zu erstellen, diese Indizes mit einer AnyIteratorInstanz und swap(_:_:)Funktion zu mischen und jedes Element dieser AnyIteratorInstanz dem entsprechenden Element des Arrays zuzuordnen .

Der folgende Spielplatzcode zeigt, wie es funktioniert:

import Darwin // required for arc4random_uniform

let array = ["Jock", "Ellie", "Sue Ellen", "Bobby", "JR", "Pamela"]
var indexArray = Array(array.indices)
var index = indexArray.endIndex

let indexIterator: AnyIterator<Int> = AnyIterator {
    guard let nextIndex = indexArray.index(index, offsetBy: -1, limitedBy: indexArray.startIndex)
        else { return nil }

    index = nextIndex
    let randomIndex = Int(arc4random_uniform(UInt32(index)))
    if randomIndex != index {
        swap(&indexArray[randomIndex], &indexArray[index])
    }

    return indexArray[index]
}

let newArray = indexIterator.map { array[$0] }
print(newArray) // may print: ["Jock", "Ellie", "Sue Ellen", "JR", "Pamela", "Bobby"]

Sie können den vorherigen Code umgestalten und eine shuffled()Funktion in einer ArrayErweiterung erstellen , um ein neues gemischtes Array aus einem Array zu erhalten:

import Darwin // required for arc4random_uniform

extension Array {

    func shuffled() -> Array<Element> {
        var indexArray = Array<Int>(indices)        
        var index = indexArray.endIndex

        let indexIterator = AnyIterator<Int> {
            guard let nextIndex = indexArray.index(index, offsetBy: -1, limitedBy: indexArray.startIndex)
                else { return nil }

            index = nextIndex                
            let randomIndex = Int(arc4random_uniform(UInt32(index)))
            if randomIndex != index {
                swap(&indexArray[randomIndex], &indexArray[index])
            }

            return indexArray[index]
        }

        return indexIterator.map { self[$0] }
    }

}

Verwendungszweck:

let array = ["Jock", "Ellie", "Sue Ellen", "Bobby", "JR", "Pamela"]
let newArray = array.shuffled()
print(newArray) // may print: ["Bobby", "Pamela", "Jock", "Ellie", "JR", "Sue Ellen"]

let emptyArray = [String]()
let newEmptyArray = emptyArray.shuffled()
print(newEmptyArray) // prints: []

Alternativ zum vorherigen Code können Sie eine shuffle()Funktion in einer ArrayErweiterung erstellen , um ein Array an Ort und Stelle zu mischen:

import Darwin // required for arc4random_uniform

extension Array {

    mutating func shuffle() {
        var indexArray = Array<Int>(indices)
        var index = indexArray.endIndex

        let indexIterator = AnyIterator<Int> {
            guard let nextIndex = indexArray.index(index, offsetBy: -1, limitedBy: indexArray.startIndex)
                else { return nil }

            index = nextIndex                
            let randomIndex = Int(arc4random_uniform(UInt32(index)))
            if randomIndex != index {
                swap(&indexArray[randomIndex], &indexArray[index])
            }

            return indexArray[index]
        }

        self = indexIterator.map { self[$0] }
    }

}

Verwendungszweck:

var mutatingArray = ["Jock", "Ellie", "Sue Ellen", "Bobby", "JR", "Pamela"]
mutatingArray.shuffle()
print(mutatingArray) // may print ["Sue Ellen", "Pamela", "Jock", "Ellie", "Bobby", "JR"]

Sie können auch die generische swapFunktion verwenden und die genannten Fisher-Yates implementieren:

for idx in 0..<arr.count {
  let rnd = Int(arc4random_uniform(UInt32(idx)))
  if rnd != idx {
    swap(&arr[idx], &arr[rnd])
  }
}

oder weniger ausführlich:

for idx in 0..<steps.count {
  swap(&steps[idx], &steps[Int(arc4random_uniform(UInt32(idx)))])
}

funktioniert !!. Organismen ist das Array zu mischen.

extension Array
{
    /** Randomizes the order of an array's elements. */
    mutating func shuffle()
    {
        for _ in 0..<10
        {
            sort { (_,_) in arc4random() < arc4random() }
        }
    }
}

var organisms = [
    "ant",  "bacteria", "cougar",
    "dog",  "elephant", "firefly",
    "goat", "hedgehog", "iguana"]

print("Original: \(organisms)")

organisms.shuffle()

print("Shuffled: \(organisms)")

In Swift 4.2 gibt es jetzt eine Methode sowohl für eine veränderlicheshuffle als auch für eine unveränderlicheshuffled . Weitere Informationen zur zufälligen Generierung und zum Array-Material finden Sie hier .

So mischen Sie ein Array mit einem Startwert in Swift 3.0.

extension MutableCollection where Indices.Iterator.Element == Index {
    mutating func shuffle() {
        let c = count
        guard c > 1 else { return }


        for (firstUnshuffled , unshuffledCount) in zip(indices, stride(from: c, to: 1, by: -1)) {
            srand48(seedNumber)
            let number:Int = numericCast(unshuffledCount)
            let r = floor(drand48() * Double(number))

            let d: IndexDistance = numericCast(Int(r))
            guard d != 0 else { continue }
            let i = index(firstUnshuffled, offsetBy: d)
            swap(&self[firstUnshuffled], &self[i])
        }
    }
}

let shuffl = GKRandomSource.sharedRandom().arrayByShufflingObjects(in: arrayObject)

Das benutze ich:

import GameplayKit

extension Collection {
    func shuffled() -> [Iterator.Element] {
        let shuffledArray = (self as? NSArray)?.shuffled()
        let outputArray = shuffledArray as? [Iterator.Element]
        return outputArray ?? []
    }
    mutating func shuffle() {
        if let selfShuffled = self.shuffled() as? Self {
            self = selfShuffled
        }
    }
}

// Usage example:

var numbers = [1,2,3,4,5]
numbers.shuffle()

print(numbers) // output example: [2, 3, 5, 4, 1]

print([10, "hi", 9.0].shuffled()) // output example: [hi, 10, 9]

Einfaches Beispiel:

extension Array {
    mutating func shuffled() {
        for _ in self {
            // generate random indexes that will be swapped
            var (a, b) = (Int(arc4random_uniform(UInt32(self.count - 1))), Int(arc4random_uniform(UInt32(self.count - 1))))
            if a == b { // if the same indexes are generated swap the first and last
                a = 0
                b = self.count - 1
            }
            swap(&self[a], &self[b])
        }
    }
}

var array = [1,2,3,4,5,6,7,8,9,10]
array.shuffled()
print(array) // [9, 8, 3, 5, 7, 6, 4, 2, 1, 10]

Working Array Extension (mutierend und nicht mutierend)

Swift 4.1 / Xcode 9

Die Top-Antwort ist veraltet, daher habe ich es mir zur Aufgabe gemacht, eine eigene Erweiterung zu erstellen, um ein Array in der neuesten Version von Swift, Swift 4.1 (Xcode 9), zu mischen:

extension Array {

// Non-mutating shuffle
    var shuffled : Array {
        let totalCount : Int = self.count
        var shuffledArray : Array = []
        var count : Int = totalCount
        var tempArray : Array = self
        for _ in 0..<totalCount {
            let randomIndex : Int = Int(arc4random_uniform(UInt32(count)))
            let randomElement : Element = tempArray.remove(at: randomIndex)
            shuffledArray.append(randomElement)
            count -= 1
        }
        return shuffledArray
    }

// Mutating shuffle
    mutating func shuffle() {
        let totalCount : Int = self.count
        var shuffledArray : Array = []
        var count : Int = totalCount
        var tempArray : Array = self
        for _ in 0..<totalCount {
            let randomIndex : Int = Int(arc4random_uniform(UInt32(count)))
            let randomElement : Element = tempArray.remove(at: randomIndex)
            shuffledArray.append(randomElement)
            count -= 1
        }
        self = shuffledArray
    }
}

Nicht mutierendes Shuffle nennen [Array] -> [Array]:

let array = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]

print(array.shuffled)

Dies wird arrayin zufälliger Reihenfolge gedruckt .

Mutating Shuffle nennen [Array] = [Array]:

var array = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]

array.shuffle() 
// The array has now been mutated and contains all of its initial 
// values, but in a randomized shuffled order

print(array) 

Dies wird arrayin der aktuellen Reihenfolge gedruckt , die bereits zufällig gemischt wurde.

Ich hoffe, dass dies für alle funktioniert. Wenn Sie Fragen, Anregungen oder Kommentare haben, können Sie diese gerne stellen!

In SWIFT 4

func createShuffledSequenceOfNumbers(max:UInt)->[UInt] {

    var array:[UInt]! = []
    var myArray:[UInt]! = []
    for i in 1...max {
        myArray.append(i)
    }
    for i in 1...max {
        array.append(i)
    }
    var tempArray:[Int]! = []
    for index in 0...(myArray.count - 1) {

        var isNotFinded:Bool = true
        while(isNotFinded){

            let randomNumber = arc4random_uniform(UInt32(myArray.count))
            let randomIndex = Int(randomNumber)

            if(!tempArray.contains(randomIndex)){
                tempArray.append(randomIndex)

                array[randomIndex] = myArray[index]
                isNotFinded = false
            }
        }
    }

    return array
}

Wenn Sie eine einfache Swift For-Schleifenfunktion verwenden möchten, verwenden Sie diese ->

var arrayItems = ["A1", "B2", "C3", "D4", "E5", "F6", "G7", "H8", "X9", "Y10", "Z11"]
var shuffledArray = [String]()

for i in 0..<arrayItems.count
{
    let randomObject = Int(arc4random_uniform(UInt32(items.count)))

    shuffledArray.append(items[randomObject])

    items.remove(at: randomObject)
}

print(shuffledArray)

Swift Array genügt mit der Erweiterung ->

extension Array {
    // Order Randomize
    mutating func shuffle() {
        for _ in 0..<count {
            sort { (_,_) in arc4random() < arc4random() }
        }
    }
}

Ab Swift 4.2 gibt es zwei praktische Funktionen:

// shuffles the array in place
myArray.shuffle()

und

// generates a new array with shuffled elements of the old array
let newArray = myArray.shuffled()

Hier ist ein Code, der auf dem Spielplatz ausgeführt wird. Sie müssen Darwin nicht in ein aktuelles Xcode-Projekt importieren.

import darwin

var a = [1,2,3,4,5,6,7]

func shuffle<ItemType>(item1: ItemType, item2: ItemType) -> Bool {
    return drand48() > 0.5
}

sort(a, shuffle)

println(a)

Es stoppt bei "Swap (& self [i], & self [j])", wenn ich die xCode-Version auf 7.4 Beta aktualisiere.
Schwerwiegender Fehler: Das Austauschen eines Standorts mit sich selbst wird nicht unterstützt

Ich habe den Grund gefunden, dass i = j (Funktion des Swaps wird explodieren)

Also füge ich eine Bedingung wie unten hinzu

if (i != j){
    swap(&list[i], &list[j])
}

YA! Für mich ist das in Ordnung.