Bir gerçeklik makinesi ( bu adama gelmesi için krediler verilir ), G / Ç'yi göstermek ve bir dilin akışını kontrol etmek için tasarlanmış çok basit bir programdır. İşte gerçek makinanın yaptığı:

• STDIN'den bir numara (0 veya 1) alır.

• Bu sayı 0 ise, 0 yazdırın ve sonlandırın.

• Bu sayı 1 ise, sonsuza dek 1 yazdırın.

Meydan okuma

Seçtiğiniz dilde yukarıda açıklandığı gibi bir gerçeklik makinesi yazın. Doğrulama makinesi bu kuralları izleyen tam bir program olmalıdır:

• STDIN'den veya kabul edilebilir bir alternatiften girdi almak
  • Diliniz STDIN'den giriş alamıyorsa, kodlanmış bir değişkenden veya programdaki uygun bir eşdeğerden giriş alabilir.
• STDOUT'a veya kabul edilebilir bir alternatife çıktı vermeli
  • Diliniz karakterleri çıkaramıyorsa 0veya 1bayt veya unary G / Ç kabul edilebilir.
• giriş olduğunda 1, sürekli olarak 1s yazdırmalı ve yalnızca program öldürüldüğünde veya hafızasının tükenmesi durumunda durmalıdır

• çıktı sadece bir 0tane ya da yeni satır veya boşluk bırakmalı veya her biri bir tane yeni satır veya boşluk bırakmalı sonsuz 1s olmalıdır 1. Dilinizin yorumlayıcısının bastırılamayan (tebrik, ANSI renk kodları veya girinti gibi) sabit çıktısı dışında başka bir çıktı üretilemez. Yeni satırları veya boşlukları kullanımınız tutarlı olmalıdır: örneğin, 1hepsinden sonra bir yeni satır çıktısını seçerseniz, hepsinde 1onlardan sonra bir yeni satır olmalıdır.

• eğer ve sadece eğer diliniz bir girişle sonlandırılamıyorsa 0, kodun hiçbir şeyin çıkmadığı sonsuz bir döngüye girmesi kabul edilebilir.

Bu bir katalog olduğundan, bu mücadeleden sonra oluşturulan dillerin rekabet etmesine izin verilir. Göndermenin test edilebilmesi için bir tercüman olması gerektiğini unutmayın. Daha önce uygulanmamış bir dil için bu tercümanı kendiniz yazmanıza izin verilir (ve hatta teşvik edilir). Bunun dışında tüm standart kod-golf kurallarına uyulmalıdır. Çoğu dilde yapılan gönderiler uygun bir önceden kodlanmış kodlamada (genellikle UTF-8) bayt olarak puanlanacaktır.

Katalog

Bu yazının altındaki Yığın Parçacığı, cevapları a) dil başına en kısa çözümün bir listesi olarak ve b) genel bir lider tablosu olarak oluşturur.

Cevabınızın göründüğünden emin olmak için, lütfen aşağıdaki Markdown şablonunu kullanarak cevabınızı bir başlık ile başlatın:

## Language Name, N bytes

Gönderinizin Nbüyüklüğü nerede ? Puanınızı artırmak varsa, olabilir onları içinden vurarak, başlığa eski hesapları tutmak. Örneğin:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Başlığınıza birden fazla sayı eklemek istiyorsanız (örneğin, puanınız iki dosyanın toplamı olduğundan veya tercüman bayrağı cezalarını ayrı ayrı listelemek istediğiniz için), gerçek puanın başlıktaki son sayı olduğundan emin olun :

## Perl, 43 + 2 (-p flag) = 45 bytes

Dil adını, daha sonra pasajda görünecek bir bağlantı da yapabilirsiniz:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 320px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 62732; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 12012; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

Altıgen , 6 bayt

Bu şaşırtıcı derecede zordu, ve optimal olduğuna ikna olmadım ...

<.@!$?

Kodu doldurup açtıktan sonra bu, aşağıdaki onaltılık ızgarayı temsil eder:

Bu, anti-diyagonal boyunca hareket eden son hatasız kedi programım gibi benzer bir kontrol akışını kullanıyor . Bunu başarmak için, mor işaretçinin sol alt köşeye dolandığı yön gösterici işaretçiyi (IP) sola döndürerek başlıyoruz.

?girişi bir tamsayı olarak okur. !geri yazdırır. .sadece bir ameliyat değil. Şimdi ızgaranın köşesi dal olarak hareket eder:

Girdi, 0IP ise, sadece programı sonlandıran kırmızı yol boyunca devam edecektir @.

Giriş yapıldıysa, 1IP yeşil yolda devam edecektir. Yine, .sadece no-op, ama $Befunge'nin trambolininin eşdeğeri: bir sonraki talimatı atlıyor. Kaydırma işleminden sonra, bir sonraki komut olacaktır ?, ancak uygulama nedeniyle $aslında mavi yol üzerinde devam eder, !başka bir kopyasını basmakla başlar 1. Sadece içerdiği bu döngü !..$şimdi süresiz olarak tekrarlanır.

Hexagony'de kontrol akışının incelenmesi ...

