Büyük iyiliğin için sana bir golf at!

204

Seçtiğiniz dili kullanarak, kısa bir golf oynayın .

Bir quine onun tek çıkış olarak kendi kaynak kodunun bir kopyasını hiçbir girdi alır ve üreten bir boş olmayan bir bilgisayar programıdır.

Hile yok - bu sadece kaynak dosyayı okuyamayacağınız ve yazdıramayacağınız anlamına geliyor. Ayrıca, birçok dilde boş bir dosya aynı zamanda bir sorundur: okunaklı bir satır sayılmaz.

Hata sorguları yok - hata sorguları için zaten ayrı bir mücadele var .

Puan:

  • En küçük kod (bayt cinsinden)
  • En karışık / belirsiz çözüm
  • Ezoterik / karanlık dilleri kullanmak
  • Golf oynamak zor dilleri başarıyla kullanmak

Aşağıdaki Yığın Parçacığı, her bir dilde geçerli puanın hızlı bir şekilde görülebilmesi ve böylece hangi dillerin mevcut cevapları olduğunu ve ne tür bir hedefi yenmek zorunda olduğunuzu bilmek için kullanılabilir:

Kod pasajını göster

code-golf  quine 
— Rafe Kettler
kaynak
4
"Daha iyi bir iyilik için golf oynuyorsun!"
— Mateen Ulhaq
50
@muntoo "Büyük İyiliğin için bir Haskell öğren" adlı oyun.
— Rafe Kettler

Yanıtlar:

106

Altıgen , kenar uzunluğu 17 16, 816 705 bayt

180963109168843880558244491673953327577233938129339173058720504081484022549811402058271303887670710274969455065557883702369807148960608553223879503892017157337685576056512546932243594316638247597075423507937943819812664454190530214807032600083287129465751195839469777849740055584043374711363571711078781297231590606019313065042667406784753422844".".>.@.#.#.#.#.#.#.#.>.(...........................<.".......".".>./.4.Q.;.+.<.#.>...........................<.".....".".>.#.#.>.N.2.'.\.>.............=.=......._.<.".....".".>.>.;.'.=.:.\.>.......................<."...".".>.\.'.%.'.<.#.>..............._.....<."...".".>.#.#.>.<.#.>...............=.=.<.".".".>.#.\.'.R./.>.................<.".!.........../.>.

Çevrimiçi deneyin!

Bu katlanmış gibi görünüyor:

                1 8 0 9 6 3 1 0 9 1 6 8 8 4 3 8
               8 0 5 5 8 2 4 4 4 9 1 6 7 3 9 5 3
              3 2 7 5 7 7 2 3 3 9 3 8 1 2 9 3 3 9
             1 7 3 0 5 8 7 2 0 5 0 4 0 8 1 4 8 4 0
            2 2 5 4 9 8 1 1 4 0 2 0 5 8 2 7 1 3 0 3
           8 8 7 6 7 0 7 1 0 2 7 4 9 6 9 4 5 5 0 6 5
          5 5 7 8 8 3 7 0 2 3 6 9 8 0 7 1 4 8 9 6 0 6
         0 8 5 5 3 2 2 3 8 7 9 5 0 3 8 9 2 0 1 7 1 5 7
        3 3 7 6 8 5 5 7 6 0 5 6 5 1 2 5 4 6 9 3 2 2 4 3
       5 9 4 3 1 6 6 3 8 2 4 7 5 9 7 0 7 5 4 2 3 5 0 7 9
      3 7 9 4 3 8 1 9 8 1 2 6 6 4 4 5 4 1 9 0 5 3 0 2 1 4
     8 0 7 0 3 2 6 0 0 0 8 3 2 8 7 1 2 9 4 6 5 7 5 1 1 9 5
    8 3 9 4 6 9 7 7 7 8 4 9 7 4 0 0 5 5 5 8 4 0 4 3 3 7 4 7
   1 1 3 6 3 5 7 1 7 1 1 0 7 8 7 8 1 2 9 7 2 3 1 5 9 0 6 0 6
  0 1 9 3 1 3 0 6 5 0 4 2 6 6 7 4 0 6 7 8 4 7 5 3 4 2 2 8 4 4
 " . " . > . @ . # . # . # . # . # . # . # . > . ( . . . . . .
  . . . . . . . . . . . . . . . . . . . . . < . " . . . . . .
   . " . " . > . / . 4 . Q . ; . + . < . # . > . . . . . . .
    . . . . . . . . . . . . . . . . . . . . < . " . . . . .
     " . " . > . # . # . > . N . 2 . ' . \ . > . . . . . .
      . . . . . . . = . = . . . . . . . _ . < . " . . . .
       . " . " . > . > . ; . ' . = . : . \ . > . . . . .
        . . . . . . . . . . . . . . . . . . < . " . . .
         " . " . > . \ . ' . % . ' . < . # . > . . . .
          . . . . . . . . . . . _ . . . . . < . " . .
           . " . " . > . # . # . > . < . # . > . . .
            . . . . . . . . . . . . = . = . < . " .
             " . " . > . # . \ . ' . R . / . > . .
              . . . . . . . . . . . . . . . < . "
               . ! . . . . . . . . . . . / . > .
                . . . . . . . . . . . . . . . .

İyi Ah, bu ben "haha, bu delilik" ve "Ben yaparsam, bekleyin arasında geçiş sayısını sayma durdu ... oldukça duygusal bir olaydı bu aslında oldukça yapılabilir olmalıdır". Hexagony'nin düzen kurallarının koda getirdiği kısıtlamalar ... ağırdı.

Genel yaklaşımı değiştirmeden kenar uzunluğunu 1 veya 2 azaltmak mümkün olabilir, ancak zor olacak (sadece #şu anda kullanılmayan ve kod çözücü için mevcut olan hücreler ). Şu anda, daha etkili bir yaklaşım için kesinlikle hiçbir fikrim kalmadı, ama birinin varlığından eminim. Bir kaç gün boyunca bu düşünceyi vereceğim ve belki bir açıklama ve her şey eklemeden önce bir yan uzunlukta golf oynamaya çalışacağım.

En azından mümkün olduğunu kanıtladım.

Gelecekteki referansım için bazı CJam scriptleri:

— Martin Ender
kaynak
51
Sevgili Pete bu nedir.
— Conor O'Brien,
2
Bunu yapmak ne kadar sürdü?
— Adnan
3
@AandN Dünden beri genel bir "şablon" kavramlarıyla uğraşıyorum ve o zaman (herhangi bir gerçek test içermiyordu ... sadece 7x7 ızgaraya bazı şeyler yazıp çalışıp çalışmadığını görmek için .. Muhtemelen orada zaten yarım düzine yaklaşımı atmıştım). Gerçek kodlama bu akşam aldı ... belki 3 saat, diyebilirim.
— Martin Ender
10
Kelimeler ben adım Ezoterik IDE adımıyla eyleminde bu görünce ... kime bu anlamak isteyebilirsiniz ne kadar hayret açıklayamam, bu Altıgen ile basılır bir tamsayı içine "dekoder" bölümünü kodlayan !bir ile daha sonra ve /2. satırdaki ayna , kodu tamamlamak için kod çözücüyü yazdırmak üzere kod çözücüye girer. Bunun çok büyük bir tamsayı okuyup mucizevi bir kullanımı var <ve >kod çözücüyü depolamak için alan oluşturuyor. Hangi "düzinelerce yaklaşımın" dikkate alındığını gerçekten bilmek isterdim?
— Sunny Pun
3
Açıklama? ---
— MD XF
77

MySQL, 167 karakter

SELECT REPLACE(@v:='SELECT REPLACE(@v:=\'2\',1+1,REPLACE(REPLACE(@v,\'\\\\\',\'\\\\\\\\\'),\'\\\'\',\'\\\\\\\'\'));',1+1,REPLACE(REPLACE(@v,'\\','\\\\'),'\'','\\\''));

Doğru. :-)

Bunu gerçekten kendim yazdım. Aslen siteme gönderildi .

— TehShrike
kaynak
72

GolfScript, 2 bayt

1

(sondaki yeni satırı not edin) Bu, 1 sayısını yığının üzerine iter. Programın sonunda, GolfScript yığındaki tüm öğeleri yazdırır (aralarında boşluk kalmaz), sonra yeni bir satır yazdırır.

Bu gerçek bir quine (soruda listelendiği gibi) çünkü gerçekten de kodu çalıştırıyor; sadece "kaynak dosyayı oku ve yazdır" değil (PHP gönderiminin aksine).

Başka bir örnek için, işte yazdırılacak bir GolfScript programı 12345678:

9,(;
  1. 9: yığına 9 basın
  2. ,: 9'u argüman olarak kullanmak, diziyi [0 1 2 3 4 5 6 7 8]yığına itmek
  3. (: diziyi argüman olarak kullanmak, diziyi [1 2 3 4 5 6 7 8]ve maddeyi 0yığına itmek
  4. ;: yığının en üst kısmını at

Yığın şimdi diziyi içeriyor [1 2 3 4 5 6 7 8]. Bu, elemanlar arasında boşluk kalmadan standart çıktıya yazılır, ardından yeni bir satır takip edilir.

— Chris Jester-Young
kaynak
18
Veya PowerShell veya PHP :-)
— Joey
6
Zamanda geriye gitmedin ve mucitlere GolfScript'i icat etme fikrini vermedin, değil mi?
— Mateen Ulhaq
78
Teknik olarak, 1GolfScript'te bir kuyruk değil: çıktılar 1\n, burada \nyeni bir çizgiyi gösterir. Ancak, iki-Char programı 1\n olan bir quine.
— Ilmari Karonen
17
Tek-char programı \nmuhtemelen aynı zamanda?
— Lynn,
10
@Pine bir quine kelimenin tam anlamıyla kendi kaynağını basan bir programdır. "Yapı" ile ilgili herhangi bir keyfi kısıtlama olduğunu sanmıyorum.
— Hugo Zink
71

Brain-Flak , 9.8e580 1.3e562 9.3e516 12818 11024 4452 4332 4240 4200 4180 3852 3656 3616 3540 2485 + 3 = 2488 bayt

Şimdi gözlemlenebilir evrende uyuyor!

(())(()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(()()()()())(())(())(())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(()()()()())(())(())(())(())(())(())(()())(())(())(())(()())(()()()())(())(()()()()())(()())(()())(()())(()()())(())(()())(())(()()()()())(()())(()()()()())(())(())(())(())(())(()())(())(())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(()())(()())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(()()())(()())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(())(())(()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(()()())(())(()()())(())(())(())(()())(()()())(()())(())(()()()()())(()())(())(()()())(())(()()()()())(())(())(())(()()())(())(())(())(()())(())(()())(()()()())(())(())(()()()()())(()())(()())(())(()()())(())(())(())(())(()()())(()())(())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()())(())(()()()()())(()()()()())(())(()()())(())(())(()())(())(()()()()())(())(()()()()())(())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(()()()()())(())(()()()()())(())(())(())(()())(())(()()()()())(())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()()()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(())(()())(()()()())(())(())(()())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(()()())(())(())(()())(())(())(()()()()())(()()()())(()())(()())(()()())(())(()())(())(()()()()())(()())(()()()()())(())(())(())(()()()())(()()()())(()())([[]]){({}()<(([{}]())<{({}())<>(((((()()()()()){}){}){}())[()])<>{({}())<>{}({}(((()()()){}())){}{})<>{({}())<>({}(((()()()()()){})){}{}())<>{{}<>({}(((()()()()){}){}){})(<>)}}<>(({})[()()])<>}}{}<>({}(<()>)<><{({}<>)<>}<>>){({}<>)<>}{}(<>)<>{({}<>)<>}{}(((((((()()()()()){}){}){}))()))>){({}()<((({}[()])()))>)}{}<>{({}<>)<>}{}>)}{}<>{({}<>)<>}<>

Çevrimiçi deneyin!

açıklama

Bu Quine ezoterik dillerdeki çoğu Quines gibi çalışır; iki bölümden bir kodlayıcı ve bir kod çözücü içerir. Kodlayıcı, başlangıçtaki tüm parantezlerdir ve kod çözücü, en uçtaki daha karmaşık kısımdır.

Programı kodlamanın saf bir yolu, kod çözücünün içindeki her karakterin ASCII değerini yığına koymaktır. Bu çok iyi bir fikir değil çünkü Brain-Flak sadece 8 karakter kullanıyor ( ()<>[]{}), bu yüzden çok az bilgiyi kodlamak için epeyce bayt ödüyorsunuz. Daha akıllıca bir fikir ve şimdiye kadar kullanılan, 8 braketin her birini daha küçük bir sayıya (1-8) atamak ve bunları kod çözücümüzle ASCII değerlerine dönüştürmektir. Bu iyi bir şey çünkü önceki 252'nin aksine bir karakteri kodlamak için 18 byte'dan fazla maliyet yok.

Ancak bu program da yok. Brain-Flak programlarının 8 teli 5'e kadar olan sayıları kodlamak için dengelenmiş olmalarına dayanır. Bunları aşağıdaki gibi kodlar.

(       -> 2
<       -> 3
[       -> 4
{       -> 5
),>,],} -> 1

Tüm yakın parantezler 1 olarak verilmiştir, çünkü belirli bir senaryoda hangisini kullanmamız gerektiğini belirlemek için bağlamı kullanabiliriz. Bu bir Brain-Flak programı için göz korkutucu bir görev gibi gelebilir, ama gerçekten değil. Örneğin, açık parantezlerin kodu çözülmüş olarak aşağıdaki kodlamaları ve yakın parantezlerin yerine a .:

(.
((..
<([.{...

Umarım algoritmanın oldukça basit olduğunu görebilirsiniz, soldan sağa okuruz, açık bir ayraçla her karşılaştığımızda, yakın ayracını hayali bir yığına iteriz ve karşılaştığımız zaman .en yüksek değeri çıkarır ve yerine koyarız. .. Bu yeni kodlama, kodlayıcıda bize çok büyük sayıda bayt kazandırırken, kod çözücüde sadece bir avuç bayt kaybediyor.

Düşük seviye açıklama

Çalışma devam ediyor

— Sriotchilism O'Zaic
kaynak
25
Kod-golf mücadelesine en uzun çözümün kazandığını düşünüyorum ...
— Mego
18
PPCG Nope tarihinin en büyük tek golfünü yaptım . 9.8e580 yine de etkileyici.
— Dennis,
19
Gözlenebilir evrene uymak için +1. Ayrıca, TIO Nexus ile, kalıcı bağlantı cevaba sığmalıdır. tio.run/nexus/…
— Dennis,
3
... çok büyük golf ...
— Yıkılabilir Limon
3
Sanırım çoğu baytı kazandın
— Christopher
68

Prelude , 5157 4514 2348 1761 1537 664 569 535 423 241 214 184 178 175 169 148 142 136 133 bayt

3 byte tasarruf için Sp3000 sayesinde.

Bu oldukça uzun ... (tamam, hala uzun ... en azından şu anda bu meydan okumada bilinen en kısa Brainfuck C # yarışmasını atıyor ) ama kendimi keşfettiğim ilk quine (Lua ve Julia gönderimlerim gerçekten sadece çeviriler. Standart quine tekniklerini diğer dillere uygulayın) ve bildiğim kadarıyla hiç kimse Prelude'de şu ana kadar bir quine yazmadı, bu yüzden gerçekten bununla gurur duyuyorum. :)

7( -^^^2+8+2-!( 6+ !
  ((#^#(1- )#)8(1-)8)#)4337435843475142584337433447514237963742423434123534455634423547524558455296969647344257)

Bu çok sayıdaki haneler, temel kodun sadece bir kodlamasıdır, bu yüzden de bu kadar uzun.

Quine kodlayan rakamlar bu CJam betiği ile üretildi .

Bu, karakterleri basan (değerleri karakter kodları olarak kullanarak) standart uyumlu bir yorumlayıcı gerektirir. Bu yüzden Python yorumlayıcısını kullanıyorsanız ayarlamanız gerekir NUMERIC_OUTPUT = False.

açıklama

İlk olarak, Prelude hakkında birkaç kelime: Prelude'deki her satır kendi yığınını yönlendiren ayrı bir "ses" tir. Bu yığınlar sonsuz sayıda O ile başlatılır. Program, sütuntaki tüm komutların önceki yığın durumlarına göre "eşzamanlı" çalıştırıldığı sütuna göre yürütülür. Rakamlar istifin üzerine ayrı ayrı itilir, 42a 4, sonra a basılır 2. Daha büyük sayıları doğrudan itmenin bir yolu yoktur, bunları eklemeniz gerekir. Değerler, vve ile bitişik yığınlardan kopyalanabilir ^. Brainfuck tarzı döngüler parantez içinde gösterilebilir. Daha fazla bilgi için başlıktaki bağlantıya bakın.

İşte quine'nin temel fikri: ilk önce quine çekirdeğini kodlayan yığının üzerine bir miktar rakamı itiyoruz. Bahsedilen çekirdek daha sonra bu rakamları alır, kendilerinin yazdırması için kodunu çözer ve sonra kodda göründüğü gibi rakamları yazdırır (ve izler )).

Bu, çekirdeği çoklu hatlara bölmek zorunda kalmamdan dolayı biraz karmaşık. Başlangıçta kodlamayı başlangıçta yaptım, ancak daha sonra diğer satırları aynı sayıda boşlukla doldurmanız gerekiyordu. Bu yüzden ilk puanların hepsi bu kadar büyüktü. Şimdi kodlamayı sonuna koydum, ancak bu ilk önce çekirdeği atlamam, sonra rakamları basmam ve tekrar başlangıcına atlayıp baskı yapmam gerektiği anlamına geliyor.

Kodlama

Kodun yalnızca iki sesi olduğundan ve bitişiklik döngüsel olduğundan ^ve veşanlamlıdır. Bu iyidir, çünkü vbugüne kadarki en büyük karakter koduna sahiptir, bu yüzden her zaman kullanmaktan kaçınmak ^kodlamayı daha basit hale getirir. Şimdi tüm karakter kodları dahil olmak üzere 10 ila 94 arasındadır. Bu, her karakteri tam olarak iki ondalık basamakla kodlayabildiğim anlamına gelir. Yine de bir sorun var: bazı karakterler, özellikle de satır beslemeleri, ondalık gösterimlerinde sıfıra sahipler. Bu bir sorun çünkü sıfırlar yığının altından kolayca ayırt edilemez. Neyse ki bunun için basit bir düzeltme var: karakter kodlarını dengeliyoruz 2, bu yüzden hala iki ondalık haneye rahatça uyan 12 - 96 arasında bir dizi var. Şimdi Prelude programında görünebilecek tüm karakterlerden,0temsilinde 0 var (50), ancak gerçekten de ihtiyacımız yok 0. İşte kullandığım kod, işte her basamağı ayrı ayrı iterek.

Ancak, bir yığınla çalıştığımız için, gösterimler tersine itilir. Yani kodlamanın sonuna bakarsanız:

...9647344257

Çiftlere bölün ve geriye doğru sürün, ardından iki tane çıkarın ve ardından karakter kodlarına bakın:

57 42 34 47 96
55 40 32 45 94
 7  (     -  ^

burada 32alanlara karşılık gelir. Çekirdek tam olarak bu dönüşümü yapar ve ardından karakterleri yazdırır.

Çekirdek

Öyleyse bu sayıların gerçekte nasıl işlendiğine bakalım. Öncelikle, eşleşen parantezlerin Prelude'da aynı satırda olmaları gerekmediğine dikkat etmek önemlidir. Sütun başına yalnızca bir parantez olabilir, bu nedenle parantezlerin birbirine ait olduğu belirsizlik yoktur. Özellikle, kapatma parantezinin dikey konumu her zaman alakasızdır - döngünün sona erip bitmediğini (veya tamamen atlandığını) kontrol etmek için kullanılan yığın her zaman olanı olacaktır (.

Kodu tam olarak iki kez çalıştırmak istiyoruz - ilk defa çekirdeği atlıyoruz ve sonunda tüm sayıları iterek, çekirdeği ikinci kez çalıştırıyoruz. Aslında, çekirdeği çalıştırdıktan sonra, tüm bu sayıları tekrar zorlayacağız, ancak döngü daha sonra sona erdiğinden, bu konu dışıdır. Bu, aşağıdaki iskeleti verir:

7(
  (                   )43... encoding ...57)

İlk olarak, 7ilk sese bir şey söyleriz - eğer bunu yapmazsak, asla döngüye girmeyiz (iskelet için bu sıfır olmayan olması önemlidir ... neden özellikle 7sonra göreceğiz) . Sonra ana döngüye giriyoruz. Şimdi, ikinci ses başka bir döngü içeriyor. İlk geçişte, ikinci yığın boş / sadece 0s içerdiğinden bu döngü atlanacak. Böylece doğrudan kodlamaya atlıyoruz ve tüm bu rakamları yığının üstüne itiyoruz. 7İlk yığın üzerine itilir hala yoktur, bu nedenle ilmek tekrarlanır.

Bu sefer, 7ikinci yığında bir de var, bu yüzden ikinci sesde döngüye giriyoruz. İkinci ses üzerindeki döngü, yığının sonunda tekrar boş olacak şekilde tasarlanmıştır, bu nedenle yalnızca bir kez çalışır. Aynı zamanda ilk yığını da tüketecektir ... Böylece döngüyü ikinci seste bıraktığımızda, tüm rakamları tekrar zorlarız, ancak şimdi 7ilk yığında atılır, böylece ana döngü sona erer ve program sona erer.

Şimdi, asıl çekirdekteki ilk döngüye bakalım. İşleri eşzamanlı olarak (veya ile )yapmak oldukça ilginç. Döngü gövdesini burada ile işaretledim =:

-^^^2+8+2-!
(#^#(1- )#)
 ==========

Bu, içeren sütunun (döngünün bir parçası olarak görülmediği anlamına gelir (oradaki karakterler yalnızca bir kez yürütülür ve döngü atlansa bile). Ama içeren sütun ) olan döngünün parçası ve her tekrarında bir defa koştu.

Böylece , ilk yığını ilk sıraya dönüştüren ... daha sonra bir tane daha ... ... -olan bir single ile başlıyoruz . Asıl döngü gelince ...7-7

Rakam yığını boşaltılmamışken döngü devam eder. Bir seferde iki basamağı işler. Bu döngünün amacı kodlamayı çözmek, karakteri yazdırmak ve aynı zamanda basamak yığınını ilk sese kaydırmaktır. Yani ilk önce bu kısım:

^^^
#^#

İlk sütun 1 haneyi ilk sese taşır. İkinci sütun, 10 rakamı ilk sese kopyalarken, 1 rakamı tekrar ikinci sese kopyalar. Üçüncü sütun bu kopyayı tekrar ilk sese taşır. Bu, ilk sesin şimdi iki kez 1 rakam ve aralarında 10 rakam olduğu anlamına gelir. İkinci ses yalnızca 10 basamaklı başka bir kopyaya sahip. Bu, yığınların üstündeki değerlerle çalışabileceğimiz ve ilk yığında daha sonra iki kopya kaldığından emin olacağımız anlamına gelir.

Şimdi karakter kodunu iki haneden kurtarıyoruz:

2+8+2-!
(1- )#

Alt kısım 10 basamak sıfıra düşüren küçük bir döngüdür. Her yineleme için en üste 10 eklemek istiyoruz. İlki 2döngünün bir parçası olmadığını unutmayın , bu nedenle ilmek gövdesi aslında +8+210 ekleyen ( 2daha önce basılanları kullanarak ) ve bir tane daha 2 iter. 10 değer ve bir başka 2. -Kodlamadaki ofseti hesaba katarak bu 2'yi çıkartıp karakteri ile yazdırırız !. #Sadece alt döngünün sonunda sıfır atar.

Bu döngü tamamlandığında, ikinci yığın boştur ve ilk yığın tüm basamakları ters sırada (ve -7altta) tutar. Gerisi oldukça basittir:

( 6+ !
8(1-)8)#

Bu, çekirdeğin, şimdi tüm basamakları geri basan ikinci halkasıdır. Bunu yapmak için, doğru karakter kodunu alabilmek için her bir basamağa 48 basmamız gerekir. Bunu, 8defalarca çalışan ve 6her seferinde ekleyen basit bir döngüle yapıyoruz . Sonuç ile yazdırılır !ve 8sonunda bir sonraki yineleme içindir.

Peki ya -7? Evet, 48 - 7 = 41karakterin kodu ). Sihirli!

Son olarak, bu döngüyü tamamladığımızda, dış döngüyü ikinci sesde bıraktığımızdan emin olmak için 8sadece itildiğimizi #atarız. Tüm rakamları tekrar basıyoruz ve program sonlandırılıyor.

— Martin Ender
kaynak
1
Şu anda Fugue'deki Hello World'ü dinlemek ... oldukça akılda kalıcı.
— Robert Fraser,
19
Martin, bir yerlerde durmalısın.
— görmek
3
Bunun genel olarak 5000'den fazla bayta sahip olmasının yanı sıra 3 tanesini kurtardığı için Sp3000'e bir onay almasını seviyorum.
— Kamil Drakari
2
@KamilDrakari Bunlar son 3 byte idi, bu yüzden oldukça büyük bir anlaşma. ;)
— Martin Ender
57

Altıgen , yan uzunluk 11, 314 bayt

164248894991581511673077637999211259627125600306858995725520485910920851569759793601722945695269172442124287874075294735023125483.....!/:;.........)%'=a':\....................\...................\..................\.................\................\...............\..............\..$@.........\$><>'?2='%.<\:;_;4Q

Çevrimiçi deneyin!

Eski versiyon:

Altıgen , yan uzunluk 11, 330 bayt

362003511553420961423766261426252539048636523959468260999944549820033581478284471415809677091006384959302453627348235790194699306179..../:{;+'=1P'%'a{:..\.....................\...................\..................\.................\................\...............\..............\.............\!$><........\..@>{?2'%<......:;;4Q/

Çevrimiçi deneyin!

Kodlayıcı: Çevrimiçi deneyin!

Program kabaca bu Python koduna eşdeğerdir: Çevrimiçi deneyin!

Katlanmamış kod:

           3 6 2 0 0 3 5 1 1 5 5
          3 4 2 0 9 6 1 4 2 3 7 6
         6 2 6 1 4 2 6 2 5 2 5 3 9
        0 4 8 6 3 6 5 2 3 9 5 9 4 6
       8 2 6 0 9 9 9 9 4 4 5 4 9 8 2
      0 0 3 3 5 8 1 4 7 8 2 8 4 4 7 1
     4 1 5 8 0 9 6 7 7 0 9 1 0 0 6 3 8
    4 9 5 9 3 0 2 4 5 3 6 2 7 3 4 8 2 3
   5 7 9 0 1 9 4 6 9 9 3 0 6 1 7 9 . . .
  . / : { ; + ' = 1 P ' % ' a { : . . \ .
 . . . . . . . . . . . . . . . . . . . . \
  . . . . . . . . . . . . . . . . . . . \ 
   . . . . . . . . . . . . . . . . . . \  
    . . . . . . . . . . . . . . . . . \   
     . . . . . . . . . . . . . . . . \    
      . . . . . . . . . . . . . . . \     
       . . . . . . . . . . . . . . \      
        . . . . . . . . . . . . . \       
         ! $ > < . . . . . . . . \        
          . . @ > { ? 2 ' % < . .         
           . . . . : ; ; 4 Q / .

İki .saniye 1 bit sürer. Diğer tüm karakterler 1 bit ve temel-97 basamak alır.

açıklama

Daha büyük boyut için resimlere tıklayın. Her açıklama kısmı, anlaşılmasına yardımcı olmak için karşılık gelen Python koduna sahiptir.

Veri bölümü

Bunun yerine (ile diğer bazı cevaplar kullanılan kompleks yapının <, "ve bazı diğer şeyler), sadece IP alt yarısında geçmesine izin verin.

Veri

Birincisi, IP çok sayıda numaradan ve no-op's ( .) ve mirrors ( \) 'dan geçer. Her hane hafızadaki sayıya eklenir, dolayısıyla hafıza değeri programın başlangıcındaki sayıya eşittir.

mem = 362003511...99306179

! yazdırır

stdout.write(str(mem))

ve $diğerine atlar >.

Den başlayarak <. Eğer hafıza değeri memyanlış ise ( <= 0yani koşul mem > 0yerine getirilmemişse), programı yazdırmayı yaptık ve çıkmalıyız . IP üst yolu izlerdi.

çıkış

(IP’nin (programı sonlandıran) programa basmadan önce yaklaşık 33 komut alması için dünyayı dolaşmasına izin verin, @çünkü başka bir yere ekleyerek başka ek baytlar alabilirsiniz)

Doğruysa, alt yolu izleriz, birkaç kez yönlendiriliriz ve başka bir koşulluya çarpmadan önce daha fazla komut yürütürüz.

# Python                    # Hexagony
# go to memory cell (a)     # {
a = 2                       # ?2
# go to memory cell (b)     # '
b = mem % a                 # %

Şimdi hafıza şöyle gözüküyor:

mem1

Değer truthy ise:

if b > 0:

aşağıdaki kod yürütülür:

# Python                    # Hexagony
b = ord('Q')                # Q
b = b*10+4                  # 4
# Note: now b == ord('.')+256*3
stdout.write(chr(b%256))    # ;
stdout.write(chr(b%256))    # ;

Ayrıntılı açıklamayı inceleyebilir Q4de MartinEnder en MerhabaDünya Hexagony cevap . Kısacası, bu kod .iki kez yazdırır .

Aslında bunun bir .kez basılmasını planladım . Buraya geldiğimde ( .iki kez yazdırın ) ve uygulayınca, yaklaşık 10 hane kaydedildi.

Sonra,

b = mem // a                # :

İşte beni 14 basamaktan kurtardığını farkettiğim önemli bir gerçek: Başladığınız yerde olmanıza gerek yok.

Ne dediğimi anlamak için, bir BF benzetmesi yapalım. (zaten anladıysanız bunu atlayın)

Kod verilen

while a != 0:
    b, a = a * 2, 0
    a, b = b, 0
    print(a)

aMevcut hücrenin bdeğeri ve doğru hücrenin değeri olacağımızı varsayarsak , bunun BF'ye basit bir çevirisi:

[             # while a != 0:
    [->++<]       # b, a = a * 2, 0
    >[-<+>]       # a, b = b, 0
    <.            # print(a)
]

Ancak, program süresince her zaman aynı konumda olmamız gerekmediğine dikkat edin. aHer yinelemenin başlangıcında ne olduğumuzun değerinin olmasına izin verebiliriz , o zaman şu koda sahibiz:

[             # while a != 0:
    [->++<]       # b, a = a * 2, 0
                  # implicitly let (a) be at the position of (b) now
    .             # print(a)
]

birkaç bayt daha kısa olan

Ayrıca, köşe sarma davranışı aynı zamanda beni \orada bir aynaya sahip olmamdan kurtarıyor - onsuz rakamları sığdıramıyordum ( \kendisi için +2 hane ve eşleştirilmemiş bir .sağa için +2 hane . bayraklar)

(Ayrıntıları:

  • IP sol alt köşeye girip sola
  • Sağ köşeye eğildi, hala baş kaldı
  • Onu \yansıtan bir şeyle karşılaşır , şimdi dik durur
  • Köşeye gidiyor ve tekrar sol alt köşeye çarpıyor

)

(Yukarıdaki mod 2 işleminin değeri) sahte ise (sıfır), o zaman şu yolu izleriz:

# Python                 # Hexagony   # Memory visualization after execution
b = mem // a             # :          # click here
base = ord('a') # 97     # a
y = b % base             # '%
offset = 33              # P1
z = y + offset           # ='+
stdout.write(chr(z))     # ;          # click here
mem = b // base          # {:         # click here

Burada çok ayrıntılı bir şekilde açıklamayacağım, ama ofset aslında tam olarak 33değil, 33mod ile uyumludur 256. Ve chrüstü kapalı % 256.

— user202729
kaynak
3
Dostum, bu çok fazla
— Jo King
26
"Ne dediğimi anlamak için, [BrainFuck] analojisine sahip olalım" de güldüm. Sadece PPCG'de ... :)
— Lynn,
2
Oyuna cevap vermek için cevabın tepesine 3 kez gibi çıktım, sadece çoktan yaptığımı öğrenmek için ...
— NieDzejkob
2
Sayıyı kısaltmaktan yeni alandan faydalanarak 310 bayt
— Jo King
2
308 byte daha fazla yer kaplayarak
— Jo King
46

Vim, 11 bayt

q"iq"qP<Esc>hqP
  • iq"qP<Esc>: Kaydın dışında olması gereken metnin bir kopyasını el ile ekleyin .
  • q"ve hqP: İçini doğrudan adsız ""kayıt defterine kaydedin , böylece orta tarafa yapıştırılabilir. hGereken tek konumlandırma olduğu; Makronun içine koyarsanız, sonuca yapıştırılır.

Düzenle

q"İle kayıt hakkında bir not : İsimsiz kayıt "", komik bir şeydir. Metin orada saklanmadığından, diğerleri gibi gerçek bir kayıt değil. Aslında, başka bir kayıt için bir işaretçi (genellikle "-yeni satır "0içermeyen "1silmeler için, yanklar için veya yeni satır içeren silmeler için). q"kuralları çiğniyor; aslında yazıyor "0. Eğer senin ""zaten dışında bazı kaydına işaret ediyordu "0, q"üzerine yazacaktır "0ama bırakın ""değişmeden. Yeni bir Vim başlattığınızda, ""otomatik olarak işaret eder "0, bu durumda iyi durumdasınız.

Temel olarak, Vim garip ve arabası.

— udioica
kaynak
bekle neden bu işe yaramıyor benim için
— Yok
@DestructibleWatermelon Kesin olarak söyleyemem ama bir açıklama daha muhtemel. Muhtemelen daha önce yazıya yazmalıydı, çünkü insanları fırlatabilirdi. Düzenlemeyi oku.
— udioica
Muhtemelen basmadan yya da koşmadan önce bir şeyin yardımcı olabileceği hakkında bir şeyler koymalısınız
— Yok Edici Limon
Neden ␛<Esc> tuşuna basmayı göstermek için kullanmıyorsunuz ? Bu Unicode
— Bloğun bir
4
@ mbomb007 <Esc>Notasyon Vim mappings ( :help <>) ' de standarttır ve vimgolf.com'un kullandığı şey budur. Herhangi bir deneyimli vimgolfer okumak için kullanılacaktır. Unicode'a gelince, küçük harfleri okumak için kenarları açmalıyım, ve onları yazma ve yardım dosyasını arama yöntemini gizliyorlar.
— udioica
44

Cubix , 20 bayt

3434Qu$v@!<"OOw\o;/"

Neredeyse var \o/ ...

Net :

    3 4
    3 4
Q u $ v @ ! < "
O O w \ o ; / "
    . .
    . .

Çevrimiçi deneyin

Burada dene !

Ek Notlar

Arka plan hikayesi

@ Ais523'ün bu harika cevabını okuduktan çok etkilendikten sonra , daha fazla golf oynamayı düşünmeye başladım. Sonuçta, orada oldukça az sayıda operasyon vardı ve bu çok fazla baskı hissetmiyordu. Bununla birlikte, cevabının (ve benimki) kullandığı teknik, kodun tüm satırlara yayılmasını gerektirdiğinden, en az 12 baytlık bir tasarruf gerekliydi. Açıklamasında beni gerçekten düşündüren bir açıklama vardı:

Bu quine daha fazla golf oynamak konusunda, [...] küpün üst yüzünü temsil etmek için [...] başka bir yola ihtiyaç duyuyordu [...]

Sonra aniden, bir şey içmek için ayağa kalkıp uzaklaştığımda, beni etkiledi: Program karakter kodlarını kullanmazsa, üst yüzünü temsil etmek için rakamları kullanırsa? Bu, yazdırdığımız rakamın 2 rakamı varsa özellikle kısadır. Cubix 3 tek baytlık çift haneli sayılar itmek için talimatlar bulunur: N, Sve Qitme, 10, 32ve 34sırasıyla, bu nedenle bu oldukça Golfy olmalı, diye düşündüm.

Bu fikrin ilk komplikasyonu, üst yüzün artık faydasız sayılarla doludur, bu yüzden artık kullanamayız. İkinci komplikasyon, üst yüzün küp kare kare olan bir boyuta sahip olması ve eşit bir boyuta sahip olması gerektiğidir, aksi halde bir sayı, talimat göstergesinin başlangıç ​​pozisyonunda kirlenmiş bir yığına yol açacaktır. Bu komplikasyonlar nedeniyle kodumun 2 büyüklüğünde bir küpe uyması gerekiyordu (ki bu sadece '24 bayt içerebilir, bu yüzden en az 21 bayt golf oynamak zorunda kaldım). Ayrıca, üst ve alt yüzler kullanılamaz olduğundan, yalnızca 16 etkili baytım vardı.

Bu yüzden üst yüzün yarısı olacak sayıyı seçerek başladım. N(10) ile başladım , fakat her şeyi basmak için kullandığım yaklaşım yüzünden bu pek işe yaramadı. Her iki durumda da, yeniden başladım ve S(32) bir sebepten kullandım. Bu düzgün bir titremeye neden oldu ya da öyle düşündüm. Her şey çok iyi çalıştı, ancak alıntılar eksikti. Sonra, Q(34) ' ün gerçekten yararlı olacağı aklıma geldi . Ne de olsa, 34 çift alıntı karakterinin karakter kodudur, bu da yığında tutmamızı sağlar, (2, daha sonra kullandığım düzende) değerli baytları kaydeder. IP yolunu biraz değiştirdikten sonra, geriye kalan tek şey boşlukları doldurmak için bir egzersizdi.

Nasıl çalışır

Kod 5 bölüme ayrılabilir. Birer birer üstlerinden geçeceğim. Orta yüzleri ters sırayla kodladığımızı unutmayın, çünkü yığın modeli ilk giren ilk çıkar.

Adım 1: Üst yüzü yazdırma

Alakasız talimatlar no-ops ( .) ile değiştirildi. IP, üçüncü çizgiyi solda, doğuya dönük olarak başlatır. Yığın (açık) boş.

    . .
    . .
Q u . . . . . .
O O . . . . . .
    . .
    . .

IP, dördüncü satırdaki en soldaki pozisyonda sona erer ve aynı çizgideki en sağdaki pozisyona dolanır. Gerçekleştirilen talimatlar (kontrol akış karakteri olmadan):

QOO
Q   # Push 34 (double quotes) to the stack
 OO # Output twice as number (the top face)

Yığın yalnızca 34'ü içerir, kaynağın son karakterini temsil eder.

Adım 2: Dördüncü satırı kodlayın

Bu bit, yapmasını beklediğiniz şeyi yapar: dördüncü satırı kodlar. IP, bu satırın sonunda çifte alıntı ile başlar ve indiği her karakterin karakter kodlarını girerek eşleşen bir çifte alıntı bulana kadar batıya gider. Bu eşleşen çift alıntı aynı zamanda dördüncü satırdaki son karakterdir, çünkü IP sol kenara ulaştığında tekrar sarılır.

Etkili bir şekilde, IP bir pozisyonu sola kaydırdı ve yığın şimdi dördüncü satırın karakter kodları ve ters sıra ile temsilini içeriyor.

Adım 3: Başka bir teklif gönder

Başka bir alıntı yapmalıyız Qve programın başlangıcında sağdan geri dönerek geri dönüşümü gerçekleştirmekten daha iyi bir yol var mı? Bu, IP’nin üçüncü satırı kodlayan alıntıya doğrudan girdiği ek bir avantaja sahiptir.

İşte bu adımın net sürümü. Alakasız yapılanmalar tekrar no-op'lar ile değiştirildi, yapılan no-op'lar #gösterim amaçlı olarak hashtag'ler ( ) ile değiştirildi ve IP dördüncü satırdaki son karakterden başlıyor.

    . .
    . .
Q u $ . . . . .
. . w \ . . / .
    . #
    . #

IP, ilk komutta üçüncü satırda biter, çünkü o satırın sonuna kadar sarılır, çünkü batıya yönelir. Aşağıdaki talimatlar (kontrol akışı hariç) hariç tutulmuştur:

$uQ
$u  # Don't do anthing
  Q # Push the double quote

Bu ikili alıntı, üçüncü satırın sonundaki alıntıyı temsil eder.

4. Adım: Üçüncü satırın kodlanması

Bu tamamen 2. adımla aynı şekilde çalışır, bu nedenle lütfen bir açıklama için oraya bakın.

Adım 5: Yığın yazdır

Yığın şimdi dördüncü ve üçüncü satırları ters sırayla içeriyor, bu yüzden şimdi yapmamız gereken tek şey yazdırıyor. IP batıya doğru hareket ederek üçüncü satırdaki sondan komutla başlar. İşte küpün ilgili kısmı (yine alakasız kısımlar no-op'larla değiştirildi).

    . .
    . .
. . . v @ ! < .
. . . \ o ; / .
    . .
    . .

Gördüğünüz / beklediğiniz gibi bu bir döngüdür. Ana yapı:

o;
o  # Print top of stack as character
 ; # Delete top of stack

Döngü, üst öğe 0 ise, ancak yığın boş olduğunda gerçekleşirse biter. Döngü sona ererse, @program biter ve yürütülür.

— Luke
kaynak
Keşke bunu daha fazla
— oylayabilseydim
Ödüller her zaman beklerim ;-)
— Luke
42

Javascript ES6 - 21 bayt

$=_=>`$=${$};$()`;$()

Ben bu quine "Bling Quine" diyorum.

Bazen tarzın golf oynamalısın.

— Mama Eğlence Rulo
kaynak
!$=_=>`!$=${$}()`()2 bayt kurtarır mı ?
— Downgoat
Invalid assignment left hand side. Çalıştığını diliyorum :(
— Mama Fun Roll
1
@ TùxCräftîñg, şablon değişmezlerin etrafındaki parantezleri ortadan kaldırmak yalnızca yerel prototip işlevlerinde çalışır Array.prototype.join.
— Mama Fun Roll
2
Hmm, emin değilim. Bunu bir yıl önce yazdım (o zaman geçerli kabul edildi) ve quine kuralı değişikliklerini çok yakından takip etmiyordum. Ancak, ok işlevini eklemek alertveya console.logsonra ve şablon dizgisini parantez içine almak işe yarar.
— Mama Fun Roll
3
Ayrıca bunu concole'da çalıştırırsanız, bu sitede $ (jQuery işlevi) yazar ve yükseltme işlevi artık çalışmaz. :)
— Steven Palinkas
41

Brainf * ck (755 karakter)

Bu, Erik Bosman (cs.vu.nl'de ejbosman) tarafından geliştirilen bir tekniğe dayanmaktadır. "ESultanik'in Quine!" metin aslında bir uğur olması için gereklidir!

->++>+++>+>+>++>>+>+>+++>>+>+>++>+++>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>++>>>+++>>>>>+++>+>>>>>>>>>>>>>>>>>>>>>>+++>>>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>++>+++>>>+>+>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>+++>+>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>+++>+>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>>+++++++++++++++>+++++++++++++>++++++>+++++++++++++++>++++++++++>+++>+++>++++>++++++++++++++>+++>++++++++++>++++>++++++>++>+++++>+++++++++++++++>++++++++>++++>++++++++++++>+++++++++++++++>>++++>++++++++++++++>+++>+++>++++>++++++>+++>+++++++++>++++>+>++++>++++++++++>++++>++++++++>++>++++++++++>+>+++++++++++++++>+++++++++++++
ESultanik's Quine!
+[[>>+[>]+>+[<]<-]>>[>]<+<+++[<]<<+]>>+[>]+++[++++++++++>++[-<++++++++++++++++>]<.<-<]
— ESultanik
kaynak
13
Bunu yapmanın akıllıca bir yolu.
— Peter Olson
13
O nasıl çalışır?
— Gurur haskeller 13:14
3
@ proudhaskeller IIRC, önceki bölüm ESultanik's Quine!, belleği ESultanik's Quine!her karakter için iki bayt bellek ile kodlayan ve ileriye doğru bir yığın olarak ayarlar (ASCII değeri 0x1F'den kayıyor ). Son kod biti hafızaya girer, önce ++>+++…her karakter için kodları programlı olarak yeniden üretir , sonra karakterleri yazdırır.
— ESultanik
4
@CatsAreFluffy Onlar bir quine olması için gerekli! Bunların kaldırılabileceği doğru olsa da, bir kişinin de quine özelliğini korumak için önceki kodu değiştirmesi gerekir.
— ESultanik
1
Bu doğru. Ayrıca yeni hatlar gereklidir.
— Hesap MakinesiFeline
36

Altıgen , yan uzunluk 15 14 13 12, 616 533 456 383 bayt

Birkaç gün dikkatlice golf oynadıktan sonra, halkaları yeniden düzenleyerek ve baştan başladıktan sonra nihayet 12 yan altı köşeye indirmeyi başardım.

1845711724004994017660745324800783542810548755533855003470320302321248615173041097895645488030498537186418612923408209003405383437728326777573965676397524751468186829816614632962096935858"">./<$;-<.....>,.........==.........<"......."">'....>+'\.>.........==........<"......"">:>)<$=<..>..............$..<"...."">\'Q4;="/@>...............<"....."">P='%<.>.............<"..!'<.\=6,'/>

Çevrimiçi deneyin!

Kırımsız:

            1 8 4 5 7 1 1 7 2 4 0 0
           4 9 9 4 0 1 7 6 6 0 7 4 5
          3 2 4 8 0 0 7 8 3 5 4 2 8 1
         0 5 4 8 7 5 5 5 3 3 8 5 5 0 0
        3 4 7 0 3 2 0 3 0 2 3 2 1 2 4 8
       6 1 5 1 7 3 0 4 1 0 9 7 8 9 5 6 4
      5 4 8 8 0 3 0 4 9 8 5 3 7 1 8 6 4 1
     8 6 1 2 9 2 3 4 0 8 2 0 9 0 0 3 4 0 5
    3 8 3 4 3 7 7 2 8 3 2 6 7 7 7 5 7 3 9 6
   5 6 7 6 3 9 7 5 2 4 7 5 1 4 6 8 1 8 6 8 2
  9 8 1 6 6 1 4 6 3 2 9 6 2 0 9 6 9 3 5 8 5 8
 " " > . / < $ ; - < . . . . . > , . . . . . .
  . . . = = . . . . . . . . . < " . . . . . .
   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .
      . . . . . . . . . $ . . < " . . . .
       " " > \ ' Q 4 ; = " / @ > . . . .
        . . . . . . . . . . . < " . . .
         . . " " > P = ' % < . > . . .
          . . . . . . . . . . < " . .
           ! ' < . \ = 6 , ' / > . .
            . . . . . . . . . . . .

En çok kullanılan Hexagony koduna benzemese de, kullandığım kodlama türü daha uzun süreli çalışmamalar için optimize edilmiştir, bu da başka türlü kaçınmanız gereken bir şeydir.

açıklama

Bu , no- op'ları ( .) farklı bir şekilde kodlayarak önceki Hexagony yanıtını yener . Bu cevap, diğer her karakteri bir a yaparak yer tasarrufu sağlarken ., benimki no-ops sayısını kodlar . Ayrıca, kaynağın bu kadar kısıtlanması gerekmediği anlamına gelir.

Burada (aralık 32 temsil 16'dan düşük sayılar 16 ve 79 arasında hiçbir-ops ishal, ve sayıları belirtmek bir taban 80 kodlamasını kullanan !95 (kadar) _) (Sadece buna bütün golfed fark ediyorum _dışına s benim kod lol). Bazı Pythonic sözde kodu:

i = absurdly long number
print(i)
base = 80
n = i%base
while n:
    if n < 16:
        print("."*(16-n))
    else:
        print(ASCII(n+16))
    i = i//base
    n = i%base

Numara, altıgenin ilk yarısında tüm kodlarla kodlanmıştır. 

" " > 
 " " > 
  ... etc

sol tarafta ve

 > ,
< "
 >
< "
... etc

Sağ tarafta, numarayı bir hücreye kodlamak için işaretçiyi yeniden yönlendirin. Bu Martin Ender'in cevabından alınmıştır (teşekkürler), çünkü daha verimli bir yol bulamadım.

Daha sonra alt bölümden şöyle girer ->:

       " " > \ ' Q 4 ; = " / @ > . . . .
        . . . . . . . . . . . < " . . .
         . . " " > P = ' % < . > . . .
          . . . . . . . . . . < " . .
     ->    ! ' < . \ = 6 , ' / > . .

!Numarayı yazdırır ve 'döngüye başlamadan önce doğru bellek hücresine gider. P='%geçerli sayıyı 80'e göre modlar. Sonuç 0 ise, sonlandırmaya kadar gider @, aksi halde aşağı iner ve mod sonucunun yanında bir değer oluşturun -16.

   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .
      . . . . . . . . . $ . . < " . . . .
       " " > \ ' Q 4 ; = " / @ > . . . .
                      /
                     /

Hücreyi (mod değeri + -16) olarak ayarlayın. Bu değer negatifse, dallanmada yukarı çık >+'\, aksi takdirde aşağı in.

Eğer değer pozitifse:

 " " > . / < $ ; - < . . . . . > , . . . . . .
  . . . = = . . . . . . . . . < " . . . . . .
   . " " > ' . . . . > + ' \ . > . . . . . .

İşaretçi ;-<, hücreyi ayarlayanda sona erer (mod değeri - -16) ve yazdırın.

Değer negatif:

   . " " > ' . . . . > + ' \ . > . . . . . .
    . . . = = . . . . . . . . < " . . . . .
     . " " > : > ) < $ = < . . > . . . . .

> ) <Döngüyü başlatan bölüme gidin . İşte yalıtılmış:

     . . > ) < $ = < . .
      . . . . . . . . .
       \ ' Q 4 ; = " /

Bu, 'Q4;="=basılan kodu çalıştırır .(tekrar karakterlerin harf-sayı kombinasyonlarını bulmak için bir program yazan Martin Ender'e teşekkürler ) ve başlangıç ​​hücresine geri döner. Daha sonra )mod değeri hücresini arttırır ( ) ve mod değeri pozitif olana kadar tekrar döngüler.

Bu yapıldığında, yukarı hareket eder ve aşağıdaki bölümdeki diğer bölüme katılır:

 " " > . / < $ ; - < . . .
            \
             \

İşaretçi daha sonra tekrar büyük döngünün başlangıcına geri gider

 " " > . / <--
  . . . = =
   . " " > ' 
    . . . = = 
     . " " > :
      . . . . .
       " " > \ ' . .
        . . . . . . .
         . . " " > P = ' % < . > . . .

Bu ='=:', geçerli sayıyı 80'e bölen yürütür ve doğru hücreye gider.

Eski versiyon (Yan uzunluk 13)

343492224739614249922260393321622160373961419962223434213460086222642247615159528192623434203460066247203920342162343419346017616112622045226041621962343418346002622192616220391962343417346001406218603959366061583947623434"">/':=<$;'<.....>(......................<"......"">....'...>=\..>.....................<"....."">....>)<.-...>...........==......<"...."">.."...'.../>.................<"..."">\Q4;3=/.@.>...............<".."".>c)='%<..>..!'<.\1*='/.\""

Çevrimiçi deneyin!

Kesinlikle başka bir yan uzunluğu ile golf oynayabilirim, ancak yarına kadar bırakmam gerekecek çünkü geç oluyor. Sabırsız olduğum ortaya çıktı ve yarına kadar bekleyemem. Belki başka bir taraf golf olabilir? :( ahhhhhhhhh ben yaptım!

Hatta bir baz 77 kodlamasıyla birkaç tane ekstra rakam bile yazdım , fakat aynı bytecount değerine sahip olduğu için farketmez.

— Jo King
kaynak
13
Bu harika. Bu hibrit koşu uzunluğu kodlaması için fikir gerçekten temiz. :) Eğer unutursam size bir ödül vermemi hatırlat.
— Martin Ender,
35

PostScript, 20 karakter

Kısa ve okunaklı. Sondaki yeni satır dahil 20 karakter.

(dup == =)
dup == =
— KirarinSnow
kaynak
33

Cubix , 45 bayt

.....>...R$R....W..^".<R.!'.\)!'"R@>>o;?/o'u"

Bu kodu burada test edebilirsiniz .

Bu programı takip etmek oldukça zordur, ancak bunu yapma şansına sahip olmak için, Cubix tercümanının yaptığı gibi onu bir küpü genişleterek başlamamız gerekir:

      . . .
      . . >
      . . .
R $ R . . . . W . . ^ "
. < R . ! ' . \ ) ! ' "
R @ > > o ; ? / o ' u "
      . . .
      . . .
      . . .

Bu, dize değişmezlerinin çalıştırılabilir kodu "sarması" yapmak için sarmadan yararlanarak çalışan bir Befunge tarzı quinedir (yalnızca tek bir "işaretle, kod aynı anda hem içinde hem de dışındadır; doğrusal olmayan ve düzlemsel olmayan programlar). Bunun, uygun bir quin tanımımıza uygun olduğuna dikkat edin, çünkü çift tırnaktan ikisi kendilerini kodlamaz, ancak daha sonra aritmetik kullanımıyla hesaplanır.

Befunge'nin aksine, biz burada bir tane yerine dört karakter kullanıyoruz. İşte yığına itilmeleri;

  1. Program sol kenarın üstünden başlayarak sağa doğru ilerler; iki kez sağa döner ( R), tüm küpün etrafına dolanan çizgilerin üçüncü ve sonunda sola doğru ilerler. Çifte alıntı kendisi ile eşleşir, bu yüzden üçüncü satırın tamamını yığının üzerine geriye doğru iteriz. Ardından çift tekliften sonra işlem devam eder.

  2. uKomut sağa U dönüşü yapar, bu yüzden koşuyoruz sonraki şey dan '"itibaren orta hatta. Bu bir "yığına iter . Etrafı sarmaya devam ederek <, küpün sol tarafına doğru çarptık ve geri döndük. Bu yönden yaklaşırken, düz bir "komut görüyoruz '", öyle değil , böylece ikinci satırın tümü yığının üzerine üçüncü satırın ve çift alıntıların üzerinde geriye doğru itiliyor.

  3. !Yığını ( '!) iterek ve onu artırarak ( )); Bu, kaynak kodumuzda (dizgeyi sonlandıracak olan) çift bir alıntı yapmaya gerek kalmadan çift alıntı yapar. Bir ayna ( \), yürütme yönünü kuzeye doğru yansıtır; daha sonra Wkomut sola döner. Bu bizi yedinci sütunda yukarı doğru çıkarır, bu bir küp olduğu için üçüncü sırada sola, sonra üçüncü sütunda aşağıya doğru sarılır. Biz bir hit R, sağa dönün ve üst satır boyunca sola doğru gitmek; daha sonra programa girdiğimiz yolu $atlar R, bu nedenle yürütme "satırın sonuna kadar kaydırılır ve ilk satırı ikinci ve üçüncü için yaptığımız gibi bir dizgede yakalarız.

  4. ^Komut güneye beşte (küp sarma izin veren) olduğu on birinci kolonda kadar kuzeye bizi gönderir. Orada karşılaştığımız tek şey !(sıfır değilse atla; yığının üstü sıfır değil) okomutun üzerinden atlayarak beşinci sütunu tamamen boşaltır. Böylece bir ukez daha U dönüşü yapan komuta geri dönüyoruz , ancak bu kez güneyde son sütunda kaldık, bu da dördüncü sütunda kuzeye sarar. Yine de U dönüşü sırasında çift bir teklife çarptık, bu yüzden dördüncü sütunun tamamını bir dize halinde aşağıdan yukarıya doğru yakaladık. Programdaki çoğu çift alıntıdan farklı olarak, bu durum kendisini kapatmaz; aksine, "sağ üst köşede kapalıdır , yani dokuz karakterli dizgiyi yakalayacağız ...>......

Öyleyse, yığın düzeni şimdi yukarıdan aşağıya doğrudur: dördüncü sütun; üst sıra; "; orta sıra; "; alt satır. Bunların her biri, yığının tepesine en yakın ilk karaktere sahip yığın üzerinde temsil edilir (Cubix, dizeleri Befunge'nin yaptığı gibi, bu sıranın tersine iter, ancak IP her zaman doğal okuma yönüne zıt yönde hareket ettiğinde, bu yüzden iki kez etkili bir şekilde tersine döndü. Yığın içeriğinin orijinal programla neredeyse aynı olduğu not edilebilir (çünkü dördüncü sütun ve küpün kuzey / üst yüzü aynı sırada aynı karakterleri içerir; açık bir şekilde kasıtlı olarak tasarlandı).

Bir sonraki adım, yığının içeriğini yazdırmaktır. Tüm baskılardan sonra IP, dördüncü sütunda kuzeye doğru gidiyor, bu yüzden >oraya çarpıyor ve sıkı bir döngüye giriyor >>o;?(yani "doğuya dön, doğuya dön, karakter olarak çıktı, pop, olumlu olursa sağa dön"). Yedinci satır NOP'lerle dolu olduğu için ilke ?geri dönecek >, bu yüzden yığının tüm içeriğini etkin bir şekilde itecektir ( ?boş bir yığında çalışmaz). Neredeyse tüm programı yazdırdık! Ne yazık ki, henüz tam olarak yapılmadı; sonunda çift alıntı kaçırıyoruz.

Döngü sona erdiğinde, bir çift ayna aracılığıyla batıya doğru hareket ederek merkezi çizgiye yansıtırız. ( \Aynanın daha önce "diğer tarafını" kullandık ; şimdi güneybatı tarafını kullanıyoruz. /Ayna daha önce kullanılmadı.) Karşılaştık '!, bu yüzden bir ünlem işareti ittik (yani 33; ASCII kullanıyoruz) ve Cubix, tamsayılar ve karakterleri) yığında ayırmaz. (Uygun bir şekilde, bu daha önce komutu !atlamak için kullanılanla aynıdır o.) Bir çift Rkomutla karşılaşırız ve bunları "manuel" U dönüşü yapmak için kullanırız ( Rburada ikinci komut ilkine ulaşmak için daha önce kullanıldı) satır, Ryanına başka bir komuta uyması çok doğal görünüyordu .Wkomutunu sola kaydırmak için. Sidestep >, ikinci satırdaki komuta düştü ve infaz tam olarak bulunduğu yere geri döndü. Bu yüzden tekrar sola gidiyoruz, ama bu sefer güneye doğru gidiyoruz, bu nedenle bir sonraki komut )(ünlem işareti ikiye katlanarak), ardından o(çıktısını almak için). Son olarak, yürütme sekizinci satır boyunca ikinci sütuna sarılır ve burada @programdan çıkmak için a bulunur .

Üçüncü satırdaki başıboş kesme işareti için özür dilerim. Programın bu sürümünde hiçbir şey yapmaz; bu benim daha önceki bir fikrimin bir parçasıydı, ama bunun gerekli olmadığı ortaya çıktı. Ancak, bir kez çalışacak bir terzi aldığımda, sadece onu bayt sayısını değiştirmeyeceği için, onunla uğraşmak yerine göndermek istedim. Bu quine daha fazla golf oynamak konusunda, eğer bu ilk 3 çizgiyi kullanarak 3 x 3'te mümkün olsaydı beni şaşırtmazdı, ama bunu yapmanın bariz bir yolunu göremiyorum ve ihtiyaç duyuyordu. Küpün üst yüzünü temsil etmek için tüm kontrol akışının daha sıkı bir şekilde paketlenmesi bile (veya algoritmayı değiştirerek, on veya on karakter uzunluğunda olmasına rağmen dördüncü sütunu kullanmaya devam edebilmesi için) .

Güzel iş, bu gerçekten etkileyici bir puan. Üst yüzü nasıl kodladığını seviyorum. :)
— Martin Ender
Bu sadece inanılmaz! Herhangi bir yardımı olursa, itmek "için başka bir yoldur Q.
— ETH Sunumları
1
Vaov! Asla bir cubix quine görsem bile!
— FlipTack
3
Açıklamayı dün okumak için zamanım yoktu, ama şimdi elimde ... Sadece ... WOW. İki ya da üç tamamen farklı amaç için kaç karakter kullanıldığına inanamıyorum. Bu muhtemelen şimdiye kadar gördüğüm en havalı Cubix programı.
— ETHProductions,
İyi açıklama.
— Robert Fraser,
33

Python 2,30 bayt

_='_=%r;print _%%_';print _%_

Buradan alındı

— hallvabo
kaynak
1
+1, benzer çözümümü yendin, ben de sildim. Bunun sadece Python 2'de çalıştığı unutulmamalıdır.
— nyuszika7h
2
Değişken adıyla garip görünüyor _, ancak herhangi bir harfe s='s=%r;print s%%s';print s%s
— atadıysanız
5
Eğer bu çözüm sizin yaratıcılığınız değilse, Topluluk Wiki'sini oluşturmalısınız. Ayrıca, bağlantı öldü.
— mbomb007
1
Partiye biraz geç kaldım, ancak biri bunun nasıl çalıştığını açıklayabilir mi?
— MadTux
9
Bunun için geçerli bir satır beslemesi geçerli. Olduğu gibi, kaynak kodu çıktıyla eşleşmiyor.
— Dennis
32

Vim, 17 , 14 tuş vuruşlarını

Birisi rastgele bunu oyladı, ben de var olduğunu hatırladım. Tekrar okuduğumda, "Hey, bundan daha iyisini yapabilirim!" Diye düşündüm, bu yüzden iki baytlık golf yaptım. Hala en kısa değil, ama en azından bir gelişme.

Uzun zamandır, vim quine mümkün olup olmadığını merak ediyorum. Bir yandan, vim tamamen döndüğü için mümkün olmalıdır. Fakat çok uzun bir süre bir vim quine aradıktan sonra bir tane bulamadım. Ben did bulmak bu PPCG meydan , ancak tam olarak yaklaşık edebi quines kapalı ve değil. Bu yüzden bir tane bulamadım çünkü bir tane bulamadım.

Çünkü iki, bu cevabın gerçekten gurur duyuyorum ilklerin :

  1. Bu yaptığım ilk quine ve

  2. Bildiğim kadarıyla, bu dünyanın şimdiye kadar yayımlanan ilk vim-quine ! Bu konuda yanılmış olabilirim, eğer birini biliyorsanız, lütfen bana bildirin.

Yani, bu uzun girişten sonra, işte burada:

qqX"qpAq@q<esc>q@q

Çevrimiçi deneyin!

Bunu yazdığınızda, <esc>tuş vuruşu olarak görüntüleneceğini unutmayın ^[. Bu oldu, hala doğru ^[temsil 0x1Bkaçmak olan ASCII ve yolu vim içten temsil <esc>anahtarı.

Ayrıca , mevcut bir vim oturumu yüklerseniz bunun test edilmesinin başarısız olabileceğini unutmayın. Daha fazla bilgi edinmek istiyorsanız , burada açıklamayı içeren bir ipucu cevap yazdım ;

vim -u NONE -N -i NONE

veyaqqq bunu çalıştırmadan önce yazın .

Açıklama:

qq                  " Start recording into register 'q'
  X                 " Delete one character before the cursor (Once we play this back, it will delete the '@')
   "qp              " Paste register 'q'
      Aq@q<esc>     " Append 'q@q' to this line
               q    " Stop recording
                @q  " Playback register 'q'

Bir yandan, bu cevap muhtemelen bir PPCG cevabında ya da başka bir şeydeki çoğu q için bir dünya rekoru.

— DJMcMayhem
kaynak
1
2i2i<esc>çok yakın. Bu işi yapmak için yapabileceğim bir şey olması gerektiğini düşünüyorum.
— Zwei
@zwei biliyorum, acıtıyor! Aslında, <Esc>V'de örtüktür, böylece çalışır . Maalesef ayrıca yeni bir satır ekliyor, bu yüzden henüz göndermedim.
— DJMcMayhem
q"iq"qbP<Esc>qbP11. Bunu reddit üzerine koyduktan sonra , buradaki vimgolfing'i araştırdım ve hesap oluşturmaya karar verdim. Oraya gönderdiğim cevap bu.
— udioica
2
@udioica Bunu bir cevap olarak gönderebilir misiniz?
— DJMcMayhem
28

Kayıp , 120 116 98 96 76 70 66 bayt

Düzenleme: yay, 100 yaş altı

Düzenleme: Tüm /satırlara geçmek için alt satırda bir demet o 'bayt kaydedildi

:2+52*95*2+>::1?:[:[[[[@^%?>([ "
////////////////////////////////

Çevrimiçi deneyin! + doğrulama tüm olası durumlar için belirleyicidir

Kayıp, başlangıç ​​konumu ve yönünün tamamen rastgele olduğu 2B bir dildir. Bu, doğru talimat göstergesine sahip olduğunuzdan emin olmak için her aşamada çok fazla hata kontrolünün yapılması gerektiği ve rastgele dolaşan bir şey olmadığı anlamına gelir.

Açıklama:

/Alt satırdaki tüm ler, dikey yönde veya alt satırda oluşan tüm işaretçilerin doğru yönde hizalandığından emin olmak için vardır. Oradan, birkaç farklı yerde son buluyorlar, fakat hepsi doğrudan doğruya gidiyorlar

 ^%?>
 ////

Yığındaki sıfır olmayan tüm sayıları temizler. Bundan ([sonra fazladan 0'lar da yok olur.

Açıklığın ortasında %, 'güvenliği' devre dışı bırakarak, programın vurduğunda bitmesine izin verir @(bu olmadan, bir işaretçi başlarsa program derhal sona erebilir @).

Oradan oldukça basit bir 2B dil quine yapar, "ilk satırın etrafına bir dizgiyi ( ) sararak , "bir boşluk ( :2+) ve ardından bir newline ( 52*) yaparak bir karakteri iterek . İkinci satır için, bir /karakter ( 95*2+) yaratır ve >::1?:[:[[[[sonunda bitmeden @ve yığını tam olarak basmadan önce bir demet ( ) çoğaltır . ?1İşaretçi erken girerse, daha sonra bunları temizlemek zorunda tasarruf, çok fazla tane 0 oluşturmasını sürecini durdurmak.

Son satırı tamamen aynı karakter yaparak 20 baytı kurtardım, yani doğrudan duping sürecinden sonuna kadar gidebilirim @.

Duping işlemi hakkında açıklama:

['Kapı' olarak bilinen bir karakterdir. İşaretçi a [veya a'nın düz tarafına çarparsa, ]yansıtır, aksi takdirde içinden geçer. İşaretçi bir Kapı ile her etkileşimde bulunduğunda, karşı tipe geçer. Bu bilgiyi kullanarak bir komutun bir komutta kaç kez uygulayacağı için basit bir formül oluşturabiliriz >:[.

İlk talimat miktarını ekleyin. Her biri [için soldaki talimat miktarının 2 katını ekleyin. Örneğin, >::::[:[[[ilk miktar olarak 5 ile başlıyoruz. İlk Kapının 4 dupe talimatı vardır, bu yüzden 13'ü almak için 4 * 2 = 8 - 5 ekleriz. Diğer üç Kapının solunda 5 çift vardır, bu yüzden 3 almak için 3 * (5 * 2) = 30 - 13 ekleriz. dupe talimatları gerçekleştirildi ve >yığında 44 saniye var. Aynı işlem (, yığıntan kapsamı içine büyük miktarda madde itmek veya yığıntan öğeleri temizlemek için burada kullanıldığı gibi diğer talimatlara da uygulanabilir .

Burada çok fazla 0'ını önlemek için kullandığım bir numara 1?. Karakter 0 ise, ?1'i atlamaz, bu da dupe'nin kalanı için 1'i kopyaladığı anlamına gelir. Bu daha sonra yığını temizlemeyi çok kolaylaştırır.

— Jo King
kaynak
25

Bu iki kısa olan Ruby quines SO :

_="_=%p;puts _%%_";puts _%_

ve

puts <<2*2,2
puts <<2*2,2
2

Bana ikinci nasıl çalıştığını sorma.

— Nakilon
kaynak
8
İkincisi, heredoc'u kullanır, <<2bir sonraki satırda bir dize başlatır ve *2tekrar eder
— Ming-Tang
Neden 2'ye ihtiyacınız var?
— CalculatorFeline
1
@CalculatorFeline Heredoc dizesinin sonlandırıcısıdır (kendi satırında görünmesi gerekir). Gerçekte 2 olması gerekmiyor: tio.run/##KypNqvz/v6C0pFjBxsZAy0jHgAuFY8D1/z8A
— Martin Ender
25

Fisyon , 6 bayt

Görünüşe göre bu şimdi bu cevaplar arasında en kısa "uygun" quine. 

'!+OR"

açıklama

Kontrol akışı, Rtek bir sağa giden (1,0)atomla başlar. "Baskı modunu değiştirir ve daha sonra tekrar basar ve baskı modundan çıkmadan '!+ORönce "baskı yapar.

Bu, "kendisini yazdırılacak şekilde bırakır . En kısa yoludur '"O(burada '"karakter koduna atomun kütlesini belirler "ve Okarakterini yazdırır ve atom tahrip), fakat yaptığımız bu "baskı modunda müdahale ederim. Bunun yerine biz atomun değeri '!(daha az birinden "), sonra birlikte artırır +ve daha sonra birlikte sonucu yazdırmak O.

Alternatifler

İşte size daha uzun olan birkaç alternatif var, ama belki de teknikleri birisine onları kullanarak daha kısa bir versiyon bulmaları için ilham veriyor (ya da bazı genelleştirilmiş sınavlarda daha yararlı olurlar).

8 bayt Jump kullanarak

' |R@JO"

Yine, kod başlar R. @Takasları kütle ve enerji vermek (0,1). Bu nedenle Jatom, Odüz üzerinden üstüne atlar ". Sonra, daha önce olduğu gibi, tümü "dize modunda yazdırılır. Daha sonra, atom |yönünü tersine çevirmek için vurur ve sonra '"Obaskıdan geçer ". Boşluk biraz can sıkıcı, ama gerekli görünüyor, çünkü aksi takdirde 'atomu |ayna yerine bir karakter gibi ele alacaktı .

İki atom kullanan 8 bayt

"'L;R@JO

Bu sol gidiş başlayarak iki atomu vardır Lve sağ-gidiş R. Sola dönen atom, değerinin ayarlandığı değeri alır ve '"derhal yazdırılır O(ve atom yok edilir). Doğru atom için, kütle ve enerjiyi tekrar değiştiririz O, kodun geri kalanını baskı modunda basmak için üstünden atlarız. Daha sonra değeri ayarlanır, 'Lancak fark etmez, çünkü atom daha sonra atılır ;.

— Martin Ender
kaynak
Kaynaktaki kod / veri ayrımı eksikliği nedeniyle teknik olarak geçersiz.
— Hesap MakinesiFeline
4
@CalculatorFeline '!+kodlar ".
— Martin Ender
Fission hakkında bilgim yok ama |R@JO"'çalışacak 'mıydı yoksa hala o alana mı ihtiyacınız var ?
— MildlyMilquetoast
1
@MistahFiggins Öyle düşünüyorum, ama daha da önemlisi 'ilk sen basacaksın .
— Martin Ender
24

Tarayıcılar arası JavaScript (41 karakter)

En iyi 5 web tarayıcısında çalışır (IE> = 8, Mozilla Firefox, Google Chrome, Safari, Opera). Bunlardan herhangi birinde geliştiricinin konsoluna girin:

eval(I="'eval(I='+JSON.stringify(I)+')'")

Bu, "hile yapmak" değildir - Chris Jester-Young'ın tek baytlık quine'inden farklı olarak, alert()işlevi kullanmak için kolayca değiştirilebilir (14 karaktere mal olur):

alert(eval(I="'alert(eval(I='+JSON.stringify(I)+'))'"))

Veya bir bookmark'a dönüştürülür (22 karaktere mal olur):

javascript:eval(I="'javascript:eval(I='+JSON.stringify(I)+')'")
— Lütfen ayakta dur
kaynak
24

C, 64 60 bayt

main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}

Şimdiye kadar, bu bilinen en kısa C quine. Daha kısa bir tane bulursanız uzatılmış bir ödül vardır .

Bu çalışır GCC , Clang ve TTK bir de POSIX ortamında. Hepsiyle aşırı miktarda tanımsız davranışa neden olur.

Sadece eğlence için, işte bildiğim tüm C sorgularını içeren bir depo . Mevcut olanlar üzerinde yeni ve yaratıcı bir şeyler ekleyen farklı bir tane bulursanız ya da yazarsanız çatal / PR çekinmeyin.

Yalnızca bir ASCII ortamında çalıştığını unutmayın . Bu EBCDIC için çalışıyor ancak yine de POSIX gerektiriyor . Yine de bir POSIX / EBCDIC ortamı bulmada iyi şanslar: P

Nasıl çalışır:

  1. main(s)kötüye kullanılanların mainargümanlarını, neredeyse yazılmamış bir değişken olarak bildirir s. ( sAslında yazılmamış olduğunu unutmayın , ancak listelenen derleyiciler onu gerektiği gibi otomatik yayınladığından * olabilir.)
  2. printf(s="..."ssağlanan dizeye ayarlar ve ilk argümana geçer printf.
  3. sayarlandı main(s){printf(s=%c%s%1$c,34,s);}.
  4. %cASCII olarak ayarlanır 34, ". Bu, çeki mümkün kılar. Şimdi sşuna benzer:
    main(s){printf(s="%s%1$c,34,s);}.
  5. %sAyarlandığında snedeniyle 2. mümkün olan kendisi. Şimdi sşuna benzer:
    main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}%1$c,34,s);}.
  6. %1$cASCII 34 olarak ayarlanır ", printfbirinci ** argüman 's. Şimdi sşuna benziyor:
    main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}
    ... orijinal kaynak kodu da öyle.

* Örnek sayesinde @Pavel için
biçim belirteci sonra ** İlk argüman - bu durumda, s. Format belirticisine başvuru yapmak imkansız.

Aynı yaklaşımla bunun daha da kısa sürmesi imkansız. Eğer printfbireyin biçim belirteci erişilebilir aracılığıyla oldu $, bu 52 byte için de kullanılabilir:

main(){printf("main(){printf(%c%0$s%1$c,34);}",34);}
— MD XF
kaynak
Her ne kadar kesinlikle rakip olarak sayılmasa da, 1994 Uluslararası Gizli Kodlu C Kod Yarışması, 1994_smr.c'den "Kuralların en kötü şekilde kötüye kullanılması" nın kazananı kesinlikle daha kısa.
— Ray
@Ray Buna izin verilmiyor. Herhangi bir tanım gereği uygun bir titiz değildir. Bu program nedeniyle quien kuralları değiştirildi: P
— MD XF
Tamamen aynı fikirdeyim, ancak herhangi birinin tarihi sebeplerden dolayı biliniyorsa, bilinen en küçük bir quine bahsettiği zamandan bahsetmeye değer, yeterince ilginç bir saldırı.
— Ray
4
stüründe int"yazılmamış bir değişken" değil.
— feersum
2
Bu derleyicilerin tümü görünüşte bir işaretçinin int'ye dönüştürülmesine izin verir. s=3Açıkçası işe yaramazdı çünkü ipi iki kere geçirmeniz gerekiyor printf.
— feersum
24

Java, 528 bayt:

Orijinal bir yaklaşıma sahip bir Java çözümü:

import java.math.*;class a{public static void main(String[]a){BigInteger b=new BigInteger("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp",36);int i=0;for(byte c:b.toByteArray()){if(++i==92)System.out.print(b.toString(36));System.out.print((char)c);}}}

okunabilir biçimde:

import java.math.*;
class a
{
    public static void main (String [] a)
    {
        BigInteger b=new BigInteger ("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp", 36); 
        int i=0; 
        for (byte c:b.toByteArray ())
        {
            if (++i==92) 
                System.out.print (b.toString (36)); 
            System.out.print ((char) c);
        }
    }
}
— bilinmeyen kullanıcı
kaynak
O nasıl çalışır?
— Loovjo
1
@Loovjo: Kodu iki parçaya bölen ve kodun tekrar yerine geçen tüm dizeyi ekleyen diğer çözümlere benzer, ancak tüm kod yalnızca bir Dize değil, temel 36'daki uzun sayı olarak kodlanmış (26 alfabetik karakter + 10) basamak).
— kullanıcı bilinmeyen
1
Eğer istersen bu kısaltılabilir if(++i==92),
— tuskiomi
2
@tuskiomi: Teşekkürler, iki karakter kısaltıldı
— kullanıcı bilinmeyen
1
@ userunknown Aslında, a*dizi Java'dan çıkmadığından , bu C'dir. Golfün diğer bölümleri: Yeni hesaplanan sihirli sayı String ( import java.math.*;class a{public static void main(String[]a){BigInteger b=new BigInteger("abc",36);int i=0;for(int c:b.toByteArray())System.out.printf("%s%c",++i==92?b.toString(36):"",c);}}nerede) abc. Java olarak 8+ değişmek da mümkündür class a{public static void mainetmek interface a{static void mainve Java 10+ o değiştirmek mümkündür import java.math.*;ve BigInteger b=new BigInteger(hiç var b=new java.math.BigInteger(.
— Kevin Cruijssen
23

Tavuk , 7

chicken

Hayır, bu doğrudan yankılanmıyor :)

— Timtech
kaynak
Kahretsin, beni yendin :)
— Taconut
Yankılı değil, dize chicken!
— Outgolfer Erik, 28:16
Kod / veri ayrımı yok ve bu nedenle geçersiz.
— Hesap MakinesiFeline
10
@CalculatorFeline Kuralları okudun mu?
— Timtech
1
@JoKing Bunun geçersiz olduğunu sanmıyorum, çünkü meydan okuma kuralları yalnızca sıfır uzunluktaki hileleri yasaklıyor (kendi kaynak dosyanızı okuyarak) sorgulanıyor. Uygun olmayan sorguları yasaklayan tek şey standart bir boşluktur - standart boşluklar hariç, genellikle onları yönlendiren cevaplar için geçerli değildir.
— pppery
23

Retina , 20 14 9 7 bayt

Başlamadan önce, tek içeren bir dosyanın önemsiz çözümünden bahsetmek istiyorum 0. Bu durumda Retina saymaya çalışacak0 boş girdideki s , bunun sonucu da aynı olacaktır 0. Buna rağmen uygun bir titreyim düşünmezdim.

Yani burada uygun bir tane:

>\`
>\`

Çevrimiçi deneyin!

Alternatif olarak, ;yerine> .

açıklama

Program iki kez yazdırdığımız tek bir bölümden oluşuyor.

İlk satırda, `yapılandırmayı regex'ten ayırır, böylece regex boştur. Bu nedenle, boş dize (yani varolmayan girdi) ikinci satır ile değiştirilir.

Sonucu iki kez yazdırmak için iki çıkış aşamasına sarıyoruz. İçteki \, sonucu takip eden bir satır besleme ile yazdırır ve dıştaki sonuç bir >olmadan yazdırır.

Retina'yı biraz tanıyorsanız, Retina'nın gizli çıktısına ne olduğunu merak ediyor olabilirsiniz. Retina'nın örtük çıktıları, bir programın son aşamasını bir çıktı aşamasına sararak çalışır. Ancak, eğer son aşama zaten bir çıktı aşamasıysa, Retina bunu yapmaz. Bunun nedeni, normal bir programda, örtük çıktı aşamasını özel bir \ya da ;tek bir bayt ile değiştirebilmenin (örtük olandan .bayrakla da kurtulmak yerine) değiştirilmesinin daha faydalı olmasıdır . Ne yazık ki, bu davranış bize quine için iki bayta mal oluyor.

— Martin Ender
kaynak
20

Javascript (36 karakter)

(function a(){alert("("+a+")()")})()

Bu, AFAICT, şimdiye kadar yayınlanan en kısa javascript quine.

— Peter Olson
kaynak
1
Bu etkileyici. Benim için nasıl çalıştığını açıklamalısın 8- |
— TehShrike
3
@TehShrike İpucu: İçeriği bir dizeye zorlayarak bir işlevi görüntüleyebilirsiniz. Örneğin, bir işleviniz avarsa, içeriğini arayarak erişebilirsiniz a.toString.
— Peter Olson
7
Bununla birlikte, bilgili olmak gerekirse, bu yalnızca JavaScript uygulamanızın işlevi ayukarıda yazılanla aynı şekilde dizdirmesi durumunda bir sorundur . Bununla birlikte, bu kodun çıktısının herhangi bir JavaScript uygulamasında bir kıskanç olması muhtemeldir.
— Ilmari Karonen
1
İşte aynı quine 1 byte daha kısa, geçerli: !function a(){alert("!"+a+"()")}().
— Ismael Miguel,
1
(a=()=>alert(({$ a})))()
— Dennis,
19

GolfScript, 8 bayt

Her zaman en kısa (gerçek) GolfScript kuyruğunun 9 bayt olduğunu düşündüm:

{'.~'}.~

İzleyen satır akışının gerekli olduğu yerlerde, GolfScript varsayılan olarak izleyen satır akışını yazdırır.

Ama ben sadece tam bu sınırlama kısıtlaması etrafında çalışan 8 baytlık bir jeton buldum:

":n`":n`

Çevrimiçi deneyin!

Bu nedenle, GolfScript'in takip eden bir satır akışını yazdırmaması, ancak nprogramın sonunda içeriğini yazdırmasıdır . Sadece nbaşlamak için bir satır beslemesi içeriyor. Bu yüzden fikir, onu dizeyle değiştirmek ":n`"ve ardından dizeye yerleştirmek , yığıntaki kopya tırnak işaretleri ve saklanan kopyada saklanacak şekilde dizektir.n olmadan kopyalar.

Thomas Kwa'nın belirttiği gibi, 7 baytlık CJam keki 8 baytlık bir çözüme uyarlanabilir:

".p"
.p

Yine, takip eden satır akışına ihtiyacımız var.

— Martin Ender
kaynak
6
Golf komut dosyası garip.
— Hesap MakinesiFeline
19

Labirent , 124 110 53 bayt

Sp3000'e 9 byte golf attığım için teşekkür ederim 7, bir tane daha golf atmamı sağladı.

44660535853919556129637653276602333!
1
:_98
/8 %
@9_.

Çevrimiçi deneyin!

açıklama

Labirent 101:

  • Labirent, yığın tabanlı bir 2B dilidir. Yığın tabansızdır ve sıfırlarla doludur, bu nedenle boş bir yığından atmak bir hata değildir.
  • Yürütme ilk geçerli karakterden başlar (burada sol üstte). Her bir kavşakta, talimat göstergesinin (IP) alınması için iki veya daha fazla yolun olduğu yerlerde, nereye gidileceğini belirlemek için yığının tepesi kontrol edilir. Negatif sola, sıfır ileri ve pozitif sağa döner.
  • Kaynak kodundaki rakamlar karşılık gelen numaraya basmaz - bunun yerine, yığının tepesini açıp bastırırlar n*10 + <digit>. Bu, çok sayıda sayının kolayca toplanmasını sağlar. Yeni bir numara başlatmak için_ , sıfıra basan .
  • " hayır ops.

İlk önce, bir bayt daha uzun ama biraz daha az büyülü olan biraz daha basit bir versiyonunu açıklayacağım:

395852936437949826992796242020587432!
"
:_96
/6 %
@9_.

Çevrimiçi deneyin!

Ana fikir, kaynağın ana gövdesini, bazı büyük taban kullanarak, tek bir sayıyla kodlamaktır. Bu sayının ardından kaynak kodun kalanını yazdırmak için kodu çözülmeden önce kolayca geri basılabilir. Kod çözme basitçe, divmod baseyazdırılan modve divsıfıra kadar çalışmaya devam eden tekrarlanan uygulamadır .

Kaçınarak {}, ihtiyacımız olan en yüksek karakter kodu _(95), taban 96'nın yeterli olacağı şekildedir (tabanı düşük tutarak, başlangıçtaki sayı daha kısadır). Yani kodlamak istediğimiz şey şudur:

!
"
:_96
/6 %
@9_.

Bu karakterleri kod noktalarına çevirmek ve sonucu temel-96 sayı olarak ele almak (en az önemli sayıya karşılık gelen !ve en önemli olana göre ., çünkü sayıyı parçalara ayıracağımız sıradır)

234785020242697299628949734639258593

Şimdi kod, kodlamayı geri yazdırmamıza ve çok az ek yük ile kod çözme için başka bir kopyasını saklamamıza olanak tanıyan oldukça havalı bir hile ile başlıyor: kodu tersine koyarız. Sonucu bu CJam betiği ile hesapladım. Şimdi gerçek koda geçelim. İşte başlangıç:

395852936437949826992796242020587432!
"

IP sol üst köşeden başlayarak doğuya doğru ilerler. Bu rakamlar üzerinden geçerken, sadece yığının üstüne bu sayıyı oluşturur. Sayının kendisi tamamen anlamsız, çünkü istediğimiz şeyin tersi. IP,! bu sayı yığından çıkar ve yazdırır. Çıktıdaki kodlamayı çoğaltmak için hepsi bu.

Fakat şimdi IP bir çıkmaza girdi. Bu onun etrafında döndüğü ve şimdi tekrar batıya doğru gittiği anlamına gelir ( !tekrar yürütmeden ). Artık yığının üstüne sayısı böylece Bu sefer rahatlıkla IP, arkadan öne doğru numarayı okur yapar kaynağının geri kalan kısmını kodlar.

IP şimdi sol üst köşeye tekrar çarptığında, bu çıkmaz bir nokta değildir, çünkü IP sola dönebilir, bu yüzden şimdi ve güneye doğru hareket eder. Bu "bir no-op, sayıyı kodun ana döngüsünden ayırmak için burada ihtiyacımız var. Bundan bahsetmek:

...
"
:_96
/6 %
@9_.

Yığının tepesi henüz sıfır olmadıkça, IP aşağıdaki döngüde oldukça yoğun olan bu koddan geçecektir:

"
>>>v
^< v
 ^<<

Veya doğrusal olarak ortaya kondu:

:_96%._96/

Bu dönüşleri almasının nedeni, Labyrinth'in kontrol akış anlambiliminden kaynaklanıyor. Mevcut hücreye en az üç komşu varsa, IP negatif yığın değerinde sola döner, sıfıra devam eder ve pozitif yığın değerinde sağa döner. Eğer seçilen yön bir duvar olduğu için mümkün değilse, IP bunun yerine ters yöne dönecektir (bu yüzden yığının tepesi asla negatif olmamasına rağmen kodda iki tane sola dönüş vardır).

Döngü kodunun kendisi oldukça basittir (bunu sıkıca sıkıştırmak değildi ve Sp3000’in ana katkısının olduğu yer):

:    # Duplicate the remaining encoding number N.
_96  # Push 96, the base.
%.   # Take modulo and print as a character.
_96  # Push 96 again.
/    # Divide N by 96 to move to the next digit.

Bir kez Nsıfıra geldiğinde kontrol akışı değişir. Şimdi IP /(yani batıdan) sonra dümdüz ilerlemek istiyor , ama orada bir duvar var. Bunun yerine geri dönerse (doğu) 6tekrar uygular . Bu, yığının tepesini pozitif yapar, böylece IP sağa döner (güneyde) ve yürütür 9. Yığının tepesi şimdi 69, ama tek umursadığımız pozitif. IP, başka bir sağa dönüş (batı) alır ve @kodun sonlandırıldığı yere ilerler .

Sonuçta, aslında oldukça basit.

Tamam, şimdi bu ek baytı nasıl tıraş ederiz? Açıkçası, bu no-op israf görünüyor, ancak şu ek satıra ihtiyacımız var: ilmek sayıya bitişik olsaydı, IP tüm sayıyı geçmek yerine hemen oraya taşınırdı. Öyleyse bu operasyon dışı için yararlı bir şeyler yapabilir miyiz?

Prensip olarak, kodlamaya son basamağı eklemek için bunu kullanabiliriz. Kodlama gerçekten ... ilk satırda tüm olması gerekmez !, sadece ne olursa olsun sağlamaktadır olduğunu da orada basılmış olur.

Yine de bir çekişme var, bunu yapamayız:

95852936437949826992796242020587432!
3
:_96
/6 %
@9_.

Sorun şu ki ", a olarak değiştirdik 3, ki bu da sahip olmak istediğimiz gerçek sayıyı da değiştiriyor. Ve bu numaranın bitmeyeceğinden eminim 3. Sayı tamamen başından itibaren kod tarafından belirlendiğinden, bu !konuda çok fazla şey yapamayız.

Ama belki başka bir rakam seçebiliriz? 3Kaynağı doğru bir şekilde kodlayan bir sayı ile bittiğimiz sürece o noktada bir noktada olup olmadığımız umrumda değil . Maalesef, 10 haneden hiçbiri, en düşük hanesi seçili olanla eşleşen bir kodlama vermez. Neyse ki, kodun geri kalanında, bayt sayısını artırmadan birkaç kodlama daha deneyebileceğimiz bir boşluk var. Üç seçenek buldum:

  1. Biz değiştirebilir @için /. Bu durumda herhangi bir rakamı kullanabilir 1357ve eşleşen bir kodlama alabiliriz. Ancak, bu daha sonra programın izin verilen ancak çok temiz görünmediği bir hatayla sona ereceği anlamına gelir.
  2. Boşluklar yalnızca "duvar" karakterleri değildir. Kullanılmayan her karakter, özellikle de tüm harfler. Eğer bir büyük harf kullanırsak, o zaman bunu barındırmak için üssü arttırmamıza gerek kalmaz (çünkü bu kod noktaları aşağıdadır _). 26 seçenek, birçok olanak sunar. İçin Örn Aherhangi garip haneli işler. Bu biraz daha hoş, ama hala o kadar da şık görünmüyor, çünkü orada gerçek harflerle bir harf kullanmazsınız.
  3. Daha büyük bir üs kullanabiliriz. Tabanı önemli ölçüde arttırmadığımız sürece, kodlamadaki ondalık basamakların sayısı aynı kalır (özellikle, 104'ün üzerindeki herhangi bir baz iyidir, ancak 99'un üzerindeki bazlar kodun kendisinde ek karakterleri gerektirir). Neyse ki, taban 98 tek bir eşleştirme çözümü sunar: rakamı kullandığımızda 1, kodlama da sona erer 1. Bu taban 96, 97, 98, 99 arasındaki tek çözüm, bu yüzden gerçekten çok şanslı. Ve bu, bu cevabın tepesindeki kod ile bitiyor.
— Martin Ender
kaynak
19

Kayıp , 293 262 249 bayt

>:2+52*:6*:(84*+75*):>:::::[[[[[[[:[(52*)>::::[[[[[[:[84*+@>%?!<((((((((((([[[[[[[[[[[[[[ "
\#<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\

Çevrimiçi deneyin!

açıklama

Bu projenin tamamı aşağı yukarı oldu. Bunun imkansız olduğunu düşünmeye devam ettim ve sonra işe yarayabilecek çılgınca bir fikir buldum.

Kayıp Quine neden bu kadar zor?

Bildiğiniz gibi Kayıp, başlangıç ​​konumu ve yönünün tamamen rastgele olduğu 2B bir programlama dilidir. Bu, radyasyon sertleştirilmiş kod yazmak kadar kaybedilen herhangi bir programın yazılmasını zorlaştırır. Mümkün olan her yeri ve yönü göz önünde bulundurmalısınız.

Olduğu söyleniyor şeyler yapmak için bazı standart yollar vardır. Örneğin, burada bir dize basmanın standart yoludur.

>%?"Stringv"(@
^<<<<<<<<<<<<<

Bu, altta ips'lerin çoğunu tutan ve onları başlangıç ​​konumuna çeken bir toplama akışına sahiptir. Ulaştıklarında başlangıç ​​yeri (sol üst), yığıntaki tüm değerlerden kurtulan bir döngü ile onları sterilize eder, daha sonra ipi itme ve çıkış güvenliğini döndürür. (Güvenlik Kayıp için benzersiz bir kavramdır %, çıkmadan önce her programın vurması gerekir , bu programın başlamasından sonra sona ermesi ihtimalini önler). Şimdi benim fikrim bu formu tam teşekküllü bir kıskaca genişletmek olacaktır.

Yapılması gereken ilk şey, döngüyü biraz yeniden işlemekti, mevcut döngü String formatına özgüydi.

>%?!<"Stringv"(@
^<<<<<<<<<<<<<<<
^<<<<<<<<<<<<<<<

Akışın !üstünden atlamak ve bir döngü oluşturmaktan kaçınmak için ikinci bir akış eklememiz gerekir .

Şimdi bunu standart Quine formatıyla karıştırmak istiyoruz. Lost, Klein'ı temel aldığından, temelde çalınan Martin Ender için Klien Quine'i ödünç aldım .

:2+@>%?!< "
<<<<^<<<<<<
<<<<^<<<<<<

Bu oldukça rahat bir şekilde sıranın ilk çizgisini basar. Şimdi tek yapmamız gereken akıntıları zor kodlamak. Söylemesi yapmaktan daha kolay. Bunu yapmak için yaklaşık dört farklı yöntem denedim. Sadece işe yarayanı tarif edeceğim.

Buradaki fikir istenen ok sayısını elde etmek için kapıları kullanmaktır. Bir Kapı, her vurulduğunda değişen özel bir ayna türüdür. [Soldan ve ]sağdan gelen ips'i yansıtır . Her iki taraftan da bir ip tarafından vurulduğunda, anahtar yönü. Tekrar tekrar bir işlem gerçekleştirmek için bu kapılardan bir çizgi ve statik bir yansıtıcı yapabiliriz.

>:[[[

:Üç kez gerçekleştirir . Bu sayede <elden önce bir yığına itersek daha az bayt ile çoğunu yapabiliriz. Bunlardan 2 tanesini yapıyoruz, her satır için bir tane ve aralarında yeni bir satır çizdik, ancak ikincisinin sadece onu !eklediğimizi kaplayana kadar devam etmesi gerekiyor , başka bir şey bizi boş bırakabilir, birkaç bayt. Tamam, şimdi dikey okları akışlarımıza eklememiz gerekiyor. Anahtar optimizasyonun yapıldığı yer burasıdır. Tüm ips'leri doğrudan programın "başlangıcına" yönlendirmek yerine, onları en sola yönlendireceğiz, çünkü çoktan başlayarak ips'in çoktan başlaması gerektiğini biliyoruz.çalışması (ya da en azından son sürümde çalışacak) diğer ips'leri de yönlendirebiliriz. Bu sadece bayt cinsinden daha ucuz olmasını sağlamakla kalmıyor, bence bu optimizasyon da cevabı mümkün kılan şey.

Ancak hala bazı problemler var, en önemlisi ips'den sonra başlayanlar >ancak kopyalarını almaya başlamadan önce ips . Bu tür ipsler fotokopi makinesine girecek ve 0'lık bir demet kopya yapacaklar. Bu kötüdür çünkü yığın temizleme mekanizmamız yığının tabanını belirlemek için sıfırlar kullanır ve altta bir miktar sıfır bırakır. Daha güçlü bir yığın sanitasyon yöntemi eklememiz gerekiyor. Yığının boş olup olmadığını söylemenin gerçek bir yolu olmadığından, yığın üzerinde mümkün olduğu kadar çok eşya imha etmek zorunda kalacağız. Burada daha önce açıklanan kapı yöntemini bir kez daha kullanacağız. ((((((((((([[[[[[[[[[[[[[Temizlikten hemen sonra sıfırlardan kurtulmak için ilk satırın sonuna ekleyeceğiz .

Şimdi bir sorun daha var, çünkü akışlarımızı sol üstteki IPS'lere yönlendirdik, %aşağı inmeye başlıyoruz ve aşağı inmeye başlıyoruz zaten güvenliği kapatmış ve erken çıkacak. Bu yüzden güvenliği kapatmamız gerekiyor. Bunu bir #akıma ekleyerek yaparız , bu şekilde akışın içinden akan ips'ler kapanır, ancak daha önce sterilize edilmiş ipsler açılmaz. #Ayrıca sert hem birinci hattına kodlanmış olmalıdır.

İşte bu, umarım şimdi nasıl çalıştığını anlarsınız.

— Sriotchilism O'Zaic
kaynak
: / pek çok yazım hatası ve eksik bağlantı
— ASCII yalnızca
17

Yup , 1165 879 606 561 540 522 498 + 7 = 505 bayt

-cheatBayrağın takma ad tanımına izin vermesini gerektirir .

022222120211111102222122021121202222212021112202222110222212202112110222221202122212022222102222212021222120222221022222102222210222221202222110222211022222210222221022222210222212202222221022221102211110222221022221220222212202112120221111022212202211210222212022222102211120222122022111202222120212212021221202222221022111102221210222122022222102222120212212022221102211110222122022221102222120212212022112120221111022212202112120222212=%;0e-=<;0<-=>;:0~--=1;1>=2;0%{{>0<~{~>~<<}>>>]}>]}${<#}%{@}

Çevrimiçi deneyin!

açıklama

Bunun için iki kısım var (çoğu sopada olduğu gibi). Veri:

022222120211111102222122021121202222212021112202222110222212202112110222221202122212022222102222212021222120222221022222102222210222221202222110222211022222210222221022222210222212202222221022221102211110222221022221220222212202112120221111022212202211210222212022222102211120222122022111202222120212212021221202222221022111102221210222122022222102222120212212022221102211110222122022221102222120212212022112120221111022212202112120222212

Ve dekoder:

=%;0e-=<;0<-=>;:0~--=1;1>=2;0%{{>0<~{~>~<<}>>>]}>]}${<#}%{@}

Veriler sadece kod çözücünün bir ikili kodlamasıdır (veya tersi). Her biri 0yeni bir karakter başlatır ve 1s ve 2s , sırasıyla 0- ve- 1bitleridir.

Bu noktada tanımlanmayan ve 0sıfırlanmayan standart bir Yup komutu olduğuna dikkat edin. Bununla birlikte, tüm veri bölümünü komuta atarız, böylece gerçekte kullanılana kadar ve tanımsız kalabilir .12%12%

Daha sonra, daha fazla komut tanımlayacağız:

0e-=<;
0<-=>;
:0~--=1;
1>=2;

<yığının en üstünü azaltır, >artırır. 1(biraz istenmeyen bir şekilde) yığının üstünü iki katına çıkarır. 2ikiye katlar ve artar. Bu tanımlamalar sayesinde, bir şey 0221111aslında yığında 48 (ikilik 110000) bırakacaktır.

Kalan 32 byte asıl kod çözme işlemini iki parça halinde gerçekleştirir. İlk önce veri dizisini yeniden yapılandırmamız gerekiyor.

0%                ` Push a zero and then the data.
{                 ` For each value...
  {               `   Until that value is zero...
    >0<~{~>~<<}>  `   divmod 2. The div is the input to the next iteration,
                  `   the mod gives us the next bit.
    >>]           `   Increment twice (gives 2 or 3) and put at the bottom
                  `   of the stack.
  }
  >]              ` Increment the 0 and put it at the bottom as well.
}
$                 ` Reverse the entire stack.
{<#}              ` Decrement and print each number.

Sonunda, verileri tekrar zorlarız ve her değeri karakter olarak basarız:

%{@}

Gelecekteki referans için, burada verileri kodlamak için bir CJam betiği .

— Martin Ender
kaynak
17

Fueue , 423 bayt

Fueue koşu programı olduğu bir kuyruk tabanlı esolang olduğunu olduğunu kuyruk.

)$$4255%%1(~):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]](H-):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611

Çevrimiçi deneyin!

Nasıl çalışır

Bu açıklama elden çıkmış olabilir veya olmayabilir . Öte yandan, insanların izleyebileceğini umduğum şekilde nasıl daha kısa açıklayacağımı bilmiyorum .

Fue hile sayfası

Bu programda kullanılmayan birkaç özellik dahil, ayrıntılar için esolang wiki makalesine bakın .

  • İlk program, aşağıdaki öğeleri içeren sıranın başlangıç ​​durumudur:

    • Tamsayı değişmezleri (yalnızca kaynakta negatif değil, ancak negatif olanlar hesaplanabilir), bunları yürütmek bir karakter yazdırır.
    • Köşeli ayraç sınırlı yuvalanmış bloklar, inert (bazı işlevler üzerine etki etmedikçe bozulmadan korunur).
    • İşlevler, argümanları hemen sırada onları takip eden elemanlardır:
      • +*/-%: tamsayı aritmetiği ( -tekdüze, %mantıksal olumsuzlama). Sayı bağımsız değişkenleri verilmezse eylemsiz.
      • ()<: elemanı parantez içine alın, parantezleri bloktan çıkarın, bloğa son eleman ekleyin. İkincisi, bir blok tarafından takip edilmedikçe etkisizdir.
      • ~:: takas, çoğalt.
      • $: kopyala (sayı + eleman alır). Sayı olmadan önce inert.
      • H: programı durdur.

    []Yuva içindeyken , ()yapma - ikincisi sadece ayrı işlevlerdir.

Yürütme izleme sözdizimi

Boşluk, rakamlar hariç, Fueue'da isteğe bağlıdır. Aşağıdaki uygulama izlerinde, özellikle program yapısını önermek için kullanılacaktır:

  • Bir fonksiyon yürütüldüğünde, onu ve argümanlarını çevreleyen elementlerden boşluklu bırakacağız. Eğer bazı argümanlar karmaşıksa, aralarında bir boşluk da olabilir.
  • Birçok uygulama izi, önemli veri manipülasyonunu yapan bir bölümden sağa ayrılarak solda bir "gecikme bloğu" na ayrılmıştır. Bir sonraki bölüme bakınız.

Kıvrımlı parantezler {}(Fueue'da kullanılmaz) izlerde matematiksel ifadelerin tamsayı sonucunu temsil etmek için kullanılır. Bu, Fueue'nun yalnızca negatif olmayan değişmezlere sahip olması nedeniyle negatif sayıları içerir - -olumsuzlama işlevidir.

Çeşitli meta değişkenli isimler ve ...değerleri ve kısaltmaları belirtmek için kullanılır.

Gecikme taktikleri

Sezgisel olarak, yürütme kuyruğun etrafında dönerek kısmen içinden geçenleri değiştirir. Bir işlevin sonuçları bir sonraki döngüye kadar tekrar uygulanamaz. Programın farklı bölümleri, etkileşime girmedikleri sürece paralel olarak etkin bir şekilde gelişir.

Sonuç olarak, kodun birçoğu senkronizasyona, özellikle programın parçalarının doğru zamana kadar ertelenmesine adanmıştır. Bunu yapmak için birçok seçenek var; bu kısımlar, sadece yürütme döngülerinin döngüsel olarak izlenerek anlaşılması mümkün olan okunamayan damlalara dönüşme eğilimindedir.

Bu taktikler aşağıda her zaman ayrı ayrı belirtilmeyecektir:

  • )[A]Abir döngü için gecikmeler . (Muhtemelen en kolay ve en okunabilir yöntem.)
  • ~efelemanları değiştirir eve fbu da onların uygulanmasını geciktirir. (Muhtemelen en az okunabilen, ancak küçük gecikmeler için genellikle en kısa olanıdır.)
  • $1etek bir elemanı geciktirir e.
  • -ve %sayıları geciktirmek için yararlıdır (ikincisi için 0ve 1.)
  • Bir satırda birkaç eşit elementi geciktirirken, :veya $bunları tek bir diziden oluşturmak için kullanılabilir.
  • (nnsonradan rahatlıkla çıkarılabilen braketler halinde sarılır . Bu özellikle sayısal hesaplamalar için çok önemlidir, çünkü sayılar ilk önce bir bloğa koymadan kopyalanamayacak kadar kararsızdır.

Genel yapı

Açıklamanın geri kalan kısmı, her biri koşu programın bir bölümü için yedi bölüme ayrılmıştır. Birçoğunun kendilerini tekrar ettiği daha büyük döngüler, onları tüm sıra boyunca tek geçişlerin "döngülerinden" ayırt etmek için "yinelemeler" olarak adlandırılır.

İlk programın aralarına nasıl bölündüğü:

A:  )$$4255%%1(~
B:  ):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
C:  
D:  (H-
E:  
F:  
G:  ):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611

Programın sonundaki büyük rakam geri kalanı tersine, her ASCII değerinden 30 çıkarılmış karakter başına iki hane 10kodlar (yani, a kodları ().

Daha yüksek bir seviyede, bu programdaki verileri (bignumdan başlayarak) sağdan sola doğru akarken, kontrolün soldan sağa doğru aktığını düşünebilirsiniz. Bununla birlikte, daha düşük bir seviyede Fueue, kod ve veri arasındaki ayrımı her zaman karıştırır.

  • Kısım G , ilk önce en az anlamlı basamağı ayırarak bignumu ASCII rakamlarına dönüştürür (örneğin 0tamsayı olarak 48rakam). Her 15 döngüde bir rakam üretiyor.
  • F bölümü, E bölümü tüketene kadar üretilen rakam ASCII değerlerini (her biri bir blok içinde) içerir.
  • E bölümü, üretilen rakamları her defasında iki kez tutar, bunları form bloklarına eşleştirir ve [x[y]]ayrıca her bir çiftin kodlanmış karakterini yazdırır.
  • Kısım D, kademeli olarak [x[y]]bloklardan, tüm basamakları içerdiği zaman, hepsini yazdırmak için çalıştırılabilir, sonra tüm programı durduracak şekilde inşa edilen derinlemesine yuvalanmış bir bloktan oluşur .
  • C bölümü, D bölümünün yapımını idare eder ve E bölümünü de yeniden oluşturur.
  • Bölüm B, her 30 döngüde bir C bölümünü ve ayrıca kendisini yeniden oluşturur.
  • Bölüm A, diğer bölümlerin son yinelemesine kadar döngüleri geri sayıyor. Sonra B bölümünü iptal eder ve D bölümünü çalıştırır.

Bölüm A

Bölüm A, programın sonunu planlayan işler. Tek bir takas fonksiyonuna indirgemek 4258 devir alır ~, bu daha sonra ana döngüsünü durduran ve bunun yerine D bölümünü çalıştırmaya başlayan B bölümüne ayar yapar.

)$ $4255% %1 (~
)$%%%...%% %0 [~]
)$%%%...% %1 [~]
⋮
)$ %0 [~]
) $1[~]
)[~]
~
  • Bir $fonksiyon aşağıdakilerden 4255 kopyalarını yaratır %iken (sarar ~parantez içinde.
  • Her döngü, %aşağıdaki sayıyı 0ve arasında değiştirmek için kullanılır 1.
  • Hepsi %kullanıldığında $1, [~](etkin bir NOP) ' nin 1 kopyasını oluşturur ve bir sonraki döngüde )parantezleri kaldırır.

B bölümü

Bölüm B her 30 döngüde bir kendini yenilemenin yanı sıra yeni bir C bölümü yinelemesini de ele alır.

) : [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]            [BkB]
)$ $24%     %0  :<  [~:)~)]    ~ [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<] [BkB]
)$ %...%%% %1   < < [~:)~)] [BkB]   [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...%% %0      < [~:)~)[BkB]] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...% %1         [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
⋮
) $1 [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]                    (1)
~:) ~)[BkB]                 [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
) : [BkB]                 ) [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]      (2)
) [BkB] [BkB]               $11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<
  • Bir :, aşağıdaki büyük bloğu kopyalar (bir kopya olarak kısaltılır [BkB]), sonra )parantezleri ilk kopyadan kaldırır.
  • $$24%%0 A bölümündeki ile benzer bir geri sayım ayarlar.
  • Bu geri sayıma başlar, :<dönüşür <<ve ~bloklardan ikisini değiştirir, kodun sonuncusunu yeni bir C bölümüne yerleştirir.
  • İki <işlev, iki son bloğu birinciye yerleştirir - bu normal yinelemelerde gereksizdir, ancak ~A bölümünün sonunda işini yapmasına izin verir .
  • (1) Geri sayım tamamlandığında, )dış braketleri çıkarır. Daha sonra ~:)dönüşür ):ve ~)a )bölümünün C kodunun başına geçer.
  • (2) Bölüm B şimdi tekrar başlangıç ​​döngüsünde, a )ise bölüm C'nin yeni bir C bölümünün yeni bir yinelemesini başlatmak için braketleri çıkarmak üzere.

Son yinelemede, ~A bölümü yukarıda (1) noktasında belirir:

~ ) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]                  (1)
[~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]              )

~Swap )kesitini B engelleyen blok arasında ve bölüm C içine yeniden çalıştırılan.

Bölüm C

C bölümü, D basamaklı bloğuna yeni rakam karakter çiftlerinin birleştirilmesini ve E bölümünün yeni yinelemelerinin yaratılmasını sağlar.

Aşağıda, hanelerin ASCII kodları ile birlikte xve bunları ytemsil eden tipik bir yineleme görülmektedir . İlk yinelemede, gelen "D" ve "E" elementleri başlangıçtır [H]ve -bunun yerine, önceki herhangi bir E bölümü rakam karakter çiftleri üretmek için çalıştırılmaz.

C                                               D             E
$11~ )  ~<[[+$4--498+*-:~-10)):])<~]  [)))~]  < [)))~[...]]   [x[y]]
~~~ ~~~ ~~~ ~~) [[+$4--498+*-:~-10)):])<~]  < [)))~] [)))~[...][x[y]]]
~~~ ~~~     )  ~ [[+$4--498+*-:~-10)):])<~] [)))~[)))~[...][x[y]]]]
~~~       ~ )   [)))~[....]]                                  [[+$4--498+*-:~-10)):])<~]
                                              ~~[)))~[....]] )[[+$4--498+*-:~-10)):])<~]
                                                [)))~[....]]  ~[+$4--498+*-:~-10)):])<~
  • Bu, bu cevap için keşfettiğim farklı bir senkronizasyon yöntemini kullanıyor. Bir ~satırda birkaç takas işleviniz olduğunda, sıra her çevrimde yaklaşık 2 / 3'üne daralacaktır (çünkü biri ~ikiyi değiştirir), ancak zaman zaman izlerini~ sürdüğü geriye kalanı dikkatlice değiştirir.
  • $11~böyle bir satır üretir. Bir sonraki ~sürüntüler <şu bloğun karşısında. <Sonunda bir diğeri , D bloğuna yeni bir rakam çifti bloğu (ASCII kodları olarak x ve y rakamları) ekler.
  • Bir sonraki döngüde, ~satırın aşağıdakini ~~değiştiren bir kalanı vardır . Diğer bölüm D'yi bir bloğa ekler .~)<[)))~]
  • Daha sonra değiştirilen ~kendisi aşağıdaki bloğu yeni bölüm E kodu ile bölüm D bloğu boyunca değiştirir. Ardından yeni bir artık ~bir takas )karşısında ve son olarak geçen ~~de ~tıpkı bölümüne E genelinde bunlardan satır takası biri )kendi parantez kaldırmıştır.

Nihai yineleme, bölüm A takımından ~bir takas etmiştir )bölüm B genelinde ve Ancak bölüm C. içine, C bölümü yüzden zaten kayboldu ve olduğu kısa ömürlü olduğunu )uçları yukarı bölümünde D. başında

Bölüm D

Bölüm D, son büyük rakamı basmak ve programı durdurmak için kullanılır. Program çalışmasının çoğunda, B – G bölümlerinin bina üzerinde işbirliği yaptığı inert bir bloktur.

    (H -
    [H]-
    ⋮
    [)))~[H-]]                  After one iteration of section C
    ⋮
    [)))~[)))~[H-][49[49]]]]    Second iteration, after E has also run
    ⋮
)   [)))~[...]]     [49[48]]    Final printing starts as ) is swapped in
    ))) ~[...][49[48]]
    )) )[49[48]] [...]
    )) 49 [48][...]             Print first 1
    ) )[48] [...]
    ) 48 [...]                  Print 0
    )[...]                      Recurse to inner block
    ...
    ⋮
    )[H-]                       Innermost block reached
    H -                         Program halts
  • Programın ilk döngüsünde (, durma işlevini Hparantez içinde sarar . Bir -iz, bir rakam çifti yerine ilk yineleme için kukla eleman olarak kullanılacaktır.
  • Dahil edilen ilk gerçek hane çifti sayıdaki sonuca [49[49]]karşılık gelir 11.
  • En son basamak çifti [49[48]]( sayının 10başlangıcına karşılık gelir ) aslında bloğa dahil değildir, ancak bu , her ikisine de dönüşen eşdeğer olan )[A[B]]ve hiçbir fark )[A][B]yaratmaz A[B].

