In nhỏ nhất tiếp theo từ 2 ^ i * 5 ^ j trong đó i, j> = 0

Tôi đã được hỏi câu hỏi này trong một buổi kiểm tra điện thoại kỹ thuật gần đây và không làm tốt. Câu hỏi được bao gồm nguyên văn dưới đây.

Tạo {2^i * 5^j | i,j >= 0}bộ sưu tập được sắp xếp. Liên tục in giá trị nhỏ nhất tiếp theo.

Thí dụ: { 1, 2, 4, 5, 8, 10...}

"Nhỏ nhất tiếp theo" khiến tôi nghĩ rằng một đống nhỏ có liên quan, nhưng tôi thực sự không biết phải đi đâu từ đó và không có sự trợ giúp nào được cung cấp bởi người phỏng vấn.

Có ai có lời khuyên về cách giải quyết vấn đề như vậy?

Hãy giải quyết vấn đề: Xuất ra mọi số từ 1 đến vô cùng sao cho số đó không có yếu tố nào ngoại trừ 2 và 5.

Dưới đây là đoạn mã C # đơn giản:

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 của / QuestionC của cách tiếp cận là nhiều hơn performant. Đoạn mã C # với cách tiếp cận này:

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 ngăn chặn chèn vào trùng lặp.

Về cơ bản, nó hoạt động bằng cách đảm bảo rằng số tiếp theo trong chuỗi nằm trong itms.

Bằng chứng rằng cách tiếp cận này là hợp lệ:
Thuật toán được mô tả đảm bảo rằng sau khi có bất kỳ đầu ra số nào trong biểu mẫu 2^i*5^j, tập hợp hiện chứa 2^(i+1)*5^jvà 2^i*5^(j+1). Giả sử số tiếp theo trong chuỗi là 2^p*5^q. Phải tồn tại số đầu ra trước đó của biểu mẫu 2^(p-1)*5^(q)hoặc 2^p*5^(q-1)(hoặc cả hai, nếu cả p và q đều không bằng 0). Nếu không, thì đó 2^p*5^qkhông phải là số tiếp theo, vì 2^(p-1)*5^(q)và 2^p*5^(q-1)cả hai đều nhỏ hơn.

Đoạn mã thứ hai sử dụng O(n)bộ nhớ (trong đó n là số lượng số đã được xuất), vì O(i+j) = O(n)(vì i và j đều nhỏ hơn n) và sẽ tìm thấy n số trong O(n log n)thời gian. Đoạn mã đầu tiên tìm thấy số trong thời gian theo cấp số nhân.

Đây là một câu hỏi phỏng vấn đủ phổ biến mà nó hữu ích để biết câu trả lời. Đây là mục có liên quan trong bảng cũi cá nhân của tôi:

• để tạo các số có dạng 3 ^a 5 ^b 7 ^c theo thứ tự , bắt đầu bằng 1, nhét cả ba người kế vị có thể (3, 5, 7) vào một cấu trúc phụ trợ, sau đó thêm số nhỏ nhất từ ​​nó vào danh sách của bạn.

Nói cách khác, bạn cần một cách tiếp cận hai bước với một bộ đệm được sắp xếp bổ sung để giải quyết vấn đề này một cách hiệu quả. (Một mô tả dài hơn là trong Bẻ khóa phỏng vấn mã hóa của Gayle McDowell.

Đây là một câu trả lời chạy với bộ nhớ không đổi, với chi phí CPU. Đây không phải là một câu trả lời tốt trong bối cảnh của câu hỏi ban đầu (tức là câu trả lời trong một cuộc phỏng vấn). Nhưng nếu cuộc phỏng vấn kéo dài 24 giờ, thì nó không quá tệ. ;)

Ý tưởng là nếu tôi có n là một câu trả lời hợp lệ, thì câu tiếp theo trong chuỗi sẽ là n lần sức mạnh của hai, chia cho một số sức mạnh bằng 5. Hoặc nếu không n nhân một sức mạnh bằng 5, chia cho a Sức mạnh của hai. Miễn là nó chia đều. (... hoặc số chia có thể là 1;) trong trường hợp bạn chỉ cần nhân với 2 hoặc 5)

