Çok havalı olacağını düşündüğüm zorluk , seçtiğiniz bir Turing tamamlayıcısı için tercüman yapmak .

Kurallar basit:

1. Bu zorlayıcıdan daha yeni olsa bile, bu tercümanı oluşturmak için herhangi bir dili kullanabilirsiniz.
2. Turing-complete dilini, yazdığınız dille aynı olmadığı sürece kullanabilirsiniz.
3. Örneğin sadece eval işlevlerini kullanmak için kodu değerlendiremezsiniz.
4. Buna nasıl yaklaştığınızın bir açıklaması iyi olacak ama gerekli değil.
5. Bu bayt cinsinden puanlanacak.
6. Her başvuru tam olarak çalışıyor olmalıdır, bu, seçtiğiniz dilin sahip olması gereken her özelliğin bulunması gerektiği anlamına gelir.

Basitçe söylemek gerekirse:

Göreviniz, seçtiğiniz herhangi bir dili olan Turing-tamamlanmış bir dil için çalışan bir tercüman oluşturmaktır.

İyi şanslar!

Brachylog (2) → Yazışma sonrası problemi , 9 bayt

~h=∋ᵐ\cᵐ=

Çevrimiçi deneyin!

Giriş, dizelerin listelerinin bir listesidir. (Vikipedi'de tanımlandığı gibi yazışma sonrası problemde, iç listelerin her biri iki elemente sahiptir, ancak bu program aslında herhangi bir sayıda elemente genelleme yapabilir.) bir çözüm bulundu. Yazışma sonrası problemin bir Turing makinesini simüle edebileceği bilinmektedir ve bu nedenle ona zorlayıcı çözümler Turing tamamlanmıştır. Bir programdan ziyade bir işlev olarak çalıştırılırsa, aslında anlamlı çıktılar üretir.

Yukarıdaki TIO bağlantısındaki program [["a","baa"],["ab","aa"],["bba","bb"]]Wikipedia'dan kopyaladığım program . Çözüm (programın oldukça hızlı bir şekilde bulduğu) ["bbaabbbaa","bbaabbbaa"].

açıklama

Bu hemen hemen yazışma sonrası sorunun Brachylog'a doğrudan çevrilmesidir.

~h=∋ᵐ\cᵐ=
~h         Find {the shortest possible} list which starts with {the input}
  =        and for which all elements are equal
   ∋ᵐ      such that taking an element of each element,
     \cᵐ   and concatenating elements in corresponding positions,
        =  produces a list all of whose elements are equal.

Temel olarak, girişin tekrarlanan kopyalarını (olabildiğince az, kaba uygulama yaparken hiçbir fırsatı kaçırmayacağımız anlamına gelir), her kopyadan bir öğe alan, ardından karşılık gelen öğeleri birleştiren (Posta yazışmalarında olduğu gibi) bir liste oluştururuz. sorun).

Jöle → "Transpozisyon için minimum ekle", 5 4 bayt

+"Ṃẞ

Çevrimiçi deneyin! (zaman aşımını önlemek için yalnızca bir yineleme çalıştırır)

Çok basit bir Turing-complete yapısı: bir program olarak kare bir matris alırız ve sonsuza dek döngü kurar, sözlüksel olarak en küçük satırı tanımlar, sonra ilk satırın her bir elemanını sözlüksel olarak en küçük olan ilk elemanla, ikinci satırın her bir elemanıyla arttırırız sözcükbilimsel olarak ikinci öğenin en küçük vb. (Jelly programı " +"girişin {karşılık gelen elemanlarını ve} Ṃasgari {, asıl {} orjinal} ẞdöngüsünü " ekler) ; bu, önceki programımdan daha kısa bir bayt Z+ṂZß, tam olarak aynı şeyi yapmıştı. Açıkçası golf oynamaya odaklanmalıydım. Jelly, sadece uygulanan dili golf oynamak değil.)

Ortaya çıkan dil, Kangaroo ile aynı sebeple Turing-tamamlandı. Her satırın ilk öğesi bir atlama sayısı gibi davranır (atlandığında azalan her komutun atlama sayısı yerine, bunun yerine, çalıştırıldığında her komutun atlama sayısını artırabiliriz ve en düşük atlama sayısına sahip olan komutu ararız. Sıfırla atlama sayıları ile komutları yerine, bu aynı şey geliyor). Bu ilk elemanın diğer elemanlardan daha yüksek olmasını sağlıyoruz (her komutun çoklu ayarında her komutun kaç kez göründüğünü gösterir), böylece ilk satırın asla minimum olmaması; ilk sıranın kalanı çöp olabilir. Geriye kalan tek sorun, eşit atlama sayısının komutların döngüsel olarak sıralı olarak çalışmasını modellemektir, ancak tüm atlama sayımlarını büyük bir sabit ile çarpıp daha sonra küçük "başlangıç" ekleyerek yapabiliriz. atlama, tiebreak işlevi gören ilk sütuna kadar sayımları atlar. Bu bize "sıralı olarak sıralı olmayan sıralı komutlar" değil, "ilk atlanmayan komut çalıştırma" dizgesini verir, ancak Kangaroo için Turing-eksiksizlik yapısı bu farkla ilgilenmez.

Mathematica, Conway'in Yaşam Oyununu, 64 bayt yorumluyor

CellularAutomaton@{224,{2,{t={2,2,2},{2,1,2},t}},{1,1}}~Nest~##&

Conway'in Yaşam Oyununun Turing'in tamamlandığı bilinmektedir; ve hücresel otomatlar Stephen Wolfram'ın en saplantısıdır. CellularAutomaton@{224,{2,{t={2,2,2},{2,1,2},t}},{1,1}}Conway'in Yaşam Oyununun bir basamağına göre iki boyutlu bir 0s ve 1s dizisini dönüştüren bir kuraldır. (Bence varsayılan davranış, bu dizinin kenarlarının etrafına sarılması, yani gerçekten ayrık bir torus olmasıdır.) ~Nest~##&, Bu kuralı, ilk kurul durumu verildiğinde (herhangi bir boyutta) ve nargümanlar olarak bir tamsayı çıkaran bir fonksiyona dönüştürür . nYaşam Oyunu kuralının yinelemelerinin sonucu .

Kendi zevkiniz için, sarılmış versiyonu kullanabilirsiniz

b = RandomInteger[1,{50,50}];
Manipulate[ArrayPlot[
  CellularAutomaton@{224,{2,{t={2,2,2},{2,1,2},t}},{1,1}}~Nest~##&
    [b, n] ]
, {{n,0}, 0, 100, 1}]

50x50'lük bir tahta üzerinde 100 nesiller arasında ilerleyin.

Turtlèd , CT , 49 bayt yorumlama

Bunu golf yapabilirim

Ayrıca, bu yararlı bir şey çıkarmaz. eğer sadece verilen CT programı durursa durur ve durur.

bu aslında bir süre önce yaptığım bir (daha sonra şimdi golf)

!-l[*+.r_]' !l[ l]r[ u.(;d' u)d(1[ r].[ l])( r)+]

