Determina il numero mancante nel flusso di dati

Riceviamo un flusso di numeri diversi a coppie dall'insieme . $n-1$ $\left\{1,\dots,n\right\}$

Come posso determinare il numero mancante con un algoritmo che legge il flusso una volta e usa una memoria di soli bit ? $O(\log_2 n)$

algorithms integers online-algorithms

— Coda
fonte

Risposte:

Sai e perché potrebbe essere codificato in bit questo può essere fatto nella memoria e in un percorso (basta trovare , questo è il numero mancante). $\sum_{i=1}^n i = \frac{n(n+1)}{2}$ $S = \frac{n(n+1)}{2}$ $O(\log(n))$ $O(\log n)$ $S - \mathrm{currentSum}$

Ma questo problema potrebbe essere risolto nel caso generale (per costante $k$ ): abbiamo $k$ numeri mancanti, scoprili tutti. In questo caso invece di calcolare solo la somma di $y_i$ , calcola la somma della j'st potenza di $x_i$ per tutti $1\le j \le k$ (ho assunto che $x_i$ manchi numeri mancanti e $y_i$ sia numeri di input):

$\qquad \displaystyle \begin{align} \sum_{i=1}^k x_i &= S_1,\\ \sum_{i=1}^k x_i^2 &= S_2,\\ &\vdots \\ \sum_{i=1}^k x_i^k &= S_k \end{align}$ $\qquad (1)$

Ricorda che puoi calcolare $S_1,...S_k$ semplicemente, perché $S_1 = S - \sum y_i$ , $S_2 = \sum i^2 - \sum y_i^2$ , ...

Ora per trovare i numeri mancanti dovresti risolvere $(1)$ per trovare tutti $x_i$ .

Puoi calcolare:

$P_1 = \sum x_i$ , $P_2 = \sum x_i\cdot x_j$ , ..., $P_k = \prod x_i$ $(2)$ .

Per questo ricorda che $P_1 = S_1$ , $P_2 = \frac{S_1^2 - S_2}{2}$ , ...

Ma è coefficienti di ma potrebbe essere considerato in modo univoco, quindi puoi trovare i numeri mancanti. $P_i$ $P=(x-x_1)\cdot (x-x_2) \cdots (x-x_k)$ $P$

Questi non sono i miei pensieri; Leggere questo .

— Raffaello
fonte

Non capisco (2). Forse se hai aggiunto i dettagli delle somme? Fa sbaglia un ?

P_{k}

$P_k$

\sum

$\sum$

— Raffaello

@Raphael, sono le identità di Newton, penso che se dai un'occhiata alla mia pagina wiki di riferimento puoi avere l'idea del calcolo, ogni potrebbe essere calcolato dai precedenti s, , ricorda la formula semplice: , puoi applicare un approccio simile a tutti i poteri. Anche come ho scritto è sigma di qualcosa, ma non ha alcun , perché c'è solo un .

P_{i}

$P_i$

P_{i}

$P_i$

P

$P$

S_{j}

$S_j$

2 \cdot x_{1} \cdot x_{2} = (x_{1} + x_{2})^{2} - (x_{1}^{2} + x_{2}^{2})

$2 \cdot x_1 \cdot x_2 = (x_1 + x_2)^2 - (x_1^2 + x_2^2)$

P_{i}

$P_i$

P_{k}

$P_k$

Σ

$\Sigma$

Π

$\Pi$

Comunque sia, le risposte dovrebbero essere autosufficienti in misura ragionevole. Dai alcune formule, quindi perché non renderle complete?

— Raffaello

Dal commento sopra:

Prima di elaborare il flusso, allocare bit, in cui si scrive ( è il la rappresentazione binaria di e è in senso esclusivo o). Ingenuamente, ciò richiede tempo. $\lceil \log_2 n \rceil$ $x:= \bigoplus_{i=1}^n \mathrm{bin}(i)$ $\mathrm{bin}(i)$ $i$ $\oplus$ $\mathcal{O}(n)$

Dopo aver elaborato il flusso, ogni volta che si legge un numero , calcolare . Sia il numero singolo di che non è incluso nello stream. Dopo aver letto l'intero flusso, abbiamo producendo il risultato desiderato. $j$ $x := x \oplus \mathrm{bin}(j)$ $k$ $\{ 1, ... n\}$

x = (⨁_{i = 1}^{n} b i n (i)) \oplus (⨁_{i \neq k} b i n (i)) = b i n (k) \oplus ⨁_{i \neq k} (b i n (i) \oplus b i n (i)) = b i n (k),

