yescoreutils'ten 91 satır uzunluğunda . Birçoğu yorum vardır, ama bu hala YOL çok uzun.

Eylül 2019’dan itibaren düzenleme: kaynak dosya son beş yılda büyüdü ve şu anda 126 satır uzunluğunda.

Taklit eden bir program yazın yes:

• stdout"y \ n" nin sonsuz akışına çıkış
• Süreci öldürmek dışında onu durdurmak için bir seçenek olmalı SIGKILL: ancak SIGINTve SIGPIPEiyi
• "y" veya "\ n" veya ASCII değerlerini kullanmanıza izin verilmez (121, 0x79, 0171, 10, 0xA veya 012)

En kısa cevap kazanır.

Bonus:

• Bir cümle alıp stdin"y" yerine yazdırabilirseniz (ancak satır sonu da dahil), kod uzunluğunuzdan 10 çıkarın .

CJam, 13 bayt - 10 = 3

l_'x)?{_oNo}h

Bunun için Java tercümanını kullanmanız gerekir , çünkü çevrimiçi tercüman yalnızca program sona erdiğinde döner.

Programı SIGINT ile iptal edebilirsiniz (Ctrl-C tuşlarına basarak). STDIN'den bir satır okuyacak ve bu satırı ya yda giriş boşsa yazdıracaktır .

açıklama

l             "Read line from STDIN.";
 _            "Duplicate.";
  'x          "Push character x.";
    )         "Increment to get y.";
     ?        "Ternary operator. Replaces line with y if it was empty.";
      {    }h "Repeat while true. Leaves condition on the stack, which is the output string.";
       _o     "Duplicate line and print.";
         No   "Push string with newline and print.";

OP'nin açıklığa kavuşturulmasından sonra, aşağıdaki hususlar daha spesifik görünmektedir:

l{_o9c)o1}g

OP yorumumu yanıtlayana kadar bu bildirimi güncellemeyi bekleyeceğim.

Brainfuck - 38 bayt

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

10 ya da 121 kullanmıyor, çünkü +-<>.,[]zaten dildeki tüm anlamlı karakterler var, ancak onları oldukça naif bir şekilde hesaplıyor (0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 = 10, 10 x 12 + 1 = 121).

Bu muhtemelen tercümana bağlı, fakat makineme bağlı ^C.

Brainfuck - (63-10) = 53

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

Python 3, 27 bayt

En azından CPython ve Jython ile çalışır.

while 1:print(str(help)[1])

SIGINT onu durdurur.

Mermer 14 bayt

0978
]]/\++
!!

Bu oldukça basittir, '/ \' cihazı sol ve sağ tarafa iki kopya yerleştirir, sağ taraf artırılır ++ve sonra tahtadan düşer ve yazdırılır. ]]STDIN boş ama değilse STDIN ilk bayt düşmek izin verirse cihaz sağa herhangi mermer iter. Bu daha sonra !!panodan çıkan cihazı tetikleyecektir . Böylece stdin'de herhangi bir şey girinceye kadar bu işlem basılacaktır.

Bu sadece python yorumlayıcısında çalışır.

Pyth, 10 9 6 bayt - 10 = 0 -1 -4

#|zePG

Uzun zamandır tatmin olduğum birisini almaya çalışıyorum. Temelde şuna dönüştürür:

#      = while True
(implied print)
|      = or
z      = (automatically initialized from stdin)
ePG    = second-to-last lowercase letter = 'y'

C #, 81 78 76 bayt

Diğer dillerle rekabet edemem, ama yine de burada:

class A{static void Main(){for(;;)System.Console.WriteLine((char)('x'+1));}}

SIGINT ile Ctrl+ tuşuna basılarak öldürülebilir C.

Bonus yok, çünkü onu almak 10 bayttan fazla sürüyor.

Java, 178

class C{public static void main(String[]a)throws Exception{for(char c='x'+1;;)((java.io.PrintStream)Class.forName("java.lang.S"+c+"stem").getField("out").get(null)).println(c);}}

Yazdırma gerektirir System, ancak ykarakter yasaktır. Bu yüzden, yansıma kullanmak zorunda kaldım.

Perl: 18 bayt - 10 = 8

Dize STDIN'den.

$_=<>;{print;redo}

Ruby, 30 23 18 bayt

loop{puts ?x.succ}

SIGINT ile Ctrl+ tuşuna basılarak öldürülebilir C.

Geliştirmeleri paylaştığınız için teşekkür ederiz !

Perl, 26 bayt

{print chr$=*2+1,$/;redo}

Bağımsız değişkenden özel girdi ( yesaslında çalışır gibi ), 22 bayt-10 = 12

{print @ARGV,$/;redo}

Stdin'den özel giriş, 22 bayt-10 = 12

while(<>){print;redo}

C, 64 55 53 45 40-10 = 30

main(int c,int**a){for(;;)puts(a[c>1]);}

Bu programdan "y" olarak adlandırılmasını ve sadece `y` ile çağrılmasını gerektirdiği için bundan çok mutlu değilim, bu yüzden $ PATH olmalı, ama hey, ilk kod yazarı :)

Alternatif:

C, 30 (+ 1 dosya adı)

main(){for(;;)puts(__FILE__);}

Değerli meslektaşım ile aynı tekniği kullanıyorum @ Matt Windsor

• EDIT: no \ n karakterinin etrafını dolaşması onu kısalttı
• EDIT2: "int", "char" den daha kısa
• EDIT3: bu değişkene hiç ihtiyaç duymadı
• EDIT4: biraz tanımsız davranışı biraz kimseye zarar vermez
• EDIT5: alternatif sürüm ekle

Linux Bash, 33-10 = 23

read a; while :; do echo $a; done

SIGINT ile Ctrl+ tuşuna basılarak öldürülebilir C.

Rust, 52 karakter

fn main(){loop{println!("{}",'Y'.to_lowercase())}}

Görünüşe göre y, Pas'ta arsızlık yapmadan hoş bir işlem yapılmadı, güvenli bir şekilde kömür yapma işini çok iyi yaptılar. BEN:

• Değişmez bir dize sağlayamaz println!, bu yüzden orada hileler izin yoktur;
• 1'e ekleyemezsiniz 'x', çünkü Pas karakterleri sayı değildir;
• ROT13 olamaz (neden Rust'da standart kütüphanede ROT13 yok !?);
• İnanılmaz derecede ayrıntılı ve 52c yaşına girmeden, C dizgilerine düşmek, sayılardan karakterlere vb. Dönüştürmek gibi güvenli olmayan hiçbir şeyi kolayca yapamazsınız.

Buna değer kod bonusu için de geçerli değil, çünkü okuma işlemi stdinhata işleme gerektiriyor: 3

Derleyici ortamına giderek daha fazla kurallara aykırı davranan şeylerle uğraşırken bulabildiğim kod azaltma işlemlerinin çoğu:

Pas, 44 karakter (+ dosya adı için en az 1 karakter)

fn main(){loop{println!("{:.1}", file!())}}

Aşağıda tarafından esir alınmıştır. Kaynak dosya adının başlaması gerektiği için bu muhtemelen sayılmaz y.

Düzenleme: Rust, 36 karakter (35 kaynak, 1 dosya adı)

fn main(){loop{println!(file!())}}

Yukarıda olduğu gibi, ancak dosya vardır çağrılacak y(değil y.rs, y). Esprili bir şekilde, Rust, kaynağın üzerine ikili kodun üzerine yazacaktır! En azından benim makinemde, ikili bundan sonra çalışıyor.

Pas, 37 karakter (+ env K='y'platformunuzdaki eşdeğeri )

fn main(){loop{println!(env!("K"))}}

Bu seferki daha da kötü: Eğer ortam değişkeni ayarlamak için ihtiyaç Kiçin yde derleme süresi .

Düzenleme : Eğer ayarlarsanız Kiçin y\n, size düşebilir lnin println!bir genel toplam, 35 karakter ve birkaç facepalms:

fn main(){loop{print!(env!("K"))}}

Linux Bash - 19 bayt

Bu, muhtemelen / usr / bin / yes'iniz yoksa veya bir usr / bin / xes veya / usr / bin / zes'iniz yoksa hile yapmakta ve başarısızlığa maruz kalmaktadır:

/usr/bin/[x-z]es $*

Sanırım şartları yerine getiriyor, belki de "y'yi değerlendiren hiçbir şey" kuralını ihlal ediyor olabilir. Belki de yeskoşarak taklit yesetmek kurallara aykırıdır.

Bu, 11 bayta indirebilmek için biraz çalışabilir (çalışma olasılığı daha düşük olsa da):

/*/*/?es $*

Koda 10 bayttan fazla eklemeden stdin'den bir dize okuyarak 10 puan bonusu nasıl elde edeceğimi bilemedim.

dc, 12

[30986Pdx]dx

Sadece çıktılar y\n. Stdin'den okumuyor, yani bonus yok.

30986, 0x790A'dır (yani "y \ n"). PKomut sadece 256 baz numarayı çevirir, ve her bir taban 256 basamak için karşılık gelen karakter basar.

Ortak Lisp: (30-10) = 20

(format t"~@{~a~%~:*~}"(read))

• (read) giriş akışından
• çıktı akışına yazdır: (format t ... )
• Tüm formatargümanları yineleyin (burada yalnızca biri):~@{ ... ~}

• Her argüman için döngü içinde:

  • print argümanı ve ~Aardından newline~%
  • geçerli öğeyi bir öncekine geri sarma ~:*(sonsuz döngü)

Ctrl+CYeniden başlatma seçenekleriyle hata bildiren bir döngüyü kırabilirsiniz (devam / iptal).

Haskell, 29 bayt

main=putStrLn[succ 'x']>>main

Bu ikisi tarafından durdurulur inanıyoruz SIGINTve SIGPIPE.

Ruby, 27 bayt - 10 = 17

Bu sadece @ ProgramFOX'un bonusla olan çözümü (bonus sorusunu çözmek için 9 bayt aldı).

loop{puts ARGV[0]||?x.succ}

dc, 21 bayt - 10 = 11

C1st?st[ltP[]ps0dx]dx

Girdiyi sarmanız gerektiğine dikkat edin [], örneğin [no], ?girdi olarak almanın tek yolu dckod olduğu için.

Commodore 64 Basic: 14 13 bayt

1?C|(11↑2):R╭

Her zamanki gibi, PETSCII'deki Unicode'da bulunmayan karakterlerin yerine geçtim. |temsil SHIFT+Hederken, ╭temsil etmek için kullanılır SHIFT+U. Bunun varsayılan Commodore karakter kümesinin 'y' olarak gösterdiği bir karakter yerine ASCII 'y' (bayt değeri 121) verdiğini unutmayın.

BASIC, öğrenmesi kolay, İngilizce benzeri bir programlama dilidir. Birçok erken lehçede bulunan yazma kısayollarını girin ve Perl'den daha kısa ve daha az okunabilen bir şey elde edin.

DÜZENLEME : "kaydırılmış modda", küçük harf "y" 89 ondalık değerinde kodlandığından, bu işlem iki bayt kısalır. 89 "ASCII değerlerini kullanmaya izin verilmez" kuralını aşmak için ASCII olmayan bir karakter kullanmak Yine de hile yapmak.

1?cH(89):rU

AWK, 38 bayt

BEGIN{for(;;)printf("%c%c",60+61,5+5)}

Stdin'de dizgeyi okuyacak değişken: 14 bytes-10 = 4

{for(;;)print}

Fakat ikisini birden yapamadığı için (eğer stdin sağlanmazsa "y" ye dön), sayıldığından emin değilim ...: o)

Her ikisi de Ctrl + C ile çıkılabilir.

Fisyon , 5 bayt

Rx+!N

Bu Fission için oldukça rekabetçi. :)

Kontrol akışı, (1,0)sağa giden bir atomla başlar R. xiçin kitle ayarlar 120ve +vermek için artırır (121,0). Sonra !karşılık gelen karakteri ( y) ve Nyeni bir satır yazdırır. Kaynak kodu kenarlarda sarar, böylece atom Rtekrar geçer (şimdi hiçbir şey yapmaz), xkütleyi 120tekrar ayarlar, arttırır , +vb.

C, 32 bayt

Küçük endian makinesi ve -O2 ile derleme gerektirir (yığın taşmasını önlemek için).

a=11*11;main(){main(puts(&a));}

PowerShell, 27 - 10 = 17

param($s=$Host[1])for(){$s}

Pash’te işe yaramayabilir. Daha sağlam bir alternatif olmalı

param($s="$(gal gh*)"[2])for(){$s}

Lua, 42 bayt - 10 = 32

while 1 do print(...or('').char(90+31))end

Lua, 49 bayt - 10 = 39

y=...or(string.char(60+61))while 1 do print(y)end

Her ikisi de Lua 5.1.4 ile test edildi ve SIGINT ( Ctrl+ C) ile öldürülebilir .

Perl, 31

İşte yessöyleyebileceğim kadarıyla, aslında GNU gibi davranan bir Perl versiyonu :

{print "@ARGV"||chr 11**2;redo}

Bu, perl'in komut satırı anahtarlarını ( -lyeni satır için) kullanmanız uygunsa çalışır , aksi takdirde 3 karakter daha uzun olur:

{print "@ARGV"||chr 11**2,$/;redo}

CAPL 1.5+; 6 giriş olmadan; 10 - 10 = 0 giriş

Sidenote
Golf sorularına tam olarak ne sorduğunu yapan yerleşik işlevler yapabildikleri için özel dillerin golf sorularına izin verilmediğini bir yerde [link?] Okudum, ancak CAPL'ı genel olarak golf oynamayı kolaylaştırmak için yaptım . Burada buna izin verilmediğini düşünüyorsanız, bana bildirin!

> <> Ve Befunge'den (Satırlar arasında hareket edebilir ve sayıları bastırmak için onaltılık karakterler kullanabilirsiniz), bazıları Ruby'den, bazıları da golf oynamayı kolaylaştırmak için bazı fikirlerim var .
CAPL soldan sağa doğru okur ve satırın sonunda bir satır aşağı gider. Son satırda ise, program sonlandırılacak.

Kimse henüz bu dili bilmediğinden, mümkün olduğunca açıklamaya çalışacağım.

Çıktı y. 6 bayt

bb*.n<

bb* bonaltılı olduğu 11, bu yüzden bb*olduğu 11*11= 121UTF-8 eşdeğer olan, y. Bu değer yığına itilir.
.Yığından en üstteki değeri çıkar ve UTF-8 olarak çıkar. 121Yığının üstünde olduğu gibi , dizin burada yoksayılır.
nYeni bir satır
<çıkarır İşaretçiyi satırın başına geri gönderir, böylece bu satırı tekrarlar. Girdiyi beklemeyeceğimiz için, girişi tekrar istemeden bunu güvenle yapabiliriz.

Girişten çıkış. 10 bayt, bonusdan sonra 0

i~a&{X:.)}

iKullanıcıdan girdi alır, yığının üstüne UTF-8 olarak basar ve bundan sonra uzunluğu iter. Yani [72,101,108,108,111,5]
~yığından bir sayı çıkar, ardından bu bayt miktarını tersine çevirir. Yani [111,108,108,101,72]
aonaltılık 10, newline karakteri
&{...}sonsuz bir döngü yapar. Girdi var, bu yüzden işaretçiyi çizgiye geri gönderemeyiz. Fonksiyonu aşağıdaki satırda tutabilirim, bu da beni bir bayt olarak güvence altına alır, ancak yeni satırlara bu zorlamada izin verilmez.
XÜst değeri yığından kaldırır (
:.Dizinden döngü) Üst değeri kopyalar, ardından UTF-8
)Yığını sağa döndürür. ( [1,2,3,4,5]-> [5,1,2,3,4])

Bununla birlikte, bunun anlamı yeni bir satırla başlayacağız, daha sonra giriş, sonra yeni satır, sonra giriş vb. Bonus

iXa#~&{X:.)}

Buradaki tek yeni komut #, yığındaki öğelerin miktarını yığına iter.
Uzunluğu kaldırdım i, çünkü 1 ekliyorum, sonra newline ile değişmek, uzunluğu tekrar alıp tekrar almaktan daha uzun.

Sadece eğlence için, burada bir "Merhaba Dünya" programı.

"Hello World"#~
#?!;.<

İşlem ?!> <> ile aynı.

APL (Dyalog APL) , 5 - 10 = -5 bayt

Uyarı: belgelenmemiş ve desteklenmeyen bir özellik / hataya dayanmaktadır.

⎕←⍣≢⍞

Boş STDIN , izin verilen ve önerilen boş satırları ("y" değil) yazdırır .

Çevrimiçi deneyin!

⎕ Takip eden yeni hatlarla STDOUT,

← alır

⍣ kadar tekrar tekrar

≢ o farklı

⍞ STDIN

yani hiçbir zaman, ancak ipliği duraklatarak kesintisiz.

> <>, 6 bayt

b:*oao

;Sonuna dahil edilmemesi halinde , > <> bir SIGINT tarafından serbest bırakılıncaya kadar yüzmeye devam edecektir.

açıklama

b:*oao
b         Push 11
 :        Duplicate
  *       Multiply top elements to get 121
   o      Print as character
    a     Push 10
     o    Print as character (yielding '\n')
          No program terminator, so our ><> will 
          keep on swimming this path forever.
^----' 

> <>, 17 - 10 = 7 bayt

Birincisi oldukça sıkıcı bir çözüm, işte stdin'den girdi alan bir çözüm. Bu suistimaller bir girdi tedarik varsayılan yolu olması > <> programı olduğunu echo 'input' | fish.py yes.fish, echosağlar \nkarakter.

 i:0)?!v
0r}o:r~<

açıklama

 i:0)?!v     Load STDIN into the stack (reversed)

             NOP           <----------,
 i           Push a byte from STDIN   |
  :          Duplicate top element    |
   0         Push 0                   |
    )?       If (i > 0):              |
      !        Wrap around  ----------'
             Else:
       v       Move to the second part

0r}o:r~<     Print STDIN until halted

       <     Go right         <---------------,
      ~      Remove top element (duplicated   |
                -1 from EOF)                  |
     r       Reverse stack                    |
    :        Duplicate top element            |
   o         Output as character              |
  }          Rotate stack to right (go to     |
                next character)               |
 r           Reverse the stack                |
0            Push 0                           |
             Wrap around       ---------------'

0rSonunda Sayesinde SFOR döngü biz hala bir ile tersine çevrilecek yığını varsayalım nerede sararak gerçekleşmesi -1üzerine.

Görünüşe göre bu tamamen taşınabilir değil. Benimki sys.version , 2.7.9 (default, Dec 11 2014, 04:42:00) \n[GCC 4.9.2]seninki farklıysa, bu işe yaramayabilir sanırım.

Python 2 - (76-10) = 66

import sys
s=sys.stdin;a=`help`[1]if s.isatty()else s.read()
while 1:print a

Çok uzun, ama bonus için gitmek istedim (10 bayttan fazlaya mal olsa bile). Görünüşe göre stdin'in boş olup olmadığını kontrol etmek için giriş sormadan uzun.

İlk başta, bonusu stdin yerine bir argüman olarak kabul ediyorum. Bunun için çözümümle gurur duyuyorum, bu yüzden yine de gönderiyorum;)

Python 2 - (52-10 + ∞) = ∞ (geçersiz!)

import sys
while 1:print(sys.argv+[0])[1]or`help`[1]

sys.argvsıfırıncı öğenin dosya adı ve her öğenin sonrasının programa verilen bir argüman olduğu bir listedir. Listenin sonuna falsey değeri eklerim; Eğer argüman yoksa, ilk unsur şu falsey değeridir, aksi takdirde ilk argümandır. a or bPython'da sonucun ne olacağını doğrulayan ilk değeri döndürür: Eğer agerçek ise, her şeyin doğru olacağını zaten biliyoruz, bu yüzden geri döndü. Eğer yanlışsa, bdöndürülür (beri False or b== b).