Ruleta Rusa, Recargada

32

¡Juguemos a la ruleta rusa!

Normalmente, esta sería una carrera para escribir el programa MOD 6 más corto, pero eso no es muy realista, ya que la probabilidad de ganar disminuye con cada clic. Estas son las reglas:

  1. Emule a un verdadero tirador de seis :
    • Se coloca una sola bala en una de las seis cámaras y se hace girar el cañón una vez, solo antes de jugar.
    • La posibilidad de perder en el n º intento es 1/6.
    • La posibilidad de perder después de n intentos es 1 / (6-n)
    • Le garantizamos que perderá, como máximo, 6 intentos.
  2. Perdiendo:
    • Mostrar el texto *BANG!*
    • Terminar el programa.
  3. Victorioso:
    • "Ganar" significa que el arma no dispara, pero la bala está una cámara más cerca del martillo.
    • Mostrar el texto *click*
    • Presente un "disparador" al usuario, junto con la capacidad de terminar el programa (por ejemplo, "ctrl + c", ver más abajo).
  4. Programa específico:
    • Apretar el gatillo es una forma de entrada del usuario, incluido el primer intento. (Esto puede ser una pulsación de tecla, un clic del mouse, lo que sea; no se requieren mensajes de texto).
    • Solo se permite una instancia del programa hasta que finalice. (Ejecutar una nueva instancia del programa es similar a darle un buen giro al barril, es decir, la probabilidad de perder en el siguiente clic se restablece a 1/6).

¡El código más corto gana!

Tabla de clasificación

Mostrar fragmento de código

code-golf  game  random 
— ayane
fuente
3
Sus suposiciones están equivocadas: la posibilidad de perder en el enésimo intento es solo ⅙ si respira las balas después de cada disparo. Sin repetir, la posibilidad de perder es ⅙ en el primer tiro, ⅕ en el segundo, ¼ en el tercero ... terminando en 1 en el 6to. Reconoce esto con "Se garantiza que perderá, como máximo, 6 intentos".
— rhialto
2
@ user2956063 se está olvidando de que existe una posibilidad (n-1) / 6 de que nunca llegue al n: ésimo intento y, por lo tanto, no puede perder. Se equilibran a un uniforme 1/6.
— Jacob Raihle
2
tal vez esa es una diferencia en la forma en que los informáticos y los estadísticos expresan la probabilidad, entonces, para mí "La posibilidad de perder en el enésimo intento es ⅙" dice que es constante, ya sea que n sea 1 o 100.
— rhialto
3
¿Por qué no se tituló "Ruleta Rusa, Recargada"?
— Hand-E-Food
1
@ user2956063: sus probabilidades son condicionales . P (perder en el tiro 2) = ⅙, pero P (perder en el tiro 2 | no perdió en el tiro 1) = ⅕. Además, nestá (implícitamente, lo concederé) limitado a [1,6], por lo que 100 está fuera.
— Tim Pederick

Respuestas:

3

Pyth, 23 bytes

VO6"*click*" w;"*BANG!*

Muy simple Un número aleatorio de iteraciones 0 - 5 muestra el clic y solicita una línea de entrada, seguida de una explosión al final.

— isaacg
fuente
1
maldita sea, pyth!
— Cyoce
+3 bytes: la última cadena debería ser *BANG!*, noBANG
— ayane
14

Ruby, 51 bytes

[*['*click*']*rand(6),'*BANG!*'].map{|x|gets;$><<x}

Sin golf:

[
  *(                        # Unwrap the following array into the outer one
    ['*click*'] * rand(6)   # An array of 0-5 clicks, see Array#*
  ),
  '*BANG!*'                 # The End
].map do |x| # Shortest way to iterate I was able to find
  gets       # Await input
  $> << x    # Shove the output string to `stdout`
end          # Return value is an array of several (0-5) `stdout`s. Who cares.

o

(['*click*']*rand(6)<<'*BANG!*').map{|x|gets;$><<x}

