Bir program sona ererse ve onu görecek kimse yoksa, durur mu?


99

Gerçekle yüzleşme zamanı: Sonsuza dek burada olmayacağız, ama en azından zamanın sonuna kadar mücadele etse bile, insan ırkını aşacak bir program yazabiliriz.

Göreviniz, evrenin sonuna kadar kalan süreden daha fazla beklenen çalışma süresi olan bir program yazmaktır.

Bunu varsayabilirsin:

  • Evren, 10 1000 yıl içinde entropi ölecek .
  • Senin bilgisayarın:
    • Unobtainium'dan yapıldığı için evreni aşacak .
    • Sonsuz hafıza / yığın / özyineleme limitine sahiptir.
    • İşlemcisi sınırlı hıza sahip.

Programınızın sona erdiğini (üzgünüz, sonsuz döngü yok) göstermesi ve beklenen çalışma süresini hesaplamanız gerekir.

Standart boşluklar geçerlidir.

Bu bir kod golf mücadelesidir, bu nedenle kriterleri sağlayan en kısa kod kazanır.

EDIT :

Ne yazık ki, (30 dakika sonra) Unobtainium'un imkansızlık alanının bilgisayarın iç saatine müdahale ettiği ve yararsız olduğu bulundu. Yani zamana dayalı programlar derhal durur. (Her neyse, sadece yaşayan mirasını bekleyen bir programı kim bırakacaktı?).

Bilgisayar işlemcisi Intel i7-4578U'ya benzer, bu nedenle çalışma süresini ölçmenin bir yolu, programınızı daha küçük bir girişe sahip (benzer bir bilgisayarda) çalıştırmak ve çalışma süresini tahmin etmektir.


Podyum

#CharsLanguageUpvotes        Author        
1    5      CJam              20       Dennis                  
2    5      J                      5         algorithmshark      
3    7      GolfScript       30       Peter Taylor          
4    9     Python             39       xnor                      
5    10   Matlab             5         SchighSchagh      

* 31.08


40
Bu soru için bir [en yavaş kod] etiketi oluşturmak için cazip geldim. : P
Doorknob

5
Bir Bogosort işe yaramaz, çünkü asla bitmemesi sonsuz derecede olanaksız olsa da, bitirmek için sonsuz miktarda zaman gerekebilir. Bununla birlikte , “bitecek, ancak evren ölmeden önce değil” kriterlerini karşılayabilecek birçok NFA temelli düzenli ifade vardır.
DavidO,

49
Başlığınız bir tshirt olmalı
user-2147482637

4
Güzel soru, ama popülerlik yarışması olmamalı mı?
IazertyuiopI

Yanıtlar:


34

CJam, 5 bayt

0{)}h

Nasıl çalışır

 0   " Push 0.                                 ";
 {   "                                         ";
   ) " Increment the Big Integer on the stack. ";
 }h  " Repeat if the value is non-zero.        ";

Yığın artık Big Integer'ı depolayamadığında bu program durur ve bu da yakında modern bir masaüstü bilgisayarda gerçekleşmez.