Yukarıdaki çözümün optimal olduğuna inanıyorum. Her biri en az birini içeren 6 baytlık Hexagony programlarını kontrol eden kaba bir forcer yazdım ?!@(zorunludur; aynı zamanda , sıfıra bölünme hatasıyla sonlandırmak için kontrol ettik :ve %yerine koyuldum) @Bu da yardımcı olmadı). Onay baskılar a) üreten tüm programlar 0girişi 0ve sona erdirmek ve b) en az iki üretmek 1ler (ve başka bir şey) ve yok (programın ilk 60 kene içinde sona 200 keneler 5 bayt çözeltiler için) . Herhangi bir geçerli çözümün, ilkini 0veya ikincisini 1böylesine küçük bir ızgaraya doğru şekilde basması için 200'den fazla tik alacağından şüpheliyim , bu yüzden herhangi bir olası çözümü kaçırdığımı sanmıyorum.

Arama işlemi 5 bayt için sonuç vermedi, ancak 6 bayt için 57 sonuç elde edildi (kullanarak @; bunu aynı miktarda baytta temiz bir şekilde çözebiliyorsak, hatayla sonlandırmamız gerekmez). Bu 57 kişiden sadece 6'sı, aslında sadece iki 1saniyeyi basan ve daha fazlasını basmadan sonsuz bir döngüye giren yanlış pozitiflerdi . Bir çözüm iki !komut içermekteydi çünkü iki komut içeriyordu . Bu tam olarak 50 geçerli çözüm bırakıyor.

Bir veya iki karakterin önemli olmadığı çözümler arasında belirli bir yozlaşma söz konusudur, örneğin, zaten etkili bir şekilde çalışamamaları. Çözümler, 23 farklı gerçek program grubuna ayrılabilir (bazı durumlarda, iki küme arasında yalnızca tek bir karakter farkı vardır, ancak kontrol akışını büyük ölçüde değiştirir, bu yüzden ayrı ayrı saydım). Gruplardan ikisi, çok yönlü komut işaretleyicilerini çok beklenmedik bir şekilde kullanıyor. Dalları ve aynaları kullanmak için bu yolların çoğunu asla bulamamış olduğum için, Hexagony'de ne tür kontrol akışının mümkün olabileceği konusunda çok ilginç bir çalışma yapıyorlar ve kesinlikle gelecekteki golf sahaları için bazı yeni püf noktaları öğrendim.

Genel kontrol akış hemen hemen her zaman aynıdır: bir sayı okumak, yazdırmak. E? Er 0için bir yol bulmak @döngü devam değilse, !bir kenar değerini mainting süre 1. Dört önemli istisna vardır:

• Bir çözüm (iki çözüm !) 1, yineleme başına iki saniyeyi yazdırır , bu nedenle programların çoğunluğunun iki katı kadar hızlı yazdırır. Bunu x2aşağıda ile işaretledim .
• Birkaç çözümler (bir içerenler o) değiştirin 1bir ile 111(karakter kodunun o), bu yüzden baskı üç 1 onları programlarının çoğunda olduğu kadar hızlı üç kere basmak yapım yineleme başına s. Bunları x3aşağıda ile işaretledim .
• İki çözelti ekleme , bir 1her tekrarında kenar değerine (böylece 1-> 11-> 111-> ...). Bunlar çok hızlı yazdırılıyor , ancak sonunda hafızası tükenecek. Bunları OoMaşağıda ile işaretledim .
• İki çözüm, sadece ileri geri sıçrayan !, her keneye (her 5. ya da öylesine yerine) baskı yapan ve bunları biraz daha hızlı (ve daha düzenli) yapan çok sıkı bir döngüye girer . Bunları ><aşağıda ile işaretledim .

Yani burada tüm hayvanat bahçesi:

#1                #5                #12                #19
?!/$.@            ?$!>$@            .?!/$@             |!|?$@  # ><
?!/$1@  # OoM     ?$!|$@            =?!/$@
?!/$=@                                                 #20
?!/$\@            #6                #13                $@.?<!
?!/$o@  # x3      ?/!<|@            .?/!$@             $@1?<!  # OoM
?!/$!@  # x2                        =?/!$@             $@=?<!
                  #7                                   $@o?<!  # x3
#2                ?\!<|@            #14
?!>$)@                              \!?__@             #21
?!>$1@            #8                                   _>_!?@
?!>$o@  # x3      ?<!>$@  # ><      #15
?!|$)@                              \_?!$@             #22
?!|$1@            #9                                   <!@.$?
?!|$o@  # x3      ?\$!@$            #16                <!@/$?
                                    \_?!_@             <!@=$?
#3                #10                                  <$@!$?
?!|)$@            ?~#!@)            #17                <.@!$?
?!|1$@            ?~#!@1            $$?\@!             </@!$?
?!|o$@  # x3                                           <=@!$?
                  #11               #18
#4                ?$)\@!            \$?\@!             #23
?_!<@>            ?$1\@!                               <<@]!?
                  ?$o\@!  # x3

Aşağıdaki, daha fazla temsili gruptan bir avuç için kısa bir adım. Özellikle 10 ve 23 numaralı gruplar kontrol etmeye değer. Diğer gruplarda birçok ilginç ve bazen karmaşık yollar var, ancak bunun sonunda sizi yeterince sıktığımı düşünüyorum. Gerçekten Hexagony'i öğrenmek isteyen herkes için, aynaların daha da muhtemel kullanımlarını sergiledikleri için bunlar kesinlikle araştırmaya değer $.

Grup 1

