yes，来自coreutils，长91行。他们中许多人的意见，但仍然WAY太长。

从2019年9月开始编辑：源文件在过去五年中增长了，现在长126行。

编写一个模仿的程序yes：

• 输出到stdout“ y \ n”的无限流
• 必须有一个选项来阻止它除了具有杀死进程SIGKILL：但SIGINT和SIGPIPE都很好
• 您不得使用“ y”或“ \ n”或其ASCII值（121、0x79、0171、10、0xA或012）

最短答案胜出。

奖金：

• 如果可以接收到一个短语stdin并打印出来而不是“ y”（但仍包括换行符），则从代码长度中减去10 。

CJam，13个字节-10 = 3

l_'x)?{_oNo}h

您将需要使用Java解释器，因为在线解释器仅在程序终止后才返回。

您可以使用SIGINT中止程序（通过按Ctrl-C）。它将从STDIN中读取一行，并打印该行，或者y输入内容为空。

说明

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进行澄清之后，以下内容似乎更符合规范：

l{_o9c)o1}g

不过，我将等待更新提交内容，直到OP回复我的评论。

Brainfuck-38字节

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

它不会使用10或121，因为+-<>.,[]无论如何该语言中的所有有意义的字符都可以，但是它确实很幼稚地计算出它们（0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 = 10，10 * 12 + 1 = 121）。

这可能取决于解释器，但是它死于^C我的机器上。

操脑-（63-10）= 53

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

Python 3，27个字节

至少与CPython和Jython一起使用。

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

SIGINT将其停止。

Marbelous 14个字节

0978
]]/\++
!!

这非常简单，“ / \”设备在其左侧和右侧放置了两个副本，右边的一个递增了++然后从板上掉下来并被打印。该]]装置推任何大理石的权利，如果STDIN是空的，但让STDIN上的第一个字节掉下来，如果它不是。然后!!，这将触发设备，该设备将退出电路板。因此，这将打印y \ n，直到您在stdin上输入任何内容为止。

这仅在python解释器中有效。

Pyth，10 9 6个字节-10 = 0 -1 -4

#|zePG

我一直在努力使自己满意。基本上转换为：

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

C＃，81 78 76字节

无法与其他语言竞争，但是无论如何，这里是：

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

可以通过按Ctrl+ 杀死SIGINT C。

没有任何好处，因为要花费超过10个字节即可。

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

需要打印System，但y禁止使用该字符。因此，我不得不使用反射。

Perl：18个字节-10 = 8

该字符串来自STDIN。

$_=<>;{print;redo}

Ruby，30 23 18字节

loop{puts ?x.succ}

可以通过按Ctrl+ 杀死SIGINT C。

感谢manatwork分享改进！

Perl，26个字节

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

来自参数的自定义输入（如yes实际可行），22字节-10 = 12

{print @ARGV,$/;redo}

来自stdin的自定义输入，22字节-10 = 12

while(<>){print;redo}

C，64 55 53 45 40-10 = 30

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

我对此并不满意，因为它要求程序被命名为“ y”，并且只能用“ y”来调用，因此它必须位于$ PATH中，但是，第一个代码高尔夫:)

选择：

C，30（+1个文件名）

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

使用与我尊敬的同事@Matt Windsor相同的技术

• 编辑：事实证明，绕过no \ n字符使其更短
• EDIT2：“ int”比“ char”短
• EDIT3：根本不需要该变量
• EDIT4：一点点未定义的行为永远不会伤害任何人
• EDIT5：添加备用版本

Linux Bash，33-10 = 23

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

可以通过按Ctrl+ 杀死SIGINT C。

铁锈，52个字符

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

y在Rust中不显得厚脸皮似乎不是一种不错的计算方法- 他们在安全地进行chars方面做得很好。一世：

• 无法为提供非文字字符串println!，因此那里没有技巧。
• 不能将1加到'x'，因为Rust字符不是数字；
• ROT13不能（为什么Rust在其标准库中没有ROT13 ！？）；
• 不能轻易地做任何不安全的事情，例如拖放到C字符串，从数字转换为字符等，而不必太冗长且超过52c。

获得代码奖金也不值得，因为从中读取stdin将需要错误处理= 3

我发现的许多代码减少工作都涉及到在编译器环境中执行越来越违规的事情：

