2016-02-19 15 views
5

Ho le seguenti matrici:Qual è un modo efficace per trovare elementi disgiunti in due array?

A = [1,2,3,4,5] 
B = [2,6,7,1] 

voglio trovare gli elementi disgiunti, che sono i seguenti:

output = [3,4,5,6,7] 

sono stato in grado di raggiungere questo obiettivo nel modo seguente,

output = A + B - (A & B) 

ma è inefficiente, poiché sto aggiungendo due array e quindi rimuovendo elementi comuni. È simile alla ricerca di elementi non intersecanti. Posso farlo meglio di questo? Se é cosi, come?

risposta

6

Come circa appena la selezione di elementi in A non in B ed elementi in B non in A.

(A - B) + (B - A) 
+1

Se questo funziona, cappello a te e rubino. Più uno. Torna a C++ per me. – Bathsheba

+1

Funziona, ed è una buona risposta, ma non vedo come sia diversa dalla soluzione dell'OP, che usa anche tre operazioni. – sawa

+1

@sawa È diverso perché è quasi 5 volte più lento, vedere i punti di riferimento nella mia risposta. – mudasobwa

6

è possibile utilizzare Set

A = Set[1,2,3,4,5] 
=> #<Set: {5, 1, 2, 3, 4}> 
B = Set[2,6,7,1] 
=> #<Set: {6, 1, 7, 2}> 
C = A^B 
=> #<Set: {5, 6, 7, 3, 4}> 
C.to_a 
=> [5, 6, 7, 3, 4] 
+0

Non hai bisogno di ordinare. 'to_a' è abbastanza. – sawa

+0

Entrambi ricevono un array. Dipende da lui se vuole che l'array sia ordinato o meno. – Ursus

+0

'sort' esegue operazioni extra. L'OP non ha chiesto di ordinare. – sawa

5

Un altro:

(A | B) - (A & B) 

Ma probabilmente vorrai usare la tua versione:

require 'benchmark' 
n = 50000 
A = (1..1000).to_a 
B = [2,6,7,1] 
Benchmark.bm do |x| 
    x.report { n.times do; (A + B) - (A & B); end } 
    x.report { n.times do; (A - B) + (B - A); end } 
    x.report { n.times do; (A | B) - (A & B); end } 
    x.report { n.times do; (Set[*A]^Set[*B]).to_a; end } 
end 

     user  system  total  real 
    2.200000 0.000000 2.200000 ( 2.208357) 
    9.600000 0.010000 9.610000 ( 9.591845) 
    10.630000 0.000000 10.630000 (10.621927) 
    31.420000 0.000000 31.420000 (31.418155) 
+0

È fantastico! Non ho mai saputo, siamo in grado di confrontare applicazioni rubino come questo. Capisco che '(A + B) - (A & B)' si distingue vedendo i risultati. Ma puoi aiutarmi a capire i risultati in dettaglio? Per aggiungere, vuol dire che il modo più efficiente è lo stesso che ho postato in questione? – Abhishek

+0

Sì, il modo più efficiente sembra essere quello che hai pubblicato in origine. Qui eseguiamo quattro test, ogni 50K volte, e stampiamo il tempo che è stato consumato da ciascuno. Come per il risultato, in generale si potrebbe semplicemente confrontare i valori nell'ultima colonna. Altri sono * NIX specifici per l'architettura e non hanno molto senso per la normale applicazione. – mudasobwa

+0

Capito. Ma mostra il tempo, non è vero? E lo spazio? Possiamo ottenere anche quello? Se sì, sarà fantastico. – Abhishek

Problemi correlati