Bu benim orijinal çözümümden daha ayrıntılı değil, ama yollar farklı yönlere gidiyor. Aynı zamanda, tek bir hücrede en fazla sayıda varyasyona izin verir, çünkü en sağdaki no op, yapısını değiştirmeden hala geçerli kılan 5 farklı komutla değiştirilebilir:

2. Grup

Bu oldukça ilginç, çünkü sadece yatay hareket ediyor. İçin sarma sonra >, IP köşesinde dalı alarak, derhal tersine çevirir. Şema tamamen gözle görülebilir bir şekilde görünmüyor, fakat durumda 1ilk satırı tekrar geçiyoruz, fakat bu sefer geriye doğru. Bu aynı zamanda ?, şimdi geri dönen 0(EOF) , tekrar karşılaştığımız anlamına gelir . Bu, )yazdırmayı sürdürmek için (artış) ile sabitlenir 1. Bu aynı zamanda, 5 varyasyonları vardır )da olabilir 1ya da ove >aynı zamanda olabilir |:

Grup 3

Bu bir öncekiyle neredeyse aynı görünüyor ama cehennem gibi dağınık. Vuruşa |ve sonra alt ya da üst sıraya hareket etmek aynıdır. Fakat bir döngü durumunda, $şimdi aynanın ) üstüne atlar . Böylece turkuaz yolu sağa doğru izliyoruz, şimdi artmaya çarpıyoruz, tekrar tekrar@ sarılmadan önce üstünden atlıyoruz ve sonra tepedeki yeşil yola geri dönüyoruz.|

4. Grup

Bunun özellikle şık olduğunu düşündüm:

_Sağ üst köşede ayna başlangıçta no-op, bu yüzden yazdırmak !ve vurmak <. 0Yolu şimdi yatay ayna vurur ve sonlandırır. 1Sarar, aşağı eğilir: yol olsa gerçekten ilginç bir yörünge alır !yatay doğru yönlendirildi ve daha sonra geri sarar ! tekrar . Daha sonra bu eşkenar dörtgen şeklinde hareket etmeye devam eder, her yineleme için iki kez basar (her üç tıklatma).

8. Grup

Bu gerçekten sıkı bir baskı döngüsüne sahip iki çözümden biridir:

<Dalı olarak görür. İki kez sardıktan sonra, 0vurur @. 1Öte yandan, önce atlar ?sonra tekrar >üzerine gönderir $, böylece atlar @. Daha sonra IP ileri ve geri arasında sıçrar turkuaz yolu içine kaydırılır >ve <(ara kenarında ambalaj).

Grup 10

Başka komut işaretçisi kullanan iki gruptan biri ve kesinlikle çok güzel. Hexagony 6'ya sahiptir - her biri saat yönünde olan kenardan farklı bir köşeden başlar, ancak bir anda sadece biri aktif durumdadır.

Her zamanki gibi okuduk ?. Şimdi ~sıradışı olumsuzlama: 1a dönüşür -1. Sonra, biz vurduk #. Bu IP'ler arasında geçiş yapmanın bir yoludur: modulo 6'nın geçerli kenar değerini alır ve karşılık gelen IP'ye geçer (IP'ler 0saat yönünde numaralandırılır ). Yani eğer girdiyse, 0IP basitçe aynı kalır ve dümdüz ileri doğru ilerler !@. Giriş Ama eğer 1, o zaman şimdiki değeridir -1olan 5 (mod 6). Böylece aynı hücrede başlayan (yeşil yol) IP'ye geçiyoruz. Şimdi #bir op-op ve ?hafıza kenarını ayarlar 0. )artımlar !a 1. Şimdi bunu ~sağlamak için tekrar vurduk#hala bir operasyon dışıdır (programı sonlandıracak olan IP 1'e geçmek yerine). Bu küçük programda her şeyin birbirine ne kadar iyi uyduğuna şaşırıyor.

Grup 22

Sadece not etmek gerekirse, bu benim orjinal çözümümün içinde bulunduğu gruptur. Aynı zamanda en büyük grup olur çünkü no-op iki farklı yerde olabilir ve gerçek (etkili no-op) komutu için birkaç seçenek vardır.

Grup 23

Bu, çoklu IP kullanan diğer gruptur. Aslında bu, 3 farklı IP kullanıyor . Sağ üst köşe biraz dağınıklık, ancak size bu konuda yürümeye çalışacağım:

Böylece, daha önce gördüğünüz başlangıç: <Kuzey-Doğu'yı saptırıyor, ?girdiyi okuyor. Şimdi ]IP'ler arasında geçiş yapmanın başka bir yolu: saat yönünde sırayla kontrolü bir sonraki IP'ye veriyor. Bu yüzden kontrolü biz (görmek zor biliyorum) Güney-Doğu'ya doğru giden Kuzey-Doğu köşesinde başlayan turkuaz patikaya geçiriyoruz. Hemen <Güney-Doğu köşesine dolanan Kuzey-Batı'ya kayıyor. Aynı zamanda vurur ]yüzden geçiş sonraki IP. Bu Doğu köşesinde başlayan ve Güneybatıya giden gri yol. Girdiyi yazdırır, ardından Kuzeydoğu köşesine kaydırır. <yolu, diğeri tarafından yansıdığı yatay olarak saptırır <. Şimdi sağ<şube görevi görür: girdiyse, 0IP Kuzey-Doğu'ya hareket eder ve @. Girdi olsaydı, 1IP moves ye hareket eder , yansıdığı yerde !sola sarılır <... şimdi köşede, tekrar sarar !, sağ tarafından saptırılır <, sola yansıtılır <ve yollar başlar bitmiş...