Rust，44个字符（文件名至少+ 1个字符）

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

在下面被废弃。这可能不算在内，因为源文件的名称需要以开头y。

编辑：Rust，36个字符（35个源，1个文件名）

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

如上所述，但该文件已被称为y（不y.rs，y）。幽默地说，Rust将用二进制文件覆盖源代码！至少在我的机器上，二进制文件确实可以在那之后工作。

Rust，37个字符（+等价env K='y'于您的平台）

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

这是一个更糟糕的：你需要设置环境变量K，以y在编译时。

编辑：如果设置K为y\n，则可以ln放入中println!，总共35个字符和几个facepalms：

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

Linux Bash-19个字节

如果您没有/ usr / bin / yes或/ usr / bin / xes或/ usr / bin / zes，这可能会作弊并可能失败：

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

我认为它符合要求，尽管可能违反了“没有结果可评估y”的规则。也许yes通过实际跑步yes来模仿是违反规则的。

可以对其进行一些优化（尽管不太可能工作），以减少到11个字节：

/*/*/?es $*

我无法弄清楚如何通过从标准输入中读取字符串而不向代码添加超过10个字节来获得10点奖励

直流电，12

[30986Pdx]dx

仅输出y\n。不从stdin读取，因此没有任何奖励。

30986是0x790A（即“ y \ n”）。该P命令仅将数字转换为256进制，并为每个256进制数字打印相应的字符。

普通Lisp：（30-10）= 20

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

• (read) 从输入流
• 打印到输出流： (format t ... )
• 遍历所有format参数（此处仅一个）：~@{ ... ~}

• 在循环中，对于每个参数：

  • 打印参数~A后跟换行符~%
  • 将当前元素后退到上一个元素~:*（无限循环）

您可以使用来中断循环Ctrl+C，这表明重启选项（继续/中止）出错。

Haskell，29个字节

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

我相信这一切都会被SIGINT和阻止SIGPIPE。

Ruby，27个字节-10 = 17

这只是@ProgramFOX的红利解决方案（花了我9个字节来解决红利问题）。

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

dc，21个字节-10 = 11

C1st?st[ltP[]ps0dx]dx

请注意，输入必须包装在中[]，例如[no]，因为这?是获取输入的唯一方法，它将输入作为dc代码执行。

Commodore 64 Basic：14 13字节

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

和往常一样，我已经替换了PETSCII中Unicode中不存在的字符。 |用于表示SHIFT+H，而╭表示SHIFT+U。请注意，这将输出ASCII“ y”（字节值121），而不是默认的Commodore字符集显示为“ y”的字符。

BASIC被认为是一种易于学习的，类似于英语的编程语言。抛弃许多早期方言中存在的键入快捷方式，您会得到比Perl更短，更易读的内容。

编辑：在“移位模式”中，由于小写的“ y”以十进制值89进行编码，因此它缩短了两个字节。使用非ASCII字符集来绕过“不允许使用其ASCII值”规则作弊，虽然。

1?cH(89):rU

AWK，38个字节

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

将在stdin上读取字符串的变体：14字节-10 = 4

{for(;;)print}

但是由于它不能同时执行两个操作（如果未提供标准输入，请返回“ y”），因此我不确定它是否可以计数...：o）

两者都可以使用Ctrl + C退出。

裂变，5字节

Rx+!N

对于裂变来说，这是相当有竞争力的。:)

控制流从处的(1,0)向右原子开始R。x将质量设置为120，并将其+增加为(121,0)。然后!打印相应的字符（y）并N换行。源代码在边缘处环绕，因此原子R再次通过（现在不执行任何操作），x将质量120再次设置为，+增加其质量，依此类推……

C，32个字节

需要很少的字节序机器并使用-O2进行编译（以避免堆栈溢出）。

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

PowerShell，27 − 10 = 17

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

可能无法在Pash中使用。一个更可靠的选择应该是

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

Lua，42个字节-10 = 32

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

Lua，49个字节-10 = 39

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

两者都通过Lua 5.1.4进行了测试，并且可以使用SIGINT（Ctrl+ C）终止。

Perl，31岁

yes据我所知，这是一个Perl版本，实际上表现得像GNU ：

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

如果可以使用perl的命令行开关（-l对于换行符），则此方法有效，否则，它的长度将增加3个字符：

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

CAPL 1.5以上；6无输入；带输入的10-10 = 0

旁注
我在某处[链接？]读过，高尔夫问题中不允许使用自定义语言，因为它们可以使内置函数完全满足问题的要求，但是我使CAPL 总体上使高尔夫更容易。如果您认为这里不允许这样做，请告诉我！

我从> <>和Befunge（可以在行之间移动并使用十六进制字符来推数字）中得到一些想法，一些想法来自Ruby，有些来自我自己，以使打高尔夫球变得容易。
CAPL从左到右读取，并在该行的末尾向下一行。如果是最后一行，则程序将退出。

到目前为止，还没有人知道这种语言，所以我会尽力解释。

输出y。6个字节

bb*.n<

bb* b为十六进制11，所以bb*是11*11= 121，这是UTF-8等效的y。该值被压入堆栈。
.从堆栈中弹出最高值，并输出为UTF-8。正如121堆栈顶部一样，这里忽略了索引。
n输出换行符
<将指针发送回该行的开头，从而重复该行。由于我们不期望输入，因此可以安全地执行此操作，而无需重新询问输入。

从输入输出。10个字节，加分后为0

i~a&{X:.)}

i接收用户的输入，将其作为UTF-8压入堆栈的顶部，然后压入长度。即[72,101,108,108,111,5]
~从堆栈中弹出一个数字，然后反转该字节数。即[111,108,108,101,72]
a十六进制为10，换行符
&{...}形成无限循环。我们有输入，所以我们不能将指针发送回该行。我可以将函数放在下面的行中，这将使我安全一个字节，但此挑战中不允许换行。
X从堆栈中删除最高值（循环中的索引）
:.复制最高值，然后输出为UTF-8
)。向右转堆栈。（[1,2,3,4,5]-> [5,1,2,3,4]）

但是，这意味着我们从换行开始，然后开始输出输入，然后是换行，然后是输入，依此类推。如果不允许我们以换行开头，请使用以下代码（12字节），或者减去2奖金。

iXa#~&{X:.)}

这里唯一的新命令是#，它将堆栈中的项目数量推入堆栈。
我从中删除了长度i，因为加1，然后与换行符交换比删除并重新获得长度长。

只是为了好玩，这里有一个“ Hello World”程序

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

该?!操作与> <>的相同

APL（Dyalog APL），5-10 = -5字节

警告：依赖于未记录且不受支持的功能/错误。

⎕←⍣≢⍞

空STDIN打印空行（不是“ y”），这是允许的并且建议使用。

在线尝试！

⎕ STDOUT末尾有换行符，

← 得到

⍣ 反复直到

≢ 它不同于

⍞ 标准输入

即从不，但通过暂停线程不间断。

> <>，​​6个字节

b:*oao

通过;在末尾不包含a ，> <>将继续游动直到被SIGINT释放。

说明

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个字节

前一个是一个很无聊的解决方案，因此这里是一个从stdin输入的解决方案。这滥用了这样的事实，即向> <>程序提供输入的默认方式是echo 'input' | fish.py yes.fish，其中echo提供了\n字符。

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

说明

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

将0r在年底让稳定部队环路通过围绕，在这里我们还是假设堆栈有逆转发生-1在最前面。

显然，这并不是完全可移植的。我 sys.version 是 2.7.9 (default, Dec 11 2014, 04:42:00) \n[GCC 4.9.2]，所以我想如果您的不同，那可能行不通。

Python 2-（76-10）= 66

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

相当长，但是我想获得奖金（即使它的成本超过10个字节）。很显然，在不提示输入的情况下检查stdin是否为空。

起初，我误以为是标准论证而不是标准论证。我为此感到自豪，因此无论如何我都会将其发布;）

Python 2-（52-10 +∞）=∞（无效！）

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

sys.argv是一个列表，其中第零个元素是文件名，每个元素后缀是提供给程序的参数。我在列表的末尾添加了一个falsey值；如果没有参数，则第一个元素是那个falsey值，否则它是第一个参数。a or bPython中的aint 返回确认结果将是什么的第一个值：如果是真实的，我们已经知道整个事情将是真实的，因此它将被返回。如果为假，b则返回（因为False or b== b）。