yes, từ coreutils, dài 91 dòng . Nhiều người trong số họ là những bình luận, nhưng đó vẫn là CÁCH quá dài.

Chỉnh sửa từ tháng 9 năm 2019: tệp nguồn đã phát triển trong năm năm qua và hiện dài 126 dòng.

Viết chương trình bắt chước yes:

• xuất ra stdoutmột luồng vô tận của "y \ n" 's
• phải có một tùy chọn để ngăn chặn nó khác hơn là giết chết quá trình này với SIGKILL: nhưng SIGINTvà SIGPIPEcũng tốt
• bạn không được phép sử dụng "y" hoặc "\ n" hoặc các giá trị ASCII của chúng (121, 0x79, 0171, 10, 0xA hoặc 012)

Câu trả lời ngắn nhất thắng.

Thêm:

• trừ 10 từ độ dài mã của bạn, nếu bạn có thể nhận được một cụm từ stdinvà in nó ra thay vì "y" (nhưng vẫn bao gồm cả ngắt dòng).

CJam, 13 byte - 10 = 3

l_'x)?{_oNo}h

Bạn sẽ cần sử dụng trình thông dịch Java cho việc này, bởi vì trình thông dịch trực tuyến chỉ trả về khi chương trình kết thúc.

Bạn có thể hủy bỏ chương trình bằng SIGINT (bằng cách nhấn Ctrl-C). Nó sẽ đọc một dòng từ STDIN và in dòng đó hoặc ynếu đầu vào trống.

Giải trình

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.";

Sau khi làm rõ OP, những điều sau đây có vẻ nhiều hơn để chỉ định:

l{_o9c)o1}g

Mặc dù vậy, tôi sẽ đợi cập nhật bài nộp cho đến khi OP trả lời bình luận của tôi.

Brainfuck - 38 byte

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

Nó không sử dụng 10 hoặc 121, vì +-<>.,[]dù sao tất cả đều là các ký tự có ý nghĩa trong ngôn ngữ, nhưng nó tính toán chúng khá ngây thơ (0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 = 10, 10 * 12 + 1 = 121).

Điều này có thể phụ thuộc vào trình thông dịch, nhưng nó chết ^Ctrên máy của tôi.

Brainfuck - (63-10) = 53

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

Python 3, 27 byte

Hoạt động với ít nhất CPython và Jython.

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

SIGINT dừng nó.

14 byte đáng kinh ngạc

0978
]]/\++
!!

Điều này khá đơn giản, thiết bị '/ \' đặt hai bản sao ở bên trái và bên phải của nó, bên phải được tăng lên ++và sau đó rơi ra khỏi bảng và được in. Thiết ]]bị đẩy bất kỳ viên bi nào sang bên phải nếu STDIN trống nhưng để byte đầu tiên trên STDIN rơi xuống nếu không. Điều này sau đó sẽ kích hoạt !!thiết bị thoát ra khỏi bảng. Vì vậy, điều này sẽ in y \ n cho đến khi bạn nhập bất cứ điều gì trên stdin.

Điều này chỉ hoạt động trong trình thông dịch python.

Bình thường, 10 9 6 byte - 10 = 0 -1 -4

#|zePG

Tôi đã cố gắng từ lâu để có được một cái mà tôi đã bão hòa. Về cơ bản chuyển đổi thành:

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

C #, 81 78 76 byte

Không thể cạnh tranh với các ngôn ngữ khác, nhưng dù sao thì đây là:

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

Có thể bị giết bằng SIGINT bằng cách nhấn Ctrl+ C.

Không có tiền thưởng, vì sẽ mất hơn 10 byte để có được nó.

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);}}

In ấn yêu cầu System, nhưng ynhân vật bị cấm. Do đó, tôi đã phải sử dụng sự phản chiếu.

Perl: 18 byte - 10 = 8

Chuỗi là từ STDIN.

$_=<>;{print;redo}

Ruby, 30 23 18 byte

loop{puts ?x.succ}

Có thể bị giết bằng SIGINT bằng cách nhấn Ctrl+ C.

Cảm ơn manatwork đã chia sẻ cải tiến!

Perl, 26 byte

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

Đầu vào tùy chỉnh từ đối số (như yesthực sự hoạt động), 22 byte-10 = 12

{print @ARGV,$/;redo}

Đầu vào tùy chỉnh từ stdin, 22 byte-10 = 12

while(<>){print;redo}

C, 64 55 53 45 40 - 10 = 30

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

Tôi không thực sự hài lòng với điều này, vì nó yêu cầu chương trình phải được đặt tên là "y" và chỉ được gọi bằng `y`, vì vậy nó phải ở dạng $ PATH, nhưng này, codegolf đầu tiên :)

Thay thế:

C, 30 (+ 1 tên tệp)

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

Sử dụng kỹ thuật tương tự như đồng nghiệp quý của tôi @Matt Windsor

• EDIT: hóa ra việc làm tròn ký tự no \ n làm cho nó ngắn hơn
• EDIT2: "int" ngắn hơn "char"
• EDIT3: hoàn toàn không cần biến đó
• EDIT4: một chút hành vi hơi không xác định không bao giờ làm tổn thương bất cứ ai
• EDIT5: thêm phiên bản thay thế

Linux Bash, 33-10 = 23

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

Có thể bị giết bằng SIGINT bằng cách nhấn Ctrl+ C.

Rust, 52 ký tự

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

Dường như đó không phải là một cách tính toán hay ymà không táo tợn trong Rust-- họ đã làm quá tốt việc làm các ký tự một cách an toàn. TÔI:

• Không thể cung cấp một chuỗi phi chữ println!, vì vậy không có thủ thuật nào được phép ở đó;
• Không thể thêm 1 vào 'x', vì trong số ký tự Rust không có số;
• Không thể ROT13 (tại sao Rust không có ROT13 trong thư viện tiêu chuẩn của nó!?);
• Không thể dễ dàng làm bất cứ điều gì không an toàn như thả xuống chuỗi C, chuyển đổi từ số sang ký tự, v.v. mà không quá dài dòng và vượt quá 52c.

Cũng không có phần thưởng mã nào xứng đáng, vì đọc từ stdinsẽ yêu cầu xử lý lỗi = 3

Phần lớn việc giảm mã mà tôi có thể tìm thấy liên quan đến việc thực hiện những thứ ngày càng lách luật với môi trường trình biên dịch:

Rust, 44 ký tự (+ ít nhất 1 char cho tên tệp)

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

Lỗi thời bởi bên dưới. Cái này có lẽ không được tính, vì tên của tệp nguồn cần bắt đầu bằng y.

Chỉnh sửa: Rust, 36 ký tự (35 nguồn, 1 tên tệp)

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

Như trên, nhưng các tập tin có được gọi là y(không y.rs, y). Một cách hài hước, Rust sẽ ghi đè lên nguồn với nhị phân! Ít nhất trên máy của tôi, nhị phân không hoạt động sau đó mặc dù.

Rust, 37 ký tự (+ tương đương với env K='y'trên nền tảng của bạn)

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

Cái này là thậm chí tệ hơn: bạn cần phải thiết lập các biến môi trường Kđể ytại thời gian biên dịch .

Chỉnh sửa : nếu bạn đặt Kthành y\n, bạn có thể thả lnvào println!, với tổng số 35 ký tự và một số facepalms:

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

Linux Bash - 19 byte

Điều này có thể gian lận và có thể thất bại nếu bạn không có / usr / bin / yes hoặc có / usr / bin / xes hoặc / usr / bin / zes:

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

Tôi nghĩ rằng nó đáp ứng các yêu cầu, mặc dù có thể nó vi phạm quy tắc "không có gì đánh giá theo y". Và có lẽ bắt chước yesbằng cách thực sự chạy yeslà trái với quy tắc.

Điều này có thể được tối ưu hóa một chút (mặc dù ít khả năng hoạt động hơn) để đưa nó xuống còn 11 byte:

/*/*/?es $*

Tôi không thể tìm ra cách nhận phần thưởng 10 điểm bằng cách đọc một chuỗi từ stdin mà không cần thêm hơn 10 byte vào mã

đc, 12

[30986Pdx]dx

Chỉ đầu ra y\n. Không đọc từ stdin, vì vậy không có tiền thưởng.

30986 là 0x790A (tức là "y \ n"). Các Plệnh đơn giản chuyển đổi số để cơ sở 256, và in các nhân vật tương ứng đối với từng cơ sở 256 chữ số.

Lisp thường gặp: (30-10) = 20

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

• (read) từ luồng đầu vào
• in ra luồng đầu ra: (format t ... )
• lặp đi lặp lại trên tất cả các formatđối số (chỉ có một ở đây):~@{ ... ~}

• trong vòng lặp, cho mỗi đối số:

  • đối số in ~Atheo sau là một dòng mới~%
  • tua lại phần tử hiện tại về phần trước ~:*(vòng lặp vô hạn)

Bạn có thể ngắt vòng lặp Ctrl+C, báo hiệu lỗi với các tùy chọn khởi động lại (tiếp tục / hủy bỏ).

Haskell, 29 byte

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

Tôi tin rằng điều này được dừng lại bởi cả hai SIGINTvà SIGPIPE.

Ruby, 27 byte - 10 = 17

Đó chỉ là giải pháp của @ ProgramFOX với phần thưởng (phải mất 9 byte để giải câu hỏi về phần thưởng).

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

dc, 21 byte - 10 = 11

C1st?st[ltP[]ps0dx]dx

Lưu ý rằng đầu vào cần phải được bọc [], ví dụ [no], bởi vì ?là cách duy nhất để lấy đầu vào, thực thi nó dưới dạng dcmã.

Hàng hóa 64 cơ bản: 14 13 byte

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

Như thường lệ, tôi đã thay thế các ký tự trong PETSCII không có trong Unicode. |được sử dụng để đại diện SHIFT+H, trong khi ╭đại diện SHIFT+U. Lưu ý rằng điều này xuất ra ASCII 'y' (giá trị byte 121) chứ không phải là một ký tự mà bộ ký tự Hàng hóa mặc định hiển thị là 'y'.

BASIC được cho là một ngôn ngữ lập trình dễ học, giống như tiếng Anh. Sử dụng các phím tắt gõ trong nhiều phương ngữ đầu tiên và bạn sẽ có được thứ gì đó ngắn hơn và ít đọc hơn Perl.

EDIT : Trong "chế độ thay đổi", điều này sẽ rút ngắn hơn hai byte, nhờ chữ thường "y" được mã hóa ở giá trị thập phân 89. Sử dụng bộ ký tự không phải ASCII để xoay quanh quy tắc "không được phép sử dụng giá trị ASCII" của chúng gian lận, mặc dù.

1?cH(89):rU

AWK, 38 byte

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

Biến sẽ đọc chuỗi trên stdin: 14 byte-10 = 4

{for(;;)print}

Nhưng vì nó không thể thực hiện cả hai (trở lại thành "y" nếu không có stdin nào được cung cấp), tôi không chắc nó được tính ...: o)

Cả hai có thể được thoát bằng Ctrl + C.

Phân hạch , 5 byte

Rx+!N

Điều này khá cạnh tranh cho phân hạch. :)

Kiểm soát dòng chảy bắt đầu với một (1,0)nguyên tử đi đúng tại R. xđặt khối lượng 120và +tăng nó để cung cấp (121,0). Sau đó !in ký tự tương ứng ( y) và Nin một dòng mới. Mã nguồn bao bọc xung quanh các cạnh, do đó nguyên tử đi qua Rmột lần nữa (hiện không làm gì cả), xđặt khối lượng thành 120một lần nữa, +tăng nó lên và cứ thế ...

C, 32 byte

Yêu cầu máy endian nhỏ và biên dịch với -O2 (để tránh tràn ngăn xếp).

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

PowerShell, 27 - 10 = 17

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

Có thể không làm việc ở Pash. Một sự thay thế mạnh mẽ hơn nên được

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

Lua, 42 byte - 10 = 32

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

Lua, 49 byte - 10 = 39

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

Cả hai đều được thử nghiệm với Lua 5.1.4 và có thể bị giết bằng SIGINT ( Ctrl+ C).

Perl, 31

Đây là phiên bản Perl thực sự hoạt động giống như GNU yes, theo như tôi có thể nói:

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

Điều này hoạt động nếu sử dụng các chuyển đổi dòng lệnh của perl ( -lđối với dòng mới), nếu không nó sẽ dài hơn 3 ký tự:

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

Vốn đầu tư 1,5+; 6 không có đầu vào; 10 - 10 = 0 với đầu vào

Sidenote
Tôi đã đọc ở đâu đó [link?] Rằng các ngôn ngữ tùy chỉnh không được phép trong các câu hỏi về golf, vì chúng có thể tạo ra các chức năng tích hợp thực hiện chính xác những gì câu hỏi đang hỏi, tuy nhiên tôi đã tạo ra CAPL để nói chung việc chơi golf dễ dàng hơn . Nếu bạn nghĩ rằng điều này không được phép ở đây, hãy cho tôi biết!

Tôi có một số ý tưởng từ > <> và Befunge (Bạn có thể di chuyển giữa các dòng và sử dụng các ký tự thập lục phân để đẩy số), một số từ Ruby và một số từ chính tôi để giúp việc chơi golf dễ dàng hơn.
CAPL đọc từ trái sang phải và đi xuống một dòng ở cuối dòng. Nếu nó là dòng cuối cùng, chương trình sẽ thoát.

Vì chưa ai biết ngôn ngữ này, tôi sẽ cố gắng giải thích càng nhiều càng tốt.

Xuất ra y. 6 byte

bb*.n<

bb* blà hệ thập lục phân cho 11, vì vậy bb*là 11*11= 121, đó là UTF-8 tương đương y. Giá trị này được đẩy lên ngăn xếp.
.Đặt giá trị hàng đầu từ ngăn xếp và xuất ra dưới dạng UTF-8. Như 121trên đỉnh của ngăn xếp, chỉ mục được bỏ qua ở đây.
nXuất ra một dòng mới
<Gửi con trỏ trở lại đầu dòng, do đó lặp lại dòng đó. Vì chúng tôi không mong đợi đầu vào, chúng tôi có thể làm điều này một cách an toàn mà không yêu cầu lại đầu vào.

Xuất ra từ đầu vào. 10 byte, 0 sau khi thưởng

i~a&{X:.)}

iLấy đầu vào từ người dùng, đẩy dưới dạng UTF-8 trên đỉnh của ngăn xếp và đẩy chiều dài sau đó. Tức là [72,101,108,108,111,5]
~Pops một số từ ngăn xếp, sau đó đảo ngược số lượng byte đó. Tức là [111,108,108,101,72]
athập lục phân cho 10, ký tự dòng mới
&{...}Tạo một vòng lặp vô hạn. Chúng tôi có đầu vào, vì vậy chúng tôi không thể gửi con trỏ trở lại dòng. Tôi có thể đặt hàm trên dòng bên dưới, điều này sẽ an toàn cho tôi một byte, nhưng các dòng mới không được phép trong thử thách này.
XXóa giá trị hàng đầu khỏi ngăn xếp (Chỉ mục từ vòng lặp)
:.Sao chép giá trị trên cùng, sau đó xuất ra dưới dạng UTF-8
)Biến chồng phải. ( [1,2,3,4,5]-> [5,1,2,3,4])

Tuy nhiên, điều này có nghĩa là chúng ta bắt đầu với một dòng mới, sau đó bắt đầu xuất ra đầu vào, sau đó là một dòng mới, sau đó là đầu vào, v.v. Nếu chúng ta không được phép bắt đầu với một dòng mới, hãy sử dụng mã sau với 12 byte hoặc 2 sau khi trừ tiền thưởng.

iXa#~&{X:.)}

Lệnh mới duy nhất ở đây là #, đẩy số lượng vật phẩm trên ngăn xếp lên ngăn xếp.
Tôi đã xóa độ dài từ i, vì thêm 1, sau đó hoán đổi với dòng mới dài hơn xóa và lấy lại độ dài.

Để giải trí, đây là chương trình "Hello World"

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

Các ?!hoạt động cũng giống như> <> 's

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

Cảnh báo: dựa trên tính năng / lỗi không có giấy tờ và không được hỗ trợ.

⎕←⍣≢⍞

STDIN trống in các dòng trống (không phải "y"), được phép và đã được đề xuất .

Hãy thử trực tuyến!

⎕ STDOUT với các dòng mới,

← được

⍣ lặp đi lặp lại cho đến khi

≢ nó khác với

⍞ STDIN

tức là không bao giờ, nhưng không bị gián đoạn bằng cách tạm dừng chuỗi.

> <>, 6 byte

b:*oao

Bằng cách không bao gồm ;phần cuối, > <> sẽ tiếp tục bơi cho đến khi được SIGINT phát hành.

Giải trình

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 byte

Cái trước là một giải pháp khá nhàm chán, vì vậy đây là một giải pháp lấy đầu vào từ stdin. Điều này lạm dụng thực tế là cách cung cấp đầu vào mặc định cho chương trình > <> là echo 'input' | fish.py yes.fish, nơi echocung cấp \nký tự.

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

Giải trình

 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       ---------------'

Các 0rcuối cùng cho phép sfor vòng lặp xảy ra bằng cách quấn xung quanh, nơi chúng tôi vẫn cho rằng ngăn xếp bị đảo ngược với một -1bên trên.

Rõ ràng điều này không hoàn toàn di động. Tôi sys.version là 2.7.9 (default, Dec 11 2014, 04:42:00) \n[GCC 4.9.2]vậy, vì vậy nếu bạn khác thì điều này có thể không hoạt động tôi đoán.

Con trăn 2 - (76-10) = 66

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

Khá lâu, nhưng tôi muốn nhận phần thưởng (mặc dù nó có giá hơn 10 byte). Rõ ràng, kiểm tra xem stdin có trống hay không mà không nhắc nhập liệu là dài.

Lúc đầu, tôi đọc sai phần thưởng là lấy một đối số thay vì stdin. Tôi tự hào về giải pháp của mình cho điều đó, vì vậy tôi vẫn đăng nó;)

Python 2 - (52-10 +) = (không hợp lệ!)

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

sys.argvlà một danh sách trong đó phần tử zeroth là tên tệp và mọi phần tử hậu quả là một đối số được cung cấp cho chương trình. Tôi thêm một giá trị falsey vào cuối danh sách; nếu không có đối số, yếu tố đầu tiên là giá trị falsey, nếu không thì đó là đối số đầu tiên. a or btrong Python trả về giá trị đầu tiên xác nhận kết quả sẽ như thế nào: Nếu alà sự thật, chúng ta đã biết rằng toàn bộ sự việc sẽ là sự thật, vì vậy nó sẽ được trả về. Nếu nó sai, bđược trả về (kể từ False or b== b).