Stampa il più piccolo successivo da 2 ^ i * 5 ^ j dove i, j> = 0

Mi è stata posta questa domanda durante uno screening tecnico del telefono di recente e non ho fatto bene. La domanda è inclusa alla lettera di seguito.

Genera {2^i * 5^j | i,j >= 0}raccolta ordinata. Stampa continuamente il valore più piccolo successivo.

Esempio: { 1, 2, 4, 5, 8, 10...}

"Next smallest" mi fa pensare che sia coinvolto un min-heap, ma non sapevo davvero dove andare da lì e non è stata fornita assistenza dall'intervistatore.

Qualcuno ha consigli su come risolvere un simile problema?

Riformuliamo il problema: emetti ogni numero da 1 a infinito in modo tale che il numero non abbia fattori tranne 2 e 5.

Di seguito è riportato un semplice frammento di C #:

for (int i = 1;;++i)
{
    int num = i;
    while(num%2 == 0) num/=2;
    while(num%5 == 0) num/=5;
    if(num == 1) Console.WriteLine(i);
}

L' approccio di Kilian / QuestionC è molto più performante. Snippet C # con questo approccio:

var itms = new SortedSet<int>();
itms.Add(1);
while(true)
{
    int cur = itms.Min;
    itms.Remove(itms.Min);
    itms.Add(cur*2);
    itms.Add(cur*5);
    Console.WriteLine(cur);
}

SortedSet impedisce inserimenti duplicati.

Fondamentalmente, funziona assicurandosi che il prossimo numero nella sequenza sia in itms.

Prova che questo approccio è valido:
l'algoritmo descritto assicura che dopo ogni output numerico nel modulo 2^i*5^j, il set ora contenga 2^(i+1)*5^je 2^i*5^(j+1). Supponiamo che il prossimo numero nella sequenza sia 2^p*5^q. Deve esistere un numero di output precedente del modulo 2^(p-1)*5^(q)o 2^p*5^(q-1)(o entrambi, se né p né q sono uguali a 0). Se no, allora 2^p*5^qnon è il numero successivo, dal momento che 2^(p-1)*5^(q)e 2^p*5^(q-1)sono entrambi più piccoli.

Il secondo frammento utilizza la O(n)memoria (dove n è il numero di numeri che sono stati emessi), poiché O(i+j) = O(n)(poiché i e j sono entrambi inferiori a n) e troverà n numeri nel O(n log n)tempo. Il primo frammento trova i numeri in tempo esponenziale.

Questa è una domanda di intervista abbastanza comune che è utile conoscere la risposta. Ecco la voce pertinente nel mio foglio personale del presepe:

• per generare i numeri del modulo 3 ^a 5 ^b 7 ^c in ordine , iniziare con 1, inserire tutti e tre i successori possibili (3, 5, 7) in una struttura ausiliaria, quindi aggiungere il numero più piccolo da esso al proprio elenco.

In altre parole, è necessario un approccio in due passaggi con un buffer ordinato aggiuntivo per risolverlo in modo efficiente. (Una buona descrizione più lunga è in Cracking the Coding Interview di Gayle McDowell.

Ecco una risposta che funziona con memoria costante, a spese della CPU. Questa non è una buona risposta nel contesto della domanda originale (ovvero la risposta durante un'intervista). Ma se l'intervista dura 24 ore, non è poi così male. ;)

L'idea è che se ho n che è una risposta valida, allora il prossimo nella sequenza sarà n volte un potere di due, diviso per un potere di 5. Oppure n volte un potere di 5, diviso per un potenza di due. A condizione che divida uniformemente. (... o il divisore può essere 1;) nel qual caso stai solo moltiplicando per 2 o 5)

Ad esempio, per andare da 625 a 640, moltiplicare per 5 ** 4/2 ** 7. O, più in generale, moltiplicare per un valore di 2 ** m * 5 ** nper alcuni m, n dove uno è positivo e uno è negativo o zero, e il il moltiplicatore divide il numero in modo uniforme.

Ora, la parte difficile è trovare il moltiplicatore. Ma sappiamo a) il divisore deve dividere il numero in modo uniforme, b) il moltiplicatore deve essere maggiore di uno (i numeri continuano ad aumentare) ec) se scegliamo il moltiplicatore più basso maggiore di 1 (cioè 1 <f <tutti gli altri f ), questo è garantito per essere il nostro prossimo passo. Il passo successivo sarà il passo più basso.