Son yinelemeden sonra, )B bölümünden sağa doğru değiştirilen bölüm D bloğu kapandı. )))~Her alt bloğun başında tüm parçaları doğru sırayla yürütülür emin olur. Sonunda en içteki blok Hprogramı durdurur.

Bölüm E

E Bölümü, G bölümü tarafından üretilen ASCII hanelerinin çiftlerini birleştirir ve her ikisi de karşılık gelen kodlanmış karakteri basar ve kombine çifti sol ve C ve D bölümlerine bırakarak bir blok gönderir.

Yine aşağıda, rakamların ASCII kodları ile birlikte xve onu ytemsil eden tipik bir yineleme görülmektedir .

E                                                   F
~ [+$4--498+*-:~-10)):] )              <  ~         [y] [x]
) [+$4--498+*-:~-10)):]                   < [x] [y]
+ $4-  - 498  +*- :~ -10 ) )              : [x[y]]
+---  -{-498} +*- ~~{-10} )       ) [x[y]]  [x[y]]
+--    - 498  +*   -{-10}       ~ ) x  [y]  [x[y]]
+-    -{-498} +               * 10 x  )[y]  [x[y]]
+      - 498                    + {10*x} y  [x[y]]
                         + {-498} {10*x+y}  [x[y]]
{10*x+y-498}  [x[y]]
[x[y]]
  • Gelen rakam blokları değiştirilir, ardından y bloğu x bloğuna eklenir ve tüm çift blok kopyalanır. C ve D bölümlerinin sonuna kadar bir kopya bırakılacaktır.
  • Diğer kopya tekrar kilitlenir, daha sonra 10*x+y-498şifrelenmiş karakterin ASCII değerini hesaplamak için bir aritmetik fonksiyon sırası uygulanır . 498 = 10*48+48-30, 48S ASCII kodlama geri xve ysüre 30gelen kodlama kaymalar 00–99için 30–129tüm yazdırılabilir ASCII içerir.
  • Sonuçta ortaya çıkan sayı, karakterini yazdıran yürütmek için bırakılır.