Varsayılan yığın boyutu bilgisayarımda 4.179.623.936 bayttır (Fedora'da Java 8). İle keyfi bir değere yükseltilebilir -Xmx, bu nedenle tek gerçek sınır mevcut ana hafızadır.

Ölüm zamanı

Yorumlayıcı ihtiyacı varsayarsak x negatif olmayan bir büyük tamsayı az depolamak için hafıza bitleri 2 x biz kadar saymak gerekir 2 8 x 4179623936 = 2 33,436,991,488 . Bir saat döngüsü başına artım ve benim Çekirdeği i7-3770 (turbo ile 3,9 GHz) ile bu alacak 2 33436991488 10> 3400000000 ÷ 10065537393 bitti saniye, 10 10065537385 yıl.


14
"Bilgisayarınızda sonsuz bellek / yığın / özyineleme sınırı var" sorusu ile sınırlı kaynaklara güvenebileceğinizi düşünmüyorum.
Greg Hewgill

4
Sonsuz hafıza !=sonsuz veri türleri. Eğer bir terabayt
RAM'ım

6
@GregHewgill: Sınırsız kaynaklarla, maksimum Java yığın boyutunu istediğiniz herhangi bir değere yükseltebilirsiniz , ancak her zaman sonlu olacaktır.
Dennis,

2
@Dennis, ancak sonra sadece yığın boyutunu ikiye katlamak için döngü boyunca her zaman bir satır ekleyin.
Sonsuzluklarla

9
@CarlWitthoft: Bunu programın içinden yapamazsınız.
Dennis,

62

JavaScript, 39

(function f(x){for(;x!=++x;)f(x+1)})(0)

açıklama

JavaScript tam olarak büyük tamsayıları temsil etmediğinden, döngü bir for(;x!=++x;)kez xvurur 9007199254740992.

For döngüsünün gövdesi , nth fibonacci sayısının Fib(9007199254740992) - 1bulunduğu zamanlar yürütülür Fib(n).

Testten sonra, bilgisayarımın saniyede 150.000 yinelemeden daha azını yapacağını biliyorum. Gerçekte, daha yavaş çalışacaktı çünkü yığın çok büyüyecekti.

Bu nedenle, programın (Fib(9007199254740992) - 1) / 150000çalışması en az saniye alacaktır . Hesaplayamadım, Fib(9007199254740992)çünkü çok büyük, ama bunun 10 1000 * 150.000'den daha büyük olduğunu biliyorum .

EDIT: Yorumlarda belirtildiği gibi , gerçekten de yeterince büyük olan Fib(9007199254740992)yaklaşık 4.4092 * 10 1882393317509686 .


9
Yaklaşılabildiğinden fib(n), bu rakamın kaç haneye ulaştığını hesaplamak phi^niçin kullanabiliriz . log((sqrt(5) + 1)/2)*9007199254740992fib(9007199254740992)1.8823933*10^15
otorractor

11
@haractor, Wolfram Alpha'ya göre Fib(9007199254740992)(sürekli form kullanarak phi) yaklaşık olarak 4.4092... * 10^1882393317509686. Hesaplama
Brian S

1
Yığın büyüyen CPU hızını azaltmaz ... sınırlı bellek adres satırı genişliğini / sınırsız adres genişliğini hesaba katmazsanız (bu durumda yavaşlama, makul kodlama varsayılarak adres uzunluğu boyunca hala doğrusaldır) ve hatta bellek depolama alanındaki fiziksel sınırlamalar ve ışığın hızı (bu durumda yavaşlama, mekansal depolamayı varsayarken adres değerinde kırılgandır; uzay yoğunluğundaki rasgele erişimi yönetseniz bile, veri yoğunluğunun DNA seviyeleri bile artmaya başlar)
John Dvorak

1
@JamesKhoury Hayır, az önce yazdığınız işlev eşdeğerdir for(x=0;x!=++x;)ve yalnızca 9007199254740992 kez tekrarlanır.
Peter Olson

4
@SylvainLeroux, sonsuz miktarda RAM'e sahip bir mimari, muhtemelen yığın ve yığının arasına girer ve her ikisinin de yukarı doğru büyümesini sağlar.
John Dvorak

47

Python (9)

9**9**1e9

Bu 10 ** 10000000 bitten daha fazladır, bu yüzden hesaplamak bizi ısı ölümünden çok uzaklara götürmelidir.

Bunun daha büyük ama yine de makul değerler için daha fazla zaman alacağını kontrol ettim, bu yüzden sadece tercüman tarafından optimize edilmedi.

Düzenleme: @ user2357112 sayesinde parens kaldırarak iki karakter Golf. Python'un ardışık üsleri güç kulesi olarak gördüğü TIL.


4
OverflowError: (34, 'Sonuç çok büyük')
apple16

93
@ apple16 Belki bilgisayarınızda, ancak benim "sonsuz bellek / yığın / özyineleme sınırı" var.
xnor

64
Tamam beyler. Son evreni koştum ve elde ettim ...82528057365719799011536835265979955007740933949599830498796942400000000009(2.6 * 10 ^ 954242509 rakam, karadelik çöküşünü önlemek için atlandı ). Gerçekten Unobtanium'a yükseltmelisin.
xnor

10
Üst üs, doğru bir ilişkidir, böylece parantezleri bırakabilirsiniz.
user2357112

10
Bunun 9**9**9e9kadar kısa olduğunu ve hesaplamak için biraz daha fazla evren boyu sürdüğünü ve biraz daha iyi göründüğünü belirtmeye değer .
abarnert

35

GolfScript ( 12 7 karakter)

9,{\?}*

Bu, 8 ^ 7 ^ 6 ^ 5 ^ 4 ^ 3 ^ 2 ~ = 10 ^ 10 ^ 10 ^ 10 ^ 183230 değerini hesaplar ve yazdırır. Basmak için (hesaplamayı boşver) 10 ^ 1000 yıl ~ = 10 ^ 1007.5 saniye içinde, saniyede yaklaşık 10 ^ (10 ^ 10 ^ 10 ^ 183230 - 10 ^ 3) basamak basması gerekir.


22
Ancak bundan çok önce bir "kağıdın bitti" mesajı ile durur ...
Floris

1
@ Floris kim bu günlerde fiziksel medya kullanıyor?
John Dvorak

3
@JanDvorak, az önce Floris ve onu yenen 7 kişinin, bütün çıktıların sürekli besleme kağıdına geldiği zaman büyükbabamın neslinden olduğunu varsaydım.
Peter Taylor

2
@PeterTaylor - belki oldukça değil o eski, ama ben değilim "toplu işler" göndererek hatırlamak yaşta (şüphesiz sen demek bilgisayar 20k bir öğrenci nüfusu içinde, orada gün) "bilgisayar" için, ve ertesi gün çıktının toplanması. Siz (ve diğer 7 kişi), bunun mükemmel ve saçma kısa yazılarınızın ciddi bir eleştirisi değil, mizah girişimi olduğunu doğru bir şekilde anladınız.
Floris

35

Mermer 68 66 bayt

}0
--@2
@2/\=0MB
}0@1\/
&0/\>0!!
--
@1
00@0
--/\=0
\\@0&0

Marbelous, sadece bir Rube Goldberg benzeri makinede bulunan mermerler tarafından temsil edilen değerlere sahip 8 bitlik bir dildir, bu yüzden bu çok kolay değildi. Bu yaklaşım kabaca şu sözde koda eşdeğerdir:

function recursiveFunction(int i)
{
    for(int j = i*512; j > 0; j--)
    {
        recursiveFunction(i - 1);
    }
}

maksimum değer 256 olduğu için (farklı yerlerde farklı şekilde ele alınan Marbleous programında 0 ile temsil edilir), recursiveFunction (1) toplamı , evreni aşacak kadar kolay, 256!*512^256eşit olan toplam olarak adlandırılır 10^1200.

Marbelous'un çok hızlı bir tercümanı yok, 10^11her yıl bu işlevin çağrılarıyla ilgili çalışabilir gibi görünüyor, bu da yılların çalışma zamanına bakıyoruz demektir 10^1189.

Marbelous kurulunun daha fazla açıklaması

00@0
--/\=0
\\@0&0

