스위프트에서 배열을 섞으려면 어떻게 해야 합니까?

스위프트에서 배열을 섞으려면 어떻게 해야 합니까?

.shuffle() 및 .shuffled()는 Swift의 일부입니다.

---

원래의 과거 질문:

Swift에서 배열 내의 요소를 랜덤화하거나 섞으려면 어떻게 해야 합니까?예를 들어, 내 배열이 52개의 플레이 카드로 구성된 경우, 배열을 섞어서 데크를 섞으려고 합니다.

이 답변은 Swift 4.2+에서 빠르고 균일한 알고리즘(Fisher-Yates)과 셔플하는 방법과 다양한 이전 버전의 Swift에서 동일한 기능을 추가하는 방법을 자세히 설명합니다.각 Swift 버전의 이름 및 동작은 해당 버전의 변환 및 비변환 정렬 방법과 일치합니다.

Swift 4.2+

shuffle Swift 4.2 이후 버전은 네이티브입니다.사용 예:

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 및 4.1

이러한 확장은 다음을 추가합니다.shuffle() mutable (하지 않은 buffers) 및a " " " " " " (으)로 변환합니다.shuffled()모든 시퀀스에 대한 방법:

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
    }
}

위의 Swift 4.2 예제와 동일한 사용법입니다.

---

스위프트 3

이러한 확장은 다음을 추가합니다.shuffle()의 변형 및 a 의의변가컬에대방한법과션a.shuffled()모든 시퀀스에 대한 방법:

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
    }
}

위의 Swift 4.2 예제와 동일한 사용법입니다.

---

스위프트 2

(구어: 2018년 7월부터 Swift 2.x를 사용하여 iTunes Connect에 게시할 수 없습니다.)

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
    }
}

용도:

[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]

---

스위프트 1.2

(구어: 2018년 7월부터 Swift 1.x를 사용하여 iTunes Connect에 게시할 수 없습니다.)

shuffle 배열

이 확장을 사용하여 변수를 섞을 수 있습니다.Array다음은 다음과 같습니다.

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 배열

이 확장 기능을 사용하면 다음 항목의 혼합된 복사본을 검색할 수 있습니다.Array인스턴스:

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]

편집: 다른 답변에서 언급한 바와 같이 Swift 4.2는 어레이 셔플링을 통해 임의의 숫자 생성을 표준 라이브러리에 추가합니다.

하만지그, 그.GKRandom/GKRandomDistribution게임플레이 키트의 제품군은 여전히 새로운 제품에서 유용할 수 있습니다.RandomNumberGenerator프로토콜 — 새로운 표준 라이브러리 프로토콜을 준수하도록 GameworkKit RNG에 확장 기능을 추가하면 다음을 쉽게 얻을 수 있습니다.

• 전송 가능한 RNG(테스트에 필요할 때 "랜덤" 시퀀스를 재현할 수 있음)
• 속도 향상을 위해 견고성을 희생하는 RNG
• 불균일한 분포를 생성하는 RNG

...Swift의 새로운 "네이티브" 랜덤 API를 계속 사용합니다.

이 답변의 나머지 부분은 RNG 및/또는 이전 Swift 컴파일러에서의 사용에 관한 것입니다.

---

여기에는 이미 몇 가지 좋은 답변과 함께, 자신만의 셔플을 작성하는 것이 조심하지 않으면 오류가 발생하기 쉬운 이유에 대한 몇 가지 좋은 설명이 있습니다.

iOS 9, macOS 10.11 및 tvOS 9(또는 그 이상)에서는 직접 작성할 필요가 없습니다.게임플레이 키트에는 Fisher-Yates의 효율적이고 정확한 구현이 있습니다(이름에도 불구하고 게임에만 해당되지 않습니다).

고유한 셔플을 원하는 경우:

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

셔플 또는 일련의 셔플을 복제하려면 특정 랜덤 소스를 선택하여 시드합니다.

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

/ 10/ 10에는 10 / macOS 10.12 / tvOS 10의 을 위한 NSArray스위프트를좀 요.Array(Swift로 돌아오면 요소 유형이 손실됩니다.)

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

그러나 유형 보존용 Swift 래퍼를 만드는 것은 매우 쉽습니다.

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()

스위프트 2.0에서는 게임플레이 키트가 구조될 수 있습니다! (iOS9 이상에서 지원)

import GameplayKit

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

여기 좀 더 짧은 것이 있을 수 있습니다.

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

네이트의 알고리즘을 사용하여 Swift 2와 프로토콜 확장 기능을 사용하면 어떻게 보이는지 알고 싶었습니다.

이것이 제가 생각해 낸 것입니다.

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
    }
}

