Sonraki en küçük 2 ^ i * 5 ^ j arasından yazdırın, burada i, j> = 0

Son zamanlarda bir teknik telefon taraması sırasında bu soruyu sordum ve iyi yapmadım. Soru, aşağıda kelimesi kelimesine verilmiştir.

Sıralı {2^i * 5^j | i,j >= 0}koleksiyon oluşturun . Bir sonraki en küçük değeri sürekli olarak yazdırın.

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

"Bir sonraki en küçük", bana bir yığın yığını olduğunu düşündürüyor, ama oradan nereye gideceğimi gerçekten bilmiyordum ve görüşmeci tarafından hiçbir yardım verilmedi.

Böyle bir sorunun nasıl çözüleceği konusunda tavsiyesi olan var mı?

Sorunu yeniden gözden geçirelim: Sayının 2 ve 5 dışında hiçbir faktörü olmayacak şekilde her sayıyı 1'den sonsuza çıkarın.

Aşağıda basit bir C # snippet'i verilmiştir:

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);
}

Kilian / QuestionC'nin yaklaşımı çok daha başarılı. Bu yaklaşımla C # snippet'i:

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 yinelenen eklemeleri önler.

Temel olarak, dizideki bir sonraki sayının girilmesini sağlayarak çalışır itms.

Bu yaklaşımın geçerli olduğunun kanıtı:
Açıklanan algoritma, formdaki herhangi bir sayı çıktısından sonra 2^i*5^j, kümenin şimdi 2^(i+1)*5^jve içermesini sağlar 2^i*5^(j+1). Sıradaki bir sonraki sayının olduğunu varsayalım 2^p*5^q. Daha önce çıkış biçiminin sayıda bulunması gerekir 2^(p-1)*5^(q)ya da 2^p*5^(q-1)(ne p de q 0 eşit olup olmadığını ya da her ikisi birden). Değilse 2^p*5^q, bir sonraki sayı değildir, çünkü 2^(p-1)*5^(q)ve 2^p*5^(q-1)her ikisi de daha küçüktür.

İkinci snippet, O(n)hafızayı kullanır (burada n, çıkan sayıların sayısıdır), çünkü O(i+j) = O(n)(i ve j'nin ikisi de n'den küçük olduğu için) ve O(n log n)zaman içinde n sayısı bulacaktır . İlk snippet, sayıları üstel zamanda bulur.

Bu, cevabı bilmenin yararlı olduğu yeterince yaygın bir görüşme sorusudur. Kişisel beşik sayfamdaki ilgili giriş:

• form 3'ün ^bir 5 ^b 7 ^c sayılarını sırayla oluşturmak için , 1 ile başlayın, olası üç ardılı da (3, 5, 7) yardımcı bir yapıya doldurun , ardından en küçük sayıyı listenize ekleyin.

Başka bir deyişle, bunu verimli bir şekilde çözmek için ek bir sıralama tamponu ile iki aşamalı bir yaklaşıma ihtiyacınız vardır. (Daha iyi bir açıklama Gayle McDowell tarafından Cracking the Coding Röportajında .

İşte CPU'nun pahasına sabit bellekle çalışan bir cevap. Bu, asıl soru bağlamında iyi bir cevap değildir (yani bir röportaj sırasında cevap). Ancak röportaj 24 saat sürüyorsa, o kadar da kötü değil. ;)

Fikir şu ki, eğer geçerli bir cevap olan n varsa, o zaman sıradaki bir sonraki iki kuvvetin n katı, 5'in gücüne bölünür. Ya da n kere 5'in gücüne bölünür. ikisinin gücü. Eşit şekilde bölünmesi şartıyla. (... veya bölen 1 olabilir;) bu durumda sadece 2 veya 5 ile çarpıyorsunuz)

Örneğin, 625'ten 640'a gitmek için 5 ** 4/2 ** 7 ile çarpın. Veya daha genel olarak, 2 ** m * 5 ** nbir kişinin pozitif ve birinin negatif veya sıfır olduğu bazı m, n için bir değerle çarpın . çarpan sayıyı eşit olarak böler.

Şimdi, zor kısmı çarpanı bulmak. Ama biliyoruz ki a) bölen sayıyı eşit olarak bölmelidir, b) çarpan birden büyük olmalıdır (sayılar artmaya devam eder) ve c) 1'den büyük en düşük çarpanı seçersek (yani 1 <f <diğer tüm f'ler) ), bu durumda bir sonraki adımımız garanti edilir. Bundan sonraki adım en düşük adım olacaktır.

Kötü kısmı m, n değerini bulmaktır. Sadece log (n) olasılıkları vardır, çünkü vazgeçecek çok fazla 2 ya da 5 vardır, ama yuvarlak kapanışla başa çıkmak için özensiz bir yol olarak -1'den + 1'e bir faktör eklemek zorunda kaldım. Bu yüzden her adımı sadece O (log (n)) üzerinden yinelemeliyiz. Yani genel olarak O (n log (n)).

İyi haber şu ki, bir değer alıyor ve bir sonraki değeri buluyor, dizinin herhangi bir yerine başlayabilirsiniz. Yani 1 milyardan sonra bir sonrakini istiyorsanız, 2/5 veya 5 / 2'leri tekrarlayarak ve 1'den büyük en küçük çarpanı seçerek bulabilirsiniz.

(Piton)

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

Sıralanan liste çözümü tarafından üretilen ilk 10.000'e göre ürettiği ilk 10.000 sayısını doğruladım ve en azından o kadar çalışıyor.

BTW bir trilyondan sonra bir sonraki 1.024.000.000.000 gibi görünüyor.

...