00onaltılık (yani 0) ile temsil edilen bir dildir (veya mermer). Bu mermer üzerine düşerek --herhangi bir mermeri 1 azalır (00 sarılır ve ondalık basılarak FF veya 255 olur). Şimdi FF değeri olan Mermer, aşağıya doğru \\bir sütun sağa, aşağıya iten yere düşüyor @0. Bu bir portal ve mermeri diğer @0cihaza ışınlıyor . Orada, /\bir kopyalayıcı olan cihazın üzerindeki mermer toprağı, mermerin bir kopyasını --soluna koyar (bu mermer portallar arasında dolaşmaya devam eder ve her döngüde azalır) ve bir =0sağa doğru.=0mermeri sıfır değerine benzetir ve eşit olması durumunda mermerin yalak düşmesine izin verir ve almazsa sağa iter. Mermerin değeri 0 ise &0, daha sonra açıklayacağım bir eşanjöre iner .

Sonuçta, bu sadece bir döngüde 0 değerinde bir mermerle başlar ve tekrar 0'a ulaşana kadar azaltır, daha sonra bu 0 değeri mermerini bir senkronize ediciye yerleştirir ve aynı anda döngülemeye devam eder.

}0@1
&0/\>0!!
--
@1

}0bir giriş aygıtıdır, başlangıçta programı çağırırken nth (temel 0) komut satırı girişi her }ncihaza yerleştirilir . Eğer bu programı komut satırı girişi 2 ile çağırırsanız, bunun yerine 02 değerinde bir mermer olacaktır }0. Bu mermer daha sonra &0cihaza düşer , başka bir senkronizatör, &nsenkronizatörler diğer tüm karşılık &ngelenler dosyalanıncaya kadar mermerleri tutar . Daha sonra mermer daha önce açıklanan döngüde olduğu gibi azaltılır, ışınlanır ve çoğaltılır. Doğru kopya daha sonra >00 değilse eşitsizlik olup olmadığını kontrol eder, 0 değilse, geçer. 0 ise, sağa doğru itilir !!ve tahtayı sona erdirir.

Tamam, şimdiye kadar 255'ten 0'a kadar sürekli geri sayım yapan bir döngü var ve başka bir, benzer döngü (komut satırı girişi tarafından beslenen) her 0 çarptığında bir kez çalışmasına izin veriyor. Bu ikinci döngü n kez çalıştığında (maksimum 256 ) program sona erer. Demek döngüde maksimum 65536 koşu var. Evreni yenmek için neredeyse yeterli değil.

}0
--@2
@2/\=0MB

Bu tanıdık görünmeye başlamalı, girdi bir kez azaltılmalı, daha sonra bu değer etrafa dolanıp kopyalanmalıdır (mermerin döngünün her hareketinde değil sadece bir kez azaldığını unutmayın). Daha sonra 0'a eşitlik olup olmadığını ve sıfır toprak olmadığını kontrol eder MB. Bu, Marbelous'taki bir fonksiyondur, her dosya birkaç pano içerebilir ve her pano bir fonksiyondur, her fonksiyonun ızgaradan önce adlandırılması gerekir :[name]. Dosyadaki ilk işlev dışında standart bir adı olan her işlev: MB. Bu yüzden bu döngü sürekli olarak ana kartı tekrar çağırır ve n - 1bu fonksiyonun hangi eşgörünümünün çağrıldığı n değeri kullanılır.

Peki neden n*512?

Eh, ilk döngü 4 tene (ve 256 kez) geçiyor ve ikinci döngü tahta sonlanmadan önce n kez çalışıyor. Bu, tahtanın yaklaşık n*4*256keneler için çalıştığı anlamına gelir . Son döngü (özyinelemeli işlev çağrısı yapar) daha sıkıştırıcıdır ve 2 tik ile çalışır, bu da işlev n*4*256/2 = n*512zamanlarını çağırmayı başardığı anlamına gelir .

Bahsetmediğiniz semboller nelerdir?

\/ mermerleri tahtadan söken bir çöp tenekesidir, bu, ayıklanmış mermerler, bir turu çevreleyen diğer mermerleri engellemez ve programın sonlandırılmasını önler.

Bonus

Mermer bir tablonun dibine düşen mermerler STDOUT'a çıktı aldığından, bu program çalışırken ASCII karakterlerinin bir bolluğunu basar.


2
Harika bir açıklama, teşekkürler!
Beta Çürüğü

2
Vay, bu mükemmel bir fikir! Marbelous dili çok eğlenceli!
rubik

2
+1 Sadece görmek istediğim şeyi. BrainFuck'tan daha çılgın bir dil :) Eğitim veren ve bu konuda daha fazla bilgi içeren bir web sitesi var mı? (Başlık bağlantısı cevabınızdan daha az doktora sahip görünüyor)
Sylwester

2
@Sylwester, Beğendiğinize sevindim, Marbelous halen geliştirilme aşamasındadır ancak yakın gelecekte daha istikrarlı bir durumda olmasını bekliyoruz; bu noktada öğreticiler, daha kapsamlı belgeler, standart kütüphaneler ve umarım bir çevrimiçi tercüman takip et.
overactor

21

Perl, 66 58 karakter

sub A{($m,$n)=@_;$m?A($m-1,$n?A($m,$n-1):1):$n+1;}A(9,9);

Yukarıdaki, Ackermann-Péter fonksiyonunun bir uygulamasıdır . A'nın (9,9) ne kadar büyük olduğu hakkında hiçbir fikrim yok, ancak değerlendirmenin şaşırtıcı derecede uzun zaman alacağından eminim.


5
+1 ... Dahili Ackermann işlevine sahip bir dil bulmaya çalışıyordum, ancak sabrım tükenmeden önce bunu başaramadı. : D
Martin Ender

3
$n?A($m-1,A($m,$n-1)):A($m-1,1)üçlü operatöre bastırarak 8 karakterlik kolay bir tasarruf sağlar.
Peter Taylor

3
A'daki (9,9) hane sayısının kübik Planck uzunluklarında ölçülen gözlemlenebilir evrenin hacminden daha büyük olduğundan eminim.
kasperd