임의의 자, 아나MutableCollectionType사용하는 경우 이러한 방법을 사용할 수 있습니다.Int한 사람으로서Index

swift 4.2 기준으로 두 가지 편리한 기능이 있습니다.

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

그리고.

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

저의 경우 Array에서 객체를 스와핑하는 데 문제가 있었습니다.그리고 나서 저는 머리를 긁적이며 바퀴를 재창조하려고 했습니다.

// 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
    }

}

이것은 네이트가 스위프트 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
    }
}

변경 사항은 다음과 같습니다.

• 조건 약조 Indices.Iterator.Element == Index▁of의 일부입니다.Collection프로토콜이며, 더 이상 확장에 적용할 필요가 없습니다.
• 요소 교환은 호출을 통해 수행해야 합니다.swapAt()컬렉션에서 SE-0173 Add를 비교합니다.
• Element는 의 별칭입니다.Iterator.Element.

Swift 4 i가 혼합비인 for 루프에서 배열의 요소를 섞습니다.

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))))
    }
}

또는 확장자 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
        }
    }
}

다음을 사용합니다.

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
}

@Nate Cook 답변에 이은 Swift 3 솔루션: (인덱스가 0으로 시작하는 경우 작업, 아래 설명 참조)

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])
        }
    }
}

이것이 가장 간단한 방법입니다.import Gamplaykit다음 코드를 사용하십시오. 8Xcode 8에서 되었습니다.

 import GameplayKit

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

 override func viewDidLoad() {
    super.viewDidLoad()

    print(array.shuffled())  
}

배열에서 셔플된 문자열을 가져오려면 아래 코드를 사용할 수 있습니다.

func suffleString() {

    let ShuffleArray = array.shuffled()

    suffleString.text = ShuffleArray.first as? String

    print(suffleString.text!)

}

Swift 3을 사용하면 배열을 제자리에서 섞거나 배열에서 새 배열을 가져오는 데 도움이 될 수 있습니다.이 아이디어는 배열에서 인덱스 배열을 만들고 이러한 인덱스를 다음과 같이 섞는 것입니다.AnyIterator인스턴스와 함수 및 이의 각 요소를 매핑합니다.AnyIterator배열의 해당 요소가 있는 인스턴스입니다.

---

다음 Playground 코드는 작동 방식을 보여줍니다.

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"]

---

이전 코드를 리팩터링하고 다음을 생성할 수 있습니다.shuffled()내부의 기능Array배열에서 새 셔플 배열을 가져오려면 확장:

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] }
    }

}

용도:

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: []

---

이전 코드의 대안으로 다음을 만들 수 있습니다.shuffle()내부의 기능Array배열을 제자리에 섞으려면 확장자:

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] }
    }

}

용도:

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

Swift 4.2에서는 이제 변수와 변수 모두에 대한 방법이 있습니다.랜덤 생성 및 배열에 대한 자세한 내용은 여기를 참조하십시오.

제네릭을 사용할 수 있습니다.swapFisher-Yates에 언급된 기능 및 구현:

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

또는 그 이하의 장황성:

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

효과가 있습니다.유기체는 섞기 위한 배열입니다.

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)")

작동 배열 확장(변종 및 비변종)

Swift 4.1 / Xcode 9

상위 답변은 더 이상 사용되지 않으므로 저는 Swift 4.1(Xcode 9)의 최신 버전에서 어레이를 셔플하기 위해 직접 확장자를 만들었습니다.

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
    }
}

---

통화 비변조 셔플[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)

인쇄합니다.array난수순으로

---

통화 음소거 순서 섞기[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) 

인쇄합니다.array이미 무작위로 뒤섞인 현재 순서대로.

---

모두에게 효과가 있기를 바랍니다. 질문, 제안 또는 의견이 있으면 언제든지 물어보세요!

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
}

간단한 Swift For 루프 기능을 사용하고 싶다면 이것을 사용하세요 ->

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 suffle ->

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

이것은 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)

다음을 사용합니다.

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]

간단한 예:

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]

여기 놀이터에서 실행되는 코드가 있습니다.실제 Xcode 프로젝트에서는 Darwin을 가져올 필요가 없습니다.

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)

xCode 버전을 7.4 베타로 업그레이드하면 "swap(&self[i], &self[j])"에서 중지됩니다.
오류:되지 않습니다. 즉, 위치 자체를 스와핑할 수 없습니다.

i = j(스왑 기능이 폭발할 것임)의 이유를 찾았습니다.

그래서 아래와 같은 조건을 추가합니다.

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

YA! 저는 괜찮아요.

언급URL : https://stackoverflow.com/questions/24026510/how-do-i-shuffle-an-array-in-swift