Oldukça karışıklık, ama güzel bir karışıklık. :)

İle oluşturulan Diyagramlar Timwi en şaşırtıcı HexagonyColorer .

Motorola MC14500B Makine Kodu, 2 bayt

Onaltılı olarak:

58EC

Açıklama:

5  OR the register with input from the data bus
8  Write the register to the data bus
E  Skip next instruction if register is zero
C  Jump

Motorola MC14500B 1 bitlik bir mikrodenetleyicidir; 1 bitlik bir kaydettirici ve 1 bitlik bir veri yolu vardır. Kodlar her biri 4 bit olduğundan, yalnızca on altı; bunların yarısı kayıt ile veri yolundaki bit arasında mantıklı bir işlem gerçekleştirir.

Atlama talimatı bir atlama bayrağı belirler; Adres verilmediğinde, program sayacını 0 olarak ayarlamak yaygındır. Giriş biti sıfırsa, işlemci atlamaz. Giriş biti 1 ise, işlemci tekrar başlangıcına atlar; ORGirişe girdiğimizden beri giriş sinyalinin ne olduğu önemli değil - kayıt sonsuza dek 1 olacak.

Alışılagelmiş olduğu gibi, kayıt 0 olarak başlatılır.

Kodların bir listesi veri sayfasında veya burada bulunabilir .

Arnold C, 296 Bayt

IT'S SHOWTIME
    HEY CHRISTMAS TREE i    
    YOU SET US UP @NO PROBLEMO
    BECAUSE I'M GOING TO SAY PLEASE i
        STICK AROUND i
            TALK TO THE HAND i
        CHILL
    BULLSHIT
        TALK TO THE HAND i
    YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE BEEN TERMINATED

Gerçekten rekabetçi değil, ama eğlencesi için. Stdin'i desteklemiyor, sıfır değeri @NO PROBLEMOile değiştirin @I LIED. @No Problemo1.

Çalıştır (dosyanın truthmachine.arnoldc olduğunu varsayarak):

wget http://lhartikk.github.io/ArnoldC.jar
java -jar ArnoldC.jar truthmachine.arnoldc
java truthmachine

Minecraft, 18 Bayt (MC Sürümü 15w45a)

Gördüğünüz gibi, içinde komut bulunan yinelenen komut bloğuna yönlendirilmiş bir kol say 1var. Bunun üzerinde bir sinyal çevirme torcu var, bu da gücü içinde komut olan tek-run komut bloğuna yönlendirir say 0.

Anahtar ne zaman trutiye yönlendirilirse, tekrarlayıcı blok say 1sonsuz 1s çıkışı için kodu kullanır . Kol yanlışa yönlendirildiğinde, tek çıktı verir 0.

Bunun [@]varsayılan olarak bir çıktı verdiğini unutmayın . Eğer varsa gerçekten sadece düz yukarı 1'ler ve sıfırları istiyorum bu komut bloklarda kodudur 34 bayt haline gelir tellraw @a [1]ve tellraw @a [0]. Bu MC için Cᴏɴᴏʀ O'Bʀɪᴇɴ önerdiği bayt sayısı @ kullanıyor Meta bulunabilir olarak .

Bash + GNU yardımcı programları, 13

grep 0||yes 1

Bash, 35

read n;for((;n;));{ echo 1;};echo 0

Ruby, 20

print while/1/||gets

Uyarıları önlemek için komut satırından çalıştırın.

ruby -e "print while/1/||gets" <<< 0
ruby -e "print while/1/||gets" <<< 1

Açıklama:

Daha az golf oynadı, bu

while /1/ || gets
  print
end

Koşullu bir Regexp kullanıldığında, değişken $_doldurulmadığında ve kalıpla eşleşmedikçe, falsey olarak değerlendirilir . Döngüde ilk kez $_boştur, bu yüzden STDIN'den okunan bir çizginin getsdeğerini ayarlayan düşüyoruz $_. printhiçbir argüman olmadan yazdırır $_. Şimdi şartlıları tekrar değerlendiriyoruz. Eğer 1 okursak kısa devre yapıyoruz ve tekrar 1 basıyoruz ve sonsuza dek sürüyoruz. Aksi takdirde, düşüyoruz gets, ancak ikinci bir girdi satırı olmadığından getsnil döndürür, böylece döngü sona erer.

Mikroscript, 3 bayt