6
@ kasperd Bu oldukça büyük bir understatement. Gözlenebilir evrenin hacmi yalnızca 10 ^ 184 planck cildi seviyesindedir. Buna karşılık, A (4,4) 'daki rakam sayısını tanımlayan sayıda 10 ^ 19700 basamak gibi bir şey var, bu da A (9,9) ile karşılaştırıldığında anlaşılmaz derecede küçük.
user19057,

3
@ user19057 Görünüşe göre Kasperd'in "büyük bir yetersiz gösterme" iddiasını devasa bir yetersizlik olarak görüyoruz. : P
Nicu Stiurca

20

MATLAB, 58 52 karakter

En az bir sonlu hassasiyetli aritmetik çözüme ihtiyacımız var, dolayısıyla:

y=ones(1,999);while y*y',y=mod(y+1,primes(7910));end

x = olanlar (1,999); y = x; herhangi bir (y), y = mod (y + x, primeler (7910));

( 6 karakter attığı için @DennisJaheruddin sayesinde )

Tamamlanması gereken döngü sayısı, ilk 999 primenin ürünü tarafından verilir. Bunların büyük çoğunluğu 10'un üzerinde olduğundan, yakınsama gerçekleştirmek için gereken süre, asgari zaman sınırından daha büyük olan yüzlerce veya binlerce büyüklük sırası olacaktır.


+1 Orada ne yaptığınızı görmem biraz zaman aldı. Güzel!
Sabit Nokta

+1 CRT, değil mi?
kusur

Y '* y, y mod (y + 1, asal (7910)) = ederken; y = olanlar (1999) uç: Güzel, bazı karakter şöyle kaydedilebilir düşünüyorum
Dennis Jaheruddin

@DennisJaheruddin: Parlak kısalma. Güncelleyeceğim.
COTO

Artık aynı çözüm olmasa da, bu yine de yeterince benzer ve yine biraz daha kısa olmalıdır:p=1:9e9;y=p;while+y*y',y=mod(y+1,p),end
Dennis Jaheruddin

19

Mathematica, 25 19 bayt

Bu çözüm, zaman işlevleri diskalifiye edilmeden önce gönderildi.

While[TimeUsed[]<10^10^5]

TimeUsed[]oturum başladığından bu yana saniye döndürür ve Mathematica isteğe bağlı olarak hassas türleri kullanır. Yılda yaklaşık 10 7 saniye vardır, bu yüzden 10 10000 saniye beklemek yeterli olacaktır.

Daha kısa / daha basit (/ geçerli) alternatif:

For[i=0,++i<9^9^9,]

Bunun yerine sadece sayalım. Biraz daha saymak zorunda kalacağız, çünkü bir saniyede oldukça fazla artış yapabiliriz, ancak daha yüksek limit aslında karaktere mal olmaz.

Teknik olarak, her iki çözümde de sorun daha düşük bir işlemci hızı belirtmediği için çok daha düşük bir limit kullanabilirim.


Sevdim! Bu cevap beni yüzümde kocaman bir gülümsemeyle kahkahalarla güldürdü.
Todd Lehman

1
Üzgünüm, yaratıcılık aşkına, zamana dayalı çözümleri kesmek zorunda kaldım (birincisi gibi). Lütfen benden nefret etme. :)
kb_sou

5
@kbsou Pekala, bir başkasıyla yendim, o yüzden umrumda değil. Ancak, aksi halde, kural değişiklikleri için geriye dönük olarak verilen yanıtları diskalifiye etmek hoş değildir. ;)
Martin Ender,

1
Mathematica gerçekten o kadar yavaş mı, bilgisayar kullanımı yıllar 9^9^9sürüyor 10^1000mu? 9^9^9Benim 1.3GHz U7300’de kullandığım bilgisayar kullanımının bc6 aydan daha az süreceğini tahmin ediyorum. (Hesaplama zamanını ekstrapolasyona dayanarak 9^200000ve 9^400000.)
kasperd

2
@ArtOfCode Mathematica, isteğe bağlı olarak hassas tipler kullanır, bu yüzden doğru değeri belirlemeye çalışır.
Martin Ender

16

Python 3 - 49

Bu yararlı bir şey yapar: Gregory-Leibniz sonsuz serisini kullanarak Pi'yi benzeri görülmemiş doğrulukta hesaplar.

Merak ediyorsanız, bu program 10**10**10**2.004302604952323zamana bağlı.

sum([4/(i*2+1)*-1**i for i in range(1e99**1e99)])

Keyfi hassasiyet: 78

from decimal import*
sum([Decimal(4/(i*2+1)*-1**i)for i in range(1e99**1e99)])

Görüntü kaynağı

Terminal Nefes

Yapılan büyük hesaplamalar nedeniyle, 1e99**1e99yinelemeler birkaç 1e99**1e99yıldan az sürüyor . Şimdi, (1e99**1e99)-1e1000ancak herhangi bir fark yaratıyor. Bu, bu programın evrenimizin ölümünden çok daha uzun süreceği anlamına gelir.

yeniden doğuş

Şimdi, bilim adamları 10**10**56 yearsevrende kuantum dalgalanmaları veya tünelleme nedeniyle yeniden doğacağını öne sürüyorlar . Öyleyse eğer her bir evren tamamen aynıysa, programım kaç evrende yaşayacak?

(1e99**1e99)/(1e10+1e1000+10**10**56)=1e9701

Evrenin her zaman 1e10+1e1000yıl yaşayacağını ve daha sonra 10**10**56'yeniden başlaması' yıllar alacağını varsayarsak, programım 1e9701evrenlerde yaşayacak . Bu, tabii ki, unobtainium'un Büyük Patlama'da yaşayabileceğini varsayıyor.


3
@Philipp aralığının sonuna geldiğinde sona erer. evet sonunda sona erer.
Malachi

1
1000**1000öyle 1e3000değil 1e2000.
Cornstalks

1
@Cornstalks Teşekkürler, bunu bulmak için yeterince iyi bir hesap makinem yoktu, bu yüzden bu gerçeğe dayanarak bir tahmin yaptım 100**100=1E200.
Beta Çürüğü