$x = \left(\bigoplus_{i=1}^n \mathrm{bin}(i)\right) \oplus \left(\bigoplus_{i \neq k } \mathrm{bin}(i)\right) = \mathrm{bin}(k) \oplus \bigoplus_{i \neq k } (\mathrm{bin}(i) \oplus \mathrm{bin}(i)) = \mathrm{bin}(k),$

Quindi, abbiamo usato lo spazio e abbiamo un tempo di esecuzione complessivo di . $\mathcal{O}(\log n)$ $\mathcal{O}(n)$

— HdM
fonte

posso suggerire una facile ottimizzazione che renda questo un vero algoritmo single-pass in streaming: al momento passo , xor con e con l'input che è arrivato sul streaming. questo ha l'ulteriore vantaggio di poterlo far funzionare anche se non è noto in anticipo: basta iniziare con un singolo bit allocato per "aumentare" lo spazio allocato secondo necessità.

i

$i$

x

$x$

b i n (i)

$\mathrm{bin}(i)$

b i n (j)

$\mathrm{bin}(j)$

n

$n$

x

$x$

— Sasho Nikolov,

La soluzione di HdM funziona. L'ho codificato in C ++ per testarlo. Non posso limitare i bit valuea , ma sono sicuro che puoi facilmente mostrare come è impostato solo quel numero di bit. $O(\log_2 n)$

Per coloro che desiderano uno pseudo codice, utilizzare una semplice operazione di con esclusivo o ( ): $\text{fold}$ $\oplus$

Missing = fold (\oplus, {1, \dots, N} \cup InputStream)

$\text{Missing} = \text{fold}(\oplus, \{1,\ldots,N\} \cup \text{InputStream})$

Hand-wavey proof: A non richiede mai più bit del suo input, quindi ne consegue che nessun risultato intermedio sopra richiede più dei bit massimi dell'input (quindi bit). è commutativo e , quindi se si espande quanto sopra e si accoppiano tutti i dati presenti nello stream, si rimarrà solo con un singolo valore non corrispondente, il numero mancante. $\oplus$ $O(\log_2 n)$ $\oplus$ $x \oplus x = 0$

#include <iostream>
#include <vector>
#include <cstdlib>
#include <algorithm>

using namespace std;

void find_missing( int const * stream, int len );

int main( int argc, char ** argv )
{
    if( argc < 2 )
    {
        cerr << "Syntax: " << argv[0] << " N" << endl;
        return 1;
    }
    int n = atoi( argv[1] );

    //construct sequence
    vector<int> seq;
    for( int i=1; i <= n; ++i )
        seq.push_back( i );

    //remove a number and remember it
    srand( unsigned(time(0)) );
    int remove = (rand() % n) + 1;
    seq.erase( seq.begin() + (remove - 1) );
    cout << "Removed: " << remove << endl;

    //give the stream a random order
    std::random_shuffle( seq.begin(), seq.end() );

    find_missing( &seq[0], int(seq.size()) );
}

//HdM's solution
void find_missing( int const * stream, int len )
{
    //create initial value of n sequence xor'ed (n == len+1)
    int value = 0;
    for( int i=0; i < (len+1); ++i )
        value = value ^ (i+1);

    //xor all items in stream
    for( int i=0; i < len; ++i, ++stream )
        value = value ^ *stream;

    //what's left is the missing number
    cout << "Found: " << value << endl;
}

— edA-qa mort-ora-y
fonte

Per favore, inserisci il codice (pseudo) leggibile solo dell'algoritmo (salta principale). Inoltre, dovrebbe essere inclusa una prova / argomento di correttezza a un certo livello.

— Raffaello

@ edA-qamort-ora-y La tua risposta presuppone che il lettore conosca il C ++. Per qualcuno che non ha familiarità con questa lingua, non c'è nulla da vedere: sia trovare il passaggio pertinente sia capire cosa sta facendo sono una sfida. Lo pseudocodice leggibile renderebbe questa una risposta migliore. Il C ++ non è davvero utile su un sito di informatica.

— Gilles 'SO- smetti di essere malvagio'

Se la mia risposta dimostra di non essere utile, le persone non devono votare per questo.

— edA-qa mort-ora-y

+1 per aver dedicato del tempo a scrivere codice C ++ e testarlo. Sfortunatamente, come altri hanno sottolineato, non è così. Ti sforzi ancora in questo!

— Julien Lebot,

Non capisco il punto di questa risposta: prendi la soluzione di qualcun altro, che è molto semplice e ovviamente molto efficiente, e la "collaudi". Perché sono necessari i test? È come testare il tuo computer aggiungendo i numeri correttamente. E non c'è nulla di non banale nemmeno nel tuo codice.

— Sasho Nikolov,