Hm. best()Adım adım genişlettiğim bir arama tablosu olarak davranarak O (n) performansını - değer (!) Başına O (1) - ve O (günlük n) bellek kullanımını elde edebilirim . Şu anda her seferinde yineleyerek bellek tasarrufu sağlıyor, ancak çok fazla hesaplama yapıyor. Bu ara değerleri - ve min değerleri listesini - tutarak, yinelenen çalışmayı önleyebilir ve çok hızlandırabilirim. Bununla birlikte, ara değerlerin listesi n ile birlikte büyüyecektir, dolayısıyla O (log n) belleği.

Brian kesinlikle haklıydı - diğer cevabım çok karmaşıktı. İşte bunu yapmanın daha basit ve daha hızlı bir yolu.

Öklid düzleminin, tamsayılarla sınırlandırılmış Çeyrek I düşünün. Bir eksene i eksenini, diğer eksene j eksenini çağırın.

Açıkçası, başlangıç ​​noktasına yakın noktalar başlangıç ​​noktasından uzak noktalardan önce seçilecektir. Ayrıca, etkin alanın j ekseninden uzaklaşmadan önce i ekseninden uzaklaşacağını unutmayın.

Bir nokta kullanıldığında, bir daha asla kullanılmayacaktır. Ve bir nokta sadece doğrudan altındaki veya solundaki nokta zaten kullanılmışsa kullanılabilir.

Bunları bir araya getirerek, başlangıç ​​noktasında başlayan ve i ekseni boyunca j ekseninden daha uzağa yayılan bir "sınır" veya "ön kenar" hayal edebilirsiniz.

Aslında, daha fazla bir şey bulabiliriz: herhangi bir i-değeri için sınırda / kenarda en fazla bir nokta olacaktır. (J'nin bir artışına eşit olması için i'yi 2 kattan fazla artırmanız gerekir.) Bu nedenle, sınırı her i koordinatı için bir öğe içeren bir liste olarak temsil edebiliriz, sadece j koordinatı ve işlev değeri ile değişir.

Her geçişte, ön kenardaki minimum elemanı seçer ve ardından bir kez j yönünde hareket ettiririz. Son öğeyi yükseltirsek, artan bir i değeri ve 0 değeri j olan yeni bir son öğe ekleriz.

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;
            }
        }
    }
}

Boşluk: O ana kadar yazdırılan eleman sayısı olarak O (n).

Hız: O (1) ekler, ancak bunlar her seferinde yapılmaz. ( List<>Büyümek gerektiğinde daha uzun , ancak yine de O (1) itfa edilir). Büyük zaman alıcısı şimdiye kadar basılmış eleman sayısında minimum, O (n) arayışıdır.

Kümeye dayalı çözüm muhtemelen görüşmecinizin aradığı şeydi, ancak öğelerin sıralanması için O(n)hafızaya ve O(n lg n)toplam süreye sahip olmanın talihsiz bir sonucu var n.

Biraz matematik bir O(1)yer ve O(n sqrt(n))zaman çözümü bulmamıza yardımcı olur . Dikkat edin 2^i * 5^j = 2^(i + j lg 5). İlk Bulma nunsurlarını {i,j > 0 | 2^(i + j lg 5)}birinci bulma azaltır nunsurlarını {i,j > 0 | i + j lg 5}fonksiyonu nedeniyle (x -> 2^x)kesinlikle monoton artan, bu nedenle bazıları için tek yol ise olduğunu .a,b2^a < 2^ba < b

Şimdi, biz sadece sırasını bulmak için bir algoritma gerek i + j lg 5, i,jdoğal sayılardır. Diğer bir deyişle, şimdiki değerimiz göz önüne alındığında i, j, bir sonraki hareketi en aza indirgeyen şey (yani, dizideki bir sonraki sayıyı verir), değerlerden birinde (örneğin j += 1) diğerinde ( i -= 2) bir azalma ile birlikte bir miktar artıştır . Bizi sınırlayan tek şey şu i,j > 0.

Dikkate alınması gereken sadece iki durum vardır - iartışlar veya jartışlar. Sekansımız arttığı için bunlardan biri artmalı ve her ikisi de artmıyor çünkü aksi takdirde sadece bir tanesine sahip olduğumuz terimi atlıyoruz i,j. Böylece biri artar, diğeri aynı kalır veya azalır. C ++ 11'de ifade edilen algoritmanın tamamı ve ayarlanan çözümle karşılaştırması burada mevcuttur .

Çıkış dizisinin yanı sıra, yöntemde yalnızca sabit miktarda nesne tahsis edildiğinden, bu sabit bellek sağlar (bkz. Bağlantı). Herhangi bir için çünkü yöntem logaritmik seferinde her yinelemesini başarır (i,j), en iyi çifti için geçtiği (a, b)böyle (i + a, j + b)değerinde en küçük artıştır i + j lg 5. Bu geçiş 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)

Her yineleme idaha sonra güncelleme yapmaya çalışır jve ikisinin daha küçük güncellemesiyle devam eder.

Yana ive jen altındadır O(sqrt(n)), biz toplam sahip O(n sqrt(n))zamanı. ive jkaresinin oranda büyümesine nbir maksimum Fonksiyonlar, değerlerin elde için yana imaxve jmaxorada mevcut O(i j)eden sekans ise eden dizisi yapmak için eşsiz çiftleri nterimler ve ive jüstel bir doğrusal oluşur, çünkü birbirlerine (bazı sabit faktör içinde büyümek ikisinin kombinasyonu), bunu biliyoruz ive jvardır O(sqrt(n)).

Kayan nokta hatası konusunda endişelenecek çok şey yok - terimler katlanarak büyüdüğü için, flop hatası bizimle birkaç büyüklükte yakalanmadan önce taşma ile uğraşmak zorundayız. Zamanım olursa buna daha fazla tartışma ekleyeceğim.