1
@ BetaDecay: Wolfram | Alpha'yı çevrimiçi bir hesap makinesi olarak önerebilirim . Hiç kullanmadıysanız, oldukça harika!
Cornstalks

2
@ ilgi duyan herhangi biri veya 1000 ^ 1000 = (10 ^ 3) ^ 1000 = (10 * 10 * 10) * (10 * 10 * 10) * ... * (10 * 10 * 10) [1000 kez] = 10 ^ 3000
IazertyuiopI

12

Python 59 (çoğu zaman çalışır)

Direnemedim

from random import*
while sum(random()for i in range(99)):0

Bunun teorik olarak bir milisaniyenin altında sona erebileceği doğru olsa da, ortalama çalışma zamanı, 10^400evrenin belirtilen ömrünün çok daha fazladır. @BetaDecay, @undergroundmonorail ve 17 karakterden aşağı inen @DaboRoss'a teşekkürler.


Eğer yerini alabilir 71 için aşağı almak için continuebirliktepass
Beta bozunumu

@BetaDecay Nice catch
KSab,

3
Sanırım soru beklenen çalışma süresini sorduğundan , bunun erken kalkması bir sorun değil. Daha büyük olan konu, sonlandırmanın kanıtlanmadığıdır.
user19057

4
@ user19057 KSab'ın söylediğini varsayarak, beklenen çalışma süresi sonludur ve program% 100 olasılıkla sona ermektedir. Elbette, rastgele modül gerçekte döngüsel olan bir PRNG kullanır, bu yüzden büyük olasılıkla bu asla sonlanmaz.
Jerome Baum

1
Sanırım 'pass' değerini '0' ile değiştirerek 3 karakteri kesebilirsiniz.
daboross

8

J - 5 karakter sanırım

Aşağıdakilerin hepsinin isteğe bağlı olarak kesin aritmetik olduğuna dikkat edin, çünkü 9 sayısı her zaman biraz xyanındadır.

Gelen yedi karakterden, biz !^:!!9x, biraz koşu gibi olan

n = 9!
for i in range(n!):
    n = n!

keyfi kesinlikte aritmetik. Bu kesinlikle sınırın üstünde çünkü Synthetica öyle dedi , bu yüzden bir üst sınırımız var.

Olarak altı karakter, aynı zamanda yazabilir ^/i.9xher ara sonuç hesaplayan, 0 ^ 1 ^ 2 ^ 3 ^ 4 ^ 5 ^ 6 ^ 7 ^ 8. Wolfram | Alpha diyor ki 2^3^4^5^6^7^8, neredeyse 10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 6.65185muhtemelen muayeneyi de temizler.

Ayrıca sadece ((9!)!)! Olan beş karakterimiz var !!!9x. W | A diyor 10 ^ 10 ^ 10 ^ 6.2695ki, hala yeterince büyük olmalı ... Bu , evrendeki nanosaniye sayısından 1.6097e1859933kesinlikle daha büyük olan -ish rakamlara benziyor 3.154e1016, ama birinin nasıl çözebileceği hakkında hiçbir fikrim olmadığını kabul edeceğim. bu şeylerin gerçek çalışma süreleri.

Yalnız baskı, evrenden daha uzun sürecek kadar uzun sürmeli, bu yüzden iyi olmalı.


7

C, 63 56 karakter

f(x,y){return x?f(x-1,y?f(x,y-1):1):y+1;}main(){f(9,9);}

Bu, Wilhelm adındaki bir adamın fikrine dayanıyor. Tek katkım kodu bu kısa (ve okunamaz) parçaya yoğunlaştırmak.

Sonlandığını ispatlamak indüksiyonla yapılır.

  • Eğer x 0 ise, derhal sonlanır.
  • Eğer x-1 ve herhangi bir y için sonlanırsa, x için de sonlanır, bunun kendisi indüksiyonla gösterilebilir.

İndüksiyon adımının indüksiyonla kanıtlanması:

  • Y, 0 ise, x-1 ile yalnızca bir özyinelemeli çağrı vardır; bu, indüksiyon varsayımıyla sonlanır.
  • Eğer f (x, y-1) sonlanırsa, f (x, y) de sonlandırır, çünkü f'nin en içteki araması tam olarak f (x, y-1) olur ve en dıştaki çağrı indüksiyon hipotezine göre sonlanır.

Beklenen çalışma süresi A (9,9) / 11837 saniyedir. Bu sayının, gözlemlenebilir evrendeki kuark sayısından daha fazla hanesi vardır.


(Ab) önişlemciyi kullanın ve m = main, r = return ve z = 99999 tanımlayın, ardından programınızı yeniden yazın, f (x, y) {rx? F (x-1, y? F (x, y- 1): 1): y + 1;} m () {f (z, z);} ki bu inanılmaz derecede uzun bir zaman alacaktır :-)
ChuckCottrill

5
@ChuckCottrill Kurallar, belirli önişlemci makroları gerektiren ve programın uzunluğu için sayılmayan programlara izin veriyorsa, herhangi bir görev tek bir karakterde çözülebilir.
kasperd

6

Matlab ( 10 8 karakter)

1:9e1016

IMHO, çoğu giriş büyük, karmaşık şeyleri hesaplayarak çok çalışıyor. Bu kod basitçe 1'den sayma 9x10 1016 double s dizisini başlatacak , bu da 7.2x10 ^ 1017 baytı alacaktır . Maksimum bellek bant genişliği 21 GB / sn veya 6.63x10 ^ 17 bayt / yıl olan modern bir işlemcide , diziyi başlatmak için en az 1.09x10 1000 yıl sürecek , zahmet etmedim çünkü yazdırmayı deneyeyim Sonucu bir noktalı virgül ile çıktının bastırılması. (;


eski çözüm

nan(3e508)

alternatif olarak

inf(3e508)

