yes, de coreutils, tiene 91 líneas de largo . Muchos de ellos son los comentarios, pero que todavía es MANERA demasiado tiempo.

Editar desde septiembre de 2019: el archivo fuente creció en los últimos cinco años y ahora tiene 126 líneas de largo.

Escribe un programa que imite yes:

• dando salida a stdoutun flujo infinito de "y \ n"
• debe haber una opción para detenerlo que no sea matar el proceso con SIGKILL: but SIGINTand SIGPIPEare fine
• no puede usar "y" o "\ n" o sus valores ASCII (121, 0x79, 0171, 10, 0xA o 012)

La respuesta más corta gana.

Prima:

• reste 10 de la longitud de su código, si puede recibir una frase stdine imprimirla en lugar de "y" (pero aún incluye el salto de línea).

CJam, 13 bytes - 10 = 3

l_'x)?{_oNo}h

Necesitará usar el intérprete de Java para esto, porque el intérprete en línea solo regresa una vez que finaliza el programa.

Puede abortar el programa con SIGINT (presionando Ctrl-C). Leerá una línea de STDIN e imprimirá esa línea, o ysi la entrada estaba vacía.

Explicación

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

Después de la aclaración del OP, lo siguiente parece más específico:

l{_o9c)o1}g

Sin embargo, esperaré con la actualización del envío hasta que el OP responda a mi comentario.

Brainfuck - 38 bytes

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

No usa 10 o 121, porque de +-<>.,[]todos modos son todos los caracteres significativos en el idioma, pero los calcula bastante ingenuamente (0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 = 10, 10 * 12 + 1 = 121).

Esto probablemente depende del intérprete, pero se muere ^Cen mi máquina.

Brainfuck - (63-10) = 53

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

Python 3, 27 bytes

Funciona con al menos CPython y Jython.

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

SIGINT lo detiene.

Maravilloso 14 bytes

0978
]]/\++
!!

Esto es bastante sencillo, el dispositivo '/ \' coloca dos copias a su izquierda y derecha, la derecha se incrementa ++y luego se cae del tablero y se imprime. El ]]dispositivo empuja cualquier canica hacia la derecha si STDIN está vacío, pero deja caer el primer byte de STDIN si no lo está. Esto activará el !!dispositivo, que sale de la placa. Entonces esto imprimirá y \ n hasta que ingrese algo en stdin.

Esto solo funciona en el intérprete de Python.

Pyth, 10 9 6 bytes - 10 = 0 -1 -4

#|zePG

Llevo años intentando conseguir uno que me satisfaga. Básicamente se convierte a:

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

C #, 81 78 76 bytes

No puede competir con los otros idiomas, pero aquí está de todos modos:

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

Se puede matar con SIGINT presionando Ctrl+ C.

Sin bonificación, porque tomaría más de 10 bytes para obtenerlo.

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

La impresión requiere System, pero el ypersonaje está prohibido. Por lo tanto, tuve que usar la reflexión.

Perl: 18 bytes - 10 = 8

La cadena es de STDIN.

$_=<>;{print;redo}

Ruby, 30 23 18 bytes

loop{puts ?x.succ}

Se puede matar con SIGINT presionando Ctrl+ C.

¡Gracias a manatwork por compartir mejoras!

Perl, 26 bytes

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

Entrada personalizada del argumento (como si yesrealmente funcionara), 22 bytes-10 = 12

{print @ARGV,$/;redo}

Entrada personalizada desde 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]);}

No estoy muy contento con esto, ya que requiere que el programa se llame "y" y se llame solo con `y`, por lo que debe estar en $ PATH, pero bueno, primero codegolf :)

Alternativa:

C, 30 (+ 1 nombre de archivo)

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

Usando la misma técnica que mi estimado colega @Matt Windsor

• EDITAR: resulta que evitar el carácter no \ n lo hizo más corto
• EDIT2: "int" es más corto que "char"
• EDITAR3: no necesitaba esa variable en absoluto
• EDITAR4: un poco de comportamiento ligeramente indefinido nunca hace daño a nadie
• EDITAR5: agregar una versión alternativa

Linux Bash, 33-10 = 23

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

Se puede matar con SIGINT presionando Ctrl+ C.

Óxido, 52 caracteres

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

Al parecer, no hay una buena manera de computar ysin ser descarado en Rust: han hecho un trabajo demasiado bueno haciendo caracteres de manera segura. YO:

• No se puede proporcionar una cadena no literal println!, por lo que no se permiten trucos allí;
• No se puede agregar 1 a 'x', porque en Rust los caracteres no son números;
• No se puede ROT13 (¿por qué Rust no tiene ROT13 en su biblioteca estándar?);
• No es fácil hacer nada inseguro como pasar a cadenas C, convertir números a caracteres, etc. sin ser increíblemente detallado y pasar de 52c.

Tampoco vale la pena el bono de código, porque leer stdinrequiere un manejo de errores = 3

Gran parte de las reducciones de código que pude encontrar involucraron hacer cosas que infringen cada vez más las reglas con el entorno del compilador:

Rust, 44 caracteres (+ al menos 1 carácter para nombre de archivo)

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

Obsoleado por abajo. Este probablemente no cuenta, ya que el nombre del archivo fuente debe comenzar y.

Editar: Rust, 36 caracteres (35 fuente, 1 nombre de archivo)

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

Como el anterior, pero el archivo tiene que ser llamado y(no y.rs, y). ¡Humorísticamente, Rust sobrescribirá la fuente con el binario! Al menos en mi máquina, el binario funciona después de eso.

Rust, 37 caracteres (+ equivalente de env K='y'en su plataforma)

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

Éste es aún peor: es necesario establecer la variable de entorno Ka yen tiempo de compilación .

Editar : si se establece Kque y\n, usted podría caer el lnen println!, para un gran total de 35 caracteres y varios facepalms:

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

Linux Bash - 19 bytes

Probablemente esto sea trampa y esté sujeto a fallas si no tiene / usr / bin / yes o tiene / usr / bin / xes o / usr / bin / zes:

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

Creo que cumple con los requisitos, aunque tal vez está violando la regla "nada que se evalúe como y". Y tal vez imitar yesal correr realmente va en yescontra de las reglas.

Esto podría optimizarse un poco (aunque es menos probable que funcione) para reducirlo a 11 bytes:

/*/*/?es $*

No pude descubrir cómo obtener la bonificación de 10 puntos leyendo una cadena de stdin sin agregar más de 10 bytes al código

dc, 12

[30986Pdx]dx

Solo salidas y\n. No lee de stdin, así que no hay bonificación.

30986 es 0x790A (es decir, "y \ n"). El Pcomando simplemente convierte el número a base 256 e imprime el carácter correspondiente para cada base 256 dígitos.

Lisp común: (30-10) = 20

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

• (read) de flujo de entrada
• imprimir a flujo de salida: (format t ... )
• iterar sobre todos los formatargumentos (solo uno aquí):~@{ ... ~}

• dentro del bucle, para cada argumento:

  • argumento de impresión ~Aseguido de una nueva línea~%
  • rebobinar el elemento actual al anterior ~:*(bucle infinito)

Puede romper el ciclo con Ctrl+C, lo que indica un error con las opciones de reinicio (continuar / cancelar).

Haskell, 29 bytes

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

Creo que esto es detenido por ambos SIGINTy SIGPIPE.

Rubí, 27 bytes - 10 = 17

Es solo la solución de @ ProgramFOX con el bono (tomó mis 9 bytes para resolver la pregunta del bono).

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

cc, 21 bytes - 10 = 11

C1st?st[ltP[]ps0dx]dx

Tenga en cuenta que la entrada debe incluirse [], por ejemplo [no], porque ?es la única forma de tomar la entrada, que la ejecuta como dccódigo.

Commodore 64 Basic: 14 13 bytes

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

Como de costumbre, he realizado sustituciones de caracteres en PETSCII que no están presentes en Unicode. |se usa para representar SHIFT+H, mientras que ╭representa SHIFT+U. Tenga en cuenta que esto genera ASCII 'y' (valor de byte 121) en lugar de un carácter que el conjunto de caracteres Commodore predeterminado muestra como 'y'.

BASIC es supuestamente un lenguaje de programación fácil de aprender, similar al inglés. Agregue los atajos de mecanografía presentes en muchos dialectos tempranos, y obtendrá algo que es más corto y menos legible que Perl.

EDITAR : En el "modo desplazado", esto se acorta dos bytes, gracias a que "y" se codifica en minúscula con el valor decimal 89. El uso de un conjunto de caracteres no ASCII para sortear la regla "no está permitido usar sus valores ASCII" podría ser trampa, sin embargo.

1?cH(89):rU

AWK, 38 bytes

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

Variante que leerá la cadena en stdin: 14 bytes-10 = 4

{for(;;)print}

Pero como no puede hacer las dos cosas (volver a "y" si no se proporciona ninguna entrada estándar), no estoy seguro de que cuente ...: o)

Ambos pueden salir con Ctrl + C.

Fisión , 5 bytes

Rx+!N

Esto es bastante competitivo para Fission. :)

El flujo de control comienza con un (1,0)átomo a la derecha en R. xestablece la masa en 120, y la +incrementa para dar (121,0). Luego !imprime el carácter correspondiente ( y) e Nimprime una nueva línea. El código fuente se envuelve en los bordes, por lo que el átomo pasa de Rnuevo (que ahora no hace nada), xestablece la masa 120nuevamente, la +incrementa y así sucesivamente ...

C, 32 bytes

Requiere una pequeña máquina endian y compilación con -O2 (para evitar el desbordamiento de la pila).

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

PowerShell, 27-10 = 17

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

Podría no funcionar en Pash. Una alternativa más robusta debería 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 fueron probados con Lua 5.1.4 y pueden ser eliminados con SIGINT ( Ctrl+ C).

Perl, 31

Aquí hay una versión de Perl que realmente se comporta como GNU yes, por lo que puedo decir:

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

