En yaygın standart görevlerden biri (özellikle ezoterik programlama dillerini gösterirken) bir "cat programı" uygulamaktır : tüm STDIN'leri okuyun ve STDOUT'a yazdırın. Bu, Unix kabuk yardımcı programından sonra adlandırılmış olsa catda, normalde diskten okunan birkaç dosyayı yazdırmak (ve birleştirmek) için kullanılan gerçek şeyden çok daha az güçlüdür.

Görev

Standart giriş akışının içeriğini okuyan ve bunları standart çıkış akışına sözlü olarak yazan tam bir program yazmalısınız . Eğer ve eğer diliniz standart giriş ve / veya çıkış akışlarını desteklemiyorsa (çoğu dilde anlaşıldığı gibi), bu terimleri kendi dilinizde en yakın karşılığı (örneğin, JavaScript promptve benzeri) anlamında kullanabilirsiniz alert. Bunlar sadece başka bir arayüz, büyük ölçüde görevin niteliğini değiştirmek ve daha az karşılaştırılabilir cevapları kılacağı için, I / O ve kabul edilebilir formlar.

Çıktı tam olarak girişi içermeli ve başka bir şey içermemelidir . Bu kuralın tek istisnası, selamlama, ANSI renk kodları veya girintiler gibi bastırılamayan dilinizin tercümanının sürekli çıktısıdır. Bu aynı zamanda takip eden yeni hatlar için de geçerlidir. Girdi sonunda yeni bir satır içermiyorsa, çıkışın da birini içermemesi gerekir! (Bunun tek istisnası, dilinizin yürütmeden sonra mutlaka daima yeni bir satırsonu yazmasıdır.)

Standart çıkış akımı beklenen çıkışı içerdiği sürece standart hata akışına çıkış dikkate alınmaz. Bu, özellikle, standart çıkış akışını kirletmemesi koşuluyla, programınızın akışın sonuna (EOF) çarptığında bir hatayla sona erebileceği anlamına gelir. Bunu yaparsanız, cevabınıza hatasız bir versiyon eklemenizi de tavsiye ederim (referans için).

Bu, diller arasında değil, her dilde bir zorluk olarak tasarlandığından, dile özgü birkaç kural vardır:

• Dilinizde standart giriş akışındaki boş baytları EOF'den ayırt etmek mümkün ise, programınız diğer baytlar gibi boş baytları da desteklemelidir (yani standart çıkış akışına da yazılmalıdır).
• Kendi dilinizde keyfi bir sınırsız giriş akışını desteklemek mümkün ise (örn. Girişte EOF tuşuna basmadan önce çıktıya bayt yazdırmaya başlayabilirseniz), programınızın bu durumda doğru çalışması gerekir. Örnek olarak yes | tr -d \\n | ./my_catsonsuz ys s yazdırmalısınız . Standart çıkış akışını ne sıklıkta yazdırıp sıkıştıracağınız size bağlıdır, ancak akıştan bağımsız olarak sınırlı bir süre sonra gerçekleşmesi garanti edilmelidir (bu, özel bir karakter için bekleyemeyeceğiniz anlamına gelir) yazdırmadan önce bir satır beslemesi).

Lütfen boş baytlar, sonsuz akışlar ve yabancı çıktılarla ilgili tam davranış hakkındaki yanıtınıza bir not ekleyin.

Ek kurallar

• Bu, bunun için en kısa çözümü içeren dili bulmakla ilgili değildir (boş programın hile yaptığı bazı yerler vardır) - bu, her dilde en kısa çözümü bulmakla ilgilidir . Bu nedenle, hiçbir cevap kabul edilmiş olarak işaretlenmeyecektir.

• Çoğu dilde yapılan gönderiler, genellikle önceden var olan bir UTF-8 kodlama kodunda bayt olarak puanlanacaktır .

  Klasörler gibi bazı dilleri puanlamak biraz zor. Şüpheniz varsa, üzerine sorabilirsiniz Meta .

• Bu zorluktan daha yeni olsa bile, bir dili (veya dil sürümünü) kullanmaktan çekinmeyin. Bu zorluğa 0 baytlık bir cevap göndermek için özel olarak yazılan diller adil oyundur ancak özellikle ilgi çekici değildir.

  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).

  Ayrıca, dillerin programlama dilleri için genel kriterlerimizi yerine getirmesi gerektiğine dikkat edin .

• Seçtiğiniz dil, zaten bir cevabı olan (belki de BASIC veya SQL lehçeleri, Unix kabukları veya önemsiz Brainfuck türevlerini düşünen), başka bir (potansiyel olarak daha popüler) dilin önemsiz bir değişkeni ise, mevcut cevaba bir not eklemeyi düşünün. aynı veya çok benzer bir çözüm diğer dilde de en kısa olanıdır.

• Daha önce reddedilmediklerinde , http://meta.codegolf.stackexchange.com/q/1061 dahil tüm standart kod golf kuralları uygulanır .

Bir yandan not olarak, lütfen golf için fazla bir şey olmadığı dillerde sıkıcı (ama geçerli) cevapları azaltmayınız; Bunlar bir kataloğu mümkün olduğu kadar eksiksiz bir şekilde derlemeye çalıştığı için bu soru için hala faydalıdır. Bununla birlikte, öncelikle yazarın gerçekte kodu golf oynamak için çaba harcadığı dillerde cevapları çoğaltınız.

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: 290px; 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 = 62230; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 8478; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "//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 "//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(42), 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>

sed, 0

Boş sedprogram burada tam olarak ne gerekiyorsa onu yapar:

$ printf "abc\ndef" | sed ''
abc
def$ 

Ziim , 222 201 196 185 182 bayt

    ↓ ↓

 ↓ ↓     ↓
 ↗ ↗↙↔↘↖ ↖
 ↓↓⤡⤢  ⤢↙
↘ ↖⤡ ↖
  ↙
  ↕↘ ↑ ↙
→↘↖↑ ↙ ↑
→↖   ↑
→↖↘ ↙
  ↑↓↑

   ⤡

Bu muhtemelen tarayıcınızda doğru görüntülenmeyecektir, bu nedenle kodun bir şeması:

Ziim'deki problemi çözmek için daha basit bir yapı düşünemiyorum, fakat gerçek kodun hala oldukça golf oynayabildiğinden eminim.

Ziim muhtemelen sonsuz akışlarla başa çıkamaz çünkü program sonunda herhangi bir şey yazdırmak mümkündür.

açıklama

Ziim oldukça benzersiz, bildirimsel bir kontrol akış modeline sahip olduğundan, zorunlu bir sözde kod algoritması burada kesmiyor. Bunun yerine, Ziim'in temelini ve şimdiki kodu, yukarıdaki kodun düzenlenmiş yapısını (benzer grafiksel olarak) ASCII sanatı olarak açıklayacağım.

Ziim'deki kontrol akışı her yerde gerçekleşir: başka bir okla işaret edilmeyen her ok, diğerlerinden bağımsız olarak işlenen bir "iş parçacığı" başlatır (gerçekten paralel değil, ancak hangi sırada işlendiklerine dair hiçbir garanti yoktur) , birleştirme ile onları senkronize etmediğiniz sürece). Bu tür bir iş parçacığı, olarak başlayan, ikilik basamakların bir listesini tutar {0}. Şimdi koddaki her ok, bir veya iki girişi ve bir veya iki çıkışı olan bir tür komuttur. Kesin komut, hangi yönlerden hangi okla işaret ettiğine bağlıdır.

Komutların listesi m -> n, komutun mgirişleri aldığını ve nçıktılar ürettiğini gösterir .

• 1 -> 1, no-op : sadece ipliği yönlendirir.
• 1 -> 1, invert : iş parçacığındaki her biti olumsuzlar (ve ayrıca onu yönlendirir).
• 1 -> 1, read : EOF'a basarsak, iş parçacığının değerini STDIN'den sonraki bit ile veya boş listeyle değiştirir.
• 2 -> 1, birleştirmek : konuları senkronize etmenin tek yolu budur. Bir iplik okun bir tarafına çarptığında, başka bir iplik diğer tarafa çarpana kadar askıya alınır. Bu noktada tek bir iş parçacığında birleştirilecekler ve yürütmeye devam edecekler.
• 2 -> 1, label : farklı yürütme yollarına katılmanın tek yolu budur. Bu sadece iki olası girişe sahip bir no-op'tur. Böylece, "etikete" her iki yoldan giren dişler aynı yöne yönlendirilecektir.
• 1 -> 2, split : tek bir iplik alır ve farklı kopyalarla iki kopya gönderir.
• 1 -> 1, Sıfır mı? : ipliğin ilk bitini tüketir ve bitin 0 veya 1 olmasına bağlı olarak ipliği iki yönden birine gönderir.
• 1 -> 1, Boş mu? : listenin tamamını tüketir (yani boş bir listeyle değiştirilir) ve listenin zaten boş olup olmamasına bağlı olarak, diziyi iki yönden birine gönderir.

Bu nedenle, genel bir strateji belirleyebiliriz. Birleştirmeyi kullanarak art arda tüm girişi temsil eden bir dizeye yeni bitler eklemek istiyoruz. Biz sadece çıktısını döngü yapabilirsiniz BİRLEŞTİR geri girişlerine birine (ve biz temizleyerek, boş bir listeye bu initialize {0}ile IsEmpty? ). Sorun, bu süreci nasıl sonlandırabiliriz.

Geçerli biraz ilave etmek de olacak prepend biz EOF ulaştınız olmadığını gösteren 0 veya 1 a. Dizimizi isZero ile gönderirsek? , yine bu bitlerden kurtulacak, ancak akışın sonunu ayırt edelim, bu durumda ipliğin ızgara kenarından ayrılmasına izin veririz (bu da Ziim'in ipliğin içeriğini STDOUT'a yazdırmasına ve programı sonlandırmasına neden olur) .

EOF'ye ulaşıp ulaşmadığımız isEmpty kullanılarak belirlenebilir mi? girişin bir kopyasına.

İşte söz verdiğim şema:

              +----------------------------+   {0} --> isEmpty --> label <--+
              |                            |                    n    |      |
              v                            |                         v      |
    {0} --> label --> read --> split --> split ------------------> concat   |
                                 |                                   |      |
                           n     v     y                             |      |
 inv --> label --> concat <-- isEmpty --> concat <-- label <-- {0}   |      |
  ^        ^          |                     |          ^             |      |
  |        |          v                     v          |             |      |
 {0}       +------- split ---> label <--- split -------+             |      |
                                 |                                   |      |
                                 +-------------> concat <------------+      |
                                                   |                        |
                                              y    v                        |
                         print and terminate <-- isZero --------------------+

Nerede okumaya başlayacağınızla ilgili bazı notlar:

• {0}Sol üst köşeye giriş döngü başlar ilk tetikleyicidir.
• {0}Sağ üst köşede doğru hemen boş bir listeye temizlenir bir yavaş yavaş girişi olan doldururuz ilk dizeyi temsil eder.
• Diğer ikisi {0}, bir "üretici" döngüsüne (biri ters çevrilmiş, biri değil) beslenir, bize dizgeye hazırlamamız gereken sınırsız 0s ve 1s kaynağını verir .

Altıgen , 6 bayt

Bu 3 bayt (aşağıya bakınız) idi, ancak bu sürüm dilin en son güncellemesinden bu yana uzun sürmedi. Asla kasıtlı olarak bu sürümün kullandığı hatayı vermedim, saymayacağım.

Hatasız bir çözüm (yani, sabit tercümanla çalışan bir çözüm) çok daha zor görünüyor. 2x2'lik bir ızgaraya sıkarken biraz sorun yaşadım, ancak 7 bayta ihtiyacım olmasına rağmen şimdi bir çözüm buldum :

<)@,;.(

Açtıktan sonra, biz alırız:

İlk bellek kenarı 0 olduğu için, <koşulsuz olarak komut göstergesini gri yola sarıldığı Kuzey-Doğu köşegenine saptırır. .No-operasyon. Şimdi ,bir bayt okur ), geçerli baytların (boş baytlar dahil) pozitif ve EOF 0 olacağı şekilde artırır.

Böylece, EOF'de IP @, programı sonlandırdığı kırmızı yola sarılır . Ancak yine de bir bayt okursak, IP yeşil yola (kaydırılır , bunun yerine kenarı orijinal değerine ;indirgeyen STDOUT'a yazdırır. IP şimdi koşulsuz olarak gri yola geri dönüyor ve işlemi tekrarlıyor.

Hakikat Makinesi cevabım için kaba kuvvet komut dosyası yazdıktan sonra , onu kedi programı için de hatasız 6 baytlık bir çözüm bulmaya ayarladım . Şaşırtıcı bir şekilde, bir - evet, tüm olası 6 bayt Hexagony programlarında tek bir çözüm buldu. Gerçeği makineden 50 çözümleri sonra, bu oldukça şaşırtıcıydı. İşte kod:

~/;,@~

unfolding:

Kullanımı ~(tekli olumsuzlama) yerine ()a) sıfıra no-op, çünkü ilginçtir, b) şube kenarlarına swapları, c) Bazı kodlar tek ~kendisiyle işlemi geri iki kez kullanılabilecek . Yani burada neler oluyor:

Geçtiğimiz ilk zaman (mor renkli yol) ~no-op. /Diyagonal Kuzey-Batı içine IP yansıtır. Gri yol şimdi bir karakter okuyor ve karakter kodunu ile çarpıyor -1. Bu, EOF ( -1) 'yi bir gerçek (pozitif) değere ve tüm geçerli karakterleri sahte (pozitif olmayan) değerlere dönüştürür. EOF durumunda IP kırmızı yolu alır ve kod sonlandırılır. Geçerli bir karakter durumunda IP, ~olumsuzlamayı geri ;alan ve karakteri basan yeşil yolu alır . Tekrar et.

Son olarak, burada orijinal sürüm Hexagony tercüman üzerinde çalışmak için kullanılan 3 baytlık versiyon var.

,;&

Labirentin cevabı gibi, giriş akımı sonlu ise bu hata ile sonlanır.

Kodu açtıktan sonra, aşağıdaki onaltılık ızgaraya karşılık gelir:

Operasyon dışı .. Mor yoldan yürütme başlar.

,Bir bayt okur, bir bayt ;yazar. Sonra uygulama somon (ish?) Yolunda devam eder. &İkinci satırın sonundaki köşeye vururken IP'nin mor satıra geri sıçraması için mevcut bellek kenarını sıfıra sıfırlamamız gerekir . Bir kez ,EOF'a basarsa geri döner -1, bu ;da yazdırmaya çalışırken bir hataya neden olur .

Diyagramlar ile oluşturulan Timwi 'ın inanılmaz HexagonyColorer .

TeaScript , 0 bayt

TeaScript, JavaScript için derlenmiş kısa bir golf dilidir.

En son güncellemede, giriş ilk özellik olarak örtük olarak eklenir.

Çevrimiçi deneyin

Alternatif olarak, 1 bayt

x

xTeaScript'te girişi içerir. Çıktı kapalı

Brian ve Chuck , 44 bayt

#{<{,+?+}_+{-?>}<?
_}>?>+<<<{>?_}>>.<+<+{<{?

Başlangıçta bu dili yalnızca kullanılamaz görünen görünen bir programlama dili oluştur için oluşturdum . Ancak basit problemleri golf oynamak için çok hoş bir egzersiz olduğu ortaya çıktı.

Temel Bilgiler: İki satırdan her biri, diğer programın kaynak kodunda çalışan Brainfuck benzeri bir program tanımlar; ilk program Brian, ikincisi ise Chuck olarak adlandırılır. Sadece Brian okuyabilir ve sadece Chuck yazabilir. Brainfuck'ın döngülerinin yerine ?kontrolü diğer programa geçirirsiniz (ve öğretim göstergesinin ve teyp kafasının rolü de değişir). Brainfuck için bir ektir {ve }burada birinci sıfır olmayan hücre için bant (veya sol uç) tarar. Ayrıca,_ boş bayt ile değiştirilir.

Bunun henüz optimal olmadığını düşünmeme rağmen, bu çözümden oldukça memnunum. İlk girişimim 84 bayttı ve Sp3000 ile yapılan birkaç golf seansından sonra (ve bu girişimlerden ilham alarak), yavaş yavaş 44'e, bir seferde birkaç bayta indirmeyi başardım. Özellikle parlak +}+numara onun fikriydi (aşağıya bakınız).

açıklama

Girdi, Chuck'ın kasetindeki ilk hücreye okunur, ardından özenle basıldığı Brian kasetinin sonuna kopyalanır. Sonuna kopyalayarak, önceki karakteri sıfıra ayarlayarak baytları kaydedebiliriz.

Bu #sadece bir yer tutucudur, çünkü kumanda kontrolü açdığımız hücreyi çalıştırmaz. {<{Bant başlığının Chuck'ın ilk hücresinde olmasını sağlar. ,STDIN'den bir byte okur veya EOF'a -1basarsak. Bu yüzden +EOF için sıfır yapmak, aksi takdirde sıfır olmayan yapmak için bunu artırıyoruz .

Şimdilik EOF'de olmadığımızı varsayalım. Böylece hücre pozitifdir ve ?kontrolü Chuck'a çevirir. }>için (Brian üzerine) bant kafasını taşır ve geri Brian kontrol geçer.+_?

{-şimdi Chuck'taki ilk hücreyi azaltır. Henüz sıfır değilse, kontrole tekrar Chuck'a geçeriz ?. Bu süre }>, kaset kafasını Brian'a, son sıfır olmayan hücrenin sağındaki iki hücreye taşır. Başlangıçta burada:

#{<{,+?+}_+{-?>}<?__
                   ^

Ama daha sonra, orada zaten bazı karakterler olacak. Örneğin, zaten okuyup yazdırırsak abc, şöyle görünür:

#{<{,+?+}_+{-?>}<?11a11b11c__
                            ^

Nerede 1s aslında 1-byte (biz daha sonra hakkında ne görürsünüz).

Bu hücre hep sıfır olacak, bu yüzden bu sefer ? olmayacak kontrolünü değiştirin. >bir başka hücreyi sağa doğru hareket ettirir ve +o hücreyi artırır. Bu nedenle girişteki ilk karakterin sağındaki üç hücreyi ?(ve sonraki her üç hücreyi de sağa) biter .

<<<Bu listedeki son karaktere geri döner (veya ?ilk karakterse) ve giriş hücresini yavaşça Brian'ın bandının ucuna aktaran döngüyü tekrarlamak için Brian'ın bandına {>geri döner +.

Bu giriş hücresi boşaldıktan ?sonra {-kontrol artık değişmeyecektir. Sonra >}<Chuck üzerindeki bant kafasını hareket ettirir ve _Chuck'ın ikinci yarısı yerine geçecek şekilde kumandasını değiştirir.

}>>şu an yazdığımız hücreye taşındı ve Brian'ın kasetinin sonundan, STDIN'den okuduğumuz bayt, bu yüzden geri yazdırıyoruz .. }Kasette bu yeni karakteri geçebilmek için iki boş bayt boşluğunu kapatmamız gerekir, bu yüzden onları 1birlikte arttırırız <+<+(bu yüzden son kasetteki gerçek karakterler arasında 1 bayt vardır). Sonunda {<{Brian'ın kasetinin başına geri döner ve ?her şeyi baştan başlatır.

Okuduğumuz karakter bir boş byte ise ne olacağını merak edebilirsiniz. Bu durumda, yeni yazılan hücrenin kendisi sıfır olacaktır, ancak Brian'ın kasetinin sonunda olduğu ve bu sonun nerede olduğu umrumda olmadığı için, basitçe bunu görmezden gelebiliriz. Bu, eğer giriş olsaydı, ab\0deBrian'ın kaseti aslında şöyle gözükecekti:

#{<{,+?+}_+{-?>}<?11a11b1111d11e

Sonunda, bir kez EOF'a geldiğimizde, ilk ?önce Brian'ın kasetinde no-op olacağına karar verildi. Bu noktada programı sonlandırıyoruz. Saf çözüm, Chuck'ın bandının sonuna gitmek ve programın sonlandırdığı şekilde kontrol anahtarını değiştirmek olacaktır >}>}<?. Sp3000’in gerçekten akıllıca fikrinin üç bayttan tasarruf sağladığı yer:

+Chuck'ın ilk hücresini dönüştürür 1. Bunun anlamı }bir başlangıç ​​noktasıdır ve _Chuck'ın bandının ortasını bulur . Bunun yerine geçmiş atlama, biz sadece bir dönüştürerek boşluğu kapatmak 1ile +de. Şimdi Brian'ın kodunun geri kalanının bu değiştirilmiş Chuck ile ne yaptığını görelim ...

{geri zamanki gibi Chuck'ın ilk hücreye gider ve -boş bayt içine geri döner. Bu ?, hayır operasyonu demek . Fakat şimdi >}<, genellikle bant kafasını Chuck'ın bandının ortasına kaydırdı, hemen yanından Chuck'ın bandının sonuna ?geçti ve sonra kontrolü Chuck'a geçirerek kodu sonlandırdı. İşler yoluna girdiğinde çok hoş ... :)

Haskell, 16 bayt

main=interact id

interactgirişi okur, argümanı olarak verilen işleve iletir ve aldığı sonucu yazdırır. idkimlik işlevi, yani girişini değiştirmeden döndürür. Haskell'in tembelliği interactsayesinde sonsuz girdiyle çalışabilirsiniz.

sh + binutils, 3 2 bayt

dd

O kadar açık değil. @ Random832'den

Orijinal:

cat

Acı bariz ...: D

Eğlence , 16 bayt

╔═╗
╚╤╝

(Bir malzeme listesi ile UTF-16 olarak kodlanmıştır)

açıklama

Kutu STDIN içeriğini döndürür. Gevşek uç çıkışı verir.

Motorola MC14500B Makine Kodu , 1.5 bayt

Onaltılık yazılmış:

18F

İkili olarak yazılmıştır:

0001 1000 1111

açıklama

1   Read from I/O pin
8   Output to I/O pin
F   Loop back to start

Kodlar her biri 4 bit.

Mornington Crescent , 41 bayt

Take Northern Line to Mornington Crescent

Mornington Crescent'in boş baytları kullanıp kullanamayacağını bilmiyorum ve tüm girdiler program başlamadan önce okunuyor, dilin doğası bu.

Brainfuck, 5 bayt

,[.,]

Sözde koduna eşdeğer:

x = getchar()
while x != EOF:
    putchar(x)
    x = getchar()

Bu sonsuz akışları işler, ancak boş baytları EOF olarak kabul eder. Olsun ya da olmasın BF olabilir null byte işlemek doğru uygulanmasına uygulanması değişir, ama bu en yaygın yaklaşım varsayar.

Labirent , 2 bayt

,.

Akış sonlu ise, bu bir hatayla sona erer, ancak hata tarafından üretilen tüm çıkışlar STDERR'ye gider, bu nedenle standart çıkış akışı doğru olur.

Brainfuck'ta olduğu gibi ,bir bayt okur (Labyrinth'in ana yığına iter) ve .bir bayt yazar (Labyrinth'in ana yığından çıkar).

Bu döngüler sebebi hem olmasıdır ,ve ."ölü biter" kaynak kodu ile temsil (çok önemsiz) labirent olduğunu öyle ki talimat işaretçisi sadece yerinde etrafında döner ve diğer komuta geri hareket eder.

EOF'a çarptığımızda bunun yerine ,iter -1ve .hata atar çünkü -1geçerli bir karakter kodu değildir. Bu aslında gelecekte değişebilir, ancak henüz buna karar vermedim.

Başvuru için, bunu 6 baytlık bir hatayı aşağıdaki gibi çözebiliriz:

,)@
.(

Burada, EOF'de )veren 0ve aksi takdirde olumlu olan şeyleri okuduğumuz baytı artırır . Değer ise 0, IP düz bir şekilde hareket eder @ve programı sonlandırır. Eğer değer pozitifse, IP bunun yerine (yığının tepesini tekrar eski değerine düşüren yönde sağa dönüş yapacaktır . IP artık bir köşede ve .bir kez daha .çatalına basmadan önce doğru dönüşleri yapmaya, yazdırmaya , yeni bir byte okumaya devam edecek ).

C, 40 bayt

main(i){while(i=~getchar())putchar(~i);}

> <> , 7 bayt

i:0(?;o

Burada dene . Açıklama:

i:0(?;o
i        Take a character from input, pushing -1 if the input is empty
 :0(     Check if the input is less than 0, pushing 1 if true, 0 if false
    ?;   Pop a value of the top of the stack, ending the program if the value is non-zero
      o  Otherwise, output then loop around to the left and repeat

Eğer bunu daha girdi verene kadar bunu sürdürmek istiyorsanız, yerini ;ile !.

X86 düzeneği, 70 bayt

İle sökme objdump:

00000000 <.data>:
   0:   66 83 ec 01             sub    sp,0x1
   4:   66 b8 03 00             mov    ax,0x3
   8:   00 00                   add    BYTE PTR [eax],al
   a:   66 31 db                xor    bx,bx
   d:   66 67 8d 4c 24          lea    cx,[si+0x24]
  12:   ff 66 ba                jmp    DWORD PTR [esi-0x46]
  15:   01 00                   add    DWORD PTR [eax],eax
  17:   00 00                   add    BYTE PTR [eax],al
  19:   cd 80                   int    0x80
  1b:   66 48                   dec    ax
  1d:   78 1c                   js     0x3b
  1f:   66 b8 04 00             mov    ax,0x4
  23:   00 00                   add    BYTE PTR [eax],al
  25:   66 bb 01 00             mov    bx,0x1
  29:   00 00                   add    BYTE PTR [eax],al
  2b:   66 67 8d 4c 24          lea    cx,[si+0x24]
  30:   ff 66 ba                jmp    DWORD PTR [esi-0x46]
  33:   01 00                   add    DWORD PTR [eax],eax
  35:   00 00                   add    BYTE PTR [eax],al
  37:   cd 80                   int    0x80
  39:   eb c9                   jmp    0x4
  3b:   66 b8 01 00             mov    ax,0x1
  3f:   00 00                   add    BYTE PTR [eax],al
  41:   66 31 db                xor    bx,bx
  44:   cd 80                   int    0x80

Kaynak:

sub esp, 1
t:
mov eax,3
xor ebx,ebx
lea ecx,[esp-1]
mov edx,1
int 0x80
dec eax
js e
mov eax,4
mov ebx,1
lea ecx,[esp-1]
mov edx,1
int 0x80
jmp t
e:
mov eax,1
xor ebx,ebx
int 0x80

Evrensel Lambda , 1 bayt

!

Bir Evrensel Lambda programı, ikili bir lambda teriminin, 8 bitlik parçalara bölünmüş, tamamlanmamış parçaların herhangi bir bit ile doldurulması ve bir bayt akışına dönüştürülmesiyle kodlanır.

Bitler aşağıdaki gibi bir lambda terimine çevrilir:

• 00 bir lambda soyutlama tanıtır.
• 01 müteakip iki terimin bir uygulamasını temsil eder.
• 111..10İle N bit tekrarlarının 1, değişkenine karşılık gelir , n üst lambda inci; yani, tekdüze bir De Bruijn endeksidir .

Bu dönüştürme 0010ile kimlik işlevidir λa.a, yani formun herhangi bir tek baytlık programı 0010xxxxbir catprogramdır.

PowerShell, 88 41 30 Bayt

$input;write-host(read-host)-n

_{EDIT - $inputboru hattı girişi için otomatik değişken kullanabileceğimi unuttum} ... _{EDIT2 - varlığını test etmek zorunda değilsin$input}

Evet, öyleyse ... PowerShell'deki STDIN çok garip, diyelim mi? Tüm STDIN türlerinden girdileri kabul etmemiz gerektiği varsayımına göre , bu kataloğun olası bir cevabı bu ve başkaları da var. ¹

PowerShell'deki boru hattı girişi, sandığınız gibi çalışmaz. PowerShell boru bir dilin işlevi değil, çevre / kabuğun bir fonksiyonudur (ve PowerShell gerçekten olmadığından sadece zaten bir dili), davranış bazı tuhaflıklar var.

Yeni başlayanlar için ve bu girdiye en uygun olanı, boru anında değerlendirilmez (çoğu zaman). Anlam, biz varsa command1 | command2 | command3bizim kabuğunda, command2giriş almayacağız ya kadar işleme başlamak command1tamamlar ... sürece istemiyorsun, mutfakta annene kapsülleyen command1bir ile ForEach-Object... hangi farklı daha ForEach. _{( ForEachbir takma ad olsa bile ForEach-Object, ancak bu ayrı bir konudur, çünkü ForEachtakma ad olarak konuşuyorum .}

Bu, yes | .\simple-cat-program.ps1( yesgerçekte var olmasa bile , ama ne olursa olsun) gibi bir şeyin işe yaramayacağı anlamına gelir çünkü yesasla tamamlanmaz. Bunu yapabilirsek ForEach-Object -InputObject(yes) | .\simple-cat-program.ps1(teoride) çalışması gerekir.

Microsoft'ta ForEach ve ForEach-Object'i Tanıma "Hey, Komut Dosyası Yazan !" Blog.

Yani, tüm bu paragraflar neden if($input){$input}var olduğunu açıklıyor . Boru hattı girişi varsa, otomatik olarak oluşturulan bir giriş parametresi alırız, var olup olmadığını test edin ve öyleyse çıkış yapın.

Daha sonra, (read-host)esasen ayrı bir STDIN akışı olan kullanıcı ile girdi alıyoruz write-hostve -nbayrağını geri alarak (kısaca -NoNewLine). read-hostBunun yalnızca bir satır beslemesi yapıldığında tamamlanacağı gibi isteğe bağlı uzunluk girişini desteklemediğini unutmayın (teknik olarak kullanıcı "Enter" tuşuna bastığında, ancak işlevsel olarak eşdeğer olduğunda).

Uf.

¹ Fakat başka seçenekler de var:

Örneğin, sadece boru hattı girişi ile ilgileniyorsak ve tam bir program gerektirmiyorsak | $_, girdi ne olursa olsun çıktısını alacak bir şey yapabilirsiniz . _{(Genel olarak, bu biraz gereksizdir, çünkü PowerShell hesaplamalar sonrasında “geride bırakılan” şeylerin örtük bir çıktısına sahiptir, ancak bu bir yanadır.)}

Yalnızca etkileşimli kullanıcı girişi ile ilgileniyorsak, sadece kullanabiliriz write-host(read-host)-n.

Buna ek olarak, bu fonksiyon sahiptir çıtası örneğin komut hat girişi kabul özelliği .\simple-cat-program.ps1 "test"(ve daha sonra çıkış) doldurmak olur $adeğişken.

Cubix , 6 5 bayt

Şimdi boş baytları işler!

@_i?o

Cubix, 2 boyutlu, yığın tabanlı bir esolang'dır. Cubix, kaynak kodunun bir küpün dışına sarıldığı diğer 2D şeritlerden farklıdır.

Çevrimiçi test edin! Not: Yinelemeler arasında 50 ms'lik bir gecikme var.

açıklama

Tercümanın yaptığı ilk şey, kodun uyacağı en küçük küpü bulmaktır. Bu durumda, kenar uzunluğu 1'dir. Daha sonra kod, .altı tarafın tümü doluncaya kadar no-ops ile doldurulur. İşlemden önce boşluklar kaldırıldı, bu nedenle bu kod yukarıdakilerle aynı:

  @
_ i ? o
  .

Şimdi kod çalıştırıldı. IP (talimat işaretçisi) en sol tarafta, doğuya işaret ederek başlar.

IP'nin karşılaştığı ilk karakter, IP'yi _kuzeye veya güneye bakacak şekilde döndüren bir ayna; şu anda doğuya bakıyor, bu yüzden hiçbir şey yapmıyor. Sırada iSTDIN'den bir bayt girişi var. ?Üst öğe negatifse IP'yi sola, pozitifse sağa çevirir. Burada üç olası yol var:

• Girilen bayt -1 (EOF) ise IP sola döner ve @programı sonlandıran isabet eder.
• Girilen bayt 0 (boş bayt) ise IP, bayt ile çıktısı olarak düz devam eder o.
• Aksi takdirde, IP sağa döner, alt yüz boyunca hareket eder ve aynaya çarpar _. Bu onu döndürür, geri gönderir ?, tekrar çevirir ve baytı çıkarır.

Bu programın optimal olduğunu düşünüyorum. Cubix boş baytları işleyemeden önce (EOF 0 değil -1 idi), bu program boş baytlar dışında her şey için çalıştı:

.i!@o

Tüm 5-baytlık kedi programlarını bulmak için kaba bir kuvvet yazdım . Tamamlanması ~ 5 dakika sürse de, en son sürüm 5 program buldu:

@_i?o   (works as expected)
@i?o_   (works in exactly the same way as the above)
iW?@o   (works as expected)
?i^o@   (false positive; prints U+FFFF forever on empty input)
?iWo@   (works as expected)

Vitsy, 2 bayt

zZ

ztüm giriş yığınını alır ve aktif program yığınına doğru iter. Ztüm aktif yığını STDOUT'a yazdırır.

Alternatif yöntem:

Ben \ Ç il \
Giriş yığınının uzunluğu için sonraki karakteri tekrarlayın.
  i Girişten bir öğe alın.
   l \ O anda aktif olan program yığınının uzunluğu için bir sonraki karakteri tekrarlayın.
     O Yığının üst öğesini karakter olarak çıktılayın.

MarioLANG , 11 bayt

,<
."
>!
=#

Bunun optimal olduğuna tam olarak emin değilim, ama bulduğum en kısa süre.

Bu, sonsuz akışları destekler ve EOF'ye ulaşma hatasıyla sona erer (en azından Ruby referans uygulaması yapar).

Bunun Mario'yu ikiye katlayabilen bir ninjaya dönüştüren başka bir sürümü daha var:

,<
.^
>^
==

Her iki durumda da Mario ,bir bayt okur ve .bir bayt yazar (bu ,geçerli bir karakter döndürmez çünkü EOF'da bir hata atar) , sol sütuna düşmeye başlar . >Mario'nun sağa doğru yürümesini sağlar ( =onun üzerinde yürümesi için sadece bir zemindir). Ardından sol koluna geri dönmesini söylemeden önce, ^ya bir asansörle ya da bir asansörle ( "ve #çift) çift ​​zıplayarak gider <.

rs , 0 bayt

Ciddi anlamda. rs sadece verilen betiğin tamamen boş olması durumunda ne olursa olsun yazdırır.

GolfScript, 3 bayt

:n;

Boş program standart girişi yansıtır. Dil muhtemelen sonsuz akışlarla başa çıkamaz. Ancak, @Dennis belirtildiği gibi yeni bir satır ekler. Bunu, tüm yığını bir diziye sararak ve arayarak puts, yeni bir satır print n printolduğu nşekilde tanımlayarak yapar . Bununla birlikte, nSTDIN olarak yeniden tanımlayabilir ve sonra tam olarak ne olduğu gibi yığını boşaltabiliriz :n;.

Yoğun Trafikte Yarı Kırık Araba , 9 + 3 = 12 bayt

#<
o^<
 v

Yoğun Trafikte Yarı Kırık Araba (HBCHT) komut satırının olduğu gibi girdi alıyor, yani

py -3 hbcht cat.hbc -s "candy corn"

+ -s3'nin, karakter olarak çıktı veren bayrak için olduğunu unutmayın . Ayrıca, HBCHT NUL'ları ele almıyor gibi görünmektedir, çünkü tüm sıfırlar çıkıştan düşmektedir (örneğin 97 0 98, iki karakter halinde çıkış ab).

açıklama

HBCHT'de arabanız başlar ove hedefiniz çıkış #. ^>v<Aynı anda BF benzeri bir bandı değiştirirken aracın hareketini yönlendirir ( ^>v<tercüme eder +>-<). Ancak, dil adından da anlaşılacağı gibi, arabanız yalnızca sağa dönebilir - sola dönme denemeleri tamamen göz ardı edilir (bellek efektleri dahil). Bunun sadece dönüş için olduğunu - aracınızın ileri / geri sürüş yönünü mükemmel şekilde yapabildiğini unutmayın.

HBCHT ile ilgili diğer ilginç kısımlar, arabanızın başlangıç ​​yönünün rastgele ve ızgara toroidal olmasıdır. Bu yüzden, ilk dört yön için de bandı değiştirmeden arabaya çıkmak için araca ihtiyacımız var:

• Yukarı ve aşağı, doğrudan çıkışa doğru ilerleyerek basittir.

• Sol için, sarın ve yürütmek <ile artırmaz ^. Bir sonraki adımda sola <dönemeyiz, bu yüzden vönceki artışları göz ardı ederek sarılır ve düşeriz . Şimdi aşağıya doğru yöneldiğimiz için <, imleci iki kez hareket ettirip hücre değerlerini değiştirmeden sağa ve buradan dönebiliriz .

• Sağ için sola aynı şeyi yaparız, ancak sola gidemediğimizden ilkini atlayın ^.

Düzenleme : HBCHT yorumlayıcısının komut satırı bayrağıyla yalnızca tek bir yol izlemenizi sağladığı, örneğin

py -3 hbcht -d left cat.hbc

Ancak, bayrak yalnızca bu belirli soru için çok pahalı değil (en az 5 bayt için " -d u"), kodun çalışabilmesi için tüm yolların hala çıkışa girebilmesi gerekiyor gibi görünüyor.

Minkolang , 5 bayt

od?.O

Burada dene.

açıklama

ogirişten bir karakter okur ve ASCII kodunu istifin üzerine iter ( 0giriş boşsa). ddaha sonra yığının tepesini (yeni okunan karakter) çoğaltır. ?koşullu bir trambolin olup, yığının tepesine bir sonraki talimatı atlamaz 0. Giriş boşsa, o zaman .atlama yapılmaz ve program durur. Aksi halde, Oyığının tepesini karakter olarak verir. Minkolang'ın toroidal doğası bunun baştan sona döndüğü anlamına gelir.

INTERCALL , 133 bayt

wat

INTERCALL IS A ANTIGOLFING LANGUAGE
SO THIS HEADER IS HERE TO PREVENT GOLFING IN INTERCALL
THE PROGRAM STARTS HERE:
READ
PRINT
GOTO I

V , 0 bayt

Çevrimiçi deneyin!

V'nin "bellek" fikri sadece devasa bir 2D karakter dizisidir. Herhangi bir program çalıştırılmadan önce, bu diziye yüklenen tüm girdiler ("Buffer" olarak bilinir). Ardından, herhangi bir programın sonunda, tampondaki tüm metinler yazdırılır.

Başka bir deyişle, boş bir program olan bir kedi programı.

Kardan adam 1.0.2 , 15 karakter

(:vGsP10wRsp;bD

Alınan kardanadam doğrudan examplesdizine . Satır okur, satır basar, satır okur, satır basar ...

Bir uygulama detayı nedeniyle, STDIN boş olduğunda, boş vgbir hat için olduğu gibi aynı şeyi döndüreceğini unutmayın. Bu nedenle, STDIN kapatıldıktan sonra bu, sonsuz satırdaki yeni satırları art arda yazdırır. Bu gelecekteki bir sürümde düzeltilebilir.

Kodun açıklaması:

(        // set two variables (a and f) to active—this is all we need
:...;bD  // a "do-loop" which continues looping as long as its "return value"
         // is truthy
  vGsP   // read a line, print the line
  10wRsp // print a newline—"print" is called in nonconsuming mode; therefore,
         // that same newline will actually end up being the "return value" from
         // the do-loop, causing it to loop infinitely

FireType , 7 bayt

,
&
_
=

Sadece ittiğim bazı değişiklikler gerektirir . Kurallar der ki:

Genel kurallarımızdan farklı olarak, bu zorluktan daha yeni olsa bile, bir dili (veya dil sürümünü) kullanmaktan çekinmeyin.

bu yüzden ben açıktayım!

Fisyon , 4 bayt

R?J!

Örnek programları dilin kendi deposunda yendiğinde hoş olmaz mı? :) Referans için, 7 baytlık bir çözümü var

R?J0;0!

açıklama

Böylece Rkontrol akışını doğru giden bir atomla başlatır. ?STDIN'den bir karakteri atomun kütlesine okur. Karakterleri okuduğumuz sürece, enerji sıfır kalır, bu yüzden Jdöküntü çalışmaz ve !karakteri basar. Atom başlangıcına geri döner ( Rşimdi no-op'tur) ve tüm süreci tekrar eder.

EOF'a bastığımızda, ?atomun enerjisini ayarlayacağız 1, böylece Jdöküm şimdi baskı komutunu atlayacaktır. Fakat bir atom EOF zaten geri döndürüldükten ? sonra vurduğunda , programı sonlandıran atomu yok edecektir.

(Dilin yazarından gelen çözüm, aksi takdirde ;iki 0portalla atlanan programı sonlandırmak için açık bir şekilde kullanılır .)

Shtriped , 20 bayt

e )
"
 r )
 s )
 "
"

Bu cheekily, neredeyse tüm yazdırılabilir ASCII dizgilerinin Shtriped'de geçerli bir tanımlayıcı olduğunu göstermektedir.

Nasıl çalışır:

e )   \ declares a variable named )
"     \ defines a function with 0 arguments named "
 r )  \ gets a line of string input, saving it to )
 s )  \ prints ) as a string
 "    \ recursively calls ", effectively looping forever
"     \ calls " from the main scope to get things started

EOF'yi tespit etmenin gerçek bir yolu yoktur, bu yüzden sonsuza kadar Python cevabı gibi döngüler .

Yine de boş bir satır verildiğinde kolayca durmasını sağlayabilirsiniz (30 bayt):

e )
"
 r )
 d ) \ tries to decrement ), if it was the empty string, aka 0, it can't, so 0 is returned all the way up
 i ) \ increment ) to put it back to normal after possibly decrementing
 s )
 "
"

Shtriped G / Ç'nin yalnızca yazdırılabilir ASCII , sekmeler, satır beslemeleri, satır başları, dikey sekmeler ve form beslemelerini (toplamda 100 karakter) desteklediğini unutmayın. Bunun nedeni, dahili olarak, dizelerin negatif olmayan rasgele kesinlikli tam sayılar olarak temsil edilmeleridir ve tüm dizeleri kodlayabilmek için sınırlı bir karakter alfabesi olması gerekir.