Ví dụ: để đi từ 625 đến 640, nhân với 5 ** 4/2 ** 7. Hoặc, nói chung, nhân với một số giá trị của 2 ** m * 5 ** nmột số m, n trong đó một là dương và một là âm hoặc bằng 0 và số nhân chia số đồng đều.

Bây giờ, phần khó khăn là tìm số nhân. Nhưng chúng ta biết a) số chia phải chia đều số, b) số nhân phải lớn hơn một (số tiếp tục tăng) và c) nếu chúng ta chọn hệ số nhân thấp nhất lớn hơn 1 (tức là 1 <f <tất cả các f khác ), sau đó được đảm bảo là bước tiếp theo của chúng tôi. Bước sau đó sẽ là bước thấp nhất.

Phần khó chịu là tìm giá trị của m, n. Chỉ có các khả năng đăng nhập (n), vì chỉ có rất nhiều 2 hoặc 5 để từ bỏ, nhưng tôi đã phải thêm một yếu tố -1 đến +1 như một cách cẩu thả để đối phó với vòng đấu. Vì vậy, chúng tôi chỉ phải lặp qua O (log (n)) mỗi bước. Vì vậy, tổng thể O (n log (n)).

Tin tốt là, bởi vì nó lấy một giá trị và tìm giá trị tiếp theo, bạn có thể bắt đầu ở bất cứ đâu trong chuỗi. Vì vậy, nếu bạn muốn số tiếp theo sau 1 tỷ, bạn chỉ có thể tìm thấy nó bằng cách lặp qua 2/5 hoặc 5/2 và chọn hệ số nhân nhỏ nhất lớn hơn 1.

(trăn)

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

Tôi đã xác thực 10.000 số đầu tiên mà số này tạo ra so với 10.000 số đầu tiên được tạo bởi giải pháp danh sách được sắp xếp và nó hoạt động ít nhất cho đến nay.

BTW tiếp theo sau một nghìn tỷ dường như là 1.024.000.000.000.

...

Hừm. Tôi có thể nhận hiệu suất O (n) - O (1) trên mỗi giá trị (!) - và sử dụng bộ nhớ O (log n) bằng cách xử lý best()như một bảng tra cứu mà tôi mở rộng tăng dần. Ngay bây giờ, nó tiết kiệm bộ nhớ bằng cách lặp lại mỗi lần, nhưng nó đang thực hiện rất nhiều phép tính dự phòng. Bằng cách giữ các giá trị trung gian đó - và một danh sách các giá trị tối thiểu - tôi có thể tránh được công việc trùng lặp & tăng tốc nó lên rất nhiều. Tuy nhiên, danh sách các giá trị trung gian sẽ phát triển với n, do đó bộ nhớ O (log n).

Brian hoàn toàn đúng - câu trả lời khác của tôi quá phức tạp. Đây là một cách đơn giản và nhanh hơn để làm điều đó.

Hãy tưởng tượng Quadrant I của mặt phẳng Euclide, giới hạn trong các số nguyên. Gọi một trục là trục i và trục kia là trục j.

Rõ ràng, các điểm gần điểm gốc sẽ được chọn trước các điểm ở xa điểm gốc. Cũng lưu ý rằng khu vực hoạt động sẽ di chuyển ra khỏi trục i trước khi nó di chuyển ra khỏi trục j.

Khi một điểm đã được sử dụng, nó sẽ không bao giờ được sử dụng lại. Và một điểm chỉ có thể được sử dụng nếu điểm ngay bên dưới nó hoặc bên trái của điểm đó đã được sử dụng.

Đặt những thứ này lại với nhau, bạn có thể tưởng tượng một "biên giới" hoặc "cạnh đầu" bắt đầu xung quanh gốc tọa độ và chúng lan rộng lên và sang phải, trải dọc theo trục i xa hơn trên trục j.

Trong thực tế, chúng ta có thể tìm ra một cái gì đó nhiều hơn: sẽ có nhiều nhất một điểm trên biên giới / cạnh cho bất kỳ giá trị i nào. (Bạn phải tăng i hơn 2 lần để tăng bằng j.) Vì vậy, chúng ta có thể biểu diễn biên giới dưới dạng danh sách chứa một phần tử cho mỗi tọa độ i, chỉ thay đổi theo tọa độ j và giá trị hàm.

Mỗi lần vượt qua, chúng tôi chọn phần tử tối thiểu trên cạnh đầu, và sau đó di chuyển nó theo hướng j một lần. Nếu chúng ta tình cờ nâng phần tử cuối cùng, chúng ta thêm vào phần tử mới cuối cùng với giá trị i tăng và giá trị j là 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;
            }
        }
    }
}

Không gian: O (n) về số lượng phần tử được in cho đến nay.

Tốc độ: O (1) chèn, nhưng chúng không được thực hiện mỗi lần. (Đôi khi lâu hơn khi List<>phải phát triển, nhưng vẫn bị khấu hao (1). Thời gian lớn là tìm kiếm tối thiểu, O (n) về số lượng phần tử được in cho đến nay.

Giải pháp dựa trên tập hợp có lẽ là điều mà người phỏng vấn của bạn đang tìm kiếm, tuy nhiên, nó có hậu quả đáng tiếc là có O(n)bộ nhớ và O(n lg n)tổng thời gian để sắp xếp ncác yếu tố.

Một chút toán học giúp chúng ta tìm ra giải pháp O(1)không gian và O(n sqrt(n))thời gian. Lưu ý rằng 2^i * 5^j = 2^(i + j lg 5). Tìm các nphần tử đầu tiên của {i,j > 0 | 2^(i + j lg 5)}giảm để tìm các nphần tử đầu tiên {i,j > 0 | i + j lg 5}vì hàm (x -> 2^x)này hoàn toàn tăng đơn điệu, vì vậy cách duy nhất cho một số a,bđó 2^a < 2^blà nếu a < b.

Bây giờ, chúng ta chỉ cần một thuật toán để tìm chuỗi i + j lg 5, i,jsố tự nhiên ở đâu . Nói cách khác, với giá trị hiện tại của chúng tôi i, j, những gì giảm thiểu bước tiếp theo (nghĩa là cho chúng tôi số tiếp theo trong chuỗi), là một số tăng trong một trong các giá trị (nói j += 1) cùng với việc giảm giá trị khác ( i -= 2). Điều duy nhất hạn chế chúng tôi là điều đó i,j > 0.

Chỉ có hai trường hợp để xem xét - ităng hoặc jtăng. Một trong số chúng phải tăng vì trình tự của chúng tôi đang tăng và cả hai đều không tăng vì nếu không, chúng tôi bỏ qua thuật ngữ mà chúng tôi chỉ có một i,jmức tăng. Do đó, một cái tăng, và cái kia giữ nguyên hoặc giảm. Được thể hiện trong C ++ 11, toàn bộ thuật toán và so sánh của nó với giải pháp thiết lập có sẵn ở đây .

Điều này đạt được bộ nhớ không đổi vì chỉ có một lượng đối tượng được phân bổ trong phương thức, ngoài mảng đầu ra (xem liên kết). Phương thức đạt được thời gian logarit mỗi lần lặp vì đối với bất kỳ lần nào (i,j), nó đi qua cặp tốt nhất (a, b)sao cho (i + a, j + b)giá trị tăng nhỏ nhất i + j lg 5. Truyền tải này là 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)

Mỗi lần lặp lại cố gắng cập nhật i, sau đó j, và đi với bản cập nhật nhỏ hơn của cả hai.

Vì ivà jnhiều nhất O(sqrt(n)), chúng tôi có tổng O(n sqrt(n))thời gian. ivà jtăng theo tỷ lệ bình phương nvì đối với bất kỳ giá trị tối đa nào imaxvà jmaxtồn tại O(i j)các cặp duy nhất để tạo chuỗi nếu chuỗi của chúng là ncác số hạng ivà jphát triển trong một số yếu tố không đổi của nhau (vì số mũ bao gồm một tuyến tính kết hợp cho cả hai), chúng tôi biết rằng ivà jđược O(sqrt(n)).

Không có quá nhiều lo lắng về lỗi dấu phẩy động - vì các thuật ngữ tăng theo cấp số nhân, chúng tôi sẽ phải xử lý lỗi tràn trước khi lỗi flop bắt kịp chúng tôi, theo một số cường độ. Tôi sẽ thêm thảo luận về vấn đề này nếu tôi có thời gian.