Điều này có được phân loại là thuật toán O (1) cho "Xin chào, Thế giới!" ??

public class Hello1
{
   public static void Main()
   {
      DateTime TwentyYearsLater = new DateTime(2035,01,01);
      while ( DateTime.Now < TwentyYearsLater )
      { 
          System.Console.WriteLine("It's still not time to print the hello ...");
      }
      System.Console.WriteLine("Hello, World!");
   }
}

Tôi đang nghĩ đến việc sử dụng

DateTime TwentyYearsLater = new DateTime(2035,01,01);
while ( DateTime.Now < TwentyYearsLater )
{ 
   // ... 
}

đoạn mã như một vòng lặp bận rộn để đưa vào như một trò đùa bất cứ khi nào ai đó yêu cầu một thuật toán có độ phức tạp nhất định. Điều này có đúng không?

Ký hiệu Big O trong ngữ cảnh này đang được sử dụng để mô tả mối quan hệ giữa kích thước của đầu vào của một hàm và số lượng các thao tác cần được thực hiện để tính toán kết quả cho đầu vào đó.

Hoạt động của bạn không có đầu vào mà đầu ra có thể liên quan đến, vì vậy việc sử dụng ký hiệu Big O là vô nghĩa. Thời gian hoạt động diễn ra độc lập với các yếu tố đầu vào của hoạt động (là ... không có). Kể từ đó là không có mối quan hệ giữa đầu vào và số lượng các hoạt động thực hiện, bạn không thể sử dụng Big O để mô tả mối quan hệ không tồn tại

Ký hiệu Big-O có nghĩa đại khái là 'cho một phép toán trên một lượng công việc, N, bao nhiêu thời gian tính toán, tỷ lệ với N, thuật toán mất bao nhiêu thời gian?'. Ví dụ: sắp xếp một mảng có kích thước N có thể lấy N ^ 2, Nlog (N), v.v.

Điều này không có lượng dữ liệu đầu vào để thực hiện. Vì vậy, nó không phải O(anything).

Thậm chí tệ hơn; về mặt kỹ thuật đây không phải là một thuật toán. Thuật toán là một phương pháp để tính toán giá trị của một hàm toán học - các hàm toán học là một ánh xạ từ một đầu vào đến một đầu ra. Vì điều này không cần đầu vào và không trả về gì nên nó không phải là một hàm, theo nghĩa toán học. Từ wikipedia:

Thuật toán là một phương pháp hiệu quả có thể được biểu diễn trong một khoảng không gian và thời gian hữu hạn và bằng một ngôn ngữ hình thức được xác định rõ ràng để tính toán một hàm. Bắt đầu từ trạng thái ban đầu và đầu vào ban đầu (có thể trống), các lệnh mô tả một phép tính, khi được thực thi, sẽ tiến hành thông qua một số hữu hạn các trạng thái liên tiếp được xác định rõ, cuối cùng tạo ra "đầu ra" và kết thúc ở trạng thái kết thúc cuối cùng.

Về mặt kỹ thuật, đây là một hệ thống điều khiển. Từ wikipedia;

Hệ thống điều khiển là một thiết bị hoặc một tập hợp các thiết bị, quản lý, ra lệnh, chỉ đạo hoặc điều chỉnh hành vi của các thiết bị hoặc hệ thống khác.

Đối với những người muốn có câu trả lời chuyên sâu hơn về sự khác biệt giữa các hàm toán học và thuật toán cũng như khả năng mạnh mẽ hơn của máy tính để thực hiện những việc hiệu quả hơn như xuất bảng điều khiển, hiển thị đồ họa hoặc điều khiển rô bốt, hãy đọc bài báo này trên Giả thuyết mạnh về nhà thờ Turing

trừu tượng

Quan điểm cổ điển về tính toán vị trí tính toán như một phép biến đổi hộp kín của đầu vào (số hữu tỉ hoặc chuỗi hữu hạn) thành đầu ra. Theo quan điểm tương tác của máy tính, tính toán là một quá trình tương tác liên tục chứ không phải là một sự chuyển đổi dựa trên chức năng của một đầu vào thành đầu ra. Cụ thể, giao tiếp với thế giới bên ngoài xảy ra trong quá trình tính toán, không phải trước hay sau nó. Cách tiếp cận này thay đổi hoàn toàn sự hiểu biết của chúng ta về tính toán là gì và cách nó được mô hình hóa.

