Un elemento che differisce in due matrici. Come trovarlo in modo efficiente?

Mi sto preparando per un colloquio di programmazione e non riesco davvero a capire il modo più efficace per risolvere questo problema.

Supponiamo di avere due array costituiti da numeri non ordinati. L'array 2 contiene un numero che l'array 1 non contiene. Entrambi gli array hanno numeri casuali, non necessariamente nello stesso ordine o negli stessi indici. Per esempio:

Array 1 [78,11, 143, 84, 77, 1, 26, 35 .... n]

Array 2 [11,84, 35, 25, 77, 78, 26, 143 ... 21 ... n + 1]

Qual è l'algoritmo più veloce per trovare il numero che differisce? Qual è il suo tempo di esecuzione? In questo esempio, il numero che cercheremo è 21.

La mia idea era di passare attraverso l'array 1 ed eliminare quel valore dall'array 2. Iterare fino al termine. Dovrebbe essere circa tempo di esecuzione, giusto?$O(n \log n)$

Vedo quattro modi principali per risolvere questo problema, con tempi di esecuzione diversi:

• soluzione: questa sarebbe la soluzione che proponi. Si noti che, poiché le matrici non sono ordinate, la cancellazione richiede un tempo lineare. Esegui n eliminazioni; pertanto, questo algoritmo richiede tempo quadratico.$O(n^2)$$n$

