Bu, "Merhaba Dünya!" İçin bir O (1) algoritması olarak sınıflandırılır mı? ??

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

Kullanmayı düşünüyorum

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

Birisi belirli bir karmaşıklıkta bir algoritma istediğinde şaka olarak koymak için meşgul bir döngü olarak kod pasajı. Bu doğru olur mu?

Bu bağlamda Büyük O gösterimi, bir işlevin girdisinin boyutu ile o girdinin sonucunu hesaplamak için gerçekleştirilmesi gereken işlem sayısı arasındaki bir ilişkiyi tanımlamak için kullanılmaktadır.

İşleminizde çıktının ilişkilendirilebileceği bir girdi bulunmadığından, Büyük O gösterimini kullanmak anlamsızdır. İşlemin aldığı süre, işlemin girdilerinden bağımsızdır (ki bu ... yok). Girdi ve gerçekleştirilen işlem sayısı arasında bir ilişki olmadığından , var olmayan bu ilişkiyi tanımlamak için Big O kullanamazsınız.

Big-O notasyonu, kabaca 'bir miktar iş üzerinde bir işlem verildiğinde, N, N ile orantılı olarak ne kadar hesaplama süresi alır?' Anlamına gelir. Örneğin, N boyutunda bir diziyi sıralamak N ^ 2, Nlog (N) vb. Alabilir.

Bunun üzerinde hareket edecek miktarda girdi verisi yok. Yani değilO(anything) .

Daha da kötüsü; bu teknik olarak bir algoritma değildir. Algoritma, matematiksel bir fonksiyonun değerini hesaplamak için bir yöntemdir - matematik fonksiyonları, bir girdiden bir çıktıya bir eşlemedir. Bu hiçbir girdi almadığından ve hiçbir şey döndürmediğinden, matematiksel anlamda bir işlev değildir. Wikipedia'dan:

Bir algoritma, sınırlı bir uzay ve zaman miktarı içinde ve bir işlevi hesaplamak için iyi tanımlanmış bir biçimsel dilde ifade edilebilen etkili bir yöntemdir. Bir başlangıç ​​durumundan ve ilk girişten (belki boş) başlayarak, talimatlar, yürütüldüğünde, sonlu olarak "çıktı" üreten ve son bir bitiş durumunda sona eren sınırlı sayıda iyi tanımlanmış ardışık durumlar boyunca ilerleyen bir hesaplamayı açıklar.

Teknik olarak bu, bir kontrol sistemidir. Wikipedia'dan;

Kontrol sistemi, diğer cihazların veya sistemlerin davranışını yöneten, komuta eden, yönlendiren veya düzenleyen bir cihaz veya cihazlar kümesidir.

Matematiksel işlevler ve algoritmalar arasındaki fark hakkında daha derinlemesine bir yanıt isteyenler ve bilgisayarların konsol çıkışı, grafikleri görüntüleme veya robotları kontrol etme gibi yan etki yaratan şeyler yapma konusunda daha güçlü yetenekleri hakkında daha derinlemesine bir cevap isteyenler için , bu makaleyi Güçlü Kilise Turing Hipotezi

Öz

Girdilerin (rasyonel sayılar veya sonlu dizgiler) çıktılara kapalı kutu dönüşümü olarak hesaplama pozisyonları hesaplamasının klasik görünümü. Hesaplamanın etkileşimli görünümüne göre, hesaplama, bir girdinin çıktıya işlev temelli bir dönüşümünden ziyade devam eden etkileşimli bir süreçtir. Özellikle, dış dünya ile iletişim, öncesinde veya sonrasında değil, hesaplama sırasında gerçekleşir. Bu yaklaşım, hesaplamanın ne olduğu ve nasıl modellendiği konusundaki anlayışımızı kökten değiştiriyor.