La parte cattiva sta trovando il valore di m, n. Ci sono solo possibilità di log (n), perché ci sono solo tanti 2 o 5 da rinunciare, ma ho dovuto aggiungere un fattore da -1 a +1 come un modo sciatto per gestire il roundoff. Quindi dobbiamo solo scorrere attraverso O (log (n)) ogni passaggio. Quindi è O (n log (n)) in generale.

La buona notizia è che, poiché prende un valore e trova il valore successivo, puoi iniziare ovunque nella sequenza. Quindi, se vuoi il prossimo dopo 1 miliardo, puoi semplicemente trovarlo scorrendo i 2/5 o i 5/2 e selezionando il moltiplicatore più piccolo maggiore di 1.

(pitone)

MAX = 30
F = - math.log(2) / math.log(5)

def val(i, j):
    return 2 ** i * 5 ** j

def best(i, j):
    f = 100
    m = 0
    n = 0
    max_i = (int)(math.log(val(i, j)) / math.log(2) + 1) if i + j else 1
    #print((val(i, j), max_i, x))
    for mm in range(-i, max_i + 1):
        for rr in {-1, 0, 1}:
            nn = (int)(mm * F + rr)
            if nn < -j: continue
            ff = val(mm, nn)
            #print('  ' + str((ff, mm, nn, rr)))
            if ff > 1 and ff < f:
                f = ff
                m = mm
                n = nn
    return m, n

def detSeq():

    i = 0
    j = 0
    got = [val(i, j)]

    while len(got) < MAX:
        m, n = best(i, j)

        i += m
        j += n
        got.append(val(i, j))

        #print('* ' + str((val(i, j), m, n)))
        #print('- ' + str((v, i, j)))

    return got

Ho convalidato i primi 10.000 numeri generati da questo rispetto ai primi 10.000 generati dalla soluzione dell'elenco ordinato e funziona almeno fino a quel punto.

A proposito il prossimo dopo un trilione sembra essere 1.024.000.000.000.

...

Hm. Posso ottenere O (n) prestazioni - O (1) per valore (!) - e O (log n) utilizzo della memoria trattando best()come una tabella di ricerca che estendo in modo incrementale. In questo momento risparmia memoria ripetendo ogni volta, ma sta facendo molti calcoli ridondanti. Mantenendo quei valori intermedi - e un elenco di valori minimi - posso evitare il lavoro duplicato e accelerarlo molto. Tuttavia, l'elenco dei valori intermedi crescerà con n, quindi la memoria O (log n).

Brian aveva assolutamente ragione: la mia altra risposta era troppo complicata. Ecco un modo più semplice e veloce per farlo.

Immagina il quadrante I del piano euclideo, limitato agli interi. Chiamare un asse l'asse i e l'altro asse l'asse j.

Ovviamente, i punti vicini all'origine verranno raccolti prima dei punti lontani dall'origine. Si noti inoltre che l'area attiva si allontanerà dall'asse i prima che si allontani dall'asse j.

Una volta che un punto è stato usato, non verrà mai più usato. E un punto può essere usato solo se il punto direttamente sotto di esso o alla sua sinistra è già stato usato.

Mettendoli insieme, puoi immaginare una "frontiera" o "bordo anteriore" che inizia attorno all'origine e si diffonde su e a destra, diffondendosi lungo l'asse i più lontano rispetto all'asse j.

In effetti, possiamo capire qualcosa di più: ci sarà al massimo un punto sulla frontiera / bordo per ogni dato valore i. (Devi incrementare i più di 2 volte per uguagliare un incremento di j.) Quindi, possiamo rappresentare la frontiera come un elenco contenente un elemento per ciascuna coordinata i, variando solo con la coordinata j e il valore della funzione.

Ad ogni passaggio, selezioniamo l'elemento minimo sul bordo anteriore, quindi lo spostiamo nella direzione j una volta. Se ci capita di aumentare l'ultimo elemento, aggiungiamo un nuovo ultimo elemento in più con un valore i incrementato e un valore j di 0.

using System;
using System.Collections.Generic;
using System.Text;

namespace TwosFives
{
    class LatticePoint : IComparable<LatticePoint>
    {
      public int i;
      public int j;
      public double value;
      public LatticePoint(int ii, int jj, double vvalue)
      {
          i = ii;
          j = jj;
          value = vvalue;
      }
      public int CompareTo(LatticePoint rhs)
      {
          return value.CompareTo(rhs.value);
      }
    }