Ungolfing se fue para los lectores. No es tan dificil

  • Nuevamente, felicitaciones a Martin, esta vez por un truco $><<como putsreemplazo.
  • No genera nuevas líneas, pero eso no era obligatorio.
  • Cuanto más corto, más simple. La esencia del comportamiento requerido es hacer 0-5 clics y luego disparar. Para eso, las salidas se acumulan dentro de la matriz.
  • Se pueden eliminar 2 bytes más si las salidas como "*click*"están bien (lo que se requiere se imprime al final), reemplazándolo $><<por p . No estaba seguro de si esto seguiría las reglas.

68 64 bytes

(otro enfoque)

[*0..5].shuffle.find{|x|gets;x<1||puts('*click*')};puts'*BANG!*'

No pensé mucho en el algoritmo (posiblemente puede ser aún más compacto, pero no tan claro), pero realmente me gusta el modelo que contiene:

  • Una matriz emula un barril con sus elementos como contenido de las cámaras. Como solo un elemento es una bala, rotarlo y barajarlo son equivalentes.
  • 0Es una bala. Otros números no lo son.
  • findencuentra un primer valor de retorno para el cual el bloque no es falseni nil.
  • ||-expresión se devuelve implícitamente desde el bloque. Es un cortocircuito: devuelve su primer operando (a menos que sea nilo false) o un segundo (de lo contrario). Por lo tanto, devuelve true(si x<1o, más claro pero más largo x == 0) o el valor de retorno de puts, mientras ...
  • putssiempre vuelve nil. Sí.
  • getssolicita entrada. Simplemente golpearEnter suficiente.
  • Ctrl+ Ctermina el programa
— Lado D
fuente
Tachado 64 es normal 64?
— Cyoce
@Cyoce uhm ... sí. Debería ser, probablemente. Ha sido reemplazado por la entrada anterior, pero se basa en una idea diferente, así que los dejé tachados.
— Lado D
fue un juego de palabras con esto
— Cyoce
@Cyoce oh, perdón, primera publicación y todo eso, no estoy al tanto de la tradición local :)
— D-side
9

JavaScript, 64 bytes

for(i=6;i<7&&prompt();)alert(new Date%i--?"*click*":i="*BANG!*")

Explicación

Para apretar el gatillo, ingrese cualquier texto en la solicitud. No ingrese nada o haga clic en cancelar para finalizar.

for(
  i=6;             // i = number of chambers
  i<7              // i equals "*BANG!*" (not less than 7) if we lost
    &&prompt();    // see if we should do another shot
)
  alert(           // alert the result
    new Date%i--   // use the current time in milliseconds as a random number, this is safe
                   //     to use because the gap between shots is greater than i (max 6ms)
      ?"*click*"   // on win pass "*click*" to alert
      :i="*BANG!*" // on lose alert "*BANG!*" and set i to not less than 7
  )
— usuario81655
fuente
"*Bang!*"no es mayor que 7. Pero NaNno es menor que 7.
— Bergi
@Bergi That's true. I reworded the explanation to make it a bit clearer.
— user81655
6
@Bergi only in Javascript does that statement come even close to making sense.
— MikeTheLiar
7

Lua, 82 75 bytes

Pretty long, but there's lot of verbose in lua.

for a=math.random(6),1,-1 do io.read()print(a>1 and"*click*"or"*BANG!*")end
— Katenkyo
fuente
6

LabVIEW, 46 LabVIEW Primitives

Creates an Array of 0s and one 1, has a loop to wait for clicks and outputs the string. It initially says BANG becuase i forgot to reset the indicator before starting it.

Also note that this is a gif, if if does not play/load for you please reopen the page.

— Eumel
fuente
I don't see where you do the output of "*click*" in case the gun didn't shoot. Also, does it output "bang" or "*BANG!*"?
— Katenkyo
this should be a gif but for me it doesnt play, that might be the problem. And yes it only puts bang, that was me not reading properly i change that in a sec
— Eumel
stupid me forgot to reinitialize the string to empty before starting so thats why it showes BANG at the start...
— Eumel
No problem, I saw the gif now, looks like it works pretty well :)
— Katenkyo
5