• soluzione: ordinare in anticipo gli array; quindi, eseguire una ricerca lineare per identificare l'elemento distinto. In questa soluzione, il tempo di esecuzione è dominato dall'operazione di ordinamento, quindi O ( $O(n \: log \: n)$ limite superiore.$O(n \: log \: n)$

Quando identifichi una soluzione a un problema, dovresti sempre chiederti: posso fare di meglio? In questo caso, puoi, facendo un uso intelligente delle strutture di dati. Nota che tutto ciò che devi fare è iterare un array ed eseguire ricerche ripetute nell'altro array. Quale struttura di dati ti consente di effettuare ricerche in tempo (previsto) costante? Hai indovinato bene: una tabella di hash .

• soluzione (prevista): itera il primo array e archivia gli elementi in una tabella hash; quindi, eseguire una scansione lineare nel secondo array, cercando ogni elemento nella tabella hash. Restituisce l'elemento che non si trova nella tabella hash. Questa soluzione a tempo lineare funziona per qualsiasi tipo di elemento che è possibile passare a una funzione hash (ad esempio, funzionerebbe in modo simile per le matrici di stringhe).$O(n)$

Se desideri garanzie con limite superiore e gli array sono rigorosamente composti da numeri interi, probabilmente la soluzione migliore è quella suggerita da Tobi Alafin (anche se questa soluzione non ti darà l'indice dell'elemento che differisce nel secondo array) :

• soluzione (garantita): riassume gli elementi del primo array. Quindi, riassumi gli elementi del secondo array. Infine, esegui la sottostrazione. Si noti che questa soluzione può effettivamente essere generalizzata a qualsiasi tipo di dati i cui valori possono essere rappresentati come stringhe di bit a lunghezza fissa, grazieall'operatore XOR bitabit. Questo è completamente spiegato nellarisposta diIlmari Karonen. $O(n)$

Infine, un'altra possibilità (sotto la stessa ipotesi di array di numeri interi) sarebbe quella di utilizzare un algortihm di ordinamento a tempo lineare come il conteggio dell'ordinamento. Ciò ridurrebbe il tempo di esecuzione della soluzione basata sull'ordinamento da a O ( n ) .$O(n \: log \: n)$$O(n)$

Il differenza di somme soluzione proposta da Tobi e Mario può infatti essere generalizzato a qualsiasi altro tipo di dati per cui possiamo definire una (costante di tempo) un'operazione binaria ⊕ che è:$\Theta(n)$$\oplus$

• totale , tale che per tutti i valori e b , un ⊕ b è definito e dello stesso tipo (o almeno di alcune appropriata supertype di esso, per cui l'operatore ⊕ è ancora definita);$a$$b$$a \oplus b$$\oplus$
• associativo , tale che ;$a \oplus (b \oplus c) = (a \oplus b) \oplus c$
• commutativo , tale che ; e$a \oplus b = b \oplus a$
• cancellativo , tale che esiste un operatore inverso che soddisfa ( a ⊕ b ) ⊖ b = a . Tecnicamente, questa operazione inversa non deve necessariamente essere a tempo costante, fintanto che "sottrarre" due somme di n elementi ciascuna non richiede più di O ( n ) tempo.$\ominus$$(a \oplus b) \ominus b = a$$n$${\rm O}(n)$

(Se il tipo può assumere solo un numero finito di valori distinti, queste proprietà sono sufficienti per trasformarlo in un gruppo abeliano ; anche se non lo sarà, sarà almeno un semigruppo di annullamento commutativo .)

Usando tale operazione , possiamo definire la "somma" di un array a = ( a 1 , a 2 , ... , a n ) come ( $\oplus$$a = (a_1, a_2, \dots, a_n)$ Dato un altro array b = ( b 1 , b 2 , … , b n , b n + 1 ) contenente tutti gli elementi di un più un elemento in più x , abbiamo quindi (

Ad esempio, se i valori nelle matrici sono numeri interi, l'aggiunta di numeri interi (o l'aggiunta modulare per tipi di numeri interi di lunghezza finita) può essere utilizzata come operatore , con la sottrazione come operazione inversa ⊖ . In alternativa, per qualsiasi tipo di dati i cui valori possono essere rappresentati come stringhe di bit a lunghezza fissa, possiamo usare XOR bit a bit sia come ⊕ che ⊖ .$\oplus$$\ominus$$\oplus$$\ominus$

Più in generale, possiamo persino applicare il metodo XOR bit a bit a stringhe di lunghezza variabile, imbottendole fino alla stessa lunghezza necessaria, purché abbiamo un modo per rimuovere in modo reversibile l'imbottitura alla fine.

In alcuni casi, questo è banale. Ad esempio, le stringhe di byte con terminazione null in stile C codificano implicitamente la loro stessa lunghezza, quindi applicare questo metodo per loro è banale: quando XORing due stringhe, riempire quella più corta con byte null per far corrispondere la loro lunghezza e tagliare eventuali null finali il risultato finale. Tuttavia, le stringhe di somma XOR intermedie possono contenere byte null, quindi dovrai memorizzarne esplicitamente la lunghezza (ma ne avrai bisogno solo uno o due).

$1$$0$$0$$1$$2^{32}$byte di lunghezza, potremmo codificare la lunghezza di ogni stringa come numero intero a 32 bit e anteporla alla stringa. Oppure potremmo persino codificare lunghezze di stringa arbitrarie usando un po 'di prefisso e anteporre quelle alle stringhe. Esistono anche altre possibili codifiche.

$\Theta(n)$

L'unica parte potenzialmente complicata è che, affinché la cancellazione funzioni, dobbiamo scegliere un'unica rappresentazione canonica di bitstring per ciascun valore, che potrebbe essere difficile (anzi, potenzialmente persino indecidibile dal punto di vista computazionale) se i valori di input nei due array possono essere dati in diverse rappresentazioni equivalenti. Questa non è una debolezza specifica di questo metodo, tuttavia; qualsiasi altro metodo per risolvere questo problema può anche fallire se l'input può contenere valori la cui equivalenza è indecidibile.

Pubblicherei questo come commento sulla risposta di Tobi, ma non ho ancora la reputazione.

In alternativa al calcolo della somma di ciascun elenco (soprattutto se si tratta di elenchi di grandi dimensioni o contengono numeri molto grandi che potrebbero sommare il tipo di dati quando sommati) è possibile utilizzare invece xor.

Calcola solo la somma xor (ovvero x [0] ^ x [1] ^ x [2] ... x [n]) di ciascun elenco e quindi xo quei due valori. Questo ti darà il valore dell'elemento estraneo (ma non l'indice).

Questo è ancora O (n) ed evita qualsiasi problema di overflow.

Element = Sum (Array2) - Sum (Array1)

Io sinceramente dubbio questo è l'algoritmo più ottimale. Ma è un altro modo per risolvere il problema ed è il modo più semplice per risolverlo. Spero che sia d'aiuto.

Se il numero di elementi aggiunti è più di uno, questo non funzionerà.

La mia risposta ha la stessa complessità del tempo di esecuzione per il caso migliore, peggiore e medio,

MODIFICA
Dopo aver riflettuto un po ', penso che la mia risposta sia la tua soluzione.

$n$$n-1$$1 = n-1$$2 = n+1 -1=n$

$2n-1$$2 -$$1 = 1$

$2n - 1 + 1 = 2n$

EDIT:
A causa di alcuni problemi con i tipi di dati, una somma XOR come suggerito da reffu sarà più adatta.

Supponendo che l'array 2 sia stato creato prendendo l'array 1 e inserendo un elemento in una posizione casuale, o l'array 1 sia stato creato prendendo l'array 2 e cancellando un elemento casuale.

Se si garantisce che tutti gli elementi dell'array sono distinti, il tempo è O (ln n). Si confrontano gli elementi nella posizione n / 2. Se sono uguali, l'elemento aggiuntivo va da n / 2 + 1 alla fine dell'array, altrimenti va da 0 a n / 2. E così via.

Se gli elementi dell'array non sono garantiti per essere distinti: potresti avere n volte il numero 1 nell'array 1 e il numero 2 inserito ovunque nell'array 2. In tal caso non puoi sapere dove si trova il numero 2 senza guardare tutto elementi dell'array. Pertanto O (n).

PS. Poiché i requisiti sono cambiati, controlla la tua libreria per ciò che è disponibile. Su macOS / iOS, si crea un NSCountedSet, si aggiungono tutti i numeri dall'array 2, si rimuovono tutti i numeri dall'array 1 e ciò che resta è tutto ciò che è nell'array 2 ma non nell'array 1, senza fare affidamento sull'affermazione che esiste un ulteriore articolo.

var più corto, più lungo;

Converti il ​​più breve in una mappa per un rapido riferimento e il ciclo più lungo fino a quando il valore corrente non è nella mappa.

Qualcosa del genere in javascript:

if (arr1.length> arr2.length) {più breve = arr2; più lungo = arr1; } else {shortest = arr1; più lungo = arr2; }

var map = shortest.reduce (funzione (obj, value) {obj [value] = true; return obj;}, {});

var differenza = longest.find (funzione (valore) {return !!! map [valore];});

Soluzione O (N) nella complessità temporale O (1) in termini di complessità spaziale

Dichiarazione del problema: supponendo che array2 contenga tutti gli elementi dell'array1 più un altro elemento non presente nell'array1.

La soluzione è: usiamo xor per trovare l'elemento che non è presente in array1, quindi i passaggi sono: 1. Inizia da array1 ed esegui xor di tutti gli elementi e memorizzali in una variabile. 2. Prendi l'array2 ed esegui il xor di tutti gli elementi con la variabile che memorizza il xor di array1. 3. Dopo aver eseguito l'operazione, la nostra variabile conterrà l'elemento presente solo in array2. L'algoritmo sopra funziona a causa della seguente proprietà di xor "a xor a = 0" "a xor 0 = a" Spero che questo risolva il tuo problema. Anche le soluzioni sopra suggerite vanno bene