web-dev-qa-db-de.com

Algorithmus, um zwei wiederholte Zahlen in einem Array zu finden, ohne zu sortieren

Es gibt ein Array der Größe n (Zahlen liegen zwischen 0 und n - 3) und nur zwei Zahlen werden wiederholt. Elemente werden zufällig im Array platziert.

Z.B. in {2, 3, 6, 1, 5, 4, 0, 3, 5} n = 9 und sich wiederholende Zahlen sind 3 und 5.

Wie finde ich die wiederholten Zahlen am besten?

P.S. [Sie sollten keine Sortierung verwenden]

26
Aman Jain

Es gibt eine O(n) - Lösung wenn Sie wissen, was die mögliche Eingabedomäne ist. Betrachten Sie beispielsweise den folgenden Code, wenn Ihr Eingabearray Zahlen zwischen 0 und 100 enthält. 

bool flags[100];
for(int i = 0; i < 100; i++)
    flags[i] = false;

for(int i = 0; i < input_size; i++)
    if(flags[input_array[i]])
         return input_array[i];
    else       
        flags[input_array[i]] = true;

Natürlich gibt es den zusätzlichen Speicher, aber dieser ist der schnellste. 

27
Sesh

OK, scheinbar kann ich es einfach nicht ausruhen :) 

Einfachste Lösung

int A[N] = {...};

int signed_1(n) { return n%2<1 ? +n : -n;  } // 0,-1,+2,-3,+4,-5,+6,-7,...
int signed_2(n) { return n%4<2 ? +n : -n;  } // 0,+1,-2,-3,+4,+5,-6,-7,...

long S1 = 0;  // or int64, or long long, or some user-defined class
long S2 = 0;  // so that it has enough bits to contain sum without overflow

for (int i=0; i<N-2; ++i)
{
   S1 += signed_1(A[i]) - signed_1(i);
   S2 += signed_2(A[i]) - signed_2(i);
} 

for (int i=N-2; i<N; ++i)
{
   S1 += signed_1(A[i]);
   S2 += signed_2(A[i]);
} 

S1 = abs(S1);
S2 = abs(S2);

assert(S1 != S2);  // this algorithm fails in this case

p = (S1+S2)/2;
q = abs(S1-S2)/2;

Eine Summe (S1 oder S2) enthält p und q mit demselben Vorzeichen, die andere Summe - mit entgegengesetzten Vorzeichen werden alle anderen Mitglieder eliminiert.
S1 und S2 müssen über genügend Bits verfügen, um Summen aufzunehmen, der Algorithmus steht wegen abs () nicht für Überlauf.

wenn abs (S1) == abs (S2) ist, schlägt der Algorithmus fehl, obwohl dieser Wert immer noch die Differenz zwischen p und q ist (d. h. abs (p - q) == abs (S1)).

Vorherige Lösung

Ich bezweifle, dass jemand auf diesem Gebiet jemals einem solchen Problem begegnen wird;)
Ich kenne die Erwartung des Lehrers:

Nehmen wir das Array {0,1,2, ..., n-2, n-1},
Das gegebene kann hergestellt werden, indem die letzten beiden Elemente n-2 und n-1 durch unbekanntes p und q (weniger Ordnung) ersetzt werden. 

also ist die Summe der Elemente (n-1) n/2+ p + q - (n-2) - (n-1)
.__ die Summe der Quadrate (n-1) n (2n-1)/6+ p ^ 2 + q ^ 2 - (n-2) ^ 2 - (n-1) ^ 2 

Einfache Mathematik bleibt:

  (1)  p+q = S1  
  (2)  p^2+q^2 = S2

Sicherlich werden Sie es nicht lösen, da Mathematikunterricht das Lösen von quadratischen Gleichungen lehrt. 

Berechnen Sie zunächst alles modulo 2 ^ 32, das heißt, Überlauf zulassen.
Überprüfen Sie dann die Paare {p, q}: {0, S1}, {1, S1-1} ... mit dem Ausdruck (2), um die Kandidaten zu finden (möglicherweise gibt es mehr als 2 aufgrund von Modulo und Quadratur )
.__ Überprüfen Sie schließlich die gefundenen Kandidaten, ob sie tatsächlich zweimal im Array vorhanden sind.

21
eugensk00

Sie wissen, dass Ihr Array jede Zahl von 0 bis n-3 und die zwei sich wiederholenden (p & q) enthält. Der Einfachheit halber ignorieren wir den 0-Fall vorerst.