Nasıl çalışır:

Turtlèd ızgara hücreleri kullanır. "Izgaraya bir şeyler yaz" derken, ızgaraya bitişik bir karakter grubunun yerleştirildiği anlamına gelir. örnek

[ ][ ][ ][ ][ ][ ][ ]
[ ][H][E][L][L][O][ ]
[ ][ ][ ][ ][ ][ ][ ]
[ ][ ][ ][ ][ ][ ][ ]

programa

ilk önce veriler girilir:

!-l[*+.r_]' 

Bu aslında bir kedi programıdır. girişi ızgaraya yazar.

sonra komutlar girilir:

!

bu komutlarla ne yapar:

bu komutlar "yapımlar" dır. En soldaki veri biti 1 ise, üretimi veri dizisinin sonuna kopyalar. Aksi takdirde hiçbir şey olmuyor. daha sonra en soldaki veri biti kaldırılır ve sonraki soldaki en fazla veri biti ile bir sonraki üretimi kullanır. Veri dizisinde bit olmadığında program durur. Bu yapımları yapmanın bir yolu, ayrı ayrı yapımların ve bitimlerin üstesinden gelmektir. Programımızın yaptığı bu. ayrı olarak komut dizesinden bitleri veri dizesinin sonuna kadar kopyalar ve bitleri veri dizisinden ayrı siler

Bu programın nasıl yaptığını. komutları girdikten sonra, kaplumbağa / ızgara işaretçisi veri karmasının en solundaki bitine geri döner. o zaman bir döngü içine gider