    class Program
    {
        static void Main(string[] args)
        {
            LatticePoint startPoint = new LatticePoint(0, 0, 1);

            var leadingEdge = new List<LatticePoint> { startPoint } ;

            while (true)
            {
                LatticePoint min = leadingEdge.Min();
                Console.WriteLine(min.value);
                if (min.j + 1 == leadingEdge.Count)
                {
                    leadingEdge.Add(new LatticePoint(0, min.j + 1, min.value * 2));
                }
                min.i++;
                min.value *= 5;
            }
        }
    }
}

Spazio: O (n) in numero di elementi stampati finora.

Velocità: O (1) inserisce, ma quelli non vengono eseguiti ogni volta. (Occasionalmente più a lungo quando List<>deve crescere, ma comunque O (1) ammortizzato). Il big time sink è la ricerca del minimo, O (n) nel numero di elementi stampati finora.

La soluzione basata sul set era probabilmente ciò che il tuo intervistatore stava cercando, tuttavia ha la sfortunata conseguenza di avere O(n)memoria e O(n lg n)tempo totale per gli nelementi di sequenziamento .

Un po 'di matematica ci aiuta a trovare una soluzione O(1)spaziale e O(n sqrt(n))temporale. Si noti che 2^i * 5^j = 2^(i + j lg 5). Trovare i primi nelementi di {i,j > 0 | 2^(i + j lg 5)}riduce a trovare i primi nelementi del {i,j > 0 | i + j lg 5}perché la funzione (x -> 2^x)è strettamente monotonicamente crescente, quindi l'unico modo per un po ' a,bche 2^a < 2^bè se a < b.

Ora, abbiamo solo bisogno di un algoritmo per trovare la sequenza di i + j lg 5, dove i,jsono i numeri naturali. In altre parole, dato il nostro valore attuale di i, j, ciò che minimizza la prossima mossa (cioè, ci dà il numero successivo nella sequenza), è un certo aumento di uno dei valori (diciamo j += 1) insieme a una diminuzione nell'altro ( i -= 2). L'unica cosa che ci sta limitando è quella i,j > 0.

Ci sono solo due casi da considerare: iaumenti o jaumenti. Uno di questi deve aumentare poiché la nostra sequenza è in aumento, ed entrambi non aumentano perché altrimenti saltiamo il termine in cui ne abbiamo solo uno i,j. Quindi uno aumenta e l'altro rimane uguale o diminuisce. Espresso in C ++ 11, l'intero algoritmo e il suo confronto con la soluzione impostata sono disponibili qui .

Ciò consente di ottenere una memoria costante poiché nel metodo sono allocati solo una quantità costante di oggetti, a parte l'array di output (vedere collegamento). Il metodo raggiunge il tempo logaritmico ogni iterazione poiché per ogni dato (i,j), attraversa per la coppia migliore in (a, b)modo che (i + a, j + b)sia il più piccolo aumento del valore di i + j lg 5. Questo attraversamento è O(i + j):

Attempt to increase i:
++i
current difference in value CD = 1
while (j > 0)
  --j
  mark difference in value for
     current (i,j) as CD -= lg 5
  while (CD < 0) // Have to increase the sequence
    ++i          // This while will end in three loops at most.
    CD += 1
find minimum among each marked difference ((i,j) -> CD)

Attempt to increase j:
++j
current difference in value CD = lg 5
while (j > 0)
  --i
  mark difference in value for
     current (i,j) as CD -= 1
  while (CD < 0) // have to increase the sequence
    ++j          // This while will end in one loop at most.
    CD += lg 5
find minimum among each marked difference ((i,j) -> CD)

Ogni iterazione tenta di aggiornare i, quindi j, e va con l'aggiornamento più piccolo dei due.

Poiché ie jsiamo al massimo O(sqrt(n)), abbiamo O(n sqrt(n))tempo totale . ie jcresce al ritmo del quadrato di da nallora per qualsiasi valore massimo imaxe jmaxesistono O(i j)coppie uniche da cui creare la nostra sequenza se la nostra sequenza è ntermini, ie jcrescono entro un fattore costante l'uno dall'altro (perché l'esponente è composto da un lineare combinazione dei due), lo sappiamo ie lo jsiamo O(sqrt(n)).

Non c'è molto di cui preoccuparsi riguardo all'errore in virgola mobile - poiché i termini crescono in modo esponenziale, dovremmo fare i conti con l'overflow prima che l'errore del flop ci raggiunga, di diverse dimensioni. Aggiungerò ulteriori discussioni a questo se avrò tempo.