Qual è il modo migliore per mescolare un NSMutableArray?

Se hai un NSMutableArray , come mescoli gli elementi in modo casuale?

(Ho una mia risposta per questo, che è pubblicata di seguito, ma sono nuovo di Cocoa e sono interessato a sapere se esiste un modo migliore.)

Aggiornamento: come notato da @Mukesh, a partire da iOS 10+ e macOS 10.12+, esiste un -[NSMutableArray shuffledArray]metodo che può essere utilizzato per la riproduzione casuale. Vedi https://developer.apple.com/documentation/foundation/nsarray/1640855-shuffledarray?language=objc per i dettagli. (Ma nota che questo crea un nuovo array, piuttosto che mescolare gli elementi sul posto.)

Non è necessario il metodo swapObjectAtIndex. exchangeObjectAtIndex: withObjectAtIndex: esiste già.

Ho risolto questo aggiungendo una categoria a NSMutableArray.

Modificare: Rimosso il metodo non necessario grazie alla risposta di Ladd.

Modifica: modificato (arc4random() % nElements)inarc4random_uniform(nElements) grazie alla risposta da Gregory Goltsov e commenti da Miho e blahdiblah

Modifica: miglioramento del ciclo, grazie al commento di Ron

Modifica: aggiunto verificare che l'array non sia vuoto, grazie al commento di Mahesh Agrawal

//  NSMutableArray_Shuffling.h

#if TARGET_OS_IPHONE
#import <UIKit/UIKit.h>
#else
#include <Cocoa/Cocoa.h>
#endif

// This category enhances NSMutableArray by providing
// methods to randomly shuffle the elements.
@interface NSMutableArray (Shuffling)
- (void)shuffle;
@end


//  NSMutableArray_Shuffling.m

#import "NSMutableArray_Shuffling.h"

@implementation NSMutableArray (Shuffling)

- (void)shuffle
{
    NSUInteger count = [self count];
    if (count <= 1) return;
    for (NSUInteger i = 0; i < count - 1; ++i) {
        NSInteger remainingCount = count - i;
        NSInteger exchangeIndex = i + arc4random_uniform((u_int32_t )remainingCount);
        [self exchangeObjectAtIndex:i withObjectAtIndex:exchangeIndex];
    }
}

@end

Dal momento che non posso ancora commentare, ho pensato di contribuire con una risposta completa. Ho modificato l'implementazione di Kristopher Johnson per il mio progetto in diversi modi (cercando davvero di renderlo il più conciso possibile), uno dei quali è arc4random_uniform()perché evita la distorsione del modulo .

// NSMutableArray+Shuffling.h
#import <Foundation/Foundation.h>

/** This category enhances NSMutableArray by providing methods to randomly
 * shuffle the elements using the Fisher-Yates algorithm.
 */
@interface NSMutableArray (Shuffling)
- (void)shuffle;
@end

// NSMutableArray+Shuffling.m
#import "NSMutableArray+Shuffling.h"

@implementation NSMutableArray (Shuffling)

- (void)shuffle
{
    NSUInteger count = [self count];
    for (uint i = 0; i < count - 1; ++i)
    {
        // Select a random element between i and end of array to swap with.
        int nElements = count - i;
        int n = arc4random_uniform(nElements) + i;
        [self exchangeObjectAtIndex:i withObjectAtIndex:n];
    }
}

@end

Se importi GameplayKit, esiste shuffledun'API:

https://developer.apple.com/reference/foundation/nsarray/1640855-shuffled

let shuffledArray = array.shuffled()

Una soluzione leggermente migliorata e concisa (rispetto alle risposte migliori).

L'algoritmo è lo stesso ed è descritto in letteratura come " shuffle Fisher-Yates ".

In Objective-C:

@implementation NSMutableArray (Shuffle)
// Fisher-Yates shuffle
- (void)shuffle
{
    for (NSUInteger i = self.count; i > 1; i--)
        [self exchangeObjectAtIndex:i - 1 withObjectAtIndex:arc4random_uniform((u_int32_t)i)];
}
@end

In Swift 3.2 e 4.x:

extension Array {
    /// Fisher-Yates shuffle
    mutating func shuffle() {
        for i in stride(from: count - 1, to: 0, by: -1) {
            swapAt(i, Int(arc4random_uniform(UInt32(i + 1))))
        }
    }
}

In Swift 3.0 e 3.1:

extension Array {
    /// Fisher-Yates shuffle
    mutating func shuffle() {
        for i in stride(from: count - 1, to: 0, by: -1) {
            let j = Int(arc4random_uniform(UInt32(i + 1)))
            (self[i], self[j]) = (self[j], self[i])
        }
    }
}

Nota: una soluzione più concisa in Swift è possibile da iOS10 utilizzando GameplayKit.

Nota: è disponibile anche un algoritmo per il mescolamento instabile (con tutte le posizioni costrette a cambiare se il conteggio> 1)

Questo è il modo più semplice e veloce per mescolare NSArrays o NSMutableArrays (gli oggetti puzzle è un NSMutableArray, contiene oggetti puzzle. Ho aggiunto all'indice variabile oggetto puzzle che indica la posizione iniziale nell'array)