Pyth, 31 30 28 bytes

FN.S6 EI!N"*BANG!*"B"*click*

Almost certainly can be improved. Input any number to pull the trigger, blank input to terminate early (with an error).

Explanation:

FN                               for N in...
  .S6                            shuffle(range(6))...
      E                          get a line of input
       I!N                       if N is falsy (i.e. 0)
          "*BANG!*"              implicit output
                   B             break
                    "*click*     else, print click
— Doorknob
fuente
Your first one is actually shorter, you don't need the trailing".
— FryAmTheEggman
@FryAmTheEggman Oh, right, forgot about that. Thanks!
— Doorknob
Also, I've just noticed something silly, FN<any> is still entirely identical to V<any>, that should probably be changed to not confuse new golfers... :P
— FryAmTheEggman
1
You can simply remove the chars .?. There is no need for an else.
— Jakube
@FryAmTheEggman confusing people is awesome. It can be amazing at filtering out the scrubs.
— Cyoce
5

En serio, 27 25 bytes

"*BANG!*"6J"*click*"nW,X.

No hay enlace en línea porque no hay forma de hacer un aviso con entrada entubada. El programa puede ser CTRL-C'D en cualquier momento para salir de pollo terminate.

Explicación:

"*BANG!*"6J"*click*"nW,X.
"*BANG!*"                  push "*BANG!*"
         6J                push a random integer in [0,6) (n)
           "*click*"n      push "*click*" n times
                     W     while loop (implicitly closed at EOF):
                      ,X.    get input and discard, pop and print top of stack
— Mego
fuente
4

PHP, 52 bytes

*<?=$n=&rand(0,6-$argi)?click:"BANG!*";$n||@\n?>*

Requiere la -Fopción de línea de comando, contada como tres. El gatillo se aprieta presionandoEnter.

Porque -Fliteralmente ejecuta el script nuevamente para cada entrada (no es broma), diey similares no terminarán realmente, por lo que salimos por un error de tiempo de ejecución suprimido @\n.

Uso de muestra

$ php -F primo-roulette.php

*click*
*click*
*BANG!*
$
— primo
fuente
4

Perl 5, 43 bytes

Corre con perl -p. Variante de viñeta estable, es decir, la posición de la viñeta se decide solo una vez en el comienzo.

$i//=0|rand 6;$_=$i--?'*click*':die'*BANG*'
— Oleg V. Volkov
fuente
¡Agradable! Cambiaría el encabezado a "Perl 5.10+", ya que lo está usando //=. Además, no olvide contar -pen su puntaje .
— ThisSuitIsBlackNot
4

C, 110 74 72 bytes

Gracias a Dennis por deshacerse de las inclusiones y muchos menos bytes.

main(r){for(r=time(0)%6;getchar(),r--;)puts("*click*");puts("*BANG!*");}
main(r)
{
    for(r=time(0)%6;getchar(),r--;)
        puts("*click*");
    puts("*BANG!*");
}
— Rainer P.
fuente
3

Caramelo , 36 bytes

