¿Cuál es la mejor manera de barajar un NSMutableArray?

Question

Si tiene NSMutableArray, ¿cómo baraja los elementos aleatoriamente?

(tengo mi propia respuesta para esto, lo que se publica a continuación, pero soy nuevo en cacao y estoy interesado en saber si hay una manera mejor.)

---

Actualización: Como señalado por @Mukesh, a partir de iOS 10+ y macOS 10.12+, existe un método -[NSMutableArray shuffledArray] que se puede usar para mezclar. Ver https://developer.apple.com/documentation/foundation/nsarray/1640855-shuffledarray?language=objc para más detalles. (Pero tenga en cuenta que esto crea una nueva matriz, en lugar de mezclar los elementos en su lugar.)

Answer 1

No necesita el método swapObjectAtIndex. exchangeObjectAtIndex:withObjectAtIndex: ya existe.

Answer 2

Resolví esto agregando una categoría a NSMutableArray.

Editar: Se eliminó el método innecesario gracias a la respuesta de Ladd.

Editar: Cambiado (arc4random() % nElements) a arc4random_uniform(nElements) gracias a contestar por Gregory Goltsov y comentarios de Miho y blahdiblah

Editar: mejora Loop, gracias al comentario de Ron

Editar: cheque Agregado esa matriz no está vacía, gracias al comentario de 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 

Answer 3

Esta es la forma más sencilla y rápida para mezclar NSArrays o NSMutableArrays (rompecabezas de objetos es un NSMutableArray, que contiene objetos rompecabezas. He añadido a rompecabezas objeto de índice variable que indica la posición inicial en la matriz)

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

salida del 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 

es posible que así comparar con obj1 obj2 y decidir lo que desea devolver valores posibles son:

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

Answer 4

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

Answer 5

Dado que todavía no puedo comentar, pensé que había aportar una respuesta completa. Modifiqué la implementación de Kristopher Johnson para mi proyecto de varias maneras (realmente tratando de hacerlo lo más conciso posible), una de ellas es arc4random_uniform() porque evita modulo bias.

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

Answer 6

Hay una buena biblioteca popular, que tiene este método ya que es parte, llamada SSToolKit in GitHub. El archivo NSMutableArray + SSToolkitAdditions.h contiene el método de mezcla aleatoria. Puedes usarlo también Entre esto, parece que hay toneladas de cosas útiles.

La página principal de esta biblioteca es here.

Si se utiliza este, su código será la siguiente:

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

Esta biblioteca también tiene una vaina (ver CocoaPods)

Answer 7

Si los elementos tienen repeticiones.

p. Ej. matriz: A A A B B o B B A A A

única solución es: A B A B A

sequenceSelected es un NSMutableArray que almacena elementos de obj clase, que son punteros a alguna secuencia.

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

Answer 8

Kristopher Johnson's answer es bastante agradable, pero no es totalmente aleatorio.

Dada una matriz de 2 elementos, esta función devuelve siempre la matriz inversa, porque está generando el rango de su azar sobre el resto de los índices. Una función más precisa shuffle() sería como

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

Answer 9

Editar: Esto no es correcto. Como referencia, no eliminé esta publicación. Vea los comentarios sobre la razón por la cual este enfoque no es correcto.

código simple aquí:

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

Answer 10

Después de editar las respuestas más, pensé en compartir una solución ligeramente mejorado y concisa.

El algoritmo es el mismo y se describe en la literatura como "Fisher-Yates shuffle".

En ObjectiveC:

@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 

En Swift 3.2 y 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)))) 
     } 
    } 
} 

En Swift 3.0 y 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: A more concise solution in Swift is possible from iOS10 using GameplayKit.

Nota : An algorithm for unstable shuffling (with all positions forced to change if count > 1) is also available

Answer 11

De IOS 10 puede utilizar la nueva API shuffled:

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

let shuffledArray = array.shuffled() 

Answer 12

De IOS 10, puede utilizar NSArray shuffled() from GameplayKit. He aquí un ayudante para la matriz en Swift 3:

import GameplayKit 

extension Array { 
    func shuffled() -> [Element] { 
     return (self as NSArray).shuffled() as! [Element] 
    } 
    mutating func shuffle() { 
     replaceSubrange(0..<count, with: shuffled()) 
    } 
}