Sie können die Summe und das Produkt über das Array berechnen, was Folgendes ergibt:

1 + 2 + ... + n-3 + p + q = p + q + (n-3)(n-2)/2

Wenn Sie also (n-3) (n-2)/2 von der Summe des gesamten Arrays abziehen, erhalten Sie

sum(Array) - (n-3)(n-2)/2 = x = p + q

Machen Sie jetzt dasselbe für das Produkt:

1 * 2 * ... * n - 3 * p * q = (n - 3)! * p * q

prod(Array) / (n - 3)! = y = p * q

Sie haben jetzt diese Bedingungen:

x = p + q

y = p * q

=> y(p + q) = x(p * q)

Wenn Sie diesen Ausdruck transformieren, sollten Sie p und q berechnen können

12
sdfx

Fügen Sie jedes Element in eine set/hashtable ein, und überprüfen Sie zunächst, ob es bereits darin enthalten ist.

7
tjdonaldson

Möglicherweise können Sie die Tatsache ausnutzen, dass sum (array) = (n-2) * (n-3)/2 + zwei fehlende Zahlen ist. 

Edit: Wie andere angemerkt haben, in Kombination mit der Quadratsumme, können Sie dies verwenden. Ich war nur ein bisschen langsam, um es herauszufinden.

7
Eclipse

Schauen Sie sich diese alte, aber gute Arbeit zum Thema an:

6
CMS

Einige Antworten auf die Frage: Algorithmus zur Feststellung, ob das Array n… n + m enthält. enthalten als Teilproblem Lösungen, die Sie für Ihre Zwecke übernehmen können.

Zum Beispiel hier ein relevanter Teil aus meine Antwort :

bool has_duplicates(int* a, int m, int n)
{
  /** O(m) in time, O(1) in space (for 'typeof(m) == typeof(*a) == int')

      Whether a[] array has duplicates.

      precondition: all values are in [n, n+m) range.

      feature: It marks visited items using a sign bit.
  */
  assert((INT_MIN - (INT_MIN - 1)) == 1); // check n == INT_MIN
  for (int *p = a; p != &a[m]; ++p) {
    *p -= (n - 1); // [n, n+m) -> [1, m+1)
    assert(*p > 0);
  }

  // determine: are there duplicates
  bool has_dups = false;
  for (int i = 0; i < m; ++i) {
    const int j = abs(a[i]) - 1;
    assert(j >= 0);
    assert(j < m);
    if (a[j] > 0)
      a[j] *= -1; // mark
    else { // already seen
      has_dups = true;
      break;
    }
  }

  // restore the array
  for (int *p = a; p != &a[m]; ++p) {
    if (*p < 0) 
      *p *= -1; // unmark
    // [1, m+1) -> [n, n+m)
    *p += (n - 1);        
  }

  return has_dups; 
}

Das Programm lässt das Array unverändert (das Array sollte schreibbar sein, seine Werte werden jedoch beim Beenden wiederhergestellt).

Es funktioniert für Arraygrößen bis zu INT_MAX (auf 64-Bit-Systemen ist es 9223372036854775807).

3
jfs
angenommen, das Array ist 

 a [0], a [1], a [2] ... a [n-1] 

 sumA = a [0] + a [1 ] + .... + a [n-1] 
 sumASquare = a [0] * a [0] + a [1] * a [1] + a [2] * a [2] + .. .. + a [n] * a [n] 

 sumFirstN = (N * (N + 1))/2 wobei N = n-3 so 
 sumFirstN = (n-3) (n. 3) -2)/2 ______ ähnlich

 SumFirstNSquare = N * (N + 1) * (2 · N + 1)/6 = (n-3) (n-2) (2n) -5)/6 

 Angenommen, wiederholte Elemente sind = X und Y 

 X + Y = sumA - sumFirstN; 
 X * X + Y * Y = sumASquare - sumFirstNSquare ;

 Beim Lösen dieses Quadrats können wir den Wert von X und Y erhalten .__ Zeitkomplexität = O (n) 
 Raumkomplexität = O (1) 
2
GG.

Ich weiß, die Frage ist sehr alt, aber ich habe sie plötzlich getroffen und denke, ich habe eine interessante Antwort darauf ... Wir wissen, dass dies ein Denkaufruf ist und eine triviale Lösung (dh HashMap, Sort usw.), egal wie gut sie sind wäre langweilig.

