sí, tiene 91 líneas de largo

50

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).
Ramon Snir
fuente
13
" no puede usar" y "o" \ n " ". ¿Debería leer esto como "No puede usar yo \ndentro de una cadena literal"?
apsillers
12
En una nota relacionada, GNU true.ctiene 80 líneas de largo.
Dennis Williamson
66
@DennisWilliamson En una nota similar, false.c tiene 2 líneas de largo ....; _;
LordAro
66
coreutils yestoma un argumento opcional en la línea de comando, no stdin.
Brian Minton
77
@MrLore: para conectarse a otros programas que pueden pedir constantemente confirmación de las diversas cosas que están haciendo, para que no tenga que sentarse allí escribiendo los ymensajes usted mismo.
marcus erronius

Respuestas:

37

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.

Martin Ender
fuente
16
Me gusta que su programa coincida /no/i, teniendo en cuenta cuál es el desafío.
Kevin - Restablece a Mónica el
20

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

++++++++++[>,]<<[[<]>>[[.>]<[<]>]]>[>++++++++++++>+<<-]>+[.>.<]
metro subterráneo
fuente
@fry No pude ponerlo por debajo de 39 de esa manera. Necesito 10 de todos modos, así que estoy sumando 1 a 120 o restando 1 de 11, y es más corto hacer el primero.
undergroundmonorail
Sí, me di cuenta después de que reutilizaste el 10, lo siento: P
FryAmTheEggman
En lugar de 10 * 12 + 1, ¿por qué no 11 * 11? Creo que eso podría ahorrarte un char.
ProgramFOX
@pro No pude ponerlo por debajo de 39 de esa manera. Necesito 10 de todos modos, así que estoy sumando 1 a 120 o restando 1 de 11, y es más corto hacer el primero.
undergroundmonorail
@undergroundmonorail Ah, ya veo.
ProgramFOX
18

Python 3, 27 bytes

Funciona con al menos CPython y Jython.

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

SIGINT lo detiene.

pgy
fuente
18
Hazlo python2 y puedes acortarlo while 1:print`help`[1].
undergroundmonorail
44
Jaja bueno. Olvidé por completo que "solía" haber un operador de
backtick
También podría usar chr(11**2)para guardar algunos caracteres
user1354557
2
@RamchandraApte No tienes permiso para usar 121.
Jonathon Reinhart
17

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.

overactor
fuente
17

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'
swstephe
fuente
La variable "z" se inicializa desde stdin, luego el valor simplemente se usa después de eso. Encontró una forma corta de obtener el valor ASCII sin escribirlo explícitamente.
swstephe
Cambió de "^ 11 2" a "^ hT2" para guardar un carácter.
swstephe
Hola swstephe, ¡estoy emocionado de ver a otro usuario del idioma! Un par de campos de golf: #tiene una funcionalidad equivalente W1y ePGes una forma mucho más corta de obtener el personaje yque C^hT2.
isaacg
Gracias, aplicaré esos cambios. Todavía nuevo en esta cosa del golf. Me gusta Pyth, pero desearía tener algunas funciones contextuales más y manipulación de bits.
swstephe
13

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.

ProgramFOX
fuente
¿No puedes usar while(1)? Guarda dos personajes.
Cepillo de dientes
@toothbrush He intentado eso, pero eso no funciona en C #.
ProgramFOX
1
for(;;) Debería funcionar.
core1024
2
Por alguna razón, este código todavía tiene una y. Por favor examine System.
TheNumberOne
44
@TheBestOne Eso Systemno se puede eliminar. es el espacio de nombres superior en .NET Framework, todas las clases / otros espacios de nombres están en él, por lo que la reflexión no ayudará aquí. Pero no estoy seguro si es inválido. Vea el comentario de Ramon: "nada que se evalúe como y o \ n". Esto no evalúa a y. Dejo un comentario sobre la pregunta para preguntarle a Ramón si esto es válido.
ProgramFOX
10

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.

Ypnypn
fuente
FileDescriptor.out es lo que quise decir.
TheNumberOne
Puede guardar un ;poniendo char c='x'+1;en la fordeclaración de bucle, de modo que for(char c='x'+1;;)ya que tiene un punto y coma vacío de todos modos
corsiKa
@corsiKa Buen punto.
Ypnypn
10

Perl: 18 bytes - 10 = 8

La cadena es de STDIN.

$_=<>;{print;redo}
core1024
fuente
3
¿Se imprime y\nrepetidamente si no recibe información de STDIN? Si no, entonces no imita adecuadamente yes.
vurp0
@ vurp0 yesno recibe información STDINdespués de todo :)
core1024
1
No lo hace, pero la pregunta del código de golf aquí especificó que si no recibe información, debería imprimir repetidamente y\n.
vurp0
2
@ vurp0 ¿Dónde? Cualquier programa que lea de una secuencia se bloqueará sin entrada.
core1024
@ vurp0 Vea el comentario del OP sobre la pregunta.
nyuszika7h
9

Ruby, 30 23 18 bytes

loop{puts ?x.succ}

Se puede matar con SIGINT presionando Ctrl+ C.

¡Gracias a manatwork por compartir mejoras!

ProgramFOX
fuente
1
loop{puts [*?x..?z][1]}- 23 caracteres, loop{puts ?x.succ}- 18 caracteres
manatwork
@manatwork Gracias! Actualizado.
ProgramFOX
8

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}
Nitz
fuente
El programa de @mar Nitz tiene solo 14 bytes de largo y hay un comentario muy votado en su enlace que dice que los nombres de archivos pueden ser importantes si los incluye en el bytecount. Esto me parece legítimo.
metro subterráneo
oh, espera, no vi la parte "no puedes usar \" y \ "" de la pregunta. no importa esto es malo
undergroundmonorail
Estás en lo correcto. Solucionado
Nitz
6

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
LordAro
fuente
5