Aproximadamente la mitad del programa es el texto a imprimir :(

:6H_(=b"*click*"(;):=)"*BANG!*\n"(;)

forma larga:

getc
digit6 rand range0  # build a range from 0 .. rand#
while
  popA              # these are the *click* instances  
  stack2
  "*click*"
  while
    printChr
  endwhile
  getc
  popA
endwhile
"*BANG!*\n"         # out of luck
while
  printChr
endwhile
— Dale Johnson
fuente
3

Python 3, 95 bytes

También mi primer intento de golf, también en Python 3. Juro que Bruce y yo no somos la misma persona.

from random import*
for a in range(randint(0,5)):input();print("*click*")
input();print("*bang*")

Sin golf:

from random import*
for a in range(randint(0,5)):
    input()
    print("*click*")
input()
print("*bang*")

Genere un número aleatorio entre 0 y 5 inclusive, imprima clic tantas veces, luego imprima explosión . Presione enter / return para apretar el gatillo.

— Steve Eckert
fuente
Siguiendo el ejemplo de Bruce, puede guardar algunos bytes confrom random import*
— wnnmaw
A menos que haya algo más que me falta, es un byte de ahorro. ¡Pero lo tomaré! ¡Gracias!
— Steve Eckert
Buen intento, utilicé tu solución como inspiración para mi solución de Python 2 ^^
— basile-henry
3

PlatyPar , 26 25 bytes

6#?;wT"*click*"O;"*BANG!*

Explicación:

6#?;                        ## random integer [0,6)
    w           ;           ## while stack.last
     T                      ## stack.last--
      "*click*"O            ## alert "*click*"
                 "*BANG!*   ## alert "*BANG!*"

Pruébalo en línea !

— Cyoce
fuente
2

Emacs Lisp, 94 89 bytes

(set'b(%(random)6))(dotimes(a(+ b 1))(read-string"")(message(if(eq a b)"BANG""*click*")))

Sin golf:

(set 'b (% (random) 6))
(dotimes (a (+ b 1))
  (read-string"")
  (message (if (eq a b) "BANG" "*click*")))
— Lord Yuuma
fuente
2

R, 86 80 77 bytes

Como de costumbre, R tiene características increíbles para codificar el golf, pero nombres muuuuuuuuuuuuuuuuuu como largos.

sapply(sample(0:5),function(n){!n&&{cat('*BANG!*');q()};readline('*click*')})
— durum
fuente
2

Python 2, 108 104 102 100 98 bytes

Mi primer intento de jugar golf:

from random import*
a=[1]+[0]*5
shuffle(a)
for i in a:input();print("*click*","*BANG!*")[i];" "[i]

Tal vez debería agregar que el programa no finaliza correctamente cuando pierde, solo arroja una excepción (que resulta en la finalización):

Traceback (most recent call last):
  File "russian_roulette.py", line 4, in <module>
    for i in a:input();print("*click*","*BANG!*")[i];" "[i]
IndexError: string index out of range
— ბიმო
fuente
¡Bienvenido a Programming Puzzles & Code Golf! Cuando publique una respuesta de código de golf, incluya el nombre del idioma y el recuento de bytes (lo edité para usted aquí). ¡Gracias!
— ProgramFOX
Si muchas gracias! En realidad estaba tratando de resolver ese problema, no pude editarlo correctamente antes que tú.
— ბიმო
Recibo tu byte como 112, ¿qué usaste?
— wnnmaw
Además, puede guardar 2 bytes haciendoa=shuffle([1,0,0,0,0,0])
— wnnmaw
1
Hasta donde yo sé, shuffle cambia la estructura de datos subyacente y no devuelve nada. Lo intenté, gracias de todos modos. El titular (idioma y número de bytes) fue escrito por ProgramFOX. Pero cuando lo uso wcme da 109 cuál demasiado, así que está bien. ¿Cómo cuentas?
— ბიმო
2

Perl 5, 40 bytes

<>,print"*$_*"for(click)x rand 5,'BANG!'

Correr sin opciones de línea de comandos, se aprieta el gatillo presionando Enter.

— primo
fuente
2

Python, 81 bytes

import time
for i in["*click*"]*(int(time.time())%6)+["*BANG!*"]:input();print(i)

inspirado en las soluciones Ruby (51) y Python

— Lars
fuente
1

Lisp común, 109

(do(g(b(nthcdr(random 6)#1='(t()()()()() . #1#))))(g)(read-char)(princ(if(setf g(pop b))"*BANG!*""*click*")))

No es muy competitivo, pero me gustan las listas circulares:

(do (;; auxiliary variable x
     x
     ;; initialize infinite barrel, rotate randomly
     (b (nthcdr (random 6) #1='(t()()()()() . #1#))))

    ;; we end the loop when x is T (a bullet is fired)
    (x)

  ;; press enter to shoot
  (read-char)

  ;; pop from b, which makes b advance down the list. The popped value
  ;; goes into x and is used to select the appropriate string for
  ;; printing.
  (princ
   (if (setf x(pop b))
       "*BANG!*"
       "*click*")))
— volcado de memoria
fuente
1

Perl 5, 43 bytes

42 bytes + -popción de línea de comando. Solo presione enterpara disparar.

$_=0|rand 7-$.<++$i?die"*BANG!*":"*click*"

¡Gracias a Dom Hastings por su ayuda! La respuesta original fue de 67 bytes:

$i++;$a=$i>=int(rand(6));print$_=$a?'*BANG!*':'*click*';last if($a)
— Codefun64
fuente
En realidad, el problema -pera que saldría antes de llamar a la última printdeclaración, sin saber por qué. Lo he intentado Aparte de eso, sugerencias increíbles, ¡gracias! Mi conocimiento continúa creciendo ...
— Codefun64
@DomHastings También, desafortunadamente, por alguna razón, el 0|truco no funcionó como se esperaba, pero eliminé algunos bytes, la declaración impresa y la última declaración como sugirió. ¿Cómo se ve ahora?
— Codefun64
@DomHastings Maldición, eres bueno. Recomiendo poner eso como su propia respuesta, ya que definitivamente escribió un programa más pequeño que yo (¡tiene 40 bytes en comparación con mis 67 originales!)
— Codefun64
Agradezco la explicación! ¡Siempre estoy feliz de aprender más de mi lenguaje de secuencias de comandos favorito! Nunca supe sobre el incremento de prefex, eso es bastante impresionante. Gracias :)
— Codefun64
De nada, ¡me alegro de haber ayudado!
— Dom Hastings
1

MATL , 41 bytes

6Yr`j?t@=?'*BANG!*'DT.}'*click*'DT]}T.]]x

Para apretar el gatillo, ingrese una cadena no vacía (como 'try' ).

Para terminar, ingrese una cadena vacía

Ejemplos

En este caso, el gatillo se apretó una vez y ... mala suerte:

>> matl
 > 6Yr`j?t@=?'*BANG!*'DT.}'*click*'DT]}T.]]x
 > 
> try
*BANG!*

En este caso, el usuario se detuvo (tenga en cuenta la entrada vacía final) después de dos intentos de suerte:

>> matl
 > 6Yr`j?t@=?'*BANG!*'DT.}'*click*'DT]}T.]]x
 > 
> try
*click*
> try
*click*
>

Explicación

6Yr                  % random avlue from 1 to 6    
`                    % do...while  
  j                  % input string
  ?                  % if nonempty
    t                % duplicate the orignal random value
    @                % loop iteration index  
    =                % are the equal?
    ?                % if so             
      '*BANG!*'D     % display string
      T.             % unconditional break                                     
    }                % else
      '*click*'D     % display string
      T              % true value, to go on with do...while loop
    ]                % end if               
  }                  % else                                                    
    T.               % unconditional break
  ]                  % end                                                     
]                    % end                                                     
x                    % delete original random value
— Luis Mendo
fuente
1