i{p

En kısa tanıdığım.

Açıklama:

i  Takes numeric input and puts it in register 1
{  while register 1 is truthy
  p  Print the contents of register 1

Microscript, sonlandırma üzerine yazmacın 1 yazdırılmasını içerir; bu nedenle bir girişin bir 0kez basılmasının nedeni budur .

Turing Makine Kodu, 32 bayt

Burada bulunan kural tablosu sözdizimini kullanarak .

0 0 0 * halt
0 1 1 r 1
1 _ 1 r 1

JavaScript, 28 bayt

Çünkü döngüler genellikle döngülerden daha kısadır.

alert(x)undefinedyanlış olan döner , yani bitsel veya operatör, |onu atar 0. Böylece, xbir "0"uyarı kez aksi döngü tutun. Bu cevapalert gibi STDOUT için kullanır .

for(x=prompt();alert(x)|x;);

Python 2,29 bayt

a=input()
while 1:print a;1/a

Bu 0, varsayılan olarak izin verilen bir bölme hatasıyla sona erer .

Brainfuck, 41 36 31 30 bayt

Girişten hemen sonra ve Ethan ve user46915'in yardımıyla bir kez basılarak kısaltılır.

,.+++[->>+<-----<]>>---<-[>.<]

Önceki sürüm: 48'ü girişten çıkarın ve sıfır değilse, ASCII'yi 1sonsuza dek yazdırmak için 48'e 1 ekleyin , aksi takdirde yazdırın 0.

-[>+<-----]>--->,<[->->+<<]>[>+<]>.<[>.<]

Burada koştum , ancak tamponlanmış çıktı nedeniyle, program hiç bitmediğinden herhangi bir çıktı göremiyorsunuz 1.

Düzenleme: 0Girişe yazdırmayı unutmuştum 0. Şimdi düzeltildi. >.<Sonunda yüzleri seviyorum .

Piet, 27 18 16 kod çözücüler

(Kodel, bir resim görüntülenmek üzere gerildiğinde kargaşayı önlemek için kullanılan piksel için süslü bir addır. Bayt yerine kodel saydım, çünkü piet komut dosyaları görüntü olarak kaydedilir, bu nedenle fiziksel boyut değişebilir. Bu piet mümkün olduğu kadar verimli bir şekilde 11 byte alabiliyordu. Pratikte minik gif dosyam 62 byte, optimal palet verisine sahip. Bunu, girdiyi yerine tutam miktar olarak kullanmam gerekip gerekmediğini söyle.)

Orijinal görüntü:

Genişleyen:

Piet'te iki renk arasındaki fark, hangi komutun çalıştığını belirleyen şeydir, bu nedenle aynı rengi iki kez görmek, aynı işlemi yaptığı anlamına gelmez. Yürütme, sol üst kabinde başlar. Sonra yatay olarak hareket eder ve aşağıdakileri gerçekleştirir:

1. Bir numara oku ve yığına koy
2. Yığının tepesini çoğalt
3. Yığın üstünü Pop ve çıktı
4. Yığının tepesini açın ve saat yönünde döndürerek bu sayı kadar çevirin.

Giriş 1 ise, imleç daha sonra yığında 1'i iterek kireç çubuğuna doğru hareket eder. Sonra infaz sola devam ediyor. İmleç bir renkten beyaza ve beyazdan bir renge geçtiğinde hiçbir şey olmuyor. Siyah da duvar olarak kabul edildiğinden, imleç en üst satırda bulunan kireç çubuğuna geri döner ve her şeyi 2. adımdan itibaren tekrarlar.

Bununla birlikte, eğer girdi 0 ise, imleç asla aşağı inmeyecek ve sağdaki mavi J ile bitecektir (punto buna değdi), hapsolmuş olarak kalacaktı (üst, sağ, sol ve Bu J-biçimli bloğun alt tarafları siyah kodellerin veya görüntünün kenarının yanındadır). İmleç yakalandığından, yürütme sona erer.

Beklenmeyen değerler:
Kullanıcı başka bir sayı yazarsa, yine de yazdırılır, sonra imleç değere bağlı olarak az çok döner.

• 4 veya 0'ın katı: yürütme yatay olarak devam eder ve biter.
• 3'ün katı: Yukarı çıkması imkansız olduğundan, imleç hemen saat yönünde döner ve yatay olarak devam eder, sonra sona erer.
• 2'nin katı ve 4'ün katı değil: imleç döner ve sola hareket etmeye başlar. Neyse ki, tüm bunlar program akışını etkilemeyen ve istifin boşaltılmasıyla sonuçlanan bir dizi işlem yapmaktır. Yığın boş olduğu için bir işlem yapılamadığında, basitçe yoksayılır. Sol üst köşeye çarptığında, imleç programı etkin bir şekilde yeniden başlatan başka bir yere gitmez, tekrar sağa döner.
• Diğer değerler: İmleç, 1 ile olduğu gibi aşağı iner ve bu da sonsuza dek 1 yazdırır. Giriş 5 ise, çıkış5111111111111...

Tamsayı olmayan herhangi bir değer programı sonlandırır. Uygulama normal şekilde devam edecek, ancak yığında hiçbir şey olmadığından tüm işlemler yoksayılacak. Böylece, bir şekilde, program hiçbir zaman çökmez - ya normal olarak durur ya da sonsuza dek döngüye girer.

PietDev dostu sürüm

PietDev (çok basit bir çevrimiçi Piet IDE), beyaz kodeller konusunda sorun yaşıyor gibi görünüyor, bu yüzden uygun beyaz kodlu otomatik rotasyona güvenmek yerine elle geriye dönen yeni bir sürüm yaptım. Ve yeni bir renk kullanmam bile gerekmedi! Test etmek istiyorsanız, kodun etrafına siyah bir kenarlık çizdiğinizden emin olun, çünkü PietDev özel program boyutlarını desteklemez.

eski versiyonlar

İlk sürüm 1'i yığına geri itmedi ve daha önceki bir çoğaltma komutuna geri döndü. Ayrıca dekoratif işe yaramaz kodeller vardı.

Sonra boş çizgiyi kaldırmak için yığına 1 basma fikrim vardı. Dekoratif kodellerim sayesinde bunu nasıl düşündüğüm çok komik.

Ardından, artık gerekmeyen fazladan bir kopya aldığımı farkettim ve görüntüdeki palet verisinden tasarruf etmek için renk sayısını azalttım. Ben de tek dekoratif kabarıklıktan kurtuldum çünkü bilmiyorum.

Pyth, 4 3 2

Wp

Orada bir hayır! arkadaki boşluk (teşekkürler isaac :)). While döngüsünü derlemek için gerekli alan kullanılmış, ancak Pyth o zamandan beri güncellendi. Normalde bu kullanımdan diskalifiye olur, ancak bu bir katalog olduğundan geçerli olması gerekir.

Açıklama:

Wp        : implicit Q = eval(input)
W         : while
 p        : print and return the value of Q, to be evaluated as the while condition
          : Functions without enough arguments automatically use Q now
          : do nothing in the body of the while loop

Çip , 6 bayt

e*faAs

Chip biraz entegre bir devre gibi davranan bir 2D dilidir. Her seferinde bir bayt girişi alır ve bitleri ayrı girdi öğelerine ayırır. Çıktı, çıktı öğelerinin değerlerini tekrar baytlara dönüştürür.

Bunu yıkalım:

*bir kaynak sinyaldir, tüm bitişik elemanlara gerçek bir değer gönderir. eve fçıktının beşinci ve altıncı bitine karşılık gelir. Yani, ASCII char "0" olan e*fikiliyi üretir 00110000.

Şimdi, Ailk girdi biti ve ailk çıktı biti, bu nedenle aAbu biti girişten çıktıya kopyalar. Böylece, e*fbir ASCII "0" girişi "0" üretir ve "1" "1" üretir. ( Hiçbiri sinyal üretmediğinden fve arasında bir etkileşim yoktur a.)

sGerçek bir sinyal ile aktive olduğunda ucunda, her şey aynı girişi ile tekrar çalışacaktır, yani sonraki bayta ilerleyen girdi önleyecektir.

"0" 'ın ilk baytı sıfır olduğundan, bu elemanı aktive etmeyecek ve program "0" yazacak ve böylece sonlandırmasına izin veren girişini tüketecektir. Bununla birlikte, "1", bu öğeyi harekete geçirir; bu, "1" in çıktı olduğu, ancak girdi üzerinde tüketilmediği ve döngünün süresiz olarak tekrar etmesine izin verdiği anlamına gelir.

0x0 ve 0x1 değerleri ASCII yerine çıktı için kullanılırsa, bu e*fbölümü ortadan kaldırabiliriz , sonuçta sadece 3 baytlık sonuçlanır :

aAs

Eğer sıfır, stdin'in kapanmasını beklemek yerine kendisini sonlandırmak zorunda kalırsa, programı sonlandıran ( 10 byte ) ilk baytı ters çeviren ~ve sonucu geçen aşağıdakileri alırız :t

aA~te*f
 s

( tayrıca sinyal üretmez, bu nedenle tve arasında etkileşim yoktur e.)

Brainbool , 5 bayt

,.[.]

Brainbool Brainfuck'tır, ancak yalnızca bitlerde çalışır ve G / Ç 0ve 1karakterlerle çalışır.

LOLKOD, 119 bayt

GIMMEH n
n R SUM OF n AN 0
BOTH SAEM n AN 0, O RLY?
YA RLY
 VISIBLE 0
NO WAI
 IM IN UR l
  VISIBLE 1
 IM OUTTA UR l
OIC

Ungolfed:

HAI

BTW, Read n as a string from STDIN and convert to an integer
GIMMEH n
n R SUM OF n AN 0

BTW, Test n for equality with 0
BOTH SAEM n AN 0, O RLY?
YA RLY
    BTW, Write 0 to STDOUT and exit
    VISIBLE 0
NO WAI
    BTW, Loop forever, printing 1
    IM IN YR l
        VISIBLE 1
    IM OUTTA YR l
OIC

KTHXBYE

C, 37 bayt

C. içinde nasıl yapılacağını farklı bir almak

main(c){for(gets(&c);putchar(c)&1;);}

cBir varsayılan intdeğer 1'in gets(&c)bir dize aldığı stdinburadan değerini clobbering, chackishly beri, cbir değil char*. putchar(c)değerini yazar ciçin stdoutve döner c. Yana '0'48 ve '1'ASCII 49, biz son bit kullanabilirsiniz ( &1) o olduğunu belirlemek için. Eğer öyleyse '0', döngü bozulur. Aksi takdirde, sonsuza kadar gider.

Derler (hakkında bir uyarı ile gets) ve gcc-4.8Linux altında çalışır .

Labirent , 7 bayt

 ?+
@!:

Labirent, kontrol akışının her komuttan sonra kontrol edilen yığının üst öğesinin işaretine bağlı olduğu 2B yığın tabanlı bir dildir. İcra, en üst sıradaki ilk geçerli komuttan itibaren doğru hareket etmeye başlar ?.

İlgili talimatlar:

?      Input integer
+      Add top two elements (Labyrinth's stack has infinite 0s on the bottom)
:      Duplicate top element
!      Output as number
@      Terminate program

Giriş 0 ise, IP girişi okur ?, yığının en üst iki tanesini ( 0 + 0 = 0) ekler , sonra 0 değerini çoğaltır :ve çıkar. !Burada programdaki tek kavşakla karşılaşırız ve belirlemek için yığının üstünü kontrol etmek zorunda kalırız. nereye gitmek Üst 0 olduğu için ileri doğru hareket eder ve sonlandırırız @.

Öte yandan, eğer giriş 1 ise, önceki noktadaki kavşağa varmadan önce aynı talimatları uygularız (ancak 1 çıkışını yaparız) !. Şimdi yığının tepesi pozitiftir ve sağa dönmemize neden olur ?. EOF'da Labyrinth 0'a basar, bu yüzden , duplicate ve output 0 + 1 = 1de yaparız . Bir kez daha yığının tepesinde 1 var ve döngü devam ediyor.+:!

Bir bonus için, burada benzer şekilde çalışan @ MartinBüttner'ın 7 baytlık çözümü:

?+!@
1!

Çoğu dilin aksine, 1aslında nyığından dışarı fırlar ve iterek n*10 + 1büyük sayıların oluşturulmasını kolaylaştırır. Ancak, yığının üstü bu noktada boş olduğundan, yalnızca 1'i itmekten farklı değildir.

> <> , 7 bayt

i2%:n:,

Bu, <<> 'nın 1 mod 2 olan EOF'de -1'i ittiği gerçeğini kullanır (ayrıca, fesih için STDERR çıktısının göz ardı edildiğinden, görünüşe göre tamamdır).

Sadece referans için, hatasız bir şekilde temiz çıkılması fazladan bir bayttır:

i2%:n?!;

APL, 6 bayt

→⎕←⍣⍲⎕

Açıklama:

     ⎕ Read the input, then
 ⎕←    write it out
   ⍣   repeatedly
    ⍲  until NAND of it with itself becomes true.
→      Branch to zero to avoid printing the result again.

Brian ve Chuck , 21 bayt

,}<-{-?<SOH>_{+?
_>+{?<.p

Burada, <SOH>karşılık gelen kontrol karakteriyle (0x01) değiştirilmelidir.

açıklama

Temel fikir, girişin (48 veya 49) karakter kodunu pChuck'ın sonundan çıkarmaktır ( ya ?geçerli bir komuttur) ya da @'no-op' olur.

,giriş karakterini Chuck'ın ilk hücresine okur (ile işaretli _). 0Başka bazı değişiklikler yaparken bu değeri bir döngüde düşürmek istiyoruz :

}<hareket eder pve -azaltır. Sonra {tekrar giriş hücresi -azalışlarına geri döner . Bu henüz sıfır olmadıkça, ?Chuck'a kontrol verir. Şimdi >Brian'ın bant başını bir hücreyi sağa doğru hareket ettirir (ki bu başlangıçta 1) +. Sonra döngüyü sıfırlarız {?.

Chuck'taki ilk hücre çarptığında 0, <SOH>hücre STDIN'den okuduğumuz karaktere partırılacak ?ve giriş 1ya da @giriş için olacaktır 0.

Artık ?kontrolü değiştirmiyor. Boşluktan sonraki 0ya da 1sonra gelen, sıfır baytı (ile temsil edilen _). {Chuck'ın ilk hücresine geri döner ve +pozitif olmasını sağlamak için artışlar yapar, böylece ?eller Chuck'ı kontrol eder.

Bu sefer >+Brian'ın ilk kasetinin bitiminden sonra hücreyi arttır. Bu hücre çöp, ama asla kullanmayacağız. Şimdi {tüm yolu Brian'ın kasetinin ön kısmına taramıyor, sadece _. Bu nedenle ?no-op'tur çünkü mevcut hücre sıfırdır. Sonra <.bir tane sola doğru hareket eder (giriş karakterinin kopyası) ve onu yazdırır.

Sonunda ?veya ile karşılaşıyoruz @. Girdi 0ve bu hücre ise @no-op ve program sonlandırılıyor. Fakat eğer giriş buysa 1ve bu hücre ise , Chuck’daki döngüyü sıfırlayacak ?olan Brian’a teslim oluruz {+?ve şimdi 1sonsuza kadar yazdırırız (Brian’ın kasetinin ucundaki hücrede bulunan tamsayı herhangi bir belleğe sığmayana kadar) daha fazla, sanırım ...).

Bonus

Sp3000 ve ben birkaç gündür bu işte golf oynuyoruz. 40 bayt civarında başladık ve tamamen farklı iki ikimize ulaştık, ancak çözümleri 26 bayta bağladık. Sadece benim için açıklamayı yazmaya başladığımda, yukarıdaki 21 baytlık çözüm bana geldi. Etrafa fikirlerini attığı ve B & C'deki golf oyunlarını öğrettiği için çok teşekkürler. :)

Bu onun 26 baytlık çözümü:

>,----{?{>1?0
#I<?_}<.<<<?

Ve bu benim:

,{>-<-?_0+?_1{<?
_®{?_{>.?

Nerede ®değeri 174 ile bir bayt (örneğin sadece ISO 8859-1 olarak dosyayı kaydedin).

Ki özünde maden, 21 baytlık çözeltisine benzer şekilde çalışır ®hale }girişi 1ve ~girişi için (bir-op) 0, ancak yürütme daha az şık.

Çözümü kaynak kodunun yalnızca ASCII olması ve girişi işlemek için bir döngü gerektirmemesi nedeniyle oldukça temiz. Bunun yerine, ----döner 1içine -ve 0içine ,(Chuck için no-op). Bu -daha sonra ?Brian'ın kasetindeki ilk parçayı a olarak değiştirecek >, böylece 1çanta için farklı kontrol akışı yaratacak.

Bitsel Döngüsel Etiket , 3 bit veya <1 bayt

Bitsel Döngüsel Etiket, buradaki en basit Turing-tamamlama dillerinden biridir. Program ve veriler iki bitstrings ile çalışır . Bit programı aşağıdaki gibi siklik okumak ve yorumlanır:

• 0: İlk veri bitini silin (ve çıktısı olan uygulamalarda çıktısını alın).
• 1x: İlk veri biti ise 1, verinin sonuna x( 0veya birini temsil edin 1) ekleyin . (İlk veri biti ise 0hiçbir şey yapmayın.)

Veri dizisi boşalana kadar program çalışır.

Doğruluk-makine

110

Veri dizgisi şu şekilde ayarlandığında 0:

• 11ilk veri biti olmadığı için hiçbir şey eklemez 1.
• 0siler / çıktılar 0.
• Veri dizgisi şimdi boş ve program durdu.

Veri dizgisi şu şekilde ayarlandığında 1:

• 11ekler a 1.
• 0siler / çıktılar 1.
• Veri dizesi teke geri döndü 1ve program başladığı yere geri döndü, bu yüzden sonsuza dek dönüyoruz.

GNU sed, 10

:;/1/{p;b}

açıklama

• : adsız bir etiket tanımla
• /1/Girdi regex ile eşleşiyorsa 1, o zaman
• p Desen alanını yazdırın (ör. 1)
• b ve adsız etikete geri dönün (sonsuza kadar)
• Giriş 1 değilse (yani 0), kalıp alanı değiştirilmemiş olarak yazdırılır ve program sona erer.

Cidden , 4 3 bayt

_{Geçiş 4 hala 4 :(}

,W■

,STDIN'den bir değer okur. WYığının üstündeki değer varken, gövdeyle birlikte çalışan bir döngü başlatır ■. ■üst yığın öğesini haşlama olmadan yazdırır. Döngü EOF'de dolaylı olarak kapalı

Girişte 0, döngü hiçbir zaman çalışmaz (çünkü 0falsey) ve program otomatik olarak yığına her değeri girip basarak EOF'da sona erer. Girişi üzerine 1(ya da herhangi bir değere 0, ""ya da []), sonsuz döngü olarak çalışır.

In Aslında , lider ,2 byte aşağı puanı getiren (örtük girişi sayesinde) gerekli değildir.

Salı, 34 bayt

1::=12
2::=~1
0::=~0
@::=:::
::=
@

Açıklama:

1::=12 "1" alt dizgesinin örnekleri "12" olabilir

2::=~1 "2" alt dizisinin örnekleri kaldırılarak "1" yazdırılabilir

0::=~0 "0" alt dizisinin örnekleri kaldırılabilir ve "0" yazılabilir.

@::=::: "@" Alt dizininin örnekleri girişten gelen dizelerle değiştirilebilir

::= İkame kurallarının son listesi

@ İlk dize "@"

Arnold C, 134 bayt

IT'S SHOWTIME
HEY CHRISTMAS TREE i
YOU SET US UP 0         //or 1
STICK AROUND i
TALK TO THE HAND 1
CHILL
TALK TO THE HAND 0
YOU HAVE BEEN TERMINATED

Bu diğer ArnoldC cevabı kadar eğlenceli olmasa da , golf oynuyor. Örneğin, girinti gereksizdir ve bu yüzden makrolardır @NO PROBLEMOve @I LIED.

Giriş yapamayan dilin bu sürümü ile test edilmiştir .

Cubix , 5 6 bayt

Cubix @ETHproductions, komutların bir küpün yüzleri etrafına sarıldığı 2 boyutlu yeni bir dildir. Çevrimiçi tercüman Tasarruf için @ETHproductions sayesinde.

!I\@O

Bu, küp kadar genişler

  !
I \ @ O
  .

Bu Ikomutla başlar . Yığına bir tam sayı girin.
\, komut göstergesini işlem dışı no üzerinde yönlendirir.
O, yığının tepesinin sayısal değerini çıkarır.
!, @yığının üstü doğru ise bir sonraki komutu ( ) atlayın . Bu atlar \1 eğer yönlendirmeyi
\, talimat işaretçisi yönlendirir @çıkış programı.

Bu, yığının O ? !komutlar tarafından atılmadığı gerçeğinden faydalanır .

Foo , 6 bayt

&1($i)

Foo STDIN girişine sahip olmadığından giriş ikinci karakter olarak kodlanmıştır. Foo'nun şimdi muhteşem olduğu konusunda hemfikir değil miyiz? :)

açıklama

&1          Set current cell to 1
  (  )      Do-while loop (or, at least according to the interpreter)
   $i       Print current cell as int

Perl, 18 + 1 = 19 13 + 1 = 14 bayt

print while$_

Bu şekilde koş:

echo -n NUM | perl -p truth.pl

ThisSuitIsBlackNot sayesinde (kim benden golf oynamakta daha iyi) beş byte golf oynadığı için.

> <> , 6 bayt

::n?!;

Başlamak için yığındaki girişi iter

:        copy top element on stack
 :       copy top element on stack again
  n      pop and outputs top element
   ?     condition trampoline - pops top element, if it is zero skips next instruction
    !    trampoline skips next instruction
     ;   finish execution