yesиз coreutils длиной 91 строка . Многие из них являются комментарии, но это по - прежнему WAY слишком долго.

Редактировать с сентября 2019 года: исходный файл вырос за последние пять лет и теперь составляет 126 строк.

Напишите программу, которая имитирует yes:

• вывод в stdoutбесконечный поток "y \ n"
• должна быть возможность остановить его, кроме как убить процесс с помощью SIGKILL: но SIGINTи SIGPIPEвсе в порядке
• Вам не разрешено использовать "y" или "\ n" или их значения ASCII (121, 0x79, 0171, 10, 0xA или 012)

Кратчайший ответ выигрывает.

Бонус:

• вычтите 10 из длины вашего кода, если вы можете получить фразу stdinи распечатать ее вместо «y» (но все равно включая разрыв строки).

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

После прояснения ОП, кажется, что следующее больше для спецификации:

l{_o9c)o1}g

Я подожду с обновлением представления, пока ОП ответит на мой комментарий.

Brainfuck - 38 байт

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

Он не использует 10 или 121, потому что +-<>.,[]все равно все значимые символы в языке, но вычисляет их довольно наивно (0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 = 10, 10 * 12 + 1 = 121).

Вероятно, это зависит от переводчика, но он умирает ^Cна моей машине.

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

Может быть убит с помощью SIGINT нажатием Ctrl+ 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}

Рубин, 30 23 18 байт

loop{puts ?x.succ}

Может быть убит с помощью SIGINT нажатием Ctrl+ C.

Спасибо Manatwork для обмена улучшениями!

Perl, 26 байт

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

Пользовательский ввод из аргумента (как на yesсамом деле работает), 22 байта-10 = 12

{print @ARGV,$/;redo}

Пользовательский ввод из стандартного ввода, 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, но, эй, сначала codegolf :)

Альтернатива:

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

Может быть убит с помощью SIGINT нажатием Ctrl+ C.

Ржавчина, 52 знака

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

yКажется, что в Rust нет хороших способов вычислений , если они не дерзкие - они слишком хорошо поработали над безопасными символами. Я:

• Не может предоставить не-литеральную строку 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 перезапишет исходный код двоичным файлом! По крайней мере, на моей машине бинарный код работает после этого.

Ржавчина, 37 символов (+ эквивалент env K='y'на вашей платформе)

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

Это один еще хуже: вам нужно установить переменную окружения , Kчтобы yна время компиляции .

Edit : если вы установите 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. Не читает со стандартного ввода, так что бонусов нет.

30986 - это 0x790A (т. Е. "Y \ n"). Команда Pпросто преобразует число в основную 256 и печатает соответствующий символ для каждой базовой цифры 256.

Common Lisp: (30-10) = 20

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

• (read) из входного потока
• печать в выходной поток: (format t ... )
• перебрать все formatаргументы (только один здесь):~@{ ... ~}

• внутри цикла, для каждого аргумента:

  • аргумент print с ~Aпоследующим переводом строки~%
  • перемотать текущий элемент к предыдущему ~:*(бесконечный цикл)

Вы можете разорвать цикл с помощью Ctrl+C, который сигнализирует об ошибке с опциями перезапуска (продолжить / прервать).

Haskell, 29 байт

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

Я полагаю, что это остановлено обоими SIGINTи SIGPIPE.

Рубин, 27 байт - 10 = 17

Это просто решение @ ProgramFOX с бонусом (на решение вопроса о бонусе у меня ушло 9 байтов).

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

постоянный ток, 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)}

Вариант, который будет читать строку на стандартный ввод: 14 байт-10 = 4

{for(;;)print}

Но так как он не может сделать и то и другое (вернуться к «y», если не указан stdin), я не уверен, что это считается ...: 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}

Может не работать в Паше. Более надежная альтернатива должна быть

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

Вот версия Perl, которая на самом деле ведет себя как GNU yes, насколько я могу судить:

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

Это работает, если допустимо использование переключателей командной строки perl ( -lдля новой строки), иначе это станет на 3 символа длиннее:

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

CAPL 1.5+; 6 без ввода; 10 - 10 = 0 с вводом

Sidenote
Я где-то читал [ссылка?], Что пользовательские языки не допускаются в вопросах игры в гольф, поскольку они могут делать встроенные функции, которые точно выполняют заданный вопрос, однако я сделал CAPL, чтобы упростить игру в гольф в целом . Если вы думаете, что это здесь запрещено, дайте мне знать!

Я получил некоторые идеи от > <> и Befunge (вы можете перемещаться между строками и использовать шестнадцатеричные символы для ввода чисел), некоторые из Ruby, а некоторые из моих, чтобы упростить игру в гольф.
CAPL читает слева направо и идет на одну строку вниз в конце строки. Если это последняя строка, программа закроется.

Поскольку никто еще не знает этот язык, я постараюсь объяснить как можно больше.

Вывод y. 6 байт

bb*.n<

bb* bявляется шестнадцатеричным для 11, поэтому bb*is 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"#~
#?!;.<

?!Операция такая же , как> <> 's

APL (Dyalog APL) , 5 - 10 = -5 байт

Предупреждение: полагается на недокументированную и неподдерживаемую функцию / ошибку.

⎕←⍣≢⍞

Пустой STDIN печатает пустые строки (не «y»), что разрешено и было предложено .

Попробуйте онлайн!

⎕ STDOUT с завершающими символами новой строки,

← получает

⍣ неоднократно, пока

≢ это отличается от

⍞ STDIN

то есть никогда, но непрерывно, прерывая поток.

> <>, 6 байт

b:*oao

Не добавляя ;в конце, > <> будет продолжать плавать до тех пор, пока 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это список, где нулевой элемент является именем файла, а каждый элемент afterwords является аргументом, данным программе. Я добавляю значение Falsey в конец списка; если аргументов нет, первый элемент - это значение false, иначе это первый аргумент. a or bв Python возвращает первое значение, которое подтверждает, каким будет результат: если aэто правда, мы уже знаем, что все это будет правдой, поэтому оно просто возвращается. Если это false, bвозвращается (так как False or b== b).