iphone - precios - compara dos matrices y consigue los elementos comunes

ipad pro 2018

Question

Tengo dos matrices, pero tienen diferentes longitudes . Quiero comparar estas dos matrices y colocar elementos comunes en una nueva matriz . Mientras tanto, no debería haber elementos duplicados en la tercera matriz. Realmente me equivoqué con esto, por favor, ayúdame. muy agradecido . .

Answer 1

¿Algo como esto?

NSMutableSet* set1 = [NSMutableSet setWithArray:array1];
NSMutableSet* set2 = [NSMutableSet setWithArray:array2];
[set1 intersectSet:set2]; //this will give you only the obejcts that are in both sets

NSArray* result = [set1 allObjects];

Esto tiene la ventaja de no buscar los objetos en la matriz, mientras recorre otra matriz, que tiene una complejidad de N ^ 2 y puede tomar un tiempo si las matrices son grandes.

Edición: set2 no tiene que ser mutable, también podría usarlo

NSSet* set2 = [NSSet setWithArray:array2];

Answer 2

Iterar sobre array1 y buscarlo en array2. Si lo encuentra, agréguelo a array3 si aún no lo tiene.

for (MyObject* obj in array1)
{ 
     if([array2 containsObject:obj] && ![array3 containsObject:obj])
        [array3 addObject:obj];
}

Si array1 no tiene elementos duplicados, no necesita la segunda comprobación.

HTH,

Akshay

Answer 3

Un tercer enfoque (además de usar conjuntos o el simple bucle que verifica cada elemento con contiene) sería ordenar ambas matrices y luego usar dos índices:

// approach using sets:

NSArray *arrayUsingSets(NSMutableArray *arr1, NSMutableArray *arr2)
{
    NSMutableSet *set1 = [NSMutableSet setWithArray: arr1];
    NSSet *set2 = [NSSet setWithArray: arr2];
    [set1 intersectSet: set2];
    return [set1 allObjects];
}

// my approach:

NSArray *arrayUsingComp(NSMutableArray *arr1, NSMutableArray *arr2)
{
    NSMutableArray *results = [NSMutableArray arrayWithCapacity: arr1.count + arr2.count];

    // Assumes input arrays are sorted. If not, uncomment following two lines.
//    [arr1 sortUsingSelector: @selector(compare:)];
//    [arr2 sortUsingSelector: @selector(compare:)];

    int i = 0;
    int j = 0;
    while ((i < arr1.count) && (j < arr2.count))
    {
        switch ([[arr1 objectAtIndex: i] compare: [arr2 objectAtIndex: j]])
        {
            case NSOrderedSame:
                [results addObject: [arr1 objectAtIndex: i]];
                i++, j++;
                break;
            case NSOrderedAscending:
                i++;
                break;
            case NSOrderedDescending:
                j++;
                break;
         }
    }

    // NOTE: results are sorted too.
    // NOTE 2: loop must go "backward".
    for (NSInteger k = results.count - 1; k > 0; k--) 
        if ([[results objectAtIndex: k] isEqual: [results objectAtIndex: k-1]])
            [results removeObjectAtIndex: k];

    return results;    
}

Hice algunos perfiles simples, y si hago copias mutables de los arreglos pasados ​​y los clasifico, se realiza 1.5 veces más lento que el método que usa los conjuntos. Mi enfoque anterior parece funcionar 1.5 veces más rápido que el enfoque utilizando conjuntos. Si se garantiza que los arreglos ya estarán ordenados, mi enfoque funcionará aún mejor ( casi 4 veces más rápido que la versión que usa conjuntos), ya que no se requiere clasificación.

Actualizar:

Esto no eliminó los duplicados, así que agregué el bucle al final de la rutina. Ahora es solo 3 veces más rápido que el enfoque usando conjuntos, pero aún así ...