Etkileşimin yeni bir paradigma olarak kabulü, Turing Makinelerinin (TM) tüm hesaplamaları yakaladığına dair yaygın inanç olan Strong Church-Turing Thesis (SCT) tarafından engellenmektedir, bu nedenle TM'lerden daha anlamlı hesaplama modelleri imkansızdır. Bu makalede, ÖTV'nin orijinal Church-Turing Tezini (CTT) Turing'in asla amaçlamadığı bir şekilde yeniden yorumladığını gösteriyoruz; orijinaliyle genel olarak varsayılan eşdeğerliği bir efsanedir. ÖTV inancının yaygınlaşmasının tarihsel nedenlerini tespit edip analiz ediyoruz. Ancak bunun yanlış olduğunu kabul ederek, etkileşimi alternatif bir hesaplama paradigması olarak benimsemeye başlayabiliriz.

Hayır, kodunuzun zaman karmaşıklığı var O(2^|<DeltaTime>|),

Geçerli zamanın doğru bir şekilde kodlanması için.
Lütfen önce İngilizcem için özür dilememe izin verin.

Big O nedir ve CS'de nasıl çalışır?

Büyük O gösterimi , bir programın girişini çalışma süresine bağlamak için kullanılmaz .
Büyük O notasyonu, titizliği geride bırakarak , iki miktarın asimptotik oranını ifade etmenin bir yoludur. .

Algoritma analiz durumunda, bu iki miktardır olmayan girişi (bunun için bir birinci, bir "ölçü" fonksiyonu olması gerekir) ve akış süresi.
Problem ^1'in bir örneğinin kodlama uzunluğu ve ilgili bir metriktir.

Yaygın olarak kullanılan metrikler

1. Belirli bir hesaplama modelinde algoritmayı tamamlamak için gereken adım sayısı.
2. Böyle bir kavram varsa, hesaplama modelinin gerektirdiği alan.

Örtük olarak, model olarak bir TM varsayılır, böylece ilk nokta , geçiş ² işlevinin uygulama sayısına , yani "adımlar" olarak çevrilir ve ikincisi, en az bir kez yazılmış farklı bant hücrelerinin sayısını çevirir .

Orijinal kodlama yerine polinomik olarak ilişkili bir kodlama kullanabileceğimizi de genellikle örtük olarak varsayılır mı? Örneğin, baştan sona bir diziyi arayan bir işlev O(n), böyle bir dizinin bir örneğinin kodlamasının, her bir elemanın (sabit) sembol sayısı n*b+(n-1)nerede b. Bunun nedeni b, hesaplama modelinin bir sabiti olarak kabul edilmesidir ve bu nedenle yukarıdaki ven asimptotik olarak aynı olmasıdır.

Gibi bir algoritma nedeni de açıklıyor Deneme Bölümü bir olan üstel algoritma aslında bir olmasına rağmen for(i=2; i<=sqr(N); i++)algoritma gibi ³ .

Bunu gör .

Bu aynı zamanda, büyük O notasyonunun, problemi tanımlamak için ihtiyaç duyulabilecek birçok parametreyi kullanabileceği anlamına gelir, bir k'ye sahip olmak alışılmadık bir durum değil mi? bazı algoritmalar için parametresine .

Yani bu değil "giriş" hakkında veya "herhangi bir giriş".

Şimdi çalışma vakası

Büyük O notasyonu algoritmanızı sorgulamaz, sadece ne yaptığınızı bildiğinizi varsayar. Aslında, kasıtlı olarak zor olabilecek (sizinki gibi) algoritmaya bile her yerde uygulanabilen bir araçtır.

Sorununuzu çözmek için şimdiki tarihi ve gelecekteki bir tarihi kullandınız, bu nedenle bunlar bir şekilde sorunun bir parçası olmalı; basitçe söylemek gerekirse: problemin bir parçasıdırlar.

Örnek özellikle şudur:

<DeltaTime>

Nerede olursa <>olsun, patolojik olmayan, kodlama seçimi.

Çok önemli açıklamalar için aşağıya bakın .

Yani sizin büyük O karmaşıklık zamanınız sadece O(2^|<DeltaTime>|), şu anki zamanın değerine bağlı bir dizi yineleme yaptığınız için. Asimptotik gösterim sabitleri ortadan kaldırdığı için yararlı olduğu için diğer sayısal sabitleri koymanın bir anlamı yoktur (yani örneğin kullanımı O(10^|<DeltaTime>|*any_time_unit)anlamsızdır).