Perl 6 ,  58    53 bytes

for ^6 .pick(*) {get;say <*BANG!* *click*>[?$_];!$_&&last} # 58 bytes

$ perl6 -pe '$///=^6 .pick;$_=$/--??"*click*"!!say("BANG!")&&last' # 52+1= 53 bytes

Presione enter para apretar el gatillo, o ctrl + c para soltarlo.

— Brad Gilbert b2gills
fuente
1

Pitón 2, 88 84 bytes

Esta solución está inspirada en las soluciones de Python 3 ya dadas. Elegí python 2 para eliminar el paréntesis de impresión a pesar de que esto cambia el comportamiento de input ().

import time
for i in[0]*int(time.time()%6)+[1]:input();print("*click*","*BANG!*")[i]
  • Estoy usando el módulo del tiempo como una función aleatoria (lo suficientemente bueno para la ruleta rusa)
  • la entrada del jugador debe ser "i" y luego Enter (de lo contrario input () arrojará un error), este truco se basa en el hecho de que la entrada puede ser "lo que sea".
— basile-henry
fuente
1

Rubí, 45 + 1 = 46

No es tan inteligente como el lado D pero es un poco más corto.

Con el indicador de línea de comando p, ejecute

rand(7-$.)<1?(puts'*BANG*';exit):$_='*click*'

