yes, від coreutils, становить 91 рядок . Багато з них є коментарями, але це все ще ЗАДАЧЕ задовго.

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

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

• виведення в stdoutнескінченний потік "y \ n" 's
• повинен бути варіант зупинити його, крім того, щоб вбити процес за допомогою 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 зупиняє це.

Марбельний 14 байт

0978
]]/\++
!!

Це досить просто, пристрій '/ \' розміщує дві копії зліва та справа, правий збільшується, ++а потім падає з дошки та друкується. ]]Пристрій штовхає будь мармур вправо , якщо STDIN порожній , але дозволяє перші байти на STDIN падати вниз , якщо це не так . Потім це запустить !!пристрій, який виходить з плати. Отже, це буде друкувати y \ n, поки ви нічого не введете на stdin.

Це працює лише в інтерпретаторі пітона.

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.

Дякуємо манантській роботі за те, що ви вдосконалювались!

Perl, 26 байт

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

Спеціальне введення з аргументу (як yesнасправді працює), 22 байти-10 = 12

{print @ARGV,$/;redo}

Власне введення від stdin, 22 байти-10 = 12

while(<>){print;redo}

С, 64 55 53 45 40 - 10 = 30

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

Я не надто задоволений цим, оскільки це вимагає, щоб програма мала назву "у", і щоб її називали лише "у", тому вона повинна бути в $ PATH, але ей, перший кодовий гольф :)

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

C, 30 (+ 1 ім'я файлу)

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

Використовуючи ту саму техніку, що і мій шановний колега @Matt Windsor

• EDIT: виявляється, що обхід жодного \ 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не будучи сміливим у Расті - вони зробили надто гарну роботу, щоб безпечно робити символи. Я:

• Неможливо надати нелітеральну рядок println!, тому жодні трюки там не дозволені;
• Не можна додати 1 до 'x', тому що в символах Іржі це не числа;
• Неможливо ROT13 (чому Rust13 не має ROT13 у своїй стандартній бібліотеці !?);
• Не можна легко зробити щось небезпечне, наприклад, переходити до струн C, перетворювати з чисел у знаки тощо, не будучи неймовірно багатослівним і не перевищуючи 52c.

Не варто також отримувати бонус за код, тому що для читання stdinвимагається обробка помилок = 3

Значну частину скорочень коду я міг би спричинити за те, що роблячи все частіше рушійні правила із середовищем компілятора:

Іржа, 44 символи (+ принаймні 1 знак для імені файлу)

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

Застарілий знизу. Цей, мабуть, не рахується, оскільки ім'я вихідного файлу потрібно починати y.

Редагувати: Іржа, 36 знаків (35 джерел, 1 ім'я файлу)

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

Як і вище, але файл повинен називатися y(НЕ y.rs, y). Жартівливо, Іржа замінить джерело двійковим! Принаймні, на моїй машині бінарний працює після цього, хоча.

Іржа, 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 / так або у вас / / usr / bin / xes або / usr / bin / zes:

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

Я думаю, що він відповідає вимогам, хоча, можливо, це порушує правило «нічого, що оцінює y». І, можливо, наслідування yesфактично бігом yesсуперечить правилам.

Це може бути трохи оптимізовано (хоча це менш імовірно, що працює), щоб зменшити його до 11 байт:

/*/*/?es $*

Я не міг зрозуміти, як отримати бонус у 10 балів, прочитавши рядок від stdin, не додавши до коду більше 10 байт

DC, 12

[30986Pdx]dx

Тільки виходи y\n. Не читається зі stdin, тому ніякого бонусу.

30986 дорівнює 0x790A (тобто "y \ n"). PКоманда просто перетворює число по підставі 256, і виводить відповідний символ для кожної базової 256 цифри.

Лист звичайний: (30-10) = 20

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

• (read) з вхідного потоку
• друк для вихідного потоку: (format t ... )
• повторити всі formatаргументи (тут лише один):~@{ ... ~}

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

  • аргумент друку з ~Aнаступним новим рядком~%
  • перемотати поточний елемент на попередній ~:*(нескінченна петля)

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

Хаскелл, 29 байт

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

Я вважаю, що це зупинено обома SIGINTі SIGPIPE.

Рубін, 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.

EDIT : У "зміщеному режимі" це стає на два байти коротше, завдяки малому "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", якщо не передбачено stdin), я не впевнений, що це враховується ...: o)

Обидва можна вийти за допомогою Ctrl + C.

Ділення , 5 байт

Rx+!N

Це досить конкурентоспроможно для Fission. :)

Контрольний потік починається з (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}

Луа, 42 байти - 10 = 32

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

Луа, 49 байт - 10 = 39

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

Обидва були протестовані на Lua 5.1.4 і можуть бути вбиті за допомогою SIGINT ( Ctrl+ C).

Перл, 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*це 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"#~
#?!;.<

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

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

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

⎕←⍣≢⍞

Порожній STDIN друкує порожні рядки (не "у"), що дозволено і було запропоновано .

Спробуйте в Інтернеті!

⎕ 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кінці дозволяють sfor циклу відбуватися, обертаючись навколо, де ми все ще припускаємо, що стек буде повернутий -1зверху a .

Мабуть, це не зовсім портативно. Моє sys.version це 2.7.9 (default, Dec 11 2014, 04:42:00) \n[GCC 4.9.2], так що якщо ваш відрізняються це може не працювати , я думаю.

Пітон 2 - (76-10) = 66

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

Досить довго, але я хотів піти на бонус (навіть якщо це коштувало більше 10 байт). Мабуть, перевірка того, чи stdin порожній чи ні, без запитів на введення триває.

Спочатку я перечитав бонус як аргумент замість stdin. Я пишаюся своїм рішенням для цього, тому я все-таки публікую його;)

Python 2 - (52-10 + ∞) = ∞ (недійсний!)

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

sys.argv- це список, де нульовий елемент - це ім'я файлу, а кожен елемент після слова - це аргумент, наданий програмі. Я додаю значення фальси в кінець списку; якщо аргументів немає, перший елемент - це значення фальси, інакше це перший аргумент. a or bв Python повертає перше значення, яке підтверджує, який буде результат: Якщо aце truthy, ми вже знаємо, що вся справа буде правдою, тому вона просто повертається. Якщо це неправда, bповертається (оскільки False or b== b).