Da die Zahlen ganze Zahlen sind, haben sie eine konstante Bitgröße (d. H. 32). Nehmen wir an, wir arbeiten gerade mit 4-Bit-Ganzzahlen. Wir suchen nachAundB, wobei es sich um die doppelten Zahlen handelt.

Wir benötigen 4 Eimer für jeweils ein Bit. Jeder Bucket enthält Zahlen, deren spezifisches Bit 1 ist. Zum Beispiel erhält Bucket 1 2, 3, 4, 7, ...:

Bucket 0 : Sum ( x where: x & 2 power 0 == 0 )
...
Bucket i : Sum ( x where: x & 2 power i == 0 )

Wir wissen, was die Summe jedes Buckets wäre, wenn kein Duplikat vorhanden wäre. Ich betrachte dies als Vorwissen.

Sobald die oben angegebenen Buckets generiert wurden, hätte ein Haufen davon mehr als erwartet. Wenn Sie die Anzahl aus Buckets zusammenstellen, haben wir (A OR B zu Ihrer Information).

Wir können (A XOR B) wie folgt berechnen:

A XOR B = Array[i] XOR Array[i-1] XOR ... 0, XOR n-3 XOR n-2  ... XOR 0

Wenn wir nun zu Buckets zurückkehren, wissen wir genau, welche Buckets sowohl unsere Nummern haben als auch welche nur eine (aus dem XOR - Bit).

Für die Buckets, die nur eine Nummer haben, können wir die Nummer num = (sum - erwartete Summe des Buckets) extrahieren. Wir sollten jedoch nur dann gut sein, wenn wir eine der doppelten Nummern finden können. Wenn wir also in A XOR B mindestens ein Bit haben, haben wir die Antwort.

Aber was ist, wenn A XOR B Null ist? __ Nun, dieser Fall ist nur möglich, wenn beide doppelten Zahlen die gleiche Nummer sind, wobei unsere Nummer dann die Antwort von A OR B ist.

2
naiem

antwort auf 18 ...__ Sie nehmen ein Array von 9 und die Elemente beginnen mit 0 ... so dass max ele 6 in Ihrem Array sein wird. Nehmen Sie die Summe der Elemente von 0 bis 6 und die Summe der Array-Elemente. Berechnen Sie ihre Differenz (sagen Sie d). Das ist p + q. Nehmen Sie nun XOR der Elemente von 0 bis 6 (x1). Nehmen Sie nun XOR von Array-Elementen (zB x2). x2 ist XOR aller Elemente von 0 bis 6, außer zwei sich wiederholenden Elementen, da sie sich gegenseitig aufheben. jetzt für i = 0 bis 6, sagen Sie für jedes Element des Arrays, dass p das Element a [i] ist. Sie können also q berechnen, indem Sie dieses Element von d abziehen. Machen Sie XOR von p und q und XOR mit x2 und prüfen Sie, ob x1 == x2. Ebenso für alle Elemente erhalten Sie die Elemente, für die diese Bedingung wahr ist, und Sie sind in O (n) erledigt. Codierung beibehalten!

1
Minal

Da ein Bereich angegeben ist, können Sie eine Radix-Sortierung durchführen. Dies würde Ihr Array in O (n) sortieren. Die Suche nach Duplikaten in einem sortierten Array ist dann O (n)

1
Ravi