Việc chấp nhận tương tác như một mô hình mới bị cản trở bởi Strong Church-Turing Thesis (SCT), niềm tin phổ biến rằng Máy Turing (TM) nắm bắt tất cả các phép tính, vì vậy các mô hình tính toán biểu cảm hơn TM là không thể. Trong bài báo này, chúng tôi chỉ ra rằng SCT diễn giải lại Luận văn Church-Turing (CTT) ban đầu theo cách mà Turing không bao giờ có ý định; sự tương đương thường được giả định của nó với bản gốc là một huyền thoại. Chúng tôi xác định và phân tích các lý do lịch sử dẫn đến niềm tin rộng rãi vào thuế TTĐB. Chỉ bằng cách chấp nhận rằng điều đó là sai, chúng ta mới có thể bắt đầu chấp nhận tương tác như một mô hình tính toán thay thế

Không, mã của bạn có độ phức tạp về thời gian O(2^|<DeltaTime>|),

Để có một mã hóa thích hợp của thời điểm hiện tại.
Làm ơn, cho tôi xin lỗi trước vì tiếng Anh của tôi.

Big O là gì và cách thức hoạt động của Big O trong CS

Ký hiệu Big O không được sử dụng để ràng buộc đầu vào của một chương trình với thời gian chạy của nó .
Ký hiệu Big O, để lại tính chặt chẽ, là một cách để biểu thị tỷ số tiệm cận của hai đại lượng .

Trong trường hợp phân tích thuật toán, hai đại lượng này không phải là đầu vào (mà đại lượng này trước tiên phải có chức năng "đo") và thời gian chạy.
Chúng là độ dài mã hóa của một trường hợp của vấn đề ¹ và một chỉ số quan tâm.

Các chỉ số thường được sử dụng là

1. Số bước cần thiết để hoàn thành thuật toán trong một mô hình tính toán nhất định.
2. Không gian cần thiết, nếu có bất kỳ khái niệm nào như vậy tồn tại, bởi mô hình tính toán.

Ngầm được giả định một TM là mô hình do đó điểm đầu tiên chuyển đến số ứng dụng của quá trình chuyển đổi ² chức năng , tức là "bước", và một trong những thứ hai chuyển số lượng tế bào băng khác nhau bằng văn bản ít nhất một lần .

Có phải người ta cũng thường mặc nhiên cho rằng chúng ta có thể sử dụng mã hóa đa thức liên quan thay vì mã hóa ban đầu, chẳng hạn như một hàm tìm kiếm một mảng từ đầu đến cuối có O(n)độ phức tạp mặc dù thực tế là mã hóa một phiên bản của mảng đó phải có độ dài là n*b+(n-1)ở đâu blà số ký hiệu (hằng số) của mỗi phần tử. Điều này là do bđược coi là hằng số của mô hình tính toán nên biểu thức trên vàn tiệm cận là giống nhau.

Điều này cũng giải thích tại sao một thuật toán như Bộ phận Thử nghiệm là một thuật toán hàm mũ mặc dù về cơ bản là một for(i=2; i<=sqr(N); i++)thuật toán giống ³ .

Xem này .

Điều này cũng có nghĩa là ký hiệu O lớn có thể sử dụng nhiều tham số mà người ta có thể cần để mô tả vấn đề, không có gì lạ khi có k tham số cho một số thuật toán.

Vì vậy, đây không phải là về "đầu vào" hay "không có đầu vào".

Nghiên cứu trường hợp ngay bây giờ

Ký hiệu Big O không đặt câu hỏi về thuật toán của bạn, nó chỉ giả định rằng bạn biết bạn đang làm gì. Về cơ bản, nó là một công cụ có thể áp dụng ở mọi nơi, ngay cả đối với thuật toán có thể cố tình phức tạp (như của bạn).

Để giải quyết vấn đề của bạn, bạn đã sử dụng ngày hiện tại và ngày trong tương lai, vì vậy bằng cách nào đó chúng phải là một phần của vấn đề; nói một cách đơn giản: chúng là một phần của ví dụ của vấn đề.

Cụ thể ví dụ là:

<DeltaTime>

Trường hợp <>có nghĩa là bất kỳ, không bệnh lý, mã hóa của sự lựa chọn.

Xem bên dưới cho rất quan trọng .

Vì vậy, thời gian phức tạp O lớn của bạn là O(2^|<DeltaTime>|)do bạn thực hiện một số lần lặp phụ thuộc vào giá trị của thời gian hiện tại. Không có ích gì khi đặt các hằng số khác vì ký hiệu tiệm cận rất hữu ích vì nó loại bỏ các hằng số (ví dụ như việc sử dụngO(10^|<DeltaTime>|*any_time_unit) là vô nghĩa).