El usuario puede apretar el gatillo con retorno y salir con control-c. phace que el programa se ejecute en un bucle, leyendo líneas de STDIN y generando resultados $_. Cada vez que se ejecuta, se incrementa$. . Entonces, en la primera ejecución, elige un entero positivo aleatorio menor que 6, luego 5, luego 4, y así sucesivamente. En el primer 0, salimos manualmente y salimos, hasta entonces salimos implícitamente.

(y ahora me doy cuenta de que ya hay un Perl muy similar. Oh, bueno.)

— histocrat
fuente
1

Perl 5, 69 51 49 bytes

map{<>;print"*click*"}1..rand 6;<>;print"*BANG!*"

Probablemente haya más potencial de golf, lo investigaré.

Cambios:

  • Se guardaron 8 bytes al eliminar $ly algunos puntos y comas, y 10 bytes al cambiar<STDIN> a<>
  • Guardado 2 bytes gracias a Oleg V. Volkov
— ASCIIThenANSI
fuente
1
49:map{<>;print"*click*"}1..rand 6;<>;print"*BANG!*"
— Oleg V. Volkov
@ OlegV.Volkov ¡Gracias! Lo editaré ahora.
— ASCIIThenANSI
0

VBA, 126 bytes

Versión de golf para bytes mínimos

Sub S()
r=Int(5*Rnd())
e:
a=MsgBox("")
If a=1 Then: If i=r Then MsgBox "*BANG!*" Else: MsgBox "*click*": i=i+1: GoTo e
End Sub

Versión divertida que hace que los botones sean más claros para una mayor aceptación del usuario.

Sub RR()
r = Int(5 * Rnd())
e:
a = MsgBox("Are you Feeling Lucky?", 4)
If a=6 Then: If i=r Then MsgBox "*BANG!*", 16 Else: MsgBox "*click*", 48: i=i+1: GoTo e
End Sub

Un poco de diversión con formularios personalizados y podrías hacer un bonito juego elegante en VBA.

— JimmyJazzx
fuente
0

APL, 39/65 bytes

{⍞⊢↑⍵:⍞←'*BANG*'⋄∇1↓⍵⊣⍞←'*click*'}6=6?6

Respuesta bastante directa.

— Oberon
fuente
¿Qué significan los recuentos de dos bytes?
— Mego
0

C, 180 bytes

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
int main(){srand(time(NULL));int r,i=6;while(i!=1){getchar();r=rand()%i;if(r){puts("CLICK");}else{puts("BANG");exit(0);}i--;}}

Mi primer intento en el código de golf, probablemente hay mucho margen de mejora :)

— Ryan Fitzpatrick
fuente
0

Julia, 71 bytes

b=rand(1:6);while b>0 readline();print(b>1?"*click*":"*BANG!*");b-=1end

Presione Enterpara disparar o Ctrl+C para salir. Este último termina con un InterruptException.

Sin golf:

# Set an initial bullet location
b = rand(1:6)

while b > 0
    # Read user input
    readline()

    # Check the location
    if b > 1
        print("*click*")
    else
        print("*BANG!*")
    end

    b -= 1
end
— Alex A.
fuente
0

Lua, 73 bytes

q=io.read q()for i=2,math.random(6)do print"*click*"q()end print"*BANG!*"
— Oleg V. Volkov
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.