Vim es un excelente editor de texto para sistemas Unix, pero es conocido por ser difícil de salir.

Escriba un programa completo que :qsalga para salir de Vim. Luego, debe leer una sola línea de entrada, ya que se le dará un mensaje bash, en cuyo caso la salida fue exitosa o un error, en cuyo caso hay cambios sin guardar.

El indicador de bash será este:

E37@vimmachine: /var/override)

Si bien el error será este:

E37: No write since last change (add ! to override)

Al recibir el indicador bash, el trabajo del programa está terminado y no debería dar más resultados (excepto los espacios en blanco).

Al recibir el error, su programa debe emitir aleatoriamente (es decir, cada posibilidad tiene una probabilidad distinta de cero de ser elegido) :q!, salir sin guardar, o :x, guardar y salir.

Este es el código de golf, por lo que gana menos bytes en cada idioma .

Python 2 , 66 bytes

¡Ahorré 3 bytes gracias a @ Mr.Xcoder y 4 gracias a @Mayube!

from random import*
if'('in input(':q'):print choice([':x',':q!'])

Pruébalo en línea!

Ruby , 35 bytes

p:q
p %i(q! x)[rand 2]if/\(/=~gets

Pruébalo en línea!

05AB1E , 19 bytes

„:q,'Nåi„:x…:q!‚.R,

Pruébalo en línea!

„:q,                # Print the string ":q"
    'Nåi            # If N is in the input
        „:x         #   Push the string ":x"
           …:q!     #   Push the string ":q!"
               ‚    #   Wrap them into an array
                .R, #   Randomly print one of them

Python 2 , 76 75 72 69 bytes

Esta respuesta ha sido superada .

-1 byte gracias a Rod. -3 bytes gracias a Mayube. -3 bytes gracias a Artyer.

from random import*
print'::qx!'[random()>.5:('N'in input(':q'))*5:2]

Pruébalo en línea!

Vimscript, 45 41 bytes

ec"q"|exe"/("|ec["q!","x"][getpid()%2]

Afeitó 4 bytes usando getpid()para obtener un número. (¿Alguien puede pensar en una forma más corta de obtener un número que no sea el mismo en todas partes, todo el tiempo?)

Suponiendo +3 bytes para invocar a Vim con -cpara ejecutar el script anterior y -leer la entrada de stdin:

vim -c 'ec"q"|exe"/("|ec["q!","x"][reltime()[1]%2]' -

JavaScript, 52 46 bytes

Guardado 6 bytes gracias a @ETHProductions

prompt(':q')[30]&&alert(new Date%2?':q!':':x')

C # (.NET Core) , 140 139 138 bytes

using static System.Console;class P{static void Main(){Write(":q");if(ReadLine()[3]==':')Write(new System.Random().Next()>9?":x":":q!");}}

Pruébalo en línea!

• ¡1 byte guardado gracias a LiefdeWen!
• ¡1 byte guardado gracias a Mord Zuber!

> <> , 32 30 29 bytes

• Tenía un redundante !o.
• -1 byte gracias a Aaron.

iii0["@!qx:q:"ooi{=?;o!ox~oo;

Pruébalo en línea!

Explicación (antigua)

"@!qx:q:"ooi~i~i~i{=?;o!ox~oo;
"@!qx:q:"                        Push @!qx:q: on the stack (in reverse)
         oo                      Print :q [stack: @!qx:]
           i~i~i~                Remove first 3 input characters
                 i               Load @ or : from the input (= i)
                  {              Shift stack to the left [stack: !qx:i@]
                   =?            If 4th character was @
                     ;              Exit
                                 Else
                      o             Print :
                       !o           Jump to
                         x          Random direction (left or right because
                                    up and down retrigger x)
                                       Left:
                     ;o!o                 Print x and exit.
                                       Right:
                          ~oo;            Remove x, print q! and exit.

(se actualizará pronto)

En realidad , 27 bytes

":q"ü[":x",":q!"]`⌂`J'!,cIƒ

Pruébalo en línea! (Nota: como TIO no funciona bien con stdin, he reemplazado el ,(leer de stdin) con la cadena literal, que puede cambiar para probarlo. Además, deberá deshabilitar la caché de salida para obtener una respuesta diferente con la salida aleatoria)

Explicación:

":q"ü[":x",":q!"]`⌂`J'!,cIƒ
":q"ü                       - Push the literal :q and print
     [":x",":q!"]           - Push the list of literals :x and :q!
                 `⌂`J       - Push function literals ⌂ (terminate) and J (choose random element from list)
                     '!     - Push the literal !
                       ,    - Read from stdin
                        c   - Pop top two values a,b and return "a".count(b)
                         I  - Pop top three values a,b,c and return b if a is truthy and c if a is falsy
                          ƒ - Pop a function from the stack and call it

APL (Dyalog) , 27 bytes

':q'⋄('!'∊⍞)/':q!' ':x'⊃⍨?2

Pruébalo en línea!

':q' imprime esto

⋄ luego

?2 entero aleatorio entre los dos primeros

⊃⍨ use eso para seleccionar

':q!' ':x' esta lista de dos cadenas

(… )/ Replica eso con, es decir, haz n copias de cada elemento en ese, donde n es

 '!'∊⍞ ¿Es el signo de exclamación un miembro de la entrada de texto? (Booleano, es decir, 0 o 1)

Lote, 98 bytes

@echo :q
@set/ps=
@if %s:~3,1%==@ exit/b
@set/an=%random%%%2
@if %n%==0 (echo :x)else echo :q!

Ruby , 33 bytes (código 32, +1 para el indicador -n)

p:q;$_[?!]? p([:q!,:x][$$%2]): p

No estoy muy seguro sobre el $$%2fragmento. Lo estoy usando para generar un bit aleatorio para indexar mi matriz tomando el módulo pid 2 del proceso de ruby ​​actual, y será bastante impredecible. .sampleagrega un byte extra.

Pruébalo en línea!

JavaScript, 76 71 50 bytes

prompt(":q")[3]<"@"?alert(new Date%2?":q!":":x"):0

Ahorré un montón de bytes gracias a Artyer y Neil, así como condensé mis ternaries y moví la primera alerta a prompt (duh).

Python 2 , 64 bytes

import time
if'w'in input(':q'):print'::qx!'[time.time()%2>1::2]

Pruébalo en línea!

Puesto que esto es sólo una aglomeración de ambas de estas respuestas Python, he marcado esto como wiki de la comunidad.

Python 2 , 47 bytes

print'::qx!'[id(0)%3<2:('N'in input(':q'))*5:2]

Pruébalo en línea

Explicación:

La fuente de aleatoriedad es id(0)%3<2. La función iddevuelve la ubicación de la memoria del parámetro. Pasar cualquier cosa dará una dirección de memoria no determinista. El resultado siempre será uniforme, pero a veces solo será divisible por 3. Los resultados del módulo 3 varían. Entonces, esto puede ser una fuente de aleatoriedad. Usar <2significa que aproximadamente 2/3 de las veces, el booleano resultante es True.

El resto de la respuesta está inspirada en esta .

Barril ,14 12 bytes

\:~2%[q\!|x]

Esto empuja un número aleatorio y sale correspondientemente al número aleatorio.

TCL, 95 bytes

puts :q;puts [if [string match *!* [gets stdin]] {puts [lindex ":q! :x" [expr round(rand())]]}]

Una solución simple y bastante larga en tcl ...

Asamblea 86Bytes Linux System Calls

global _start
_start:
mov edx,4
mov ecx,g 
mov ebx,1
mov eax,4
int 0x80
g db ':q!',10

LOGOTIPO, 37 36 bytes

pr[:q]if 4<count rl[pr pick[:q! :x]]

Pruébelo en línea en el corrector de rendimiento Anarchy Golf .

Explicación:

pr[:q]if 4<count rl[pr pick[:q! :x]]   Main program.
pr                                     Print
  [:q]                                 the list `[:q]` without delimiter `[]`
      if           [              ]    If...
         4<                            4 is less than...
           count                       the number of word in the...
                 rl                    ReadLine (from stdin),
                    pr                 print
                       pick            a random word picked from the list...
                           [:q! :x]    [:q! :x]

(porque E37@vimmachine: /var/override)tiene 2 palabras, mientras que E37: No write since last change (add ! to override)tiene 10 palabras)

Perl 5 (con bandera -E), 35 bytes

say":q";<>=~l&&say qw(:q! :x)[$$%2]

Ejecute esto con perl -E 'say":q";<>=~l&&say qw(:q! :x)[$$%2]'.

Pruébalo en línea!

Sin golf:

say(":q");
if(<> =~ /l/){ #read a line and check if it contains 'l'
    @a=(":q!",":x");
    say($a[$$ % 2]); #print one element from array based on PID
}