Zor kısım nerede

Yukarıda önemli bir varsayımda bulunduk: hesaplama modelinin ⁵ zamanı ve zamanla (gerçek?) Fiziksel zamanı kastettiği. Standart hesaplama modelinde böyle bir kavram yoktur, bir TM zamanı bilmez, zamanı adım sayısı ile ilişkilendiririz çünkü bizim gerçekliğimiz böyle çalışır ⁴ .

Sizin modelinizde zaman, hesaplamanın bir parçası olsa da, Main'in saf olmadığını ancak kavramın aynı olduğunu söyleyerek işlevsel insanların terminolojisini kullanabilirsiniz.

Bunu anlamak için, Çerçeve'nin fiziksel süreden iki, beş, on kat daha hızlı çalışan sahte bir zamanı kullanmasına hiçbir şeyin engel olmadığına dikkat edilmelidir. Bu şekilde kodunuz "zamanın" "yarısında", "beşte birinde", "onda birinde" çalışacaktır.

Bu yansıma, kodlamasını seçmek için önemlidir <DeltaTime>, bu aslında <(CurrentTime, TimeInFuture)> yazmanın yoğunlaştırılmış bir yoludur. Önceden zaman olmadığından, CurrentTime kodlaması çok iyi bir şekilde Şimdi kelimesi (veya başka bir seçenek) olabilir, önceki gün Dün olarak kodlanabilirdi , burada kodlamanın uzunluğunun arttığı varsayımı kırılarak fiziksel zaman olarak ileri gider (ve DeltaTime'dan biri azalır)

Yararlı bir şey yapabilmek için hesaplama modelimizde zamanı doğru şekilde modellemeliyiz.

Yapabileceğimiz tek güvenli seçenek, fiziksel zaman ilerledikçe zaman damgalarını artan uzunluklarla (ancak tekli kullanmadan) kodlamaktır. Bu, ihtiyacımız olan ve kodlamanın yakalaması gereken tek gerçek zaman özelliğidir. Sadece bu tür bir kodlamayla mı, algoritmanıza bir zaman karmaşıklığı verilebilir.

Kafanızın karışması, varsa, ' Zaman karmaşıklığı nedir?' İfadelerindeki zaman kelimesinin olmasından kaynaklanmaktadır. ve 'Ne kadar zaman alacak?' çok çok farklı şeyler anlamına gelir

Ne yazık ki terminoloji aynı kelimeleri kullanıyor, ancak kafanızda "karmaşıklık adımları" kullanmayı deneyebilir ve sorunuzu kendinize yeniden sorabilirsiniz, umarım bu, cevabın gerçekten ^ _ ^ olduğunu anlamanıza yardımcı olur

¹ Bu aynı zamanda, her bir örnek farklı, ancak keyfi olmayan bir uzunluğa sahip olduğundan, asimptotik bir yaklaşım ihtiyacını da açıklar.
² Umarım burada doğru İngilizce terimi kullanıyorum.
³ Ayrıca log(log(n))matematikte sık sık terim bulmamızın nedeni de budur .
⁴ İd est, bir adım belirli bir zaman aralığını işgal etmeli, ancak boş veya bağlantılı olmamalıdır.
⁵ Bu, hesaplama kipinin içindeki fiziksel zaman bilgisi olarak, yani onu kendi terimleriyle ifade edebileceği anlamına gelir. .NET çerçevesinde jeneriklerin nasıl çalıştığına bir benzetme var.

Burada bir sürü harika cevap olmasına rağmen, hepsini biraz yeniden ifade etmeme izin verin.

İşlevleri açıklamak için Big-O gösterimi mevcuttur . Algoritmaların analizine uygulandığında, bu, öncelikle bu algoritmanın bazı özelliklerini bir fonksiyon açısından tanımlamamızı gerektirir . Yaygın seçim, adım sayısını girdi boyutunun bir işlevi olarak düşünmektir . Diğer yanıtlarda belirtildiği gibi, sizin durumunuzda böyle bir işlev bulmak garip görünmektedir, çünkü açıkça tanımlanmış bir "girdi" yoktur. Yine de yapmayı deneyebiliriz:

• Algoritmanızı, herhangi bir boyuttaki herhangi bir girdiyi alan, yok sayan, sabit bir süre bekleyen ve biten sabit bir işlev olarak görebiliriz. Bu durumda, çalışma zamanı f (n) = sabittir ve bir O (1)-zamanlı algoritmadır. Bu duymayı beklediğin şey, değil mi? Evet, teknik olarak bir O (1) -algoritmasıdır .
• Biz kabul edebilir TwentyYearsLaterilgi parametresi benzeri "girdi-boyutu" olarak. Bu durumda, çalışma zamanı f (n) = (nx) 'dir, burada x , çağırma anındaki "şimdiki zamandır". Bu şekilde görüldüğünde, O (n) zamanlı bir algoritmadır. Teknik olarak O (1) - algoritmanızı başkalarına göstermeye gittiğinizde bu karşı argümanı bekleyin .
• Oh, ama bekle, eğer k =TwentyYearsLater girdi ise, o zaman boyutu n aslında onu temsil etmek için gereken bit sayısıdır, yani n = log (k) . Bu nedenle, n girdisinin boyutu ile çalışma zamanı arasındaki bağımlılık f (n) = 2 ^ n - x şeklindedir . Görünüşe göre algoritmanız katlanarak yavaşladı! Ugh.
• Programın diğer bir girdisi, aslında işletim sistemi tarafından döngüdeki çağrı dizisine verilen yanıtların akışıdırDateTime.Now . Aslında tüm bu dizinin programı çalıştırdığımız anda girdi olarak sağlandığını hayal edebiliriz. Daha sonra çalışma zamanının bu dizinin özelliğine, yani ilk TwentyYearsLateröğeye kadar olan uzunluğuna bağlı olduğu düşünülebilir . Bu durumda çalışma zamanı yine f (n) = n ve algoritma O (n) 'dir .

Ama sonra tekrar, sorunuzda runtime ile ilgilendiğinizi bile söylemediniz. Ya hafıza kullanımını kastettiyseniz? Durumu nasıl modellediğinize bağlı olarak, algoritmanın O (1) -bellek veya belki de O (n) -bellek olduğunu söyleyebilirsiniz (eğer uygulanması DateTime.Nowtüm çağrı dizisini bir şekilde takip etmeyi gerektiriyorsa).

Ve eğer amacınız saçma bir şey bulmaksa, neden hepsini içeri girmiyorsunuz ve algoritmanın kodunun ekrandaki piksel cinsinden boyutunun seçilen yakınlaştırma seviyesine nasıl bağlı olduğuyla ilgilendiğinizi söylemiyorsunuz? Bu, f (yakınlaştırma) = 1 / yakınlaştırma gibi bir şey olabilir ve algoritmanızın O (1 / n) piksel boyutunda olduğunu gururla beyan edebilirsiniz !

Servy'ye biraz katılmıyorum. Açık olmasa bile, bu programın bir girdisi var ve bu sistemin zamanı. Bu, amaçlamadığınız bir teknik ayrıntı olabilir, ancak TwentyYearsFromNowdeğişkeniniz sistemin şu anki zamanından yirmi yıl sonra değil , statik olarak 1 Ocak 2035'e atandı.

Yani bu kodu alır ve sistem zamanı 1 Ocak 1970 olan bir makinede çalıştırırsanız, bilgisayarın ne kadar hızlı olduğuna bakılmaksızın tamamlanması 65 yıl sürecektir (saati hatalıysa bazı değişiklikler olabilir. ). Bu kodu alır ve sistem zamanı 2 Ocak 2035 olan bir makinede çalıştırırsanız, neredeyse anında tamamlanacaktır.

Girişinizin, nolduğunu January 1st, 2035 - DateTime.Nowve O (n) olduğunu söyleyebilirim .

Bir de operasyon sayısı sorunu var. Bazı insanlar, daha hızlı bilgisayarların döngüyü daha hızlı vuracağını ve daha fazla işleme neden olacağını belirtti, ancak bu alakasız. Büyük-O gösterimi ile çalışırken, işlemcinin hızını veya tam işlem sayısını dikkate almıyoruz. Bu algoritmayı alıp bir bilgisayarda çalıştırırsanız ve sonra tekrar çalıştırırsanız, ancak aynı bilgisayarda 10 kat daha uzun süre işlem sayısının aynı 10 kat artmasını beklersiniz.

Buna gelince:

[Redacted code] kod pasajını, birisi belirli bir karmaşıklıkta bir algoritma istediğinde şaka olarak eklemek için meşgul bir döngü olarak kullanmayı düşünüyorum. Bu doğru olur mu?

Hayır gerçek değil. Diğer cevaplar bunu kapsadı, bu yüzden sadece bahsetmek istedim. Genel olarak yürütme yıllarını herhangi bir büyük-O gösterimi ile ilişkilendiremezsiniz. Örneğin. 20 yıllık infaz = O (n ^ 87) ya da bunun için başka bir şey demenin yolu yok. Verdiğiniz algoritmada bile, TwentyYearsFromNow20110, 75699436 veya 123456789 yılını değiştirebilirim ve big-O hala O (n).

Big-O analizi, işlenmekte olan veri miktarı sınırsız olarak arttığı için dahil edilen işlem miktarı ile ilgilenir.

Burada, gerçekten yalnızca tek bir sabit boyutta nesneyle uğraşıyorsunuz. Bu nedenle, büyük-O analizini uygulamak, büyük ölçüde (öncelikle?) Terimlerinizi nasıl tanımladığınıza bağlıdır.

Örneğin, genel olarak çıktıyı yazdırmak ve makul miktarda verinin tam olarak aynı zaman diliminde yazdırılması / yazdırılması için çok uzun süre beklemek demek istersiniz. Ayrıca, çok uzağa gitmek için biraz alışılmadık (tamamen yanlış değilse) tanımlara biraz daha fazla eklemelisiniz - özellikle, büyük-O analizi genellikle bir belirli bir görev (ancak karmaşıklığın sadece CPU kullanımı / gerçekleştirilen işlemler değil, bellek kullanımı gibi şeyler açısından da değerlendirilebileceğini unutmayın).

Temel işlemlerin sayısı genellikle alınan zamana oldukça yakın bir şekilde çevrilir, bu nedenle ikisini eşanlamlı olarak ele almak çok büyük bir zorlama değildir. Ancak ne yazık ki, yine de diğer bölümle sıkışıp kalıyoruz: işlenen veri miktarı sınırsız artıyor. Bu durumda, uygulayabileceğiniz hiçbir sabit gecikme gerçekten işe yaramayacaktır. O (1) ile O (N) 'yi eşitlemek için, sonsuz miktarda verinin yapacağı gibi, herhangi bir sabit verinin yazdırılması sonsuza kadar sürecek şekilde sonsuz bir gecikme uygulamanız gerekir.

Neye göre büyük-O'?

Bunun twentyYearsLaterbir "girdi" olduğu sezgisel görünüyorsunuz . İşlevini gerçekten yazdıysan

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

O (N) olur, burada N = yıl (veya sadece O(years) ).

Algoritmanızın, ile başlayan kod satırına yazdığınız sayıya göre O (N) olduğunu söyleyebilirim twentyYearsLater =. Ancak insanlar genellikle gerçek kaynak kodundaki sayıları girdi olarak dikkate almazlar. Komut satırı girdisini girdi olarak veya işlev imza girdisini girdi olarak düşünebilirler, ancak büyük olasılıkla kaynak kodunun kendisi değil. Arkadaşınızla tartıştığınız şey bu - bu "girdi" mi? Kodunuzu, sezgisel olarak bir girdi gibi görünecek şekilde ayarlıyorsunuz ve kesinlikle büyük O çalışma süresini programınızın 6. satırındaki N sayısı ile ilgili olarak sorabilirsiniz, ancak bu tür varsayılan olmayan bir seçim kullanıyorsanız girdi olarak bu konuda gerçekten açık olmanız gerekir.

Ancak girdiyi komut satırı veya işlevin girdisi gibi daha olağan bir şey olarak kabul ederseniz, hiç çıktı yoktur ve işlev O (1) olur. Yirmi yıl alır, ancak büyük-O sabit bir çarpana kadar değişmediğinden, O (1) = O (yirmi yıl).

Benzer soru - çalışma zamanı nedir:

void sortArrayOfSizeTenMillion(int[] array)

Söylediğini yaptığını ve girdinin geçerli olduğunu varsayarsak ve algoritma hızlı sıralama veya balon sıralaması veya makul herhangi bir şey kullanırsa, O (1).

Bu "algoritma" doğru bir şekilde O (1) veya sabit zaman olarak tanımlanır. Bu programa herhangi bir girdi olmadığı, dolayısıyla Big Oh açısından analiz edilecek N'nin olmadığı tartışıldı. Girdi olmadığına katılmıyorum. Bu, çalıştırılabilir bir dosyada derlendiğinde ve çağrıldığında, kullanıcı herhangi bir keyfi uzunlukta girdi belirleyebilir. Bu giriş uzunluğu N'dir.

Program sadece girişi yok sayar (uzunluk ne olursa olsun), bu nedenle alınan süre (veya yürütülen makine komutlarının sayısı) girişin uzunluğuna bakılmaksızın aynıdır (verilen sabit ortam = başlangıç ​​zamanı + donanım), dolayısıyla O (1 ).

Şaşırdığım bir şeyden henüz bahsedilmedi: büyük-O notasyonu bir üst sınırdır!

Herkesin fark ettiği sorun, algoritmaya girdileri tanımlayan N'nin olmaması, dolayısıyla büyük-O analizi yapacak bir şey olmamasıdır. Ancak, bir int n"Merhaba Dünya" nzamanını kabul etmek ve yazdırmak gibi bazı temel hilelerle bu kolayca hafifletilebilir . Bu, bu şikayetin üstesinden gelir ve bu DateTimecanavarlığın nasıl çalıştığı konusundaki gerçek soruyu geri getirir .

While döngüsünün sona ereceğine dair gerçek bir garanti yoktur. Olması gerektiğini düşünmeyi seviyoruz biraz zaman, ama bu dikkate DateTime.nowdöndürür sistem tarih ve saati . Aslında bunun monoton bir şekilde arttığına dair hiçbir garanti yok. Patolojik olarak eğitilmiş bazı maymunların sistem tarihini ve saatini sürekli olarak 21 Ekim 2015 12:00:00 UTC'ye kadar değiştirmesi mümkündür, ta ki birisi maymuna kendiliğinden oturan ayakkabı ve uçan kaykay verene kadar. Bu döngü aslında sonsuz bir süre boyunca çalışabilir!

Büyük-O notasyonlarının matematiksel tanımına gerçekten girdiğinizde, bunlar üst sınırlardır. Ne kadar olası olmasa da, en kötü senaryoyu gösterirler. Buradaki en kötü durum * senaryosu sonsuz bir çalışma zamanıdır, bu nedenle bu algoritmanın çalışma zamanı karmaşıklığını açıklamak için hiçbir büyük-O gösterimi olmadığını beyan etmek zorundayız . 1/0 olmadığı gibi, mevcut değildir.

* Düzenleme: KT ile yaptığım tartışmaya göre, büyük-O notasyonu ile modellediğimiz senaryonun en kötü durum olduğunu varsaymak her zaman geçerli değildir. Çoğu durumda, bir kişi hangi vakayı kullandığımızı belirleyemezse, en kötü durumu keşfetmeyi amaçlamaktadır. Bununla birlikte, en iyi durum çalışma zamanında büyük bir karmaşıklık analizi yapabilirsiniz.

Karmaşıklık, hesaplama "beygir gücünü" zaman / uzay açısından ölçmek için kullanılır. Big O notasyonu, hangi problemlerin "hesaplanabilir" veya "hesaplanamaz" olduğunu karşılaştırmak ve ayrıca hangi çözümlerin - algoritmalar - diğerlerinden daha iyi olduğunu karşılaştırmak için kullanılır. Bu nedenle, herhangi bir algoritmayı iki kategoriye ayırabilirsiniz: polinom zamanda çözülebilenler ve çözülemeyenler.

Erathostene Eleği gibi problemler O (n ^ exp) 'dir ve bu nedenle küçük n değerleri için çözülebilir. Hesaplanabilirler, sadece polinom zamanında (NP) değil ve bu nedenle verilen bir sayının asal olup olmadığı sorulduğunda, cevap bu sayının büyüklüğüne bağlıdır . Dahası, karmaşıklık donanıma bağlı değildir, bu nedenle daha hızlı bilgisayarlara sahip olmak hiçbir şeyi değiştirmez ...

Merhaba Dünya bir algoritma değildir ve bu nedenle karmaşıklığını belirlemeye çalışmak anlamsızdır - ki bu hiçbiri değildir. Basit bir algoritma şöyle bir şey olabilir: rastgele bir sayı verildiğinde, çift mi yoksa tek mi olduğunu belirleyin. Şimdi, verilen sayının 500 hanesi olması önemli mi? Hayır, çünkü son rakamın çift mi yoksa tek mi olduğunu kontrol etmeniz gerekiyor. Daha karmaşık bir algoritma, belirli bir sayının 3'e eşit olarak bölünüp bölünmediğini belirlemek olacaktır. Bazı sayıların hesaplanması "kolay" olsa da, diğerleri "zordur" ve bunun nedeni büyüklüğünden kaynaklanmaktadır: aradaki artanı belirlemek için gereken zamanı tek basamaklı ve 500 basamaklı bir sayı.

Daha karmaşık bir durum, bir metnin kodunu çözmek olacaktır. Açıkça rastlantısal bir semboller dizisine sahipsiniz ve bunun şifre çözme anahtarına sahip olanlar için bir mesaj ilettiğini de biliyorsunuz. Gönderenin soldaki anahtarı kullandığını ve Merhaba Dünyanızın şunu okuyacağını varsayalım: Gwkki Qieks. "Büyük çekiç, beyinsiz" çözümü, bu harfler için tüm kombinasyonları üretir: Aaaa'dan Zzzz'e ve sonra hangi kelimelerin geçerli olduğunu belirlemek ve şifrede (i, k) iki ortak harfi paylaşmak için bir kelime sözlüğü arar. aynı pozisyon. Bu dönüşüm işlevi, Big O'nun ölçtüğü şeydir!

Çoğu insan iki önemli şeyi kaçırıyor gibi görünüyor.

1. Program yapar bir giriş var. Sistem saatinin karşılaştırıldığı sabit kodlu tarih / saattir. Girişler, algoritmayı çalıştıran kişinin kontrolü altındadır ve sistem zamanı değildir. Bu programı çalıştıran kişinin kontrol edebileceği tek şey, karşılaştırmaya kodladıkları tarih / saattir.

2. Program, girdi değerine göre değişir , ancak büyük-O gösterimiyle ilgili olan girdi kümesinin boyutuna göre değişmez.

Bu nedenle, belirsizdir ve bu program için en iyi 'büyük-O' gösterimi muhtemelen O (boş) veya muhtemelen O (NaN) olacaktır.

Herkes doğru bir şekilde N'yi tanımlamadığınıza işaret etti , ancak cevap en mantıklı yorumda hayır. Eğer N biz baskı ve konum dizenin uzunluğudur “Merhaba dünya!” sadece bir örnektir, bunun tanımından "için" bir algoritma olarak çıkarsayabileceğimiz gibi hello, world!, algoritma O ( N ) olur, çünkü yazdırması otuz, kırk veya elli yıl süren bir çıktı dizeniz olabilir ve siz buna sadece sabit bir süre ekliyoruz. O ( kN + c ) ∈ O ( N ).

Zeyilname:

Şaşırtıcı bir şekilde, birisi buna itiraz ediyor. Büyük O ve büyük Θ'nin tanımlarını hatırlayın. Sabit bir c süresini bekleyen ve sonra doğrusal zamanda N uzunluğunda bir mesaj yazdıran bir algoritmamız olduğunu varsayalım . (Bu, orijinal kod örneğinin bir genellemesidir.) Rastgele diyelim ki, yazdırmaya başlamak için yirmi yıl bekliyoruz ve bir trilyon karakter basmanın bir yirmi yıl daha sürdüğünü söyleyelim. Let c = 20 ve k = 10¹², örneğin, ancak herhangi bir pozitif reel sayılar yapacağız. Bu , karakter başına d = c / k (bu durumda 2 × 10⁻¹¹) yıllık bir oran, yani yürütme süremiz f ( N ) asimptotik olarakdN + c yıl. Ne zaman N > k , dN = c / k N > c . Bu nedenle, dN < dN + c = f ) ∈ Θ ( N ). QED( N ) <2 dN tüm N > k ve f ( N

İnsanların kod olmadığı için kapalı atýlacaktý düşünüyorum bakmak geleneksel algoritma gibi. Burada daha iyi biçimlendirilmiş, ancak OP'nin sorusunun ruhuna sadık kalan kodun bir çevirisi.

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

Girişler açıkken, kodun başlatıldığı zamana ve kodu çalıştıran donanımın hızına göre dolaylı olarak verilmişlerdi. Kod deterministiktir ve belirli girdiler için iyi tanımlanmış bir çıktıya sahiptir.

Sağlayabileceğimiz girdilere getirilen sınırlamalar nedeniyle, yürütülecek işlem sayısının bir üst sınırı vardır, dolayısıyla bu algoritma aslında O (1) 'dir.

Bu zamanda, evet

Bu algoritmanın örtük bir girdisi vardır, yani programın başlatıldığı zaman. Yürütme süresi , ne zaman başlatıldığına bağlı olarak doğrusal olarak ¹ değişecektir . 2035 yılı boyunca ve sonrasında, while döngüsü hemen çıkar ve program sabit işlemlerden sonra sona erer ² . Yani çalışma zamanının O(max(2035 - start year, 1))³ olduğu söylenebilir . Ancak başlangıç ​​yılımız minimum bir değere sahip olduğundan, algoritmanın yürütülmesi asla 20 yıldan fazla sürmez (yani sabit bir değer).

⁴ tanımlayarak algoritmanızı amacınıza daha uygun hale getirebilirsiniz.DateTime TwentyYearsLater = DateTime.Now + new TimeSpan(365*20,0,0,0);

¹ Bu, işlem sayısı olarak ölçülen daha teknik yürütme süresi için geçerlidir çünkü zaman birimi başına maksimum işlem sayısı vardır.
² Getirmenin DateTime.Now, makul olan sabit bir işlem olduğunu varsayarsak .
³ Burada büyük O notasyonunu bir şekilde kötüye kullanıyorum çünkü bu, göre azalan bir fonksiyondur start year, ancak bunu terimleriyle ifade ederek kolayca düzeltebiliriz years prior to 2035.
⁴ O zaman algoritma artık başlangıç ​​zamanının örtük girdisine bağlı değildir, ancak bunun bir önemi yoktur.

Bunun O (n) olduğunu iddia ediyorum. referans olarak http://www.cforcoding.com/2009/07/plain-english-explanation-of-big-o.html kullanarak .

Big O nedir?

Big O notasyonu, anahtar faktör sonsuzluğa yöneldiğinde büyüme oranını anahtar faktörlere indirgeyerek bir algoritmanın göreceli karmaşıklığını açıklamaya çalışır.

ve

Big-O''nun aklıma gelen en iyi örneği aritmetik yapmaktır. Okulda öğrendiğimiz temel aritmetik işlemler şunlardı:

ilave; çıkarma; çarpma işlemi; ve bölünme. Bunların her biri bir operasyon veya problemdir. Bunları çözmenin bir yöntemine algoritma denir.

Örneğiniz için,

n = 20 girdisi verildiğinde (birim yıllarla).

algoritma matematiksel bir fonksiyondur f (). burada f (), arada 'hata ayıklama' dizeleri ile n yıl bekler. Ölçek faktörü 1'dir. F (), bu ölçek faktörü değiştirilerek azaltılabilir / veya artırılabilir.

bu durum için çıktı da 20'dir (girdiyi değiştirmek çıktıyı doğrusal olarak değiştirir).

esasen işlev

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