Linux Bash, 33-10 = 23

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

Se puede matar con SIGINT presionando Ctrl+ C.

Orace
fuente
Debe leer solo una línea e imprimir la misma línea repetidamente. Sus programas no son yessino catprogramas.
jimmy23013
Lo malo, no debería haberlo intentado después de un día de trabajo.
Orace
¿Qué talread a;for((;;));{ echo $a;}
Core1024
5

Ó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"))}}
Matt Windsor
fuente
Nuestra política habitual para requerir ciertos nombres de archivo o indicadores de compilación es simplemente incluirlos en el recuento de bytes.
Martin Ender
@ MartinBüttner lo suficientemente justo. Por extraño que parezca, el óxido no es el mejor lenguaje para el golf de código>: P
Matt Windsor
Puede agregar uno de xuna manera, pero aún no es corto:(b'x' + 1) as char
Shepmaster
5

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

Johnny
fuente
2
/*/*/?es `line` , o /*/*/?es `head -n1` si no tienes /usr/bin/line.
jimmy23013
2
O sed qpara line.
jimmy23013
5

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.

Trauma digital
fuente
Eso es bastante inteligente, ¿cómo se evalúa 30986 y\n?
nyuszika7h
Lo sabía Ppero no sabía que puede hacer más de un personaje a la vez.
nyuszika7h
5

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).

volcado de memoria
fuente
3

Haskell, 29 bytes

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

Creo que esto es detenido por ambos SIGINTy SIGPIPE.

Taneb
fuente
sugerencia: usar en '\89'lugar desucc 'x'
orgullosa haskeller
3

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}
alexanderbird
fuente
3

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.

nyuszika7h
fuente
Puedes usar en C2lugar de 122. De hecho, yo diría que 122 1-podrían ser reemplazados con C1lo C1que no está prohibido explícitamente en la pregunta
Trauma digital
3

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
marca
fuente
Con todo el 💩 que existe en Unicode, parece sorprendente que el conjunto de caracteres completo utilizado por el C64 no esté allí en alguna parte.
kasperd
@kasperd, los caracteres de dibujo de caja de Unicode provienen principalmente del conjunto "DOS" de IBM y pasan por el centro de la celda de caracteres. PETSCII tiene un conjunto mucho más grande, gran parte del cual usa los bordes de la celda de caracteres. U + 2502 es probablemente una aproximación decente de la barra vertical producida por SHIFT+H, pero el carácter de la tubería es más fácil de escribir. No hay nada que corresponda a las "líneas en los bordes superior e izquierdo" producidas por `SHIFT + O".
Mark
Muy bien, pero podría guardar un byte reemplazando "Goto 1" por "Run": "1? CH (89): rU"
LeFauve
@LeFauve, gracias. También lo he aplicado a la versión que emite ASCII.
Mark
3

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.

LeFauve
fuente
3

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

Martin Ender
fuente
3

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));}
nutki
fuente
2

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}
Joey
fuente
2

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).

Digpoe
fuente
¡Increíble! Mi madre escribe en Lua, nunca antes lo había visto en la naturaleza. ( ¡Hola mamá! ¡Adivina lo que vi! )
Signal15
2

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}
xebtl
fuente
error tipográfico: -l(no -e) es el interruptor para la nueva línea.
Chris-l
Además, la bonificación es solo si su script puede leer desde el stdin . Sí, sé que el verdadero no se lee en el stdin, sino en un argumento, pero esa es la regla del OP; tiene que ser de stdin para tener la bonificación.
Chris-l
@ Chris-l arregló el tipo, gracias. También eliminé el reclamo con respecto a la bonificación, pero dejaré mi respuesta tal como está
:-P
jeje seguro, mi propia respuesta es como la tuya; utiliza un argumento en lugar de stdin. En mi humilde opinión, la operación debería dar la bonificación a los que realmente hacen lo que hace el verdadero .
Chris-l
2

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

Charlie
fuente
En realidad, la restricción se aplica a idiomas / bibliotecas / características personalizadas publicadas después de que se publicó la pregunta.
manatwork
@manatwork Eso significaría que mi respuesta no es válida. Gracias por la aclaración. Hice este lenguaje, y quería hacer algunos desafíos de golf para probar lo que podría mejorar para futuras versiones, si eso mejora algo.
Charlie
En mi opinión, esto no es inválido, simplemente no es elegible para ganar. El objetivo de la restricción era evitar el engaño, pero como incluyó la declaración sobre la frescura del lenguaje, esto difícilmente podría considerarse un intento de engaño.
manatwork
2

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.

Adán
fuente
Hmm abusando de los errores ... interesante.
Matthew Roh
@MatthewRoh Usando, no abusando. La "característica" está utilizando el operador en la asignación , aunque no es una función real propiamente dicha y, por lo tanto, no es realmente elegible para ser un operando. Todavía funciona a través de ...
Adám
2

> <>, 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.

PidgeyUsedGust
fuente
1

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).

metro subterráneo
fuente
@fry podría, pero le avisaría al usuario. Quería que comenzara a escupir de y\ninmediato si el stdin estaba vacío.
undergroundmonorail
@fry Eso es raro, funciona para mí. ¿Podría depender de cPython? No tengo otras ideas.
undergroundmonorail
buena idea, en él
undergroundmonorail
r=raw_input();p=r if r else`help`[1]\nwhile 1:print p 52 personajes
globby
1
Hmm, ya parece que la primera línea tiene una y, la segunda también.
Paŭlo Ebermann