Bu kod basitçe x 8-bayt çift veya bayt NaNboyutunda s / sonsuzluk bir kare matris yaratacaktır .3e5083e508 = 9e10167.2e1017


1
Bu da ne? 1016? Bu 9999 olmalı! (Ya da bir şeyi yanlış mı anladım?)
Mega Man

@MegaMan Sorun istemi 10 ^ 1000 yıllık çalışma süresi alt sınırını sorar. Bu varlık, golf, ben israf ve hesaplamak istemiyordu çok çok daha uzun, bu yüzden mümkün olduğunca eşiğine ulaştıktan sonra en kısa durdurmaya almaya çalıştı. :)
Nicu Stiurca

ah, tamam, bu kuralı bilmiyordum
Mega Man

5

Perl, 16 karakter

/$_^/for'.*'x1e9

Bu, milyarlarca kez ". *" Yineleyen bir dize oluşturur, daha sonra bir regex eşleşmesinde hem iğne hem de samanlık olarak kullanır. Bu da regex motorunun, iki milyar karakter uzunluğundaki bir dizgenin mümkün olan her bölümünü denemesine neden oluyor. Vikipedi bu formüle göre , yaklaşık 10 35218 böyle bölümleri vardır.

Yukarıdaki çözüm 16 karakter uzunluğundadır, ancak yalnızca yaklaşık 2 Gb bellek gerektirir, yani gerçek bir bilgisayarda çalıştırılabilir. Sonsuz bellek ve sonlu kayıt büyüklüğü varsayarsak (ki muhtemelen mantıklı değil), çalışma süresini önemli ölçüde arttırırken 15 karaktere kadar kısaltılabilir:

/$_^/for'.*'x~0

(Test etmedim, ancak 64 bitlik bir makinede en az 6GB RAM olan 32 bitlik bir Perl ile çalışabileceğini düşünüyorum.)

Notlar:

  • x dize tekrar işleci.
  • forgerçek bir döngü değildir; sadece bir karakteri (karşılaştırıldığında $_=".*"x1e9;/$_^/) kaydetmek için kullanılır .
  • ^regex'in finali yalnızca boş dizginin eşleşmesini sağlar; regex niceleyicileri varsayılan olarak açgözlü olduğundan, motorun deneyeceği son şey budur.
  • Bilgisayarımdaki değerler (1..13) ile ilgili kriterler, çalışma zamanının Wikipedia formülündeki O (exp (sqrt (n))) değerinden bile daha fazla olduğu O (exp (n)) olduğunu gösteriyor.

4

J (12)

(!^:(!!9))9x

Python'da bunun ne !işe yaradığı ( eserler varsayarak ):

a = 9 
for i in range((9!)!):
    a = a!

DÜZENLE:

Eh, program 2 × 10^-1858926gerekli süre içinde tamamlamak için, en fazla, döngü başına saniye sürebilir . İpucu: bu ilk döngü için bile işe yaramaz, sonuncuyu boşver;).

Ayrıca: bu program evrende entropi olduğundan daha fazla belleğe ihtiyaç duyabilir ...


3
"Evrende entropinin olduğundan daha fazla belleğe ihtiyaç duyabilir" - Bunu xrange()
kısaltabilirsiniz

1
Ayrıca, !Python'da da çalışmıyor. İhtiyacınız import mathve math.factorial().
daviewales

4

C # 217

Çok golfçü değilim ama Ackerman'ın işlevine karşı koyamadım . Ayrıca çalışma zamanını nasıl hesaplayacağımı bilmiyorum, ama kesinlikle duracak ve kesinlikle bu sürümden daha uzun sürecek .

class P{
static void Main(){for(int i=0;i<100;i++){for(int j=0;j<100;j++){Console.WriteLine(ack(i,j));}}}
static int ack(int m,int n){if (m==0) return n+1;if (n ==0) return ack(m-1,1);return ack(m-1,ack(m,n-1));}
}

ackİşlevi yeniden adlandırarak 10 karakterlik bir karakter atayabilirsiniz a.
pppery

4

Kod golf ilk girişimi ama işte gidiyor.

VBA - 57 45

x=0
do
if rnd()*rnd()<>0 then x=0
x=x+1
while 1=1

Dolayısıyla, 2'si 1 arada bir 128 olay meydana gelirse X birer birer artar ve gerçekleşmezse sıfırlanır. Bu olay üst üste 2 ^ 64 + 1 kez gerçekleştiğinde kod sona erer. Zamanı nasıl hesaplayacağımı bilmiyorum ama sanırım çok büyük.

EDIT: Ben matematik hesapladım ve her döngüde bunun gerçekleşmesi olasılığı yaklaşık 20000 hane uzunluğunda olan 2 ^ 128 ^ 'de (1 + 2 ^ 64) 1. 1000000 döngü / sn (ince hava numarasındaki ballpark dışında) ve 30000000 s / yr'ın yılda 3 * 10 ^ 13 döngü kalması durumunda 10 ^ 1000 yıl 3 * 10 ^ 1013 döngü olduğunu varsayarsak, bu 20 evrende kalan süre. Matematiğim sezgimi desteklediğine sevindim.


Bence bu son satır olmalı While x=1, değil mi? (aksi takdirde sonsuz bir döngü). Eğer yerine eğer Ayrıca, 12 karakter kapalı tıraş edebilirsiniz Dim x As Doubleile x=0(VBA belirttiğiniz sürece değişkenleri bildirmek için gerektirmez Option Explicit)
kb_sou

Sonunda x taşdığında kırıldığı için sonsuz bir döngü olarak görmüyorum.
Myles Horne

Bu, kesinlikle döngünün çalışmasını engelleyeceğinden, x = 1 iken kesinlikle çalışmaz.
Myles Horne

Bu şekilde girerken döngü "sonsuz döngü yok" kriterlerini karşılamıyorsa, WHILE 1 = 1 WHILE ISNUMERIC (X) olarak değişebilir.
Myles Horne