Bölüm F

Bölüm F, ASCII basamak kodlarını içeren inert bloklardan oluşur. Programın çoğu çalışması için burada en fazla iki tane olacak, çünkü E bölümü bunları G ile aynı hızda kullandığı için. Ancak, son baskı aşamasında bazı fazlalık 0rakamlar burada toplanacaktır.

[y] [x] ...

Bölüm G

Kısım G, programın sonunda büyük sayının ayrılmasından, en az önce en az haneden önce ayrılmasından ve ASCII kodlarının diğer bölümlere bırakılmasıyla blok gönderilmesinden sorumludur.

Durma kontrolü olmadığından, 0sayı 0'a düştüğünde rakamlar üretmeye devam eder , D bölümü Hfonksiyonun tamamı ile duruncaya kadar .

[BkG] Yeni yinelemeleri başlatmak için kendi kendini çoğaltması için kullanılan büyük başlangıç ​​kod bloğunun bir kopyasını kısaltır.

İlk döngülerde ilklendirme:

) :~  : [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]  ( 106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
)  ~ ~ [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]  [BkG] [10...11]
) [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:]     ~ [BkG] [10...11]
) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]       ~ : [10...11]  [BkG]

Tipik yineleme, Nbölünecek sayıyı belirtir:

) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]        ~ : [N]  [BkG]
) :~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+ :5 )         : [N]  : [BkG]
)  ~ ~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]  +5 5     ) [N]  [N] [BkG] [BkG]
) [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]               ~ 10 N  [N] [BkG] [BkG]
) ~:~  ~ ( [:~)*[):~[$1(+48]):~+]-:~~)10)~~]               / N 10  [N] [BkG] [BkG]
)  ~ : [:~)*[):~[$1(+48]):~+]-:~~)10)~~]                 ( {N/10}  [N] [BkG] [BkG]
) [:~)*[):~[$1(+48]):~+]-:~~)10)~~]                    : [{N/10}]  [N] [BkG] [BkG]
:~ )*[):~[$1(+48]):~+]- :~ ~)10 )           ~ ~ [{N/10}]  [{N/10}] [N] [BkG] [BkG]
~~) *[):~[$1(+48]):~+]- ~~10 )             ) [{N/10}]  ~ [{N/10}] [N]  [BkG] [BkG]
)  ~ * [):~[$1(+48]):~+]  -10            ~ ) {N/10}  [N] [{N/10}] [BkG] [BkG]
) [):~[$1(+48]):~+]               * {-10} {N/10}  ) [N]  [{N/10}] [BkG] [BkG]
) :~ [$1(+48]) :~                 + {-10*(N/10)} N  [{N/10}] [BkG] [BkG]
)  ~ ~ [$1(+48]  )                 ~ ~ {N%10}  [{N/10}] [BkG] [BkG]
) [$1(+48]                 ~ ) {N%10}  ~ [{N/10}] [BkG]  [BkG]
$1(                     + 48 {N%10}    ) [BkG]  [{N/10}] [BkG]
                        ( {48+N%10}   BkG [{N/10}] [BkG]            New iteration starts
                        [{48+N%10}]   ....
  • Buradaki gecikme bloğu özellikle kıllı. Bununla birlikte, tek yeni gecikme numarası iki çevrimi geciktirmek +:5yerine kullanmaktır . Ne yazık ki programdaki s yalnızca bir tanesi bu yardımcı oldu.--101010
  • [N]Ve [BkG]bloklar çoğaltılır, daha sonra bir kopyası Nbölünür 10.
  • [{N/10}]yineleniyor, daha sonra aritmetik fonksiyonlar son basamağının ASCII kodu hesaplamak için kullanılır Nolarak 48+((-10)*(N/10)+N). Bu ASCII koduna sahip blok F bölümü için bırakılmıştır.
  • Diğer bir kopyası yeni bir yinelemenin başlangıcını ayarlamak [{N/10}]için [BkG]bloklar arasında değiştirilir .

Bonus quine (540 bayt)

)$$3371%%1[~!~~!)!]):[)$$20%%0[):]~)~~[)$$12%%0[<$$7%~~0):~[+----48+*-~~10))]<]<~!:~)~~[40~[:~))~:~[)~(~~/[+--48):]~10]+30])):]]][)[H]](11(06(06(21(21(25(19(07(07(19(61(96(03(96(96(03(11(03(63(11(28(61(11(06(06(20(18(07(07(18(61(11(28(63(96(11(96(96(61(11(06(06(19(20(07(07(18(61(30(06(06(25(07(96(96(18(11(28(96(61(13(15(15(15(15(22(26(13(12(15(96(96(19(18(11(11(63(30(63(30(96(03(28(96(11(96(96(61(22(18(96(61(28(96(11(11(96(28(96(61(11(96(10(96(96(17(61(13(15(15(22(26(11(28(63(96(19(18(63(13(21(18(63(11(11(28(63(63(63(61(11(61(42(63(63

Çevrimiçi deneyin!

Hangi yöntemin en kısa olacağından emin olamadığım için, ilk önce karakterleri (s ile ayırarak iki basamaklı sayılar olarak kodlamayı denedim . Çekirdek kod biraz daha kısa, ancak% 50 daha büyük veri sunumu bunu telafi ediyor. Diğerleri kadar golf oynamadım, fark ettim dediğimde durduramadım. Bir avantaja sahiptir: Bignum desteğine sahip bir uygulama gerektirmez.

Genel yapısı, ana yapıya biraz benzemektedir. Veri gösterimi doğrudan F bölümünü doldurduğu için G Bölümü eksik. Bununla birlikte, bölüm E, iki basamaklı sayıların rakamlarını yeniden oluşturmak için benzer bir divmod hesaplaması yapmalıdır.

— Ørjan Johansen
kaynak
1
Açıklama XD
— VFDan
1
)$n[)](gecikme sayacı için bir bayt daha kısadır.
— jimmy23013
15

Jöle, 3 bayt

”ṘṘ

Çevrimiçi deneyin!

Doğrulama

$ echo $LANG
en_US
$ xxd -g 1 quine.jelly
0000000: ff cc cc                                         ...
$ ./jelly f quine.jelly | xxd -g 1
0000000: ff cc cc                                         ...

Nasıl çalışır

”ṘṘ    Main link. No input.

”Ṙ     Set the return value to the character 'Ṙ'.
  Ṙ    Print a string representation of the return value.
       This prints: ”Ṙ
       (implicit) Print the return value.
       This prints: Ṙ
— Dennis
kaynak
Tercümanın hangi sürümünü kullanıyor? Test ettiğimde, giriş Jelly'in kod sayfasında olmasına rağmen UTF-8'de çıktı veriyor (ve kodlamadaki değişiklik onu bir adım atmaz).
1
Çıkışın kodlaması terminal ayarlarınıza bağlıdır: UTF-x olarak ayarlanmışsa, bunu kullanır; başka bir şeye ayarlanmışsa Jelly'in kod sayfasını kullanır. Linux'ta, LANG=en_USsadece bunu başarır. tio.run/nexus/bash#@@/…
— Dennis,
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.