[ u.(;d' u)d(1[ r].[ l])( r)+]

Bu döngüde yaptığı şey, en soldaki veri diziliminden yukarı doğru hareket ediyor ve mevcut komut karakterini (u.) yazıyor. eğer öyleyse; üretimin sonu ise aşağı doğru hareket eder ve altındaki en soldaki veri bitini siler ve tekrar yukarı doğru hareket eder ( (;d' u)). sonra, her iki durumda da, bir ( d) aşağı hareket eder . oradaki bit silinmediyse, sonunda komutlardan bir bit kopyalanıp kopyalanmayacağını kontrol etmesi gerektiği anlamına gelir. öyleyse, en soldaki veri tabanı olan veya bu karakter 1 ise, veri dizesinin sağ ucunun sonuna gider, biti komut dizesinden kopyalar ve en soldaki verinin solundaki boşluğa geri gider bit ( (1[ r].[ l])). şimdi, ya sıfır olan en soldaki veri tabanında ya da en soldaki veri tabanının solundadır. öyleyse, bir boşluk üzerindeyse doğru hareket ederiz (( r)). daha sonra komut işaretçisi artırılır, böylece bir sonraki komutu döngünün bir sonraki yinelemesinde yazacağız. Başka veri dizisi yoksa, bu bir alanda olacağımız ve döngü sona ereceği anlamına gelir. Aksi takdirde, döngüyü yeniden çalıştırırız.

Perl → Üç Yıldızlı Programcı varyantı, 26 + 1 = 27 bayt

++$a[$a[$a[$_]]]for@F;redo

Çevrimiçi deneyin! (Bu bağlantı, belirli sayıda yinelemeden sonra programdan çıkan bir başlık içerir (böylece TIO zaman aşımına uğramaz) ve her yinelemenin iç durumunu yazdırmak için (gözlenebilir bir şey yapar).)

İle çalıştırın -a(daha önce bunu sığabilecek kadar, 1 bayt cezası -M5.010üretmek için -aM5.010).

Spesifik olarak, bu komutların boşluklarla ayrıldığı ve dosyada G / Ç eklentisi olmadan yorum yapılmasına izin verilmeyen Üç Yıldızlı Programlayıcı uygular. (Bu değişiklikler açıkça dilin Turing'in eksiksizliği üzerinde hiçbir fark yaratmaz.) Çevrimiçi olarak Üç Yıldız Programcısının Turing'in tamamlandığına dair bir kanıt yok, ancak Turing tamamlandı (Turing'in eskiz bir kanıtını paylaşıyorum) -diğer esoprogramcılar ile olan bütünlük, ancak orijinal şoktan kurtulduktan sonra programlamanın oldukça kolay olduğunu öğrendiğimde dil üzerinde çalışmayı bıraktı).

Program gerçekten fazla açıklamaya ihtiyaç duymuyor; Üç Yıldızlı Programcı'nın çok basit bir özelliği vardır ve bu doğrudan bir çevirisidir. Tek ince noktalar: @FPrograma dizi biçiminde girdi (bunun bir sonucudur -a); ve redotüm programı örtük bir döngü içinde olduğu gibi tekrarlar -a.

x86 derlemesi (Intel sözdizimi / MASM) -Brainfuck 2127 bayt.

Hala golf yapabiliyor

.386
.model flat,stdcall
.stack 4096
include \masm32\include\masm32.inc
includelib \masm32\lib\masm32.lib
ExitProcess proto,dwExitCode:dword
.data
bfsrc BYTE 200 dup(0) 
bfcells BYTE 100 dup(0) 
loopStack DD 5 dup(0) 
charBuf BYTE 5 dup(0) 
newline BYTE 10,0 
prompt BYTE "$",0 
hr BYTE 50 dup('-'),0 
space BYTE ' ',0
.code
EvalBf proc
    start:
    invoke StdOut, addr prompt
    invoke StdIn, addr bfsrc,200
    cmp bfsrc,0
    je exit
    mov eax,0 
    mov ebx,0 
    mov ecx,0 
    processInstruction:
    cmp BYTE PTR bfsrc[ebx], '+'
    je plus
    cmp BYTE PTR bfsrc[ebx], '-'
    je minus
    cmp BYTE PTR bfsrc[ebx], '>'
    je fwd
    cmp BYTE PTR bfsrc[ebx], '<'
    je back
    cmp BYTE PTR bfsrc[ebx], '['
    je open
    cmp BYTE PTR bfsrc[ebx], ']'
    je close
    cmp BYTE PTR bfsrc[ebx], '.'
    je dot
    jmp processNextInstruction
    plus:
    inc BYTE PTR bfcells[eax]
    jmp processNextInstruction
    minus:
    dec BYTE PTR bfcells[eax]
    jmp processNextInstruction
    fwd:
    inc eax
    jmp processNextInstruction
    back:
    dec eax
    jmp processNextInstruction
    open:
    mov loopStack[ecx*4],ebx
    inc ecx
    jmp processNextInstruction
    close:
    dec ecx
    cmp BYTE PTR bfcells[eax], 0
    je processNextInstruction
    mov ebx,loopStack[ecx*4]
    inc ecx
    jmp processNextInstruction
    dot:
    mov dl, BYTE PTR bfcells[eax]
    mov BYTE PTR charBuf[0], dl
    mov BYTE PTR charBuf[1],0anything
    push eax
    push ecx
    invoke StdOut, addr charBuf
    pop ecx
    pop eax
    jmp processNextInstruction
    processNextInstruction:
    inc ebx
    cmp BYTE PTR bfsrc[ebx], 0
    je done
    jmp processInstruction
    done:
    invoke StdOut, addr newline
    mov eax, 0
    printNext:
    cmp eax, 100
    jge reset
    push eax
    invoke dwtoa, BYTE PTR bfcells[eax], addr charBuf
    invoke StdOut, addr charBuf
    invoke StdOut, addr space
    pop eax
    inc eax
    jmp printNext
    reset:
    invoke StdOut, addr newline
    invoke StdOut, addr hr
    invoke StdOut, addr newline
    jmp start

    exit:
    invoke ExitProcess,0
EvalBf endp
end EvalBf

Pip yorumlayarak halkalı etiket sistemleri , 16 bayt

YqWyyPBg@++vXPOy

Tag sisteminin yapımını komut satırı argümanları ve stdin'den ilk veri dizgisi olarak alır.

Yukarıdaki kodun doğrulanması zordur çünkü herhangi bir çıktı üretmez (bu nedenle gözlemlenebilir tek davranış "sonlandırmaktır" vs. "sonlandırmaz"). Bu nedenle, burada her adımdan sonra veri dizgisini çıkaran ve ayrıca 20 adımdan sonra sona eren, bu nedenle TIO'nun sonsuz döngülerden tonlarca çıktıyla uğraşması gerekmeyen yıpranmış bir sürüm var: Çevrimiçi deneyin!

Döngüsel etiket sistemleri

Döngüsel etiket sistemleri son derece basit ama Turing-complete bir hesaplama modelidir. Bir veri dizisindeki işlemleri tanımlayan üretim listesinden oluşur . Yapımlar ve veri dizgisi 1 ve 0'dan oluşuyor.

Her adımda, veri dizisinin en soldaki karakteri kaldırılır.

• Karakter 1 ise, geçerli üretim veri dizesinin sağ tarafına eklenir.
• Karakter 0 ise, hiçbir şey eklenmez.

Her iki durumda da, mevcut üretim listedeki bir sonraki üretime geçer, döngüsel olarak: eğer son üretimde olsaydık, ilk etapta dolanırdık. Veri dizisi boşalana kadar yürütme devam eder.

açıklama

                  g is list of cmdline args; v is -1 (implicit)
 q                Read a line of stdin for the data string
Y                 and yank it into the y variable
  Wy              While data string is nonempty:
       g@++v       Retrieve the next production from g (using cyclic indexing)
             POy   Pop the first character of y
            X      String-multiply: result is the production if the first character of y
                   was 1, or empty string if it was 0
    yPB            Push that string to the back end of y

Yinelenmiş Genelleştirilmiş Kollatz İşlevleri -> Python 2, 46 bayt

a,b,x,m=input()
while-~x%m:x=x/m*a[x%m]+b[x%m]

Bu işlevi m-1 a ve b'lerin bir listesiyle, başlangıç ​​değeri x ve topluca IGCF için bir "program" oluşturan bölen m ile çağırın. Hangi modüllerin durduğunu göstermek için üçüncü bir dizi almak yerine, modül sadece m-1 olduğunda bu durur. Bu sadeleştirme, belirli bir Fractran programını bu değişkene dönüştürmek için biraz çaba harcayabileceği anlamına gelir, ancak tercümanda birkaç bayttan tasarruf sağlar.

Çevrimiçi deneyin! Bu TIO, bu dille nasıl 5 + 5 ekleneceğini gösterir. Program a = [3], b = [0], m = 2 ekler ve 7776 = 2 ^ 5 * 3 ^ 5 ile başlar ve sonuçta 59049 = 3 ^ 10 olur.

ResPlicate varyantı -> Python 2, 47 bayt

l=input()
while l:l=l[2+l[0]:]+l[2:2+l[0]]*l[1]

Bu işlev ResPlicate'in bir türevini yorumlar.

• bunun için bir program, eşit indislerde eşit elemanlarla eşit uzunluktaki bir python listesidir.
• G / Ç yok.
• çünkü kuyruğun geri kalan kısmında mevcut olandan daha fazla değer kopyalamaya çalışmak, sıranın kalanını basitçe kopyalar (yani, kopyalanan bit sıfır ile istenen uzunluğa kadar dolmaz).

Son değişiklik, bazı ResPlicate programlarının (birinci koşulu yerine getiren) bu varyantta aynı şekilde davranmayacağı anlamına gelir, ama neyse ki, BCT tercümanları kaldırılmış işlevselliği gerektirmez ve bu nedenle dil TC kalır.

Çevrimiçi deneyin! Bu TIO'nun çalıştığını ve 1 saniye sonra programı öldüren bir başlığı ve TIO'nun bir saniyede idare edebileceğinden daha fazla çıktı üretmeyi başaran bir örnek olduğunu gösteren bir baskısı var.

Perl -a → G / Ç makinesi , 24 bayt

$p=$a[$p]+=$_ for@F;redo

Çevrimiçi deneyin! (davranışı gözlemlemek için iç durumu basan ve 10 yinelemeden sonra durduran bir başlık içerir)

Dil hakkında

Son birkaç günümü, basit programlama dilleri için en son fikirlerimden biri olan I / D makinede çalışarak geçirdim . Aşağıdaki şekilde çalışır: veri depolama, başlangıçta tüm sıfırlardan oluşan sınırsız bir RAM'den oluşur. Her eleman sınırlandırılmamış bir tamsayı depolayabilir (pratikte çoğu I / D makine programı, çoğu küçük kük tam sayıları depolar ve sınırlandırılmamış tamsayıları yalnızca büyük adresli hücrelere hitap etmenin bir yolu olarak kullanır). Ayrıca bir hücreye işaret eden bir veri işaretçisi de vardır (örneğin adresi bir hücre olarak tutar); başlangıçta da sıfır.

Sadece iki komut var:

• I: Veri işaretçisinin işaret ettiği hücreyi artır. (Veri işaretçisinin kendisi değişmeden kalır.)
• D: Veri işaretçisini ayırın, yani veri işaretçisinin işaret ettiği hücrenin değerini okuyun. Ardından okuduğunuz sonucu elde ettiğiniz değeri veri işaretçisine kaydedin.

İşlem, programı sonsuza dek tekrar tekrar bir döngüde çalıştırır.

Bu kadar basit bir dilin Turing-tamamlanmış olması oldukça şaşırtıcı, bu yüzden bunu kanıtlamaya çalışıyorum. İşte kanıtı . Oldukça benzer bir dil olan Üç Yıldızlı Programcı'nın ispatına benzer (ancak daha basit) (ve aslında, bu gönderim, programın etrafında sadece gerçek talimatlarda farklı olan aynı temel OISC "kabuğu" kullanır).

Program hakkında

kullanım

Girdi standart girişte verilmelidir ve yorum yapmadan ve RLE / OISC sözdizimini kullanan bir I / D makine programıdır. (G / Ç makinesinin iki farklı, eşdeğer sözdizimi vardır, ancak golf için bu program yalnızca birini destekler.) Bu sözdiziminde, bir program Ikomutlar arasındaki Dkomutların uzunluğunu temsil eden ondalık sayı dizisidir . ( Aralarında " D0 Ikomutu çalıştırma " komutu vererek iki veya daha fazla ardışık komut belirleyebilirsiniz , böylece sözdizimi tamamen geneldir.)

açıklama

Programdan görülebileceği gibi, bu Ive Dkomutlarını ayrı ayrı uygulamak değildir . Aslında, (çok hafif) bir optimizasyon tercümanıdır (yalnızca bu şekilde yazmak daha kısa olduğu için). Anahtar, bir n artırma komutları çalıştırmasının veri göstergesinin hedefini n kere arttırdığını, yani ona n eklediğini ; ve 0 artış komutunun çalıştırılması da bu şekilde gerçekleştirilebilir, çünkü belleğe 0 eklenmesinin bir etkisi yoktur. Bu yüzden aslında uyguladığımız işlem, bir deneme Ive a D. Veya başka bir deyişle, "add nveri işaretçisi tarafından gösterilen değere (onu veri işaretçisi tarafından gösterilen değere geri saklayarak), daha sonra veri işaretçisi tarafından gösterilen değeri okuyun ve veri işaretleyicisine depolayın ". ve "Bunu veri işaretçisinin gösterdiği değere n eklemek , ardından bu değeri hem veri işaretleyicisinin hedefinde hem de veri işaretleyicisinin kendisinde saklamak " için basitleştirebiliriz .

Böylece programımızın özü için yapar. $aRAM'i saklamak için bir dizi kullanıyoruz ve $pveri işaretçisi olarak (diziye endeksleme):

$p=$a[$p]+=$_
         + $_  add {the run length}
   $a[$p]      to the element of $a pointed to by $p
   $a[$p] =    storing the result back into that element
$p=            and also in the pointer itself

Uygun bir şekilde Perl, numaralandırılmamış dizi elemanlarını sayı gibi ele alındığında 0 olarak yorumlar, bu nedenle dizi, ihtiyaç duyulan açık bir kod olmadan bizim için sıfırdan başlatılır. (Sayılar büyük olduğunda olası bir sorun sayısal doğruluktur; ancak, bu yalnızca kullanılan dizinin miktarı makinenin adres alanını aşarsa gerçekleşir (Perl tamsayıları işaretçileri tutacak kadar büyüktür), olamaz idealize bir makinede.)

Son olarak, tek yapmamız gereken, bu programı birkaç döngüye yerleştirmek. for@Fİle kombine döngü, -akomut satırı seçeneği, standart girdi alanları üzerinde irade döngü ( "alanında" varsayılan tanımı burada boşluklarla ayrılır olacaktır). redoDöngü (dışında, uygun, standart giriş okuma) bir kapalı döngü içinde tüm programı yerleştirir I / D makinede semantik gerektirdiği gibi program sürekli bir döngü içinde çalışmasına neden olur.

Jöle → 2-Tag sistemi , 8 bayt

µḢị⁴⁸;Ḋß

Çevrimiçi deneyin!

Pratik dilleri tercih eden bir lütufum var, ancak orijinal görevimi kazanırken deneyebileceğimi düşündüm (kendi ödülümü tam olarak kazanamadığım için).

Turing eksiksizliği için gerekmediğinden, durma durumu olmayan bir çeşit etiket sistemi uygular. Durumlar arka arkaya 1 ile numaralandırılmıştır ve ilk dize programdan önce gelir.

Örneğin, Vikipedi bir etiket sisteminin bir örnek verir { a, b, c}, { a→ bc, b→ a, c→ aaa} ilk dizeyle aaa; var Bu giriş biçiminde [1,1,1], [[2,3],[1],[1,1,1]]. (Etiket sistemlerinin sabit bir sözdizimi yoktur ve bu bunu yapmanın makul bir yolu gibi görünmektedir.)

TIO bağlantısının, Ṅprogramın gerçekten çalıştığını göstermek için eklenmiş (“iç durumu ve stdout'a yeni bir satır yaz”) vardır.

açıklama

µḢị⁴⁸;Ḋß
           {implicit: initialise internal state from first argument}
µ          Disregard the second command-line argument by default
 Ḣ         Take the first element, removing it from the internal state
  ị⁴       Use the value to index into the second argument
    ⁸;     Prepend (the rest of) the internal state
      Ḋ    Discard the first element of the internal state
       ß   Loop forever

BF / P "bir Turing Makinesi'nde uygulandı, 842 bayt

Geçiş masası (uzunluk nedeniyle bağlantılı)

Geçiş masası, daha az golflü versiyon

Turing Makine simülatörü kullandım

Bu kesinlikle herhangi bir uzunluk ödülü kazanamayacak, ancak BF bir Turing Makinesi'ne çok benzer olduğu için her zaman yapmak istediğim bir şey. Her hücre, 0x0- arasında bir değer saklar 0xF. Bununla birlikte, genişlik Turing Machine web sitesi tarayıcınızı kilitlemeden gidebilir. ,Ve .biraz daha gerçek BF daha P" gibi öyle çok fonksiyonları (giriş ve çıkış), tanımlanmamıştır.

Çalıştırmak için geçiş tablosunu Turing Machine simülatörüne yapıştırın, girişi bir BF koduna ayarlayın ve run tuşuna basın.

TM'nin bandı, hem BF kodunu hem de BF verilerini, ortasında tek bir boşluk olacak şekilde saklar. Halen çalışmakta olan karakteri ( [-> (, vb.) Ve verideki konumunu ^hücrenin önünde bulunan bir pozisyonda değiştirerek koddaki konumunu takip eder . Bir komut karakterini okuduğunda, şapka işaretine basana kadar hareket eder, bir hücreyi sağa taşır ve uygun işlevi gerçekleştirir. Sonra BF kodundaki "modifiye" komut karakterlerinden birini ararken geri döner ve tüm işlemi tekrarlayarak bir sonrakine geçer. Kod bittiğinde durur.

Nasıl çalıştığını anlamanın en iyi yolu asılsız sürümü çalıştırmak, adım kipine koymak ve hangi çizgilerin diğerlerine ve her bir satır / blok bloğunun ne yaptığını izlemektir.

Golf ve ungolfed versiyonları tam olarak nasıl çalıştıkları bakımından aynıdır, ancak ungolfed versiyonunun daha insan dostu isimleri vardır ve bölümlere ayrılmıştır.

(2,3) Turing Makinesi , 236 205 byte'ı uygulayarak C ( garip girdileri umursamıyorsanız 46 31 daha az)

-11 bayt için Appleshell, -12 bayt için VisualMelon ve -7 bayt için Johan du Toit sayesinde.

CeilingCat sadece 144 bayt kullanan bir sürüm yaptı, buraya bakın .

(Buraya birkaç satır sonu ekledim, bu nedenle kaydırmanız gerekmez, ancak normalde çoğu silinir)

#define c char
j;i;k;c s,d[256];c main(){c*p=d+128;gets(d);
for(;k<256&&d[k];)d[k++]-=48;for(;++j<256;)
{c t=*p;*p=-t*t+(2-s)*t+1+s;p+=(s^t==0)*2-1;s=s?t%2:!t%3;
for(i=0;++i<256;)printf("%d",d[i]);puts("");}}

Çevrimiçi deneyin!

Kullanmak için: Kaseti başlatmak için en fazla 256 tane olan bir dize, sıfır ve iki giriş girin. Başlatılmamış değerler sıfır olacaktır. (0, 1 ve 2 dışındaki değerler tanımsız davranışa neden olabilir.) Program, 256 adımdan fazla yinelenir. Yinelenen adımların sayısı, kodu değiştirerek arttırılabilir, ancak açıkçası bu daha fazla karakter gerektirir.

Oldukça uzun bir giriş, ama bu benim ilk kez bunlardan birini yapıyorum ve özel bir golf dili kullanmadım. Beklediğimden daha uzun sürse bile çok eğlendim.

Baytların çoğu giriş ve çıkışla ilgileniyor ve NUL, SOH, STX yerine 0, 1 ve 2 kabul ederek tüm 42 baytı kaybettim. (Bunu değiştirmek k;için önden ve for(;k<256&&d[k];)d[k++]-=48;ikinci satırdan silin .)

Transistion tablosu, özellikle çizgi *p=-t*t+(2-s)*t+1+s;(bant üzerindeki değerleri ayarlayan) muhtemelen daha da sıkıştırılabilir.

Röda uygulanması Fractran , 114 112 106 bayt

@Fergusq sayesinde parametreleri yeniden düzenleyerek 1 bayt kurtarıldı

f&n,a{x=1{x=0;(a/" ")()|[_/`/`]|[parseInteger(_[0],_1[1])]|{|q,w|{n*=q/w;x=1}if[n%w<1,x<1]}_,_}while[x>0]}

Çevrimiçi deneyin!

Şöyle işlevini çağırın: f reference_to_input program. Çıkış, konumunda saklanacaktır input.

Clojure, 82 81 bayt (Turing Makinesi)

Güncelleme: alanından bir boşluk kaldırıldı t{} s.

#(loop[p 0 t{}s 1](if-let[[S M N](%[(or(t p)0)s])](recur(+ p M)(assoc t p S)N)t))

Turing Machine'i bir döngü olarak uygular, durma durumuna ulaşıldığında bandı döndürür. Durum geçiş kurallarında bu, geçiş durumunu atlayarak belirtilir. Bu Settins Niçin nilve daha sonra if-letkarşılık gelen durum geçişi olarak iptal eder, giriş karma haritadan bulunamadı %. Aslında bu durum için herhangi bir değer :abort0 veya -1 gibi olacaktır .

Bir örnek 3 durum, 2-simge yoğun kunduz ile Ungolfed Wikipedia .

(def f #(loop[pos 0 tape {} state 1]
          (if-let [[sym move next-state](%[(get tape pos 0)state])]
            (do (println [pos tape state])
                (recur(+ pos move)(assoc tape pos sym)next-state))
            tape)))

(f {[0 1] [1  1 2]
    [0 2] [1 -1 1]
    [0 3] [1 -1 2] 
    [1 1] [1 -1 3]
    [1 2] [1  1 2]
    [1 3] [1  1]})

{0 1, 1 1, -1 1, -2 1, -3 1, 2 1}

Çevrimiçi deneyin .

6700K'lık tek bir çekirdekte, 5 durumlu 2 sembollü yoğun kunduz (47.1 milyon adım), yaklaşık 29 saniye veya 1.6 milyon adım / saniye çalıştırılıyor.

M → İpucu , 4 bayt

Ṅ×ịß

Çevrimiçi deneyin!

TIO bağlantısı, Esolang sayfasında gösterilen örnek İpucu programı ile işlev çağrısı yapmak için bir altbilgi ekler (M'nin "otomatik sarmalayıcı", programlar sanki rasyonel veya sabit nokta numaralarını kaldıramazlar ya da en azından ben nasıl söyleyeceğimi çözemedik, bu yüzden çalışabilmek için bu işlevi el ile tam bir program haline getirmem gerekiyor.)

Bu aslında yararlı hata ayıklama çıktısını yazdırır; program 3 bayt ile yazılamaz çünkü tam olarak üç günden oluşan bir program ayrıştırıcıda özel bir durum tetikler, bu yüzden özel durumdan kaçınmak için fazladan bir komut eklemek zorunda kaldım. Bunu Ṅ(newline ile yazdırmak) en azından faydalı bir amaç haline getirmek.

ı$i=\sqrt{-1}$

G / Ç uygulamıyor (durma / durma dışında). G / Ç, Tip'in bir uzantısıdır (dilin kendisinin bir parçası değildir) ve Turing'in eksiksiz olması için gerekli değildir.

Açıklama / arka plan

Ṅ×ịß
Ṅ     Print {the left argument} and a newline; also resolves a parser ambiguity
  ị   {The left argument}th element of {the right argument}, wrapping on OoB
 ×    Multiply {the left argument} by {the chosen element}
   ß  Recursive call; arguments: {the product} and {the same right argument}

[1,2,3][1,2,3,1,2,3,1,2,3,…]$rx+s$Bu bir polinomdur ve birçok golf dilinin sahip olduğu “temel dönüşüm” aslında kılık değiştirmiş genel amaçlı bir polinom değerlendiricisidir. Tek yapmamız gereken, bir basamaklar listesine endekslemek, onları taban-dönüştürmek ve bitti, tamam mı?

$x$$x$

ḅ$x\oplus(x\otimes y)$$x\otimes y$${\oplus}$. Elbette, zincirleme davranışını istediğimiz herhangi bir şey için geçersiz kılabiliriz, ancak bu bir bayta mal olur ve bu soruya golf dili girişleri o kadar kısa oluyor ki bir bayt çok fazla.

Bu yüzden geriye baktım ve yeniden değerlendirdim. Polinom değerlendirmesi yerine kullanabileceğimiz herhangi bir işlem var mı? İdeal olarak, değişmeli olanlar, bu nedenle tartışma sırası için endişelenmek zorunda değiliz? Kısa bir süre sonra Collatz fonksiyonlarının olması gerekenden daha karmaşık olduğunu anladım.

$s$

Tabii ki, temel dönüşümden ( ḅ) farklı olarak , multiplication ( ×) değişimlidir ve bu nedenle argümanların hangi sıraya yerleştirildiği önemli değildir. Bu yüzden yazmamız gereken tek şey ×ị, sonra programı sonsuz bir özyinelemeye yerleştirmek ß. ve Turing tamamlanmış bir dilimiz var. Sağ?

$(x\odot y)\oplus(x\otimes y)$¹×ịß¹¹Ṅ faydalı bir hata ayıklama çıktısı ürettiği için iyi bir seçimdir.

Üç bayt mümkün mü? Bir şeyleri özümsemediğim sürece, bu özel uygulama ve uygulamalı dil seçeneği ile değil, fakat bu noktada kesinlikle bir şekilde mümkün olacak gibi görünüyor, çünkü bunu dörtte yapmanın birçok yolu ve Turing-tamamlandı. uygulayabileceğiniz dilleri

C Brainfuck yorumlama, 187 bayt

t[999],*p=t,c,i,l;f(char*t){for(i=0;c=t[i];i++){c^62?c^60?c^43?c^45?c^46?c^44?c^91:(*p=getchar()):putchar(*p):--*p:++*p:--p:++p;if(c==93&&*p)for(l=1;l>0;)c=t[--i],c==91?l--:c==93?l++:0;}}

Çevrimiçi deneyin

Lua, Brainf'i yorumlayan ***, 467 bayt

b,r,a,i,n,s=0,io.read,{0},1,1,"><+-.,[]"c,f=r(),{function()n=n+1;a[n]=a[n]or 0;end,function()n=n-1;a[n]=a[n]or 0;end,function()a[n]=a[n]+1;end,function()a[n]=a[n]-1;end,function()io.write(string.char(a[n]))end,function()a[n]=io.read():byte()end,function()i=a[n]~=0 and i or c:find("]",i)end,function()if a[n]~=0 then b,x=1,""repeat i=i-1 x=c:sub(i,i)b=x=="["and b-1 or x=="]"and b+1 or b until b==0 and x=="["end end}repeat f[s:find(c:sub(i,i),1,1)]()i=i+1 until i>#c

Biliyorum, daha sonra yapabileceğim bir miktar zayıflama var, ama işte ilk geçişimin bittiği yer. Brainf kodunu standart girdiden alır.

CJam → ResPlicate Variant, 15 14 13 bayt

^{@ Ais523 sayesinde -1 bayt}

l~{(/((*+e_}h

Değişken, sıradan alınan öğe sayısının sıradaki en üstteki sayıdan daha düşük olması dışında, bu cevabın içindekiyle aynıdır .

l~{ ... }hKısmı sadece girdi olarak bir dizi alır ve bu dizi boşalana kadar tekrar eder.

Ana döngünün açıklaması:

    e# Stack:             | [3 2 1 1 2 2 2 1]
(   e# Pop first element: | [2 1 1 2 2 2 1] 3
/   e# Split chunks:      | [[2 1 1] [2 2 2] [1]]
(   e# Pop first:         | [[2 2 2] [1]] [2 1 1]
(   e# Pop first:         | [[2 2 2] [1]] [1 1] 2
*   e# Repeat array:      | [[2 2 2] [1]] [1 1 1 1]
+   e# Concatenate:       | [[2 2 2] [1] 1 1 1 1]
e_  e# Flatten:           | [2 2 2 1 1 1 1 1]

Çip , 20 + 3 = 23 bayt (Kural 110)

AZZ
>}/a
`)\'E~Zte*f

Bayrak için +3 -z

Çevrimiçi deneyin!

Chip'in (henüz) herhangi bir döngü kabiliyetine sahip olmadığı için bu gönderim mükemmel değildir, bu nedenle çıktı, birden fazla nesli simüle etmek için girdi olarak iletilmelidir, bunun gibi bir şeyle (tabii ki, bu döngüyü süresiz olarak çalıştırabilirsiniz, ve Chip isteğe bağlı olarak uzun girdiler elde edebilir, bu yüzden bu kombinasyon Turing Complete'dir).

Bu uygulama, ASCII 0ve 1s şeklinde girdi ve çıktı aldı . Buradaki mantık aşağıdaki gibidir:

p := value of left neighbor cell    AZZ
q := value of current cell          AZ
r := value of right neighbor cell   A

q' := ((r xor q) and p) or          >}/a
      ((r or q) and ~p)             `)\'

Elemanların geri kalanı temizlik içindir: e*fASCII sayısal çıktısına neden olur E~Ztve girişin tükenmesinden sonra iki baytı yürütmeyi sonlandırır (genişlik her nesil 2 büyüdüğü için).

Clojure, 75 bayt (Döngüsel etiket sistemi)

Güncelleme 1: değiştirilmiştir some?ile nil?.

Güncelleme 2: SBaşka bir şubedeki eksikler giderildi if s.

#(loop[[p & P](cycle %)[s & S]%2](if(nil? s)S(recur P(if s(concat S p)S))))

Döngüsel etiket sistemini uygular, nilprogram durursa döner , aksi takdirde sonsuza kadar döngüye girer. Clojure gerçekten burada sonsuz tembel dizileri ( döngü gibi ) ve yıkıcı ile parlıyor . Birler ve sıfırlar doğru ve yanlış değerler olarak belirtilmiştir. Veri dizgisi bittiğinde solur nil.

Ungolfed:

(def f #(loop[[p & P] (cycle %) [s & S] %2 i 5]
          (do
            (pprint [p (concat [s] S)])
            (if (and (some? s) (pos? i))
              (recur P (if s (concat S p) S) (dec i))))))

Örnek sonuçlar:

(f [[false]] [true true])
[[false] (true true)]
[[false] (true false)]
[[false] (false false)]
[[false] (false)]
[[false] (nil)]

(f [[false true true] [true false] [true false true]] [true])
[[false true true] (true)]
[[true false]      (false true true)]
[[true false true] (true true)]
[[false true true] (true true false true)]
[[true false]      (true false true false true true)]
[[true false true] (false true false true true true false)]

JavaScript yorumlama Kural 110 , 131 bayt (99 bayt ?, 28 bayt?)

a=(p,q,r)=>q+r+q*r+p*q*r
b=l=>{r="";for(i=0;i<l.length-2;i++)r+=a(l[i],+l[i+1],+l[i+2])%2;return r}
c=(l,n)=>!n?l:c(b(0+l+0),n-1)

Gördüğünüz gibi, kod 3 işlevi tanımlar a, bve c. Belki de baytları 1 işlevde birleştirerek kurtarmak mümkündür (nasıl olduğunu göremiyorum), ama her biri zaten bu zorlukla bir anlamda bir araya geldiği için ayrı olması iyidir.

İşlev agiriş olarak 3 sayı alır ve bunlardan bazı garip polinomları hesaplar. Bu 3 sayı olduğunda 0veya 1arı, Kural 110 hücreleri olarak görülebilir. Çıktının paritesi adaha sonra yeni nesildeki orta hücrenin değeri olarak görülebilir. Yani, bir anlamda, bu basit fonksiyon zaten bir Kural 110 'tercüman' (28 bayt):

a=(p,q,r)=>(q+r+q*r+p*q*r)%2

Daha sonra birler dizisinin her karakterini ve sıfırlarını bdeğerlendiren yeni bir işlev yaratabiliriz a. Bu b, daha sonra, abir Kural 110 tercümanından daha iyidir . Tasarruf parantezinin değerlendirilmesinden sonra mod 2 alınması (99 bytes):

a=(p,q,r)=>q+r+q*r+p*q*r
b=l=>{r="";for(i=0;i<l.length-2;i++)r+=a(l[i],+l[i+1],+l[i+2])%2;return r}

Kural 110 ile bir fonksiyonu gerçekten hesaplamak için, kullanıcının başlangıç ​​durumunu ve çıktının 'görüneceği' nesil sayısını belirtmesi gerekir. cSıfırları ve sıfırları alan üçüncü bir fonksiyon yapabiliriz ve ndaha sonra bstringi değerlendiren pozitif bir tamsayı yapabiliriz n. Bunun gibi, Kural 110'u gerçekten bir programın başlangıç ​​durumu ve bir sayı nolduğu ve çıktının nnesiller sonrası durum olduğu bir programlama dili olarak görebiliriz . İşlev cşimdi bu programlama dili için gerçek bir tercümandır, bu nedenle bu zorluğun son kodu yukarıda sunduğum şeydir.

JS -> Newline 854 bayt

(function(d){var b=0;var n=!0;var c=[];var h=[];var e=0;var l=[];var m=0;var f=2;var a=0;var g=!1;var k=function(a){if(a===1)return!1;if(a%2===0&&a!==2)return!1;if(a%3===0&&a!==3)return!1;if(a%5===0&&a!==5)return!1;if(a%7===0&&a!==7)return!1;for(var b=7;b<d.round(d.sqrt(a))+1;b++)if(a%b===0)return!1;return f=a,!0;};var j=0;var i=0;var o=function(q){var o=d.__split(q,'\n');d.println(o);for(var n=0;n<o.length;n++)if(n>=f^2&&n<=f+1^2&&k(n)){f=n;for(var p=0;p<o[n].length;p++){if(o[n]==='+'&&(a+=c[b],b++),o[n]==='-')if(g===!0&&a<=0)break;else a-=c[b],b++;if(o[n]==='*'&&(a*=c[b],b++),o[n]==='/'&&(a/=c[b],b++),o[n]==='s'&&(a=d.sqrt(a)),o[n]==='%'&&(a%=c[b],b++),o[n]==='a'&&l.push(a),o[n]==='g'&&(a=c[b],b++),o[n]==='q'&&c.push(a),o[n]==='i'&&a++,o[n]==='d')if(g===!0&&a<=0)break;else a--;o[n]==='r'&&(g=!0),o[n]==='w'&&(g=!1),o[n]==='['&&(j=n),o[n]===']'&&a>0&&(n=j,h[e]--),o[n]==='{'&&(i=n),o[n]==='}'&&h[e]>0&&(n=i,h[e]--),m=a,o[n]==='k'&&e++;}}};});

Süper google sayesinde golf oynadı.

Clojure, 87 bayt (Kural 110)

Parite kodu için kredi Jens Renders’e gidiyor! Bunu nasıl ifade edeceğimi gerçekten çok zorluyordum ve [p q r]ikiliden bir tamsayıya çevirip bir arama tablosu kullanacaktım.

#(iterate(fn[S](for[[p q r](partition 3 1(concat[0]S[0]))](mod(+ q(* q(+ 1 p)r)r)2)))%)

Burada partitionve Clojure'un yıkımı, mantık uygulamasını oldukça basit hale getiriyor. Bu işlev sonsuz bir durum dizisi döndürür, böylece arayan kişi takeihtiyaç duyduğu kadar sorumludur veya yalnızca nthbelirli bir duruma geçmekten sorumludur . Eğer sıfıra sahip dolgular sadece bir tane yerine iki eleman olsaydı, o zaman bant sürekli olarak büyür ve sınır sorunlarından kaçınırdı. Şimdi orijinal genişliğini koruyor.

Örnek:

(def f #(iterate(fn[S](for[[p q r](partition 3 1(concat[0]S[0]))](mod(+ q(* q(+ 1 p)r)r)2)))%))

(pprint (take 5 (f '(0 0 0 0 0 1 1 1 0 0 1 0 0))))
((0 0 0 0 0 1 1 1 0 0 1 0 0)
 (0 0 0 0 1 1 0 1 0 1 1 0 0)
 (0 0 0 1 1 1 1 1 1 1 1 0 0)
 (0 0 1 1 0 0 0 0 0 0 1 0 0)
 (0 1 1 1 0 0 0 0 0 1 1 0 0))

APL (Dyalog) → Fractran varyantı, 15 bayt

(⊃0~⍨××0=1|×)⍣≡

Çevrimiçi deneyin!

Fonksiyon, rasyonel ve payda içeren iki liste yerine bir sayılar listesi olarak alır ve program sona erdiğinde sonucu verir. Bu, program sonunda rasyonel 1/1 (= 1) olan bir Fractran çeşidi uygular. 1'in Turing'in bütünlüğü üzerinde hiçbir etkisi yoktur (benim anladığım kadarıyla) çünkü programın girişi yalnızca diğer gerekçelerin hiçbiri işe yaramadığında ve girdi değiştiğinde 1'e girer. Bu sadece fonksiyonun ne zaman biteceğini bilmesi için kullanılır.

TIO bağlantısı, ilk girişte işlevi 2 yinelemeye (çıkışı programın bitmediğini görebilmeniz için görebilirsiniz) çalıştırır ve tamamlanana kadar ikinci girişi çalıştırır, daha sonra çıkışı döndürür.

(⊃0~⍨××0=1|×)⍣≡ arg olarak adlandırılacak olan sol argüman ve ⊢ olarak adlandırılacak olan doğru argüman olan giriş listesini ⊢

(⊃0~⍨××0=1|×) fonksiyon treni

• 1|××⊣ ve ⊢ ürününün ondalık noktasından (modulo 1) sonraki kısmı alın

• 0= 0'a eşit mi?

• ×× bu sonucu ⊣ × an ile çarpın; rasyonel × inte bir tamsayı değilse, 0 ile değiştirilir.

• 0~⍨ tüm 0'ları kaldır

• ⊃ ilk elemanı al

⍣≡Giriş değişmeyene kadar döngü yapın , sonucunun (⊃0~⍨××0=1|×)giriş olarak tekrar kullanıldığını unutmayın , bu yüzden eğer değişmeyi bırakırsa (sonunda 1)

JavaScript: Lambda Matematik ( 123 114)

Duples'taki Debruijn Indicies kullanılarak temsil edildi.

V=function b(c,d){if(!isNaN(c)){for(;--c;)d=d[1];return d[0]}return 0==c[0]?e=>b(c[1],[e,d]):b(c[0],d)(b(c[1],d))}

S birleştiricisi [0, [0, [0, [[3, 1], [2, 1]]]]]

K [0, [0, 2]]

Ben [0, 1]

Düzenleme: "number"==typeof cile değiştirerek tıraş 9 bayt!isNaN(c)

APL (Dyalog Unicode) , 15 bayt ^SBCS

Genelleştirilmiş bir boyutlu hücresel otomat uygulayıcısı uygulayan tam program. Bu , Turing tamamlandı olan Kural 110'u içerir . Başlangıç ​​durumu, yinelemelerin sayısı (veya ≡sabit olana kadar devam {⍵≡⎕←⍺}etmek veya sabit olana kadar tüm ara değerleri görüntülemek için) ve kural koymak için istekler sorulur .

⎕∊⍨∘(⊢∘⊂⌺3)⍣⎕⊢⎕

Çevrimiçi deneyin! (4 Kural 110 yineleme)

⎕ başlangıç ​​durumu istemi ve

⊢ verimi (durumu yineleme sayısından ayıran) verimi

⍣⎕ yineleme sayısını isteyin ve aşağıdaki işlevi birçok kez uygulayın:

 (… ) Aşağıdaki taktik işlevini uygulayın:

  ⌺3 Tüm uzunluk-3 mahallelerini alın (sınırda olup olmadıklarına dair bilgi ile birlikte) ve her bir parite aşağıdaki taktik fonksiyonunu uygulayın:

   ⊂ mahalleyi kuşatmak

   ∘ ve

   ⊢ verimini sağlamak (sınırda olma hakkındaki bilgiyi silmek)

 ∘ sonra

 ∊⍨ üye olup olmadıklarını kontrol edin

 ⎕ Bir sonraki yinelemede bulunmaya giden mahallelerin listesini isteyin