4

C, 30 karakter

main(i){++i&&main(i)+main(i);}

İkisinin tamamlayıcı imzalı taşması ve 32-bit inç olduğunu varsayarsak, bu , evrenin bitmesi için yeterli zaman olması gereken yaklaşık 2 2 32 işlev çağrısı için geçerli olacaktır.


Yine de, çok uzun zaman önce yığın biter.
Sparr

1
@Sparr Kurallardan biri sonsuz yığın ve yığın boyutunu varsaymaktır.
scragar

3

GolfScript, 13 karakter

0{).`,9.?<}do

Bu program sadece 0 - 10 9 9 −1 = 10 387420488 arasında sayılır . İyimser olarak, bilgisayarın 100 GHz’de çalıştığını ve programın her bir yinelemesini tek bir döngüde yürütebileceğini varsayarsak, program 10 9 9 −12 saniye veya yaklaşık 3 × 10 9 9 −20 = 3 × 10 387420469 yıl.

Programı test etmek için, yerine 9bir ile 210 durdurmak yapacak, 2 2 -1 = 10 3 , bir kullanma (= 1000 3yerine bir 210 dur yapacak 3 3 -1 = 10 26 , burada , yukarıdaki iyimser varsayımlarla bile, en az birkaç milyon yıl boyunca erişemeyecektir.)



3

Haskell, 23

main=interact$take$2^30

Bu program, 1073741824 karakterinden okuduktan sonra sona erer stdin. Herhangi bir veri aktarılmadan çalıştırılıyorsa stdin, klavyenize bu sayıdaki karakterleri yazmanız gerekir. Klavyenizin, her biri 100k mekanik döngü için derecelendirilen ve ölü olmayan tuş vuruşları oluşturmak üzere programlanan 105 tuşa sahip olduğunu farz edersek, otomatik tur kapalı, ve klavye soketiniz 100 bağlantı döngüsüne izin verir; Programın sonlandırılması için yeterli değil.

Bu nedenle, program yalnızca, bu çalışan evrende etkin bir şekilde olmayan döngü sayısı bakımından daha iyi donanımlar mevcut olduğunda sona erecektir. Belki bir dahaki sefere, kalite miktardan daha yüksek önceliğe sahip olduğunda. O zamana kadar, bu program prensipte sona ermekte ancak pratikte sona ermemektedir.


Ya klavyeleri çaldıkça değiştirirseniz?
Thomas,

Bu klavye soketinin 100 bağlantı döngüsü ile kaplıdır.
IspanishInquisition 29:14

Ama sorunun puanı program olmasıdır gelmez yerde evrenin ısı ölümünden sonra sona erer. Bu program asla sona ermeyebilir; entropi yeterince yükseldiğinde, prize
takılacak

1
Hala ikna olmadım. Programı uzaktan (veya bir VM'de) çalıştırırsanız, o zaman tek bir bilgisayarın donanım özellikleriyle sınırlı kalmazsınız ve 1 milyar vuruş gerçekten de o kadar fazla değildir. Bunun yanı sıra, sorun bilgisayarın unobtainium'dan yapıldığını ve klavyenin 2 ^ 30 tuş vuruşlarını da kaldırabileceği anlamına geldiğini söylüyor
Thomas

3

~ ATH, 56

Gelen kurgusal dille ~ ATH :

import universe U;
~ATH(U) {
} EXECUTE(NULL);
THIS.DIE()

~ ATH çalışmak için vazgeçilmez bir dildir. Mantığı, sonsuz döngülerden veya en iyi ihtimalle etkili bir şekilde iç içe geçebilen yapı döngülerinden başka bir şey değildir.

Pek çok ATH kodlayıcısının yaptığı şey sonlu yapıları ithal etmek ve döngüleri ömrüne bağlamaktır. Örneğin, buradaki ana döngü, U olarak adlandırılan evrenin ölümüyle sona erecektir.

Borderline kaçamak ihlalleri için özür dilerim; Pas geçmenin fazla alakalı olduğunu düşündüm.

Eğer biri bununla eğlenmişse, daha fazla ayrıntı: (1) , (2) , (3) , (4)


2

Yakut (34)

Satır ([0]*9).permutation.each{print}9 için yaklaşık 2.47 saniye sürer! makineme yazdırıyor, satır ([0]*10).permutation.each{print}10 için 24.7 saniye sürüyor! yazdırır, bu yüzden burada fazladan tahmin edebilir ve (24.7/10!)*470! seconds in yearshangisinin 6.87 * 10 ^ 1040 olduğunu hesaplayabilirim .

([0]*470).permutation.each{print}

2

JavaScript 68 62 karakter

(function a(m,n){return m==0?n+1:a(m-1,n==0?1:a(m,n-1))})(5,1)

Bu, Ackermann işlevini kullanarak yazılabilir.

function ackermann(a, b) {
  if (a == 0) return b + 1;
  if (b == 0) return ackermann(a-1, 1);
  else return ackermann(a-1, ackermann(a, b-1));
}

Çalışma süresi, üssel olarak artar ve bu nedenle hesaplanması çok uzun sürer. Burada ingilizce olmasa da, geri dönüş değerleri hakkında genel bilgi edinebilirsiniz. Tabloya göre ackermann(5,1)eşittir 2↑↑(65533)-3sen çok büyük, biliyorum, hangi.


2
Bu, önceki Perl Ackermann fonksiyon uygulaması ile aynı optimizasyonlardan bazılarından yararlanabilir.
Peter Taylor

Perl çözümünü gözden kaçırmış olmalıyım. Bunu gösterdiğin için teşekkürler.
henje

yerine, n==0?X:Yher zaman yapabilirsinizn?Y:X
Cyoce

2

Befunge '93 - 40 bayt

(20x2 programı)

v<<<<<<<<<<<<<<<<<<<
>??????????????????@

Bu program gecikme vermek için rasgele sayılar kullanır. Befunge tercümanları oldukça yavaş olduğundan, bu programın faturasına uyması gerekir. Olmazsa, yatay olarak her zaman genişletebiliriz. Bu programın beklenen çalışma zamanını nasıl hesaplayacağımı tam olarak bilmiyorum ama her birini biliyorum. 50 / 50'de yatay pozisyonunu 1 ile yeniden başlatma veya değiştirme şansı var. 18? 'ler var. Ben google hesap makinesi "Infinity" olduğunu söylüyor, (18 ^ 2)! Satırlarında bir şey olması gerektiğini düşünüyorum

EDIT: Öte yandan diğer Befunge'nin cevabını fark etmedim, bu benim ilk mesajım. Üzgünüm.


Hey, diğer şüpheli cevaplar için endişelenmeyin, ya da genel olarak başkasıyla aynı dili kullanmak. Demek istediğim, kimse bir tane daha matematik matrisini geçemez, bu yüzden diğer tüm başvurular eğlencelidir. Benimki öyleydi.
AndoDaan

2

APL, 10

Bunun geçerli bir cevap olduğunu sanmıyorum (deterministik olmadığı için), ama yine de ......

{?⍨1e9}⍣≡1

Bu program 1e9 sayıları ( ?⍨1e9) rasgele bir permütasyon hesaplar ve iki ardışık çıkış eşit ( ⍣≡) kadar tekrarlar

Yani, her permütasyon hesaplandığında 1000000000’de 1 olur! sonlandırma şansı. Ve 1000000000! en az 10 10 8'dir .

Bir permütasyon hesaplamak için harcanan zaman 1000000000! 'İn kitleselliği ile ilgisiz hale getirilir. Ancak bazı testler gösteriyor ki bu O(n)ve ekstrapolasyon yaklaşık 30 saniye veriyor.

Ancak, tercümanım 2 31 -1'den büyük ( rastgele 1e9 kullandım) rastgele fonksiyona girdi almayı reddediyor ve 1000000000 sayısının permütasyonunu oluşturmak bir çalışma alanı için tam bir hata verdi. Bununla birlikte, kavramsal olarak sonsuz belleğe sahip ideal bir APL yorumlayıcısı ile yapılabilir.

Bu bizi 64-bit mimariyi varsayarak çalışma süresini en az 10 10 20'ye çıkarmak için 1e9 yerine 2 63 -1 kullanma olasılığını ortaya koyuyor .

Fakat bekle, mimari ideal bir tercüman ile alakalı mı? Cehennem hayır yani aslında çalışan zamanında bağlı bir üst yok !!


2

R, 45 bayt

(f=function(x)if(x)f(x-1)+f(x-1)else 0)(9999)

Bu eski bir konu ama R cevabı göremiyorum ve buna sahip olamayız!

Benim için çalışma zamanı, x 20 olduğunda 1 saniye idi, bu da 2 ^ 9979 saniyelik bir çalışma zamanı gösteriyordu.

Sıfırı bir taneyle değiştirirseniz, çıkış 2 ^ x olur, ancak x olduğu gibi çıktısı sıfır olur (taşma problemlerini önler).


1

Javascript, 120 bayt

a=[0];while(a.length<1e4)(function(){var b=0;while(b<a.length){a[b]=(a[b]+1)%9;if(a[b])return;b++}a.push(1)})();alert(a)

Minimal bellekle (muhtemelen yarım megabayttan az) yapılabilir, ancak (muhtemelen) yaklaşık 10 8,750 yıl durması gerekir.

Tekrar tekrar küçük bir endian üssü-9 BigInteger 9 9 4 -1'e ulaşana kadar artar .


1

Python 3, 191 Bayt

from random import*
r=randint
f=lambda n:2if n<2else f(n-1)
x=9E999
s=x**x
for i in range(f(x)**f(s)):
 while exec(("r(0,f(x**i))+"*int(f(x)))+"r(0,f(x**i))")!=0:
  s=f(x**s)
  print(s)

Birincisi, f özyinelemeli bir faktoring işlevi ve ultra yavaş. Daha sonra, bir OverflowError oluşturan 9 * 10⁹⁹⁹'luk güç var, ancak bu bu Unobtanium bilgisayarda olmuyor. For-Loop 9E999'u tekrar ediyor! ^ (9E999 ^ 9E999)! kez ve yalnızca bir sonraki yinelemeye gider, eğer 9E999! +1 0 ile 9E99 arasında rastgele girdi ise, ^ ^ i! hepsi 0'dır ve while döngüsünün her yinelemesinde (9E999 ^ s)! ayarlanır. Ah, baskıların muuuuccchhhh zaman aldığını unuttum ...
En kısa çözüm olmadığını biliyorum, ama gerçekten etkili olduğunu düşünüyorum. Biri çalışma süresini hesaplamama yardımcı olabilir mi?


1

Makine Ancak Daha Kötü Bir Şekilde Dönüyor , 167 bayt

0 0 1 1 2 0 0
1 0 1 0 4 0 0
0 1 1 1 2 0 0
1 1 1 1 5 0 0
0 2 1 0 3 0 0
1 2 0 1 1 0 0
0 3 1 1 4 0 0
1 3 0 0 2 0 0
0 4 1 0 0 0 0
1 4 0 1 3 0 0
0 5 1 0 6 0 1
1 5 1 1 2 0 0

Çevrimiçi deneyin!

Vikipedi sayfasından 6 durumlu 2 sembollü Meşgul Beaver kullanmalısınız .

Vikipedi sayfasında dediği gibi, içinde çalışır 7,412x1036534adım. Bu, her bir komutu bir nanosaniyeden daha fazla veya ona eşit bir şekilde çalıştırdığını varsayarsak, sıcaklık ölümünden çok daha fazla bir şeydir.

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.