O Vim é um ótimo editor de texto para sistemas unix, mas é notório por ser difícil sair.

Escreva um programa completo que será exibido :qpara sair do Vim. Ele deve ler uma única linha de entrada, pois receberá um prompt do bash; nesse caso, a saída foi bem-sucedida ou um erro; nesse caso, há alterações não salvas.

O prompt do bash será este:

E37@vimmachine: /var/override)

Enquanto o erro será este:

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

Ao receber o prompt do bash, o trabalho do programa é concluído e não deve fornecer mais saída (exceto espaços em branco).

Após receber o erro, seu programa deve aleatoriamente (ou seja, cada possibilidade tem uma probabilidade diferente de zero de ser escolhido) sair :q!, para sair sem salvar, ou :xpara salvar e sair.

Isso é código-golfe, e o menor número de bytes em cada idioma vence!

Python 2 , 66 bytes

Economizou 3 bytes graças a @ Mr.Xcoder e 4 graças a @Mayube!

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

Experimente online!

Ruby , 35 bytes

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

Experimente online!

05AB1E , 19 bytes

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

Experimente online!

„: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 resposta está fora do campo de golfe .

-1 byte graças a Rod. -3 bytes graças ao Mayube. -3 bytes graças a Artyer.

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

Experimente online!

Vimscript, 45 41 bytes

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

Raspou 4 bytes usando getpid()para obter um número. (Alguém pode pensar em uma maneira mais curta de obter um número que não será o mesmo em todos os lugares, o tempo todo?)

Supondo +3 bytes para chamar o Vim -cpara executar o script acima e -ler a entrada de stdin:

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

JavaScript, 52 46 bytes

Guardado 6 bytes graças 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!");}}

Experimente online!

• 1 byte salvo graças ao LiefdeWen!
• 1 byte economizado graças a Mord Zuber!

> <> , 32 30 29 bytes

• Teve um redundante !o.
• -1 byte graças a Aaron.

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

Experimente online!

Explicação (antiga)

"@!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.

(será atualizado em breve)

Na verdade , 27 bytes

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

Experimente online! (Nota: Como o TIO não funciona bem com o stdin, substituí o ,(read from stdin) pela string literal, que você pode alterar para testá-lo. Além disso, será necessário desativar o cache de saída para obter uma resposta diferente com a saída aleatória.)

Explicação:

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

Experimente online!

':q' imprima isto

⋄ então

?2 número inteiro aleatório entre os dois primeiros

⊃⍨ use isso para selecionar

':q!' ':x' esta lista de duas cordas

(… )/ Replique isso com, ou seja, faça n cópias de cada elemento, onde n é

 '!'∊⍞ o ponto de exclamação é um membro da entrada de texto? (Booleano, ou seja, 0 ou 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 sinalizador -n)

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

Não tenho muita certeza do $$%2trecho. Estou usando-o para gerar um bit aleatório para indexar minha matriz, usando o módulo pid 2 do processo ruby ​​atual, e será bastante imprevisível. .sampleadiciona um byte extra.

Experimente online!

JavaScript, 76 71 50 bytes

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

Economizei um monte de bytes graças a Artyer e Neil, além de condensar meus ternários e mover o primeiro alerta para solicitar (duh).

Python 2 , 64 bytes

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

Experimente online!

Uma vez que este é apenas um aglomerado de ambos de essas respostas Python, eu marquei isso como uma comunidade wiki.

Python 2 , 47 bytes

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

Experimente online

Explicação:

A fonte da aleatoriedade é id(0)%3<2. A função idretorna a localização da memória do parâmetro. Passar qualquer coisa fornecerá um endereço de memória não determinístico. O resultado será sempre uniforme, mas às vezes será divisível por 3. Os resultados do módulo 3 variam. Portanto, isso pode ser uma fonte de aleatoriedade. Usar <2significa que aproximadamente 2/3 das vezes, o booleano resultante é True.

O restante da resposta é inspirado por esta .

Barril ,14 12 bytes

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

Isso envia um número aleatório e gera uma correspondência correspondente ao número aleatório.

TCL, 95 bytes

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

Uma solução simples e bastante longa em tcl ...

Chamadas de sistema do Assembly 86Bytes Linux

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

LOGO, 37 36 bytes

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

Experimente online no verificador Anarchy Golf Performance .

Explicação:

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)tem 2 palavras, enquanto E37: No write since last change (add ! to override)tem 10 palavras)

Perl 5 (com sinalizador -E), 35 bytes

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

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

Experimente online!

Ungolfed:

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
}