Esto funciona si está bien usar los interruptores de línea de comando de perl ( -lpara la nueva línea), de lo contrario, se volverían 3 caracteres más largos:

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

CAPL 1.5+; 6 sin entrada; 10-10 = 0 con entrada

Además
, he leído en alguna parte [¿enlace?] Que los idiomas personalizados no están permitidos en las preguntas de golf, ya que podrían hacer funciones integradas que hagan exactamente lo que la pregunta pregunta, sin embargo hice CAPL para facilitar el golf en general . Si crees que esto no está permitido aquí, ¡házmelo saber!

Tengo algunas ideas de > <> y Befunge (puedes moverte entre líneas y usar caracteres hexadecimales para empujar números), algunas de Ruby y otras mías para facilitar el golf.
CAPL lee de izquierda a derecha y va una línea hacia abajo al final de la línea. Si es como la última línea, el programa se cerrará.

Como nadie conoce este idioma todavía, intentaré explicar lo más posible.

Salida y. 6 bytes

bb*.n<

bb* bes hexadecimal para 11, entonces bb*es 11*11= 121, que es el equivalente UTF-8 de y. Este valor se empuja a la pila.
.Muestra el valor superior de la pila y se muestra como UTF-8. Como 121está encima de la pila, el índice se ignora aquí.
nEmite una nueva línea
<Envía el puntero al principio de la línea, repitiendo así esa línea. Como no esperamos entradas, podemos hacerlo de forma segura sin volver a pedir la entrada.

Salida de entrada. 10 bytes, 0 después de la bonificación

i~a&{X:.)}

iToma información del usuario, empuja como UTF-8 en la parte superior de la pila y empuja la longitud después de eso. Es decir, [72,101,108,108,111,5]
~saca un número de la pila y luego invierte esa cantidad de bytes. Es decir, [111,108,108,101,72]
ahexadecimal para 10, el personaje de nueva línea
&{...}hace un bucle infinito. Tenemos entrada, por lo que no podemos enviar el puntero a la línea. Podría colocar la función en la línea de abajo, lo que me ahorraría un byte, pero no se permiten nuevas líneas en este desafío.
XElimina el valor superior de la pila (El índice del bucle)
:.Duplica el valor superior, luego sale como UTF-8
)Gira la pila a la derecha. ( [1,2,3,4,5]-> [5,1,2,3,4])

Sin embargo, esto significa que comenzamos con una nueva línea, luego comenzamos a generar la entrada, luego una nueva línea, luego la entrada, etc. Si no se nos permite comenzar con una nueva línea, use el siguiente código con 12 bytes, o 2 después de restar El bono.

iXa#~&{X:.)}

El único comando nuevo aquí es #, que empuja la cantidad de elementos en la pila a la pila.
Eliminé la longitud de i, porque agregar 1, luego intercambiar con la nueva línea es más largo que eliminar y obtener la longitud nuevamente.

Solo por diversión, aquí hay un programa "Hello World"

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

La ?!operación es la misma que la de> <>

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

Advertencia: se basa en una característica / error no documentado y no compatible.

⎕←⍣≢⍞

STDIN vacío imprime líneas vacías (no "y"), lo cual está permitido y se ha sugerido .

Pruébalo en línea!

⎕ STDOUT con nuevas líneas al final,

← consigue

⍣ repetidamente hasta

≢ difiere de

⍞ STDIN

es decir, nunca, pero ininterrumpible al pausar el hilo.

> <>, 6 bytes

b:*oao

Al no incluir un ;al final, el > <> seguirá nadando hasta que sea liberado por un SIGINT.

Explicación

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

La anterior es una solución bastante aburrida, así que aquí hay una que toma la entrada de stdin. Esto abusa del hecho de que la forma predeterminada de proporcionar entrada a un programa > <> es echo 'input' | fish.py yes.fish, donde echoproporciona el \ncarácter.

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

Explicación

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

Al 0rfinal, permite que el bucle suceda envolviéndose, donde todavía asumimos que la pila se invierte con una -1en la parte superior.

Aparentemente esto no es totalmente portátil. Lo sys.version es 2.7.9 (default, Dec 11 2014, 04:42:00) \n[GCC 4.9.2], así que si el tuyo es diferente, esto podría no funcionar, supongo.

Python 2 - (76-10) = 66

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

Bastante largo, pero quería obtener el bono (a pesar de que costaba más de 10 bytes). Comprobar si stdin está vacío o no sin solicitar entrada es aparentemente largo.

Al principio, leí mal la bonificación como una discusión en lugar de stdin. Estoy orgulloso de mi solución para eso, así que lo publico de todos modos;)

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

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

sys.argves una lista donde el elemento cero es el nombre del archivo y cada elemento posterior es un argumento dado al programa. Agrego un valor falsey al final de la lista; Si no hay argumentos, el primer elemento es ese valor falso, de lo contrario es el primer argumento. a or ben Python devuelve el primer valor que confirma cuál será el resultado: si aes verdad, ya sabemos que todo será cierto, por lo que simplemente se devuelve. Si es falso, bse devuelve (ya que False or b== b).