Sie können einfache verschachtelte for-Schleife verwenden  

 int[] numArray = new int[] { 1, 2, 3, 4, 5, 7, 8, 3, 7 };

        for (int i = 0; i < numArray.Length; i++)
        {
            for (int j = i + 1; j < numArray.Length; j++)
            {
                if (numArray[i] == numArray[j])
                {
                   //DO SOMETHING
                }
            }

*OR Sie können das Array filtern und die rekursive Funktion verwenden, wenn Sie die Anzahl der Vorkommen * ermitteln möchten. 

int[] array = { 1, 2, 3, 4, 5, 4, 4, 1, 8, 9, 23, 4, 6, 8, 9, 1,4 };
int[] myNewArray = null;
int a = 1;

 void GetDuplicates(int[] array)
    for (int i = 0; i < array.Length; i++)
            {
                for (int j = i + 1; j < array.Length; j++)
                {
                    if (array[i] == array[j])
                    {
                          a += 1;
                    }
                }
                Console.WriteLine(" {0} occurred {1} time/s", array[i], a);

                IEnumerable<int> num = from n in array where n != array[i] select n;
                 myNewArray = null;
                 a = 1;
                 myNewArray = num.ToArray() ;

                 break;

            }
             GetDuplicates(myNewArray);
1
Tarek Fouda

check this out ... O (n) Zeit und O(1) Platzkomplexität 

 for(i=0;i< n;i++)
 xor=xor^arr[i]
 for(i=1;i<=n-3;i++)
 xor=xor^i;

Im gegebenen Beispiel erhalten Sie also das xor von 3 und 5 

xor=xor & -xor  //Isolate the last digit

for(i = 0; i < n; i++)
{
if(arr[i] & xor)
  x = x ^ arr[i]; 
else
  y = y ^ arr[i]; 
}
for(i = 1; i <= n-3; i++)
{
if(i & xor)
  x = x ^ i; 
else
  y = y ^ i; 

}

x und y sind deine Antworten 

1
Sree Ram

Das Sortieren des Arrays scheint die beste Lösung zu sein. Eine einfache Sortierung würde dann die Suche trivial machen und würde viel weniger Zeit/Raum benötigen.

Wenn Sie die Domäne der Zahlen kennen, erstellen Sie ansonsten ein Array mit so vielen Buckets und erhöhen Sie jedes Feld, während Sie durch das Array gehen. etwas wie das:

int count [10];

for (int i = 0; i < arraylen; i++) {
    count[array[i]]++;
}

Suchen Sie dann in Ihrem Array nach Zahlen, die größer als 1 sind. Dies sind die Elemente mit Duplikaten. Erfordert nur einen Durchgang über das ursprüngliche Array und einen Durchlauf über das Zähl-Array.

1
Steve Rowe

Hier ist die Implementierung der Antwort von @ eugensk00 (eine ihrer Überarbeitungen) in Python, die keine modulare Arithmetik verwendet. Es ist ein single-pass Algorithmus, O(log(n)) im Raum. Wenn ganze Zahlen mit fester Breite (z. B. 32 Bit) verwendet werden, sind nur zwei Zahlen mit fester Breite erforderlich (z. B. für 32 Bit: eine 64-Bit-Zahl und eine 128-Bit-Zahl). Es kann mit beliebig großen ganzzahligen Sequenzen umgehen (es wird jeweils eine ganze Zahl gelesen, daher muss sich eine ganze Sequenz nicht im Speicher befinden).

def two_repeated(iterable):
    s1, s2 = 0, 0
    for i, j in enumerate(iterable):
        s1 += j - i     # number_of_digits(s1) ~ 2 * number_of_digits(i)
        s2 += j*j - i*i # number_of_digits(s2) ~ 4 * number_of_digits(i) 
    s1 += (i - 1) + i
    s2 += (i - 1)**2 + i**2

    p = (s1 - int((2*s2 - s1**2)**.5)) // 2 
    # `Decimal().sqrt()` could replace `int()**.5` for really large integers
    # or any function to compute integer square root
    return p, s1 - p

Beispiel:

>>> two_repeated([2, 3, 6, 1, 5, 4, 0, 3, 5])
(3, 5)

Eine ausführlichere Version des obigen Codes folgt mit Erläuterung:

def two_repeated_seq(arr):
    """Return the only two duplicates from `arr`.

    >>> two_repeated_seq([2, 3, 6, 1, 5, 4, 0, 3, 5])
    (3, 5)
    """
    n = len(arr)
    assert all(0 <= i < n - 2 for i in arr) # all in range [0, n-2)
    assert len(set(arr)) == (n - 2) # number of unique items

    s1 = (n-2) + (n-1)       # s1 and s2 have ~ 2*(k+1) and 4*(k+1) digits  
    s2 = (n-2)**2 + (n-1)**2 # where k is a number of digits in `max(arr)`
    for i, j in enumerate(arr):
        s1 += j - i     
        s2 += j*j - i*i

    """
    s1 = (n-2) + (n-1) + sum(arr) - sum(range(n))
       = sum(arr) - sum(range(n-2))
       = sum(range(n-2)) + p + q - sum(range(n-2))
       = p + q
    """
    assert s1 == (sum(arr) - sum(range(n-2)))

    """
    s2 = (n-2)**2 + (n-1)**2 + sum(i*i for i in arr) - sum(i*i for i in range(n))
       = sum(i*i for i in arr) - sum(i*i for i in range(n-2))
       = p*p + q*q
    """
    assert s2 == (sum(i*i for i in arr) - sum(i*i for i in range(n-2)))

    """
    s1 = p+q
    -> s1**2 = (p+q)**2
    -> s1**2 = p*p + 2*p*q + q*q
    -> s1**2 - (p*p + q*q) = 2*p*q
    s2 = p*p + q*q
    -> p*q = (s1**2 - s2)/2

    Let C = p*q = (s1**2 - s2)/2 and B = p+q = s1 then from Viete theorem follows
    that p and q are roots of x**2 - B*x + C = 0
    -> p = (B + sqrtD) / 2
    -> q = (B - sqrtD) / 2
    where sqrtD = sqrt(B**2 - 4*C)

    -> p = (s1 + sqrt(2*s2 - s1**2))/2
    """
    sqrtD = (2*s2 - s1**2)**.5
    assert int(sqrtD)**2 == (2*s2 - s1**2) # perfect square
    sqrtD = int(sqrtD)
    assert (s1 - sqrtD) % 2 == 0 # even
    p = (s1 - sqrtD) // 2
    q = s1 - p
    assert q == ((s1 + sqrtD) // 2)
    assert sqrtD == (q - p)
    return p, q

HINWEIS: Durch die Berechnung der Ganzzahlwurzel einer Zahl (~ N ** 4) wird der obige Algorithmus nicht linear.

1
jfs

In c:

    int arr[] = {2, 3, 6, 1, 5, 4, 0, 3, 5};

    int num = 0, i;

    for (i=0; i < 8; i++)
         num = num ^ arr[i] ^i;

Seit x^x=0 werden die Zahlen, die ungerade Male wiederholt werden, neutralisiert. Rufen wir die eindeutigen Nummern a und b auf. Wir bleiben mit a^b. Wir kennen a^b != 0, seit a != b. Wählen Sie ein beliebiges 1-Bit von a^b und verwenden Sie dieses als Maske, dh. Wählen Sie x als Potenz von 2 aus, damit x & (a^b) nicht Null ist.

Teilen Sie nun die Liste in zwei Unterlisten auf - eine Unterliste enthält alle Zahlen y mit y&x == 0, und der Rest geht in die andere Unterliste. Bei der Wahl von x wissen wir, dass sich die Paare von a und b in unterschiedlichen Eimern befinden. Wir können also jetzt die gleiche Methode unabhängig voneinander auf jeden Bucket anwenden und herausfinden, was a und b sind.

0

Wie wäre es damit:

for (i=0; i<n-1; i++) {
  for (j=i+1; j<n; j++) {
    if (a[i] == a[j]) {
        printf("%d appears more than once\n",a[i]);
        break;
    }
  }
}

Sicher ist es nicht das schnellste, aber es ist einfach und leicht zu verstehen und erfordertkeine zusätzliche Speicherkapazität. Wenn n eine kleine Zahl wie 9 oder 100 ist, kann es die "beste" sein. (d. h. "Best" kann verschiedene Bedeutungen haben: Schnellste Ausführung, geringster Speicherbedarf, am besten zu warten, geringste Entwicklungskosten usw.)

0
vulcan

Ich habe ein kleines Programm geschrieben, das herausfindet, wie viele Elemente sich nicht wiederholen. Lassen Sie es mich wissen. Lassen Sie mich Ihre Meinung wissen. Im Moment gehe ich davon aus, dass die Anzahl der Elemente gerade ist.

Meine Idee ist also, zuerst die Zahlen zu sortieren und dann meinen Algorithmus anzuwenden. Eine schnelle Sortierung kann zum Sortieren dieser Elemente verwendet werden.

Nehmen wir ein Eingabefeld wie folgt

int arr[] = {1,1,2,10,3,3,4,5,5,6,6};

die Nummern 2,10 und 4 werden nicht wiederholt. Sie sind jedoch in sortierter Reihenfolge. Wenn nicht sortiert, verwenden Sie Quick Sort, um sie zuerst zu sortieren.

Lasst uns mein Programm darauf anwenden

using namespace std;

main()
{
    //int arr[] = {2, 9, 6, 1, 1, 4, 2, 3, 5};
    int arr[] = {1,1,2,10,3,3,4,5,5,6,6};

    int i = 0;

    vector<int> vec;

    int var = arr[0];
    for(i = 1 ; i < sizeof(arr)/sizeof(arr[0]); i += 2)
    {
            var = var ^ arr[i];

            if(var != 0 )
            {
                //put in vector
                var = arr[i-1];
                vec.Push_back(var);
                i = i-1;
            }
            var = arr[i+1];
    }

    for(int i = 0 ; i < vec.size() ; i++)
        printf("value not repeated = %d\n",vec[i]);

}

Dies gibt die Ausgabe:

value not repeated= 2

value not repeated= 10

value not repeated= 4

Es ist einfach und sehr unkompliziert, verwenden Sie einfach XOR man.

0
Yusuf Khan

Hier ist ein Algorithmus, der die Bestellstatistik verwendet und in O(n) ausgeführt wird.

Sie können dieses Problem lösen, indem Sie wiederholt SELECT mit dem Median als Parameter aufrufen.

Sie verlassen sich auch darauf, dass nach einem Aufruf von SELECT, Die Elemente, die kleiner oder gleich dem Median sind, nach links vom Median verschoben werden.

  • Rufen Sie SELECT für A mit dem Median als Parameter auf.
  • Wenn der Medianwert floor(n/2) ist, sind die wiederholten Werte auf den Median genau richtig. Sie fahren also mit der rechten Hälfte des Arrays fort.
  • Wenn dies nicht der Fall ist, bleibt dem Median ein wiederholter Wert. Sie fahren also mit der linken Hälfte des Arrays fort.
  • Sie setzen diesen Weg rekursiv fort.

Zum Beispiel:

  • Wenn A={2, 3, 6, 1, 5, 4, 0, 3, 5}n=9, dann sollte der Median der Wert 4 sein.
  • Nach dem ersten Aufruf von SELECT
  • A={3, 2, 0, 1, <3>, 4, 5, 6, 5} Der Medianwert ist kleiner als 4, so dass wir mit der linken Hälfte fortfahren.
  • A={3, 2, 0, 1, 3}
  • Nach dem zweiten Aufruf von SELECT
  • A={1, 0, <2>, 3, 3} dann sollte der Median 2 sein und es geht also weiter mit der rechten Hälfte.
  • A={3, 3}, gefunden.

Dieser Algorithmus läuft in O(n+n/2+n/4+...)=O(n).

0
Avi Cohen
for(i=1;i<=n;i++) {
  if(!(arr[i] ^ arr[i+1]))
        printf("Found Repeated number %5d",arr[i]);
}
0
srinunaik

Für jede Nummer: Prüfen Sie, ob sie im Rest des Arrays vorhanden ist.

0
mookid8000

Ohne zu sortieren, werden Sie die bereits besuchten Zahlen im Auge behalten.

in Psuedocode wäre dies im Prinzip so (so gebe ich Ihnen nicht nur die Antwort):

for each number in the list
   if number not already in unique numbers list
      add it to the unique numbers list
   else
      return that number as it is a duplicate
   end if
end for each
0
mezoid

Was ist mit dem https://de.wikipedia.org/wiki/HyperLogLog

Redis tut http://redis.io/topics/data-types-intro#hyperloglogs

Ein HyperLogLog ist eine probabilistische Datenstruktur, die zum Zählen von eindeutigen Dingen verwendet wird (technisch wird dies als Schätzen der Kardinalität einer Menge bezeichnet). Für das Zählen eindeutiger Elemente ist normalerweise eine Menge Speicher erforderlich, die der Anzahl der Elemente entspricht, die Sie zählen möchten, da Sie sich die Elemente merken müssen, die Sie bereits in der Vergangenheit gesehen haben, um sie nicht mehrfach zählen zu müssen. Es gibt jedoch eine Reihe von Algorithmen, die den Speicher gegen Genauigkeit tauschen: Sie enden mit einem geschätzten Maß mit einem Standardfehler, im Falle der Redis-Implementierung, der weniger als 1% beträgt. Die Magie dieses Algorithmus besteht darin, dass Sie nicht mehr eine Menge Speicher verwenden müssen, die proportional zur Anzahl der gezählten Elemente ist, sondern stattdessen eine konstante Menge Speicher verwenden kann! 12k Byte im schlimmsten Fall oder viel weniger, wenn Ihr HyperLogLog (wir nennen sie jetzt nur noch HLL) nur sehr wenige Elemente hat.

0
brutuscat