int randomSort(id obj1, id obj2, void *context ) {
        // returns random number -1 0 1
    return (random()%3 - 1);    
}

- (void)shuffle {
        // call custom sort function
    [puzzles sortUsingFunction:randomSort context:nil];

    // show in log how is our array sorted
        int i = 0;
    for (Puzzle * puzzle in puzzles) {
        NSLog(@" #%d has index %d", i, puzzle.index);
        i++;
    }
}

uscita registro:

 #0 has index #6
 #1 has index #3
 #2 has index #9
 #3 has index #15
 #4 has index #8
 #5 has index #0
 #6 has index #1
 #7 has index #4
 #8 has index #7
 #9 has index #12
 #10 has index #14
 #11 has index #16
 #12 has index #17
 #13 has index #10
 #14 has index #11
 #15 has index #13
 #16 has index #5
 #17 has index #2

puoi anche confrontare obj1 con obj2 e decidere cosa vuoi restituire possibili valori sono:

• NSOrderedAscending = -1
• NSOrderedSame = 0
• NSOrderedDescending = 1

C'è una bella libreria popolare, che ha questo metodo come parte, chiamata SSToolKit in GitHub . Il file NSMutableArray + SSToolkitAdditions.h contiene il metodo shuffle. Puoi usarlo anche. Tra questi, sembrano esserci tonnellate di cose utili.

La pagina principale di questa biblioteca è qui .

Se lo usi, il tuo codice sarà così:

#import <SSCategories.h>
NSMutableArray *tableData = [NSMutableArray arrayWithArray:[temp shuffledArray]];

Questa libreria ha anche un Pod (vedi CocoaPods)

Da iOS 10, puoi usare NSArray shuffled()da GameplayKit . Ecco un aiuto per Array in Swift 3:

import GameplayKit

extension Array {
    @available(iOS 10.0, macOS 10.12, tvOS 10.0, *)
    func shuffled() -> [Element] {
        return (self as NSArray).shuffled() as! [Element]
    }
    @available(iOS 10.0, macOS 10.12, tvOS 10.0, *)
    mutating func shuffle() {
        replaceSubrange(0..<count, with: shuffled())
    }
}

Se gli elementi hanno ripetizioni.

ad es. array: AAABB o BBAAA

l'unica soluzione è: ABABA

sequenceSelected è un NSMutableArray che memorizza elementi della classe obj, che sono puntatori a una sequenza.

- (void)shuffleSequenceSelected {
    [sequenceSelected shuffle];
    [self shuffleSequenceSelectedLoop];
}

- (void)shuffleSequenceSelectedLoop {
    NSUInteger count = sequenceSelected.count;
    for (NSUInteger i = 1; i < count-1; i++) {
        // Select a random element between i and end of array to swap with.
        NSInteger nElements = count - i;
        NSInteger n;
        if (i < count-2) { // i is between second  and second last element
            obj *A = [sequenceSelected objectAtIndex:i-1];
            obj *B = [sequenceSelected objectAtIndex:i];
            if (A == B) { // shuffle if current & previous same
                do {
                    n = arc4random_uniform(nElements) + i;
                    B = [sequenceSelected objectAtIndex:n];
                } while (A == B);
                [sequenceSelected exchangeObjectAtIndex:i withObjectAtIndex:n];
            }
        } else if (i == count-2) { // second last value to be shuffled with last value
            obj *A = [sequenceSelected objectAtIndex:i-1];// previous value
            obj *B = [sequenceSelected objectAtIndex:i]; // second last value
            obj *C = [sequenceSelected lastObject]; // last value
            if (A == B && B == C) {
                //reshufle
                sequenceSelected = [[[sequenceSelected reverseObjectEnumerator] allObjects] mutableCopy];
                [self shuffleSequenceSelectedLoop];
                return;
            }
            if (A == B) {
                if (B != C) {
                    [sequenceSelected exchangeObjectAtIndex:i withObjectAtIndex:count-1];
                } else {
                    // reshuffle
                    sequenceSelected = [[[sequenceSelected reverseObjectEnumerator] allObjects] mutableCopy];
                    [self shuffleSequenceSelectedLoop];
                    return;
                }
            }
        }
    }
}

NSUInteger randomIndex = arc4random() % [theArray count];

La risposta di Kristopher Johnson è piuttosto carina, ma non è del tutto casuale.

Dato un array di 2 elementi, questa funzione restituisce sempre l'array inverso, perché stai generando l'intervallo del tuo casuale rispetto al resto degli indici. Una shuffle()funzione più accurata sarebbe come

- (void)shuffle
{
   NSUInteger count = [self count];
   for (NSUInteger i = 0; i < count; ++i) {
       NSInteger exchangeIndex = arc4random_uniform(count);
       if (i != exchangeIndex) {
            [self exchangeObjectAtIndex:i withObjectAtIndex:exchangeIndex];
       }
   }
}

Modifica: questo non è corretto. A scopo di riferimento, non ho eliminato questo post. Vedi i commenti sul motivo per cui questo approccio non è corretto.

Codice semplice qui:

- (NSArray *)shuffledArray:(NSArray *)array
{
    return [array sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
        if (arc4random() % 2) {
            return NSOrderedAscending;
        } else {
            return NSOrderedDescending;
        }
    }];
}