Phần khó khăn nằm ở đâu

Chúng tôi đã đưa ra một giả định quan trọng ở trên: rằng mô hình tính toán đặc tả lại ⁵ thời gian, và theo thời gian, ý tôi là thời gian vật lý (thực?). Không có khái niệm này trong mô hình tính toán tiêu chuẩn, một TM không biết thời gian, chúng ta liên kết thời gian với số bước bởi vì đây là cách thực tế của chúng ta hoạt động ⁴ .

Trong mô hình của bạn, tuy nhiên thời gian là một phần của tính toán, bạn có thể sử dụng thuật ngữ của những người chức năng bằng cách nói rằng Main không thuần túy nhưng khái niệm thì giống nhau.

Để hiểu điều này, cần lưu ý rằng không có gì ngăn cản Framework sử dụng thời gian giả chạy nhanh hơn gấp đôi, năm, mười lần thời gian vật lý đó. Bằng cách này, mã của bạn sẽ chạy trong "một nửa", "một phần năm", "một phần mười" của "thời gian".

Sự phản ánh này rất quan trọng đối với việc chọn mã hóa <DeltaTime>, về cơ bản đây là một cách cô đọng để viết <(CurrentTime, TimeInFuture)>. Vì thời gian không tồn tại ở thời điểm ban đầu, nên mã hóa của CurrentTime rất có thể là từ Bây giờ (hoặc bất kỳ lựa chọn nào khác) ngày trước có thể được mã hóa là Ngày hôm qua , bằng cách phá vỡ giả định rằng thời lượng mã hóa tăng lên theo thời gian thực. tiếp tục (và một trong số DeltaTime giảm)

Chúng ta phải mô hình hóa thời gian đúng cách trong mô hình tính toán của mình để làm điều gì đó hữu ích.

Sự lựa chọn an toàn duy nhất mà chúng tôi có thể làm là mã hóa dấu thời gian với độ dài ngày càng tăng (nhưng vẫn không sử dụng đơn phân) khi thời gian vật lý tiến lên. Đây là thuộc tính thực sự duy nhất về thời gian mà chúng ta cần và là thuộc tính mã hóa cần nắm bắt. Có phải chỉ với loại mã hóa này, thuật toán của bạn có thể có độ phức tạp về thời gian.

Sự nhầm lẫn của bạn, nếu có, phát sinh từ thực tế là từ thời gian trong các cụm từ ' Độ phức tạp về thời gian của nó là gì?' và ' Sẽ mất bao nhiêu thời gian ?' có nghĩa là những thứ rất khác

Than ôi, thuật ngữ sử dụng những từ giống nhau, nhưng bạn có thể thử sử dụng "độ phức tạp của các bước" trong đầu và tự hỏi lại câu hỏi của mình, tôi hy vọng điều đó sẽ giúp bạn hiểu câu trả lời thực sự là gì ^ _ ^

¹ Điều này cũng giải thích sự cần thiết của phương pháp tiệm cận vì mỗi trường hợp có độ dài khác nhau, nhưng không tùy ý.
² Tôi hy vọng tôi đang sử dụng thuật ngữ tiếng Anh chính xác ở đây.
³ Ngoài ra, đây là lý do tại sao chúng ta thường tìm log(log(n))các số hạng trong toán học.
⁴ Id est, một bước phải chiếm một khoảng thời gian hữu hạn, nhưng không rỗng, cũng không liên kết với nhau.
⁵ Điều này có nghĩa là chế độ tính toán như một kiến ​​thức về thời gian vật lý trong nó, có thể diễn đạt nó bằng các thuật ngữ của nó. Tương tự là cách các generic hoạt động trong .NET framework.

Mặc dù có rất nhiều câu trả lời tuyệt vời ở đây, nhưng hãy để tôi diễn đạt lại tất cả chúng một chút.

Kí hiệu Big-O tồn tại để mô tả các chức năng . Khi được áp dụng để phân tích các thuật toán, điều này trước tiên đòi hỏi chúng ta phải xác định một số đặc điểm của thuật toán này dưới dạng một hàm . Sự lựa chọn phổ biến là coi số bước là một hàm của kích thước đầu vào . Như đã lưu ý trong các câu trả lời khác, việc đưa ra hàm như vậy trong trường hợp của bạn có vẻ lạ, vì không có "đầu vào" được xác định rõ ràng. Tuy nhiên, chúng tôi vẫn có thể cố gắng làm điều đó:

• Chúng tôi có thể coi thuật toán của bạn là một hàm hằng lấy bất kỳ đầu vào nào có kích thước bất kỳ, bỏ qua nó, đợi một khoảng thời gian cố định và kết thúc. Trong trường hợp này, thời gian chạy của nó là f (n) = const , và nó là một thuật toán thời gian O (1). Đây là những gì bạn mong đợi được nghe, phải không? Vâng, về mặt kỹ thuật, nó là một thuật toán O (1) .
• Chúng ta có thể coi TwentyYearsLatertham số giống như "kích thước đầu vào" được quan tâm. Trong trường hợp này thời gian chạy là f (n) = (nx) trong đó x là "bây giờ" tại thời điểm gọi. Khi nhìn theo cách này, nó là một thuật toán thời gian O (n). Mong đợi phản đối này bất cứ khi nào bạn hiển thị thuật toán O (1) về mặt kỹ thuật của mình cho người khác.
• Ồ, nhưng chờ đã, nếu k =TwentyYearsLater là đầu vào, thì kích thước n của nó thực sự là số bit cần thiết để biểu diễn nó, tức là n = log (k) . Do đó, sự phụ thuộc giữa kích thước của đầu vào n và thời gian chạy là f (n) = 2 ^ n - x . Có vẻ như thuật toán của bạn vừa trở nên chậm chạp theo cấp số nhân! Ặc.
• Một đầu vào khác cho chương trình trên thực tế là dòng câu trả lời được đưa ra bởi Hệ điều hành cho chuỗi các lệnh DateTime.Nowgọi trong vòng lặp. Chúng ta thực sự có thể tưởng tượng rằng toàn bộ chuỗi này được cung cấp làm đầu vào tại thời điểm chúng ta chạy chương trình. Sau đó, thời gian chạy có thể được coi là phụ thuộc vào thuộc tính của chuỗi này - cụ thể là độ dài của nó cho đến TwentyYearsLaterphần tử đầu tiên . Trong trường hợp này, thời gian chạy lại là f (n) = n và thuật toán là O (n) .

Nhưng một lần nữa, trong câu hỏi của bạn, bạn thậm chí không nói rằng bạn quan tâm đến thời gian chạy. Nếu bạn muốn sử dụng bộ nhớ thì sao? Tùy thuộc vào cách bạn mô hình hóa tình huống, bạn có thể nói thuật toán là O (1) -memory hoặc, có lẽ, O (n) -memory (nếu việc triển khai DateTime.Nowyêu cầu theo dõi toàn bộ chuỗi lệnh gọi nào đó).

Và nếu mục tiêu của bạn là đưa ra một điều gì đó vô lý, tại sao bạn không đi vào và nói rằng bạn quan tâm đến kích thước của mã thuật toán tính bằng pixel trên màn hình phụ thuộc vào mức thu phóng đã chọn như thế nào. Đây có thể là một cái gì đó giống như f (zoom) = 1 / zoom và bạn có thể tự hào tuyên bố thuật toán của mình là kích thước O (1 / n) -pixel!

Tôi hơi không đồng ý với Servy. Có một đầu vào cho chương trình này, ngay cả khi nó không rõ ràng, và đó là thời gian của hệ thống. Đây có thể là một kỹ thuật mà bạn không dự định, nhưng TwentyYearsFromNowbiến của bạn không phải là hai mươi năm so với thời điểm của hệ thống bây giờ , nó được gán tĩnh vào ngày 1 tháng 1 năm 2035.

Vì vậy, nếu bạn lấy mã này và thực thi nó trên một máy có thời gian hệ thống là ngày 1 tháng 1 năm 1970, thì sẽ mất 65 năm để hoàn thành, bất kể máy tính có nhanh như thế nào (có thể có một số biến thể nếu đồng hồ của nó bị lỗi ). Nếu bạn lấy mã này và thực thi nó trên máy có thời gian hệ thống là ngày 2 tháng 1 năm 2035, nó sẽ hoàn tất gần như ngay lập tức.

Tôi sẽ nói rằng đầu vào của bạn n, làJanuary 1st, 2035 - DateTime.Now , và đó là O (n).

Sau đó, cũng có vấn đề về số lượng hoạt động. Một số người đã lưu ý rằng máy tính nhanh hơn sẽ chạy vòng lặp nhanh hơn, gây ra nhiều hoạt động hơn, nhưng điều đó không liên quan. Khi làm việc với ký hiệu big-O, chúng tôi không xem xét tốc độ của bộ xử lý hoặc số lượng hoạt động chính xác. Nếu bạn sử dụng thuật toán này và chạy trên máy tính, sau đó chạy lại nhưng lâu hơn 10 lần trên cùng một máy tính, bạn sẽ mong đợi số lượng hoạt động tăng theo cùng một hệ số là 10 lần.

Đối với điều này:

Tôi đang nghĩ đến việc sử dụng đoạn mã [redacted code] như một vòng lặp bận rộn để đưa vào như một trò đùa bất cứ khi nào ai đó yêu cầu một thuật toán có độ phức tạp nhất định. Điều này có đúng không?

Không thật sự lắm. Các câu trả lời khác đã đề cập đến vấn đề này, vì vậy tôi chỉ muốn đề cập đến nó. Nhìn chung, bạn không thể so sánh số năm thực thi với bất kỳ ký hiệu big-O nào. Ví dụ. Không có cách nào để nói 20 năm thực hiện = O (n ^ 87) hay bất cứ điều gì khác cho vấn đề đó. Ngay cả trong thuật toán bạn đã đưa ra, tôi có thể thay đổi TwentyYearsFromNownăm 20110, 75699436 hoặc 123456789 và big-O vẫn là O (n).

Phân tích Big-O đề cập đến số lượng xử lý liên quan khi lượng dữ liệu được xử lý tăng lên mà không có giới hạn.

Ở đây, bạn thực sự chỉ xử lý một đối tượng duy nhất có kích thước cố định. Do đó, việc áp dụng phân tích big-O phụ thuộc rất nhiều (chủ yếu?) Vào cách bạn xác định các điều khoản của mình.

Ví dụ, bạn có thể có nghĩa là in đầu ra nói chung và áp đặt một thời gian chờ đợi quá lâu để bất kỳ lượng dữ liệu hợp lý nào sẽ / sẽ được in chính xác trong cùng một khoảng thời gian. Bạn cũng phải bổ sung thêm một chút theo cách định nghĩa hơi khác thường (nếu không muốn nói là hoàn toàn sai) để đi được rất xa - đặc biệt, phân tích big-O thường là được định nghĩa theo số lượng các thao tác cơ bản cần thiết để thực hiện nhiệm vụ cụ thể (nhưng lưu ý rằng độ phức tạp cũng có thể được xem xét về những thứ như sử dụng bộ nhớ, không chỉ sử dụng CPU / hoạt động được thực hiện).

Tuy nhiên, số lượng các hoạt động cơ bản thường chuyển dịch khá chặt chẽ với thời gian thực hiện, vì vậy nó không phải là một khoảng lớn khi coi cả hai là đồng nghĩa. Tuy nhiên, thật không may, chúng tôi vẫn còn mắc kẹt với phần khác: số lượng dữ liệu đang được xử lý ngày càng tăng mà không có giới hạn. Trong trường hợp đó, không có sự chậm trễ cố định nào mà bạn có thể áp đặt sẽ thực sự hiệu quả. Để cân bằng O (1) với O (N), bạn phải áp dụng độ trễ vô hạn để bất kỳ lượng dữ liệu cố định nào sẽ mất vĩnh viễn để in, giống như lượng dữ liệu vô hạn.

big-O liên quan đến cái gì?

Bạn dường như đang hiểu rằng đó twentyYearsLaterlà một "đầu vào". Nếu thực sự bạn đã viết hàm của mình là

void helloWorld(int years) {
   // ...
}

Nó sẽ là O (N) trong đó N = năm (hoặc chỉ nói O(years) ).

Tôi sẽ nói thuật toán của bạn là O (N) so với bất kỳ số nào bạn tình cờ viết trong dòng mã bắt đầu bằng twentyYearsLater =. Nhưng mọi người thường không coi các số trong mã nguồn thực tế là đầu vào. Họ có thể coi đầu vào dòng lệnh là đầu vào hoặc đầu vào chữ ký hàm là đầu vào, nhưng, rất có thể không phải chính mã nguồn. Đó là những gì bạn đang tranh chấp với bạn của bạn - đây có phải là "đầu vào"? Bạn thiết lập mã của mình theo cách để làm cho nó trông giống như một đầu vào một cách trực quan và bạn chắc chắn có thể hỏi thời gian chạy O lớn của nó đối với số N trên dòng 6 của chương trình của bạn, nhưng nếu bạn sử dụng lựa chọn không mặc định như vậy là đầu vào, bạn thực sự cần phải rõ ràng về nó.

Nhưng nếu bạn coi đầu vào là một cái gì đó bình thường hơn, như dòng lệnh hoặc đầu vào cho hàm, sẽ không có đầu ra nào cả và hàm là O (1). Phải mất hai mươi năm, nhưng vì big-O không thay đổi đến bội số không đổi nên O (1) = O (hai mươi năm).

Câu hỏi tương tự - thời gian chạy của:

void sortArrayOfSizeTenMillion(int[] array)

Giả sử nó thực hiện những gì nó nói và đầu vào là hợp lệ, và thuật toán khai thác sắp xếp nhanh hoặc bong bóng hoặc bất cứ điều gì hợp lý, đó là O (1).

"Thuật toán" này được mô tả chính xác là O (1) hoặc thời gian không đổi. Người ta lập luận rằng không có đầu vào cho chương trình này, do đó không có N để phân tích về Big Oh. Tôi không đồng ý rằng không có đầu vào. Khi điều này được biên dịch thành tệp thực thi và được gọi, người dùng có thể chỉ định bất kỳ đầu vào nào có độ dài tùy ý. Độ dài đầu vào đó là N.

Chương trình chỉ bỏ qua đầu vào (có độ dài bất kỳ), do đó thời gian thực hiện (hoặc số lượng lệnh máy được thực thi) là như nhau bất kể độ dài của đầu vào (môi trường cố định đã cho = thời gian bắt đầu + phần cứng), do đó O (1 ).

Một điều tôi ngạc nhiên vẫn chưa được đề cập: ký hiệu big-O là một giới hạn trên!

Vấn đề mà mọi người đều nhận thấy là không có N nào mô tả các đầu vào cho thuật toán, vì vậy không có gì để thực hiện phân tích big-O. Tuy nhiên, điều này có thể dễ dàng được giảm thiểu với một số thủ thuật cơ bản, chẳng hạn như chấp nhận int nvà in nthời gian "Hello World" . Điều đó sẽ giải quyết được lời phàn nàn đó và quay trở lại câu hỏi thực sự là làm thế nàoDateTime hoạt động của sự quái dị .

Không có gì đảm bảo thực tế rằng vòng lặp while sẽ kết thúc. Chúng tôi nghĩ rằng nó phải vào một lúc nào đó, nhưng hãy cân nhắc điều đó DateTime.nowtrả về ngày và giờ hệ thống . Thực tế không có gì đảm bảo rằng điều này đang tăng lên một cách đơn điệu. Có thể có một con khỉ được huấn luyện bệnh lý nào đó liên tục thay đổi ngày và giờ hệ thống trở lại ngày 21 tháng 10 năm 2015 12:00:00 UTC cho đến khi ai đó đưa cho con khỉ một số đôi giày tự động lắp và một ván trượt. Vòng lặp này thực sự có thể chạy trong một khoảng thời gian vô hạn!

Khi bạn thực sự tìm hiểu định nghĩa toán học của các ký hiệu big-O, chúng là giới hạn trên. Họ chứng minh tình huống xấu nhất, bất kể khả năng xảy ra như thế nào. Trường hợp xấu nhất * ở đây là thời gian chạy vô hạn, vì vậy chúng tôi buộc phải tuyên bố rằng không có ký hiệu big-O nào để mô tả độ phức tạp thời gian chạy của thuật toán này. Nó không tồn tại, cũng như 1/0 không tồn tại.

* Chỉnh sửa: từ cuộc thảo luận của tôi với KT, không phải lúc nào cũng hợp lệ khi cho rằng tình huống chúng ta đang lập mô hình với ký hiệu big-O là trường hợp xấu nhất. Trong hầu hết các trường hợp, nếu một cá nhân không xác định được trường hợp nào chúng tôi đang sử dụng, họ định khám phá trường hợp xấu nhất. Tuy nhiên, bạn có thể thực hiện phân tích độ phức tạp big-O trong thời gian chạy trường hợp tốt nhất.

Độ phức tạp được sử dụng để đo "mã lực" tính toán về thời gian / không gian. Ký hiệu Big O được sử dụng để so sánh vấn đề nào là "có thể tính toán được" hoặc "không thể tính toán được" và cũng để so sánh các giải pháp - thuật toán- tốt hơn các giải pháp khác. Như vậy, bạn có thể chia bất kỳ thuật toán nào thành hai loại: những thuật toán có thể giải được trong thời gian đa thức và những thuật toán không thể.

Các bài toán như Sàng Erathostene là O (n ^ exp) và do đó có thể giải được đối với các giá trị nhỏ của n. Chúng có thể tính toán được, chỉ không tính theo thời gian đa thức (NP) và do đó khi được hỏi liệu một số đã cho có phải là số nguyên tố hay không, câu trả lời phụ thuộc vào độ lớn của số đó. Hơn nữa, độ phức tạp không phụ thuộc vào phần cứng, vì vậy việc có máy tính nhanh hơn không có gì thay đổi ...

Hello World không phải là một thuật toán và như vậy là vô nghĩa để cố gắng xác định độ phức tạp của nó - mà là không có. Một thuật toán đơn giản có thể là một cái gì đó như: cho một số ngẫu nhiên, xác định xem nó là chẵn hay lẻ. Bây giờ, nó có quan trọng là số đã cho có 500 chữ số không? Không, vì bạn chỉ cần kiểm tra xem chữ số cuối cùng là chẵn hay lẻ. Một thuật toán phức tạp hơn sẽ là xác định xem một số nhất định có chia đều cho 3. Mặc dù một số số "dễ tính", những số khác lại "khó" và điều này là do độ lớn của nó: so sánh thời gian cần thiết để xác định phần dư giữa một số có một chữ số và một số khác có 500 chữ số.

Một trường hợp phức tạp hơn sẽ là giải mã một văn bản. Bạn có một dãy ký hiệu ngẫu nhiên rõ ràng mà bạn cũng biết đang chuyển tải một thông điệp cho những người có khóa giải mã. Giả sử rằng người gửi đã sử dụng phím ở bên trái và Hello World của bạn sẽ đọc: Gwkki Qieks. Giải pháp "búa lớn, không cần não" sẽ tạo ra tất cả các kết hợp cho các chữ cái đó: từ Aaaa đến Zzzz và sau đó tìm kiếm từ điển từ để xác định từ nào hợp lệ và chia sẻ hai chữ cái phổ biến trong cypher (i, k) trong cùng một vị trí. Hàm biến đổi này là những gì Big O đo lường!

Hầu hết mọi người dường như đang thiếu hai thứ rất quan trọng.

1. Chương trình này không có một đầu vào. Đây là ngày / giờ được mã hóa cứng để so sánh với thời gian của hệ thống. Các đầu vào nằm dưới sự kiểm soát của người chạy thuật toán, còn thời gian của hệ thống thì không. Điều duy nhất mà người chạy chương trình này có thể kiểm soát là ngày / giờ họ đã mã hóa cứng vào so sánh.

2. Chương trình thay đổi dựa trên giá trị đầu vào , nhưng không phải kích thước của tập hợp đầu vào , đó là điều mà ký hiệu big-O quan tâm.

Do đó, nó là không xác định và ký hiệu 'big-O' tốt nhất cho chương trình này có thể là O (null), hoặc có thể là O (NaN).

Mọi người đều chỉ ra một cách chính xác rằng bạn không định nghĩa N , nhưng câu trả lời là không theo cách giải thích hợp lý nhất. Nếu N là độ dài của chuỗi chúng ta đang in và "xin chào, thế giới!" chỉ là một ví dụ, vì chúng tôi có thể suy ra từ mô tả về điều này như một thuật toán “cho” hello, world!, sau đó thuật toán là O ( N ), bởi vì bạn có thể có một chuỗi đầu ra mất ba mươi, bốn mươi hoặc năm mươi năm để in và bạn chỉ thêm một thời gian không đổi vào đó. O ( kN + c ) ∈ O ( N ).

Phụ lục:

Tôi ngạc nhiên, ai đó đang tranh chấp điều này. Nhắc lại các định nghĩa về lớn O và lớn Θ. Giả sử chúng ta có một thuật toán chờ một khoảng thời gian không đổi c và sau đó in ra một thông báo có độ dài N theo thời gian tuyến tính. (Đây là tổng quát của mẫu mã gốc.) Hãy tùy tiện nói rằng chúng ta đợi hai mươi năm để bắt đầu in, và việc in một nghìn tỷ ký tự phải mất thêm hai mươi năm nữa. Hãy c = 20 và k = 10¹², ví dụ, nhưng bất kỳ số thực dương sẽ làm. Đó là tỷ lệ d = c / k (trong trường hợp này là 2 × 10⁻¹¹) năm cho mỗi ký tự, vì vậy thời gian thực hiện của chúng tôi f ( dN + N ) là tiệm cận cnhiều năm. Bất cứ khi nào N > k , dN = c / k N > c . Do đó, dN < dN + c = f ( N ) <2 dN với mọi N > k , và f ( N ) ∈ Θ ( N ). QED

Tôi nghĩ rằng mọi người đang bị bỏ rơi vì mã trông không giống như một thuật toán truyền thống. Đây là bản dịch của đoạn mã được hình thành tốt hơn, nhưng vẫn đúng với tinh thần câu hỏi của OP.

void TrolloWorld(long currentUnixTime, long loopsPerMs){
    long laterUnixTime = 2051222400000;  //unix time of 01/01/2035, 00:00:00
    long numLoops = (laterUnixTime-currentUnixTime)*loopsPerMs;

    for (long i=0; i<numLoops; i++){
        print ("It's still not time to print the hello …");
    }
    print("Hello, World!");
}

Các đầu vào là rõ ràng trong khi trước khi chúng được đưa ra một cách ngầm định bởi thời điểm mã được bắt đầu và tốc độ của phần cứng chạy mã. Mã là xác định và có đầu ra được xác định rõ ràng cho các đầu vào nhất định.

Do các giới hạn được áp đặt cho các đầu vào mà chúng tôi có thể cung cấp, có một giới hạn trên đối với số lượng hoạt động sẽ được thực hiện, vì vậy thuật toán này trên thực tế là O (1).

Tại thời điểm này, có

Thuật toán này có một đầu vào ngầm định, cụ thể là thời gian chương trình được bắt đầu. Thời gian thực hiện sẽ thay đổi tuyến tính ¹ tùy thuộc vào thời điểm nó được bắt đầu. Trong suốt năm 2035 trở về sau, vòng lặp while ngay lập tức thoát ra và chương trình kết thúc sau các hoạt động liên tục ² . Vì vậy, có thể nói rằng thời gian chạy là O(max(2035 - start year, 1))³ . Nhưng vì năm bắt đầu của chúng ta có giá trị nhỏ nhất, nên thuật toán sẽ không bao giờ mất hơn 20 năm để thực thi (tức là một giá trị không đổi).

Bạn có thể làm cho thuật toán của mình phù hợp hơn với ý định của mình bằng cách xác định DateTime TwentyYearsLater = DateTime.Now + new TimeSpan(365*20,0,0,0);⁴

¹ Điều này mang lại cảm giác kỹ thuật hơn về thời gian thực hiện được đo bằng số lượng hoạt động vì có số lượng tối đa hoạt động trên một đơn vị thời gian.
² Giả sử tìm nạp DateTime.Nowlà một hoạt động liên tục, điều này là hợp lý.
³ Tôi hơi lạm dụng ký hiệu O lớn ở đây bởi vì đây là một chức năng giảm dần đối với start year, nhưng chúng tôi có thể dễ dàng khắc phục điều này bằng cách diễn đạt nó dưới dạng years prior to 2035.
⁴ Sau đó, thuật toán không còn phụ thuộc vào đầu vào ngầm định của thời gian bắt đầu, nhưng điều đó không có hậu quả.

Tôi tranh luận rằng đây là O (n). sử dụng http://www.cforcoding.com/2009/07/plain-english-explanation-of-big-o.html làm tài liệu tham khảo.

Big O là gì?

Ký hiệu Big O tìm cách mô tả độ phức tạp tương đối của một thuật toán bằng cách giảm tốc độ tăng trưởng cho các yếu tố chính khi yếu tố chính có xu hướng vô cùng.

và

Ví dụ tốt nhất về Big-O mà tôi có thể nghĩ đến là thực hiện số học. Các phép toán số học cơ bản mà chúng tôi đã học ở trường là:

thêm vào; phép trừ; phép nhân; và sự phân chia. Mỗi điều này là một hoạt động hoặc một vấn đề. Một phương pháp giải những điều này được gọi là một thuật toán.

Ví dụ của bạn,

cho đầu vào là n = 20 (với đơn vị năm).

thuật toán là một hàm toán học f (). trong đó f () sẽ đợi trong n năm, với các chuỗi 'gỡ lỗi' ở giữa. Hệ số tỷ lệ là 1. f () có thể giảm / hoặc tăng bằng cách thay đổi hệ số tỷ lệ này.

đối với trường hợp này, đầu ra cũng là 20 (thay đổi đầu vào thay đổi đầu ra một cách tuyến tính).

về cơ bản chức năng là

f(n) = n*1 = n
    if  n = 20, then 
f(20) = 20