yes, de coreutils, tem 91 linhas . Muitos deles são comentários, mas que ainda é MANEIRA demasiado longo.

Editar a partir de setembro de 2019: o arquivo de origem cresceu nos últimos cinco anos e agora tem 126 linhas.

Escreva um programa que imite yes:

• saída para stdoutum fluxo infinito de "y \ n" 's
• deve haver uma opção para pará-lo, exceto matar o processo com SIGKILL: but SIGINTand SIGPIPEare fine
• você não tem permissão para usar "y" ou "\ n" ou seus valores ASCII (121, 0x79, 0171, 10, 0xA ou 012)

A resposta mais curta vence.

Bônus:

• subtraia 10 do comprimento do código, se você puder receber uma frase stdine imprimi-la em vez de "y" (mas ainda incluindo a quebra de linha).

CJam, 13 bytes - 10 = 3

l_'x)?{_oNo}h

Você precisará usar o intérprete Java para isso, porque o intérprete on-line só retorna quando o programa termina.

Você pode abortar o programa com SIGINT (pressionando Ctrl-C). Ele lerá uma linha de STDIN e imprimirá essa linha, ou yse a entrada estiver vazia.

Explicação

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

Após o esclarecimento do PO, o seguinte parece ser mais específico:

l{_o9c)o1}g

Esperarei atualizar o envio até que o OP responda ao meu comentário.

Brainfuck - 38 bytes

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

Ele não usa 10 ou 121, porque +-<>.,[]são todos os caracteres significativos no idioma, mas calcula-os de maneira bastante ingênua (0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 = 10, 10 * 12 + 1 = 121).

Provavelmente isso depende do intérprete, mas ele morre ^Cna minha máquina.

Brainfuck - (63-10) = 53

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

Python 3, 27 bytes

Funciona com pelo menos CPython e Jython.

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

SIGINT para.

Marbelous 14 bytes

0978
]]/\++
!!

Isso é bem simples: o dispositivo '/ \' coloca duas cópias à esquerda e à direita, a direita é incrementada ++e depois cai do quadro e é impressa. O ]]dispositivo empurra qualquer mármore para a direita se STDIN estiver vazio, mas permite que o primeiro byte no STDIN caia se não estiver. Isso acionará o !!dispositivo, que sai do quadro. Portanto, isso será impresso y \ n até você inserir qualquer coisa no stdin.

Isso funciona apenas no interpretador python.

Pitão, 10 9 6 bytes - 10 = 0 -1 -4

#|zePG

Eu venho tentando há muito tempo conseguir um que eu esteja satisfeito. Basicamente, converte para:

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

C #, 81 78 76 bytes

Não pode competir com os outros idiomas, mas aqui está mesmo assim:

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

Pode ser morto com o SIGINT pressionando Ctrl+ C.

Nenhum bônus, porque levaria mais de 10 bytes para obtê-lo.

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

A impressão requer System, mas o ycaractere é proibido. Por isso, tive que usar a reflexão.

Perl: 18 bytes - 10 = 8

A sequência é de STDIN.

$_=<>;{print;redo}

Ruby, 30 23 18 bytes

loop{puts ?x.succ}

Pode ser morto com o SIGINT pressionando Ctrl+ C.

Obrigado ao manatwork por compartilhar melhorias!

Perl, 26 bytes

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

Entrada personalizada do argumento (como yesrealmente funciona), 22 bytes-10 = 12

{print @ARGV,$/;redo}

Entrada personalizada de stdin, 22 bytes-10 = 12

while(<>){print;redo}

C, 64 55 53 45 40 - 10 = 30

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

Eu não estou muito feliz com isso, pois exige que o programa seja nomeado "y" e chamado apenas com `y`, portanto, ele deve estar em $ PATH, mas ei, primeiro codegolf :)

Alternativa:

C, 30 (+ 1 nome do arquivo)

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

Usando a mesma técnica do meu estimado colega @ Windsor Windsor

• EDIT: acontece que contornar o caractere no \ n tornou mais curto
• EDIT2: "int" é menor que "char"
• EDIT3: não precisava dessa variável
• EDIT4: um pouco de comportamento ligeiramente indefinido nunca faz mal a ninguém
• EDIT5: adicionar versão alternativa

Linux Bash, 33-10 = 23

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

Pode ser morto com o SIGINT pressionando Ctrl+ C.

Ferrugem, 52 caracteres

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

yParece que simplesmente não há uma maneira agradável de calcular sem ser atrevido no Rust - eles fizeram um trabalho muito bom ao fazer chars com segurança. EU:

• Não é possível fornecer uma string não literal para println!, portanto, nenhum truque é permitido lá;
• Não é possível adicionar 1 a 'x' , porque no Rust os caracteres não são números;
• Não é possível o ROT13 (por que o Rust não possui o ROT13 em sua biblioteca padrão !?);
• Não é possível fazer algo inseguro com facilidade, como passar para C, converter de números para caracteres, etc., sem ser incrivelmente detalhado e ultrapassar 52c.

Também não vale o bônus de código, porque a leitura de stdinexigiria tratamento de erros = 3

Muitas das reduções de código que pude encontrar envolviam fazer coisas cada vez mais desrespeitadoras de regras com o ambiente do compilador:

Ferrugem, 44 caracteres (+ pelo menos 1 caractere para o nome do arquivo)

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

Obsoleto abaixo. Este provavelmente não conta, pois o nome do arquivo de origem precisa começar y.

Edit: Rust, 36 caracteres (35 fonte, 1 nome do arquivo)

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

Como acima, mas o arquivo tem de ser chamado y(não y.rs, y). Bem humorado, Rust substituirá a fonte pelo binário! Pelo menos na minha máquina, o binário funciona depois disso.

Ferrugem, 37 caracteres (+ equivalente env K='y'na sua plataforma)

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

Essa é ainda pior: você precisa definir a variável de ambiente Kcomo yem tempo de compilação .

Editar : se você definir Kcomo y\n, poderá fazer o drop- lnin println!, para um total geral de 35 caracteres e vários facepalms:

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

Linux Bash - 19 bytes

Isso provavelmente está trapaceando e está sujeito a falha se você não tiver / usr / bin / yes ou tiver um / usr / bin / xes ou / usr / bin / zes:

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

Acho que atende aos requisitos, embora talvez esteja violando a regra "nada que avalie para y". E talvez imitar yesexecutando de verdade yesseja contra as regras.

Isso pode ser otimizado um pouco (embora menos provável que funcione) para reduzir para 11 bytes:

/*/*/?es $*

Eu não conseguia descobrir como obter o bônus de 10 pontos lendo uma string do stdin sem adicionar mais de 10 bytes ao código

dc, 12

[30986Pdx]dx

Somente saídas y\n . Não lê de stdin, então nenhum bônus.

30986 é 0x790A (ou seja, "y \ n"). O Pcomando simplesmente converte o número na base 256 e imprime o caractere correspondente para cada dígito de base 256.

Lisp comum: (30-10) = 20

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

• (read) do fluxo de entrada
• imprimir no fluxo de saída: (format t ... )
• itere sobre todos os formatargumentos (apenas um aqui):~@{ ... ~}

• dentro do loop, para cada argumento:

  • argumento de impressão ~Aseguido por uma nova linha~%
  • rebobinar o elemento atual para o anterior ~:*(loop infinito)

Você pode interromper o loop Ctrl+C, o que indica um erro nas opções de reinicialização (continuar / abortar).

Haskell, 29 bytes

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

Eu acredito que isso é interrompido por ambos SIGINTe SIGPIPE.

Ruby, 27 bytes - 10 = 17

É apenas a solução do @ ProgramFOX com o bônus (foram necessários meus 9 bytes para resolver a questão do bônus).

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

dc, 21 bytes - 10 = 11

C1st?st[ltP[]ps0dx]dx

Observe que a entrada precisa ser inserida [], por exemplo [no], porque ?é a única maneira de obter entrada, que a executa como dccódigo.

Commodore 64 Basic: 14 13 bytes

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

Como sempre, fiz substituições de caracteres no PETSCII que não estão presentes no Unicode. |é usado para representar SHIFT+H, enquanto ╭representa SHIFT+U. Observe que isso gera ASCII 'y' (valor de byte 121) em vez de um caractere que o conjunto de caracteres padrão do Commodore exibe como 'y'.

O BASIC é supostamente uma linguagem de programação fácil de aprender, semelhante ao inglês. Use os atalhos de digitação presentes em muitos dialetos antigos e você terá algo mais curto e menos legível que o Perl.

EDIT : No "modo deslocado", isso fica dois bytes mais curto, graças à codificação "y" minúscula no valor decimal 89. O uso de um conjunto de caracteres não ASCII para contornar a regra "não permitido usar seus valores ASCII" pode ser trapaça, no entanto.

1?cH(89):rU

AWK, 38 bytes

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

Variante que lerá a string em stdin: 14 bytes-10 = 4

{for(;;)print}

Mas como ele não pode fazer as duas coisas (reverta para "y" se nenhum stdin for fornecido), não tenho certeza se isso conta ...: o)

Ambos podem ser encerrados com Ctrl + C.

Fissão , 5 bytes

Rx+!N

Isso é bastante competitivo para a fissão. :)

O fluxo de controle começa com um (1,0)átomo à direita em R. xdefine a massa como 120e a +incrementa para fornecer (121,0). Em seguida, !imprime o caractere correspondente ( y) e Nimprime uma nova linha. O código fonte envolve as bordas, para que o átomo passe Rnovamente (o que não faz mais nada agora), xajusta a massa 120novamente, a +incrementa e assim por diante ...

C, 32 bytes

Requer pouca máquina endian e compilação com -O2 (para evitar o estouro da pilha).

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

PowerShell, 27 - 10 = 17

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

Pode não funcionar em Pash. Uma alternativa mais robusta deve ser

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

Lua, 42 bytes - 10 = 32

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

Lua, 49 bytes - 10 = 39

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

Ambos foram testados com Lua 5.1.4 e podem ser eliminados com SIGINT ( Ctrl+ C).

Perl, 31

Aqui está uma versão do Perl que realmente se comporta como o GNU yes, até onde eu sei:

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

Isso funciona se não há problema em usar as opções de linha de comando do perl ( -lpara a nova linha), caso contrário, isso tornaria mais três caracteres:

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

CAPL 1.5+; 6 sem entrada; 10 - 10 = 0 com entrada

Sidenote
: Li em algum lugar [link?] Que linguagens personalizadas não são permitidas em perguntas sobre golfe, pois elas podem criar funções internas que fazem exatamente o que a pergunta está perguntando; no entanto, eu fiz o CAPL para facilitar o golfe em geral . Se você acha que isso não é permitido aqui, me avise!

Eu tenho algumas idéias de > <> e Befunge (você pode se mover entre linhas e usar caracteres hexadecimais para pressionar números), algumas de Ruby e outras de minha autoria para facilitar o golfe.
O CAPL lê da esquerda para a direita e desce uma linha no final da linha. Se for a última linha, o programa será encerrado.

Como ninguém conhece esse idioma ainda, tentarei explicar o máximo possível.

Saída y. 6 bytes

bb*.n<

bb* bé hexadecimal para 11, assim bb*como 11*11= 121, que é o equivalente UTF-8 y. Este valor é enviado para a pilha.
.Aparece o valor superior da pilha e gera como UTF-8. Como 121está no topo da pilha, o índice é ignorado aqui.
nGera uma nova linha
< Envia o ponteiro de volta ao início da linha, repetindo a linha. Como não esperamos entrada, podemos fazer isso com segurança sem solicitar novamente a entrada.

Saída da entrada. 10 bytes, 0 após bônus

i~a&{X:.)}

iRecebe a entrada do usuário, pressiona como UTF-8 na parte superior da pilha e pressiona o comprimento depois disso. Ou seja, [72,101,108,108,111,5]
~aparece um número da pilha e depois inverte essa quantidade de bytes. [111,108,108,101,72]
aOu seja, Hexadecimal para 10, o caractere de nova linha
&{...}Faz um loop infinito. Temos entrada, portanto não podemos enviar o ponteiro de volta para a linha. Eu poderia colocar a função na linha abaixo, o que me garantiria um byte, mas novas linhas não são permitidas neste desafio.
XRemove o valor superior da pilha (O índice do loop)
:.Duplica o valor superior e emite como UTF-8
)Vira a pilha para a direita. ( [1,2,3,4,5]-> [5,1,2,3,4])

No entanto, isso significa que começamos com uma nova linha, depois iniciamos a saída da entrada, depois uma nova linha, depois a entrada etc. Se não for permitido iniciar com uma nova linha, use o código a seguir com 12 bytes ou 2 após subtrair o bônus.

iXa#~&{X:.)}

O único novo comando aqui é o #que envia a quantidade de itens da pilha para a pilha.
Eu removi o comprimento de i, porque adicionar 1 e trocar com a nova linha é mais longo do que remover e obter o comprimento novamente.

Apenas por diversão, aqui está um programa "Hello World"

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

A ?!operação é igual à de> <>

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

Aviso: confia em um recurso / bug não documentado e não suportado.

⎕←⍣≢⍞

STDIN vazio imprime linhas vazias (não "y"), o que é permitido e foi sugerido .

Experimente online!

⎕ STDOUT com novas linhas à direita,

← fica

⍣ repetidamente até

≢ difere de

⍞ STDIN

ou seja, nunca, mas ininterrupta ao pausar o thread.

> <>, 6 bytes

b:*oao

Ao não incluir um ;no final, o > <> continuará nadando até que ele seja liberado por um SIGINT.

Explicação

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 bytes

A anterior é uma solução bastante chata, então aqui está uma que recebe a entrada de stdin. Isso abusa do fato de que a maneira padrão de fornecer entrada para um programa > <> é echo 'input' | fish.py yes.fish, onde echofornece o \ncaractere.

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

Explicação

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

O 0rfinal permite que o loop aconteça ao redor, onde ainda presumimos que a pilha seja revertida com um -1no topo.

Aparentemente, isso não é totalmente portátil. Meu sys.version é 2.7.9 (default, Dec 11 2014, 04:42:00) \n[GCC 4.9.2], então, se o seu for diferente, isso pode não funcionar, eu acho.

Python 2 - (76-10) = 66

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

Muito tempo, mas eu queria ir para o bônus (mesmo que custe mais de 10 bytes). Aparentemente, verificar se stdin está vazio ou não sem solicitar a entrada é longo.

No começo, interpretei mal o bônus como argumento em vez de stdin. Estou orgulhoso da minha solução para isso, então estou postando assim mesmo;)

Python 2 - (52-10 + ∞) = ∞ (inválido!)

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

sys.argvé uma lista em que o elemento zeroth é o nome do arquivo e cada elemento posterior é um argumento fornecido ao programa. Eu adiciono um valor falsey ao final da lista; se não houver argumentos, o primeiro elemento é esse valor de falsey, caso contrário, é o primeiro argumento. a or bem Python retorna o primeiro valor que confirma qual será o resultado: se afor verdade, já sabemos que tudo será verdade, então é retornado. Se for falso, bserá retornado (desde False or b== b).