Roleta Russa, Recarregada

32

Vamos jogar roleta russa!

Normalmente, seria uma corrida para escrever o programa MOD 6 mais curto, mas isso não é muito realista, pois a chance de ganhar diminui a cada clique. Aqui estão as regras:

  1. Emule um verdadeiro jogo de seis tiros :
    • Uma única bala é colocada em uma das seis câmaras e o cano é girado uma vez, apenas antes de tocar.
    • A chance de perder no n º tentativa é 1/6.
    • A chance de perder após n tentativas é de 1 / (6-n)
    • Você está garantido para perder em, no máximo, 6 tentativas.
  2. Perdendo:
    • Exibir o texto *BANG!*
    • Encerre o programa.
  3. Ganhando:
    • "Vencer" significa que a arma não dispara, mas a bala é uma câmara mais próxima do martelo.
    • Exibir o texto *click*
    • Apresente um "gatilho" ao usuário, juntamente com a capacidade de finalizar o programa (por exemplo, "ctrl + c", veja abaixo).
  4. Programa específico:
    • Puxar o gatilho é uma forma de entrada do usuário, incluindo a primeira tentativa. (Pode ser um pressionamento de tecla, um clique do mouse, o que for; prompts de texto não são necessários.)
    • Somente uma instância do programa é permitida até que seja finalizada. (A execução de uma nova instância do programa é semelhante a dar uma boa rodada no barril, ou seja, a probabilidade de perda no próximo clique é redefinida para 1/6.)

O código mais curto vence!

Entre os melhores

Mostrar snippet de código

code-golf  game  random 
— ayane
fonte
3
Suas suposições estão erradas - a chance de perder na n-ésima tentativa é apenas ⅙ se você acertar as balas após cada tiro. Sem respin, a chance de perder é ⅙ no primeiro tiro, ⅕ no segundo, ¼ no terceiro ... terminando em 1 no 6º. Você reconhece isso com "Você está garantido para perder em, no máximo, 6 tentativas".
— Rhialto
2
@ user2956063 você está esquecendo que há uma chance (n-1) / 6 de nunca atingir a n-ésima tentativa e, portanto, não pode perder. Eles equilibram um uniforme 1/6.
— perfil completo de Jacob Raihle
2
talvez essa seja uma diferença na maneira como os cientistas e os estatísticos computador expressar probabilidade então - para mim "A chance de perder na tentativa enésima é ⅙" dizem é que é constante - se n é 1 ou 100.
— Rhialto
3
Por que isso não foi intitulado "Roleta Russa, Recarregada"?
— Hand-E-Food
11
@ user2956063: Suas probabilidades são condicionais . P (derrota no arremesso 2) = ⅙, mas P (perde no arremesso 2 | não perdeu no arremesso 1) = ⅕. Além disso, né (implicitamente, eu vou lhe conceder) limitado a [1,6], então 100 está fora.
— Tim Pederick

Respostas:

3

Pitão, 23 bytes

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

Realmente simples. Um número aleatório de iterações de 0 a 5 exibe o clique e solicita uma linha de entrada, seguida por uma batida no final.

— isaacg
fonte
11
maldito seja, pitão!
— Cyoce 18/12/2015
+3 bytes: a última string deve ser *BANG!*, nãoBANG
— ayane 18/12/2015
14

Ruby, 51 bytes

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

Ungolfed:

[
  *(                        # 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.

ou

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

A retirada do golfe para os leitores. Não é tão difícil

  • Mais uma vez, parabéns a Martin, desta vez para um truque $><<como putssubstituto.
  • Não gera novas linhas, mas isso não foi necessário.
  • Quanto mais curto, mais simples. A essência do comportamento necessário é fazer 0-5 cliques e depois disparar. Para isso, as saídas são acumuladas dentro da matriz.
  • Mais 2 bytes podem ser eliminados se as saídas "*click*"estiverem corretas (o que é necessário é impresso no final), substituindo $><<por p . Eu não tinha certeza se isso ainda seguiria as regras.

68 64 bytes

(outra abordagem)

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

Não pensei muito no algoritmo (ele pode ser ainda mais compacto, mas não tão claro), mas realmente gosto do modelo:

  • Uma matriz emula um barril com seus elementos sendo o conteúdo das câmaras. Como apenas um elemento é uma bala, girá-lo e embaralhá-lo é equivalente.
  • 0é uma bala. Outros números não são.
  • findlocaliza um primeiro valor de retorno para o qual o bloco não é nem falsenem nil.
  • ||-expression é retornado implicitamente do bloco. É um curto-circuito: retorna seu primeiro operando (a menos que seja nilou false) ou um segundo (caso contrário). Portanto, ele retorna true(se x<1ou, mais claro, mas por mais tempo x == 0) ou o valor de retorno de puts, enquanto ...
  • putssempre retorna nil. Sim.
  • getssolicita entrada. Apenas bater Enteré suficiente.
  • Ctrl+ Cfinaliza o programa
— Lado D
fonte
Riscado 64 é 64 normal?
— Cyoce
@Cyoce uhm ... sim. Deveria ser, provavelmente. Ela foi substituída pela entrada acima, mas é baseada em uma idéia diferente, então eu as deixei riscadas.
— D-side
foi um trocadilho com isso
— Cyoce 19/12/15
@Cyoce oh, perdoe-me, primeiro post e tudo isso, sem conhecer a tradição local :) #
— D-side
9

JavaScript, 64 bytes

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

Explicação

Para puxar o gatilho, digite qualquer texto no prompt. Digite nada ou clique em 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
  )
— user81655
fonte
"*Bang!*"não é maior que 7. Mas NaNnão é menor que 7.
— Bergi
@ Bergi Isso é verdade. Eu reformulei a explicação para torná-la um pouco mais clara.
— user81655
6
@ Bergi apenas em Javascript essa declaração chega perto de fazer sentido.
— MikeTheLiar
7

Lua, 82 75 bytes

Muito longo, mas há muita verbosidade na lua.

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

LabVIEW, 46 Primitivas do LabVIEW

Cria uma matriz de 0s e uma 1, possui um loop para aguardar cliques e gera a string. Inicialmente, diz BANG porque esqueci de redefinir o indicador antes de iniciá-lo.

Observe também que este é um gif, se não for reproduzido / carregado para você, reabra a página.

— Eumel
fonte
Não vejo de onde você sai "*click*", caso a arma não atire. Além disso, ele produz "bang"ou "*BANG!*"?
— precisa
isso deve ser um gif, mas para mim não funciona, esse pode ser o problema. E sim, só coloca bang, que me foi não ler corretamente mudança i que, em um segundo
— Eumel
me estúpido esqueceu de reinicializar a corda para esvaziar antes de começar isso é assim porque ele showes BANG no início ...
— Eumel
Não tem problema, eu vi o gif agora, parece que ele funciona muito bem :) #
— 504
5

Pitão, 31 30 28 bytes

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

Quase certamente pode ser melhorado. Insira qualquer número para puxar o gatilho, entrada em branco para terminar mais cedo (com erro).

Explicação:

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
— Maçaneta da porta
fonte
Seu primeiro é realmente mais curto, você não precisa do final ".
— FryAmTheEggman
@FryAmTheEggman Ah, claro, esqueci disso. Obrigado!
— Maçaneta
Além disso, eu só notei algo bobo, FN<any>está ainda totalmente idêntico ao V<any>que provavelmente deve ser alterada para não confundir novos golfistas ...: P
— FryAmTheEggman
11
Você pode simplesmente remover os caracteres .?. Não há necessidade de um else.
— Jakube
@FryAmTheEggman confundir as pessoas é incrível. Pode ser incrível filtrar os panos .
— Cyoce
5

Sério, 27 25 bytes

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

Nenhum link online porque não há como fazer um prompt com entrada canalizada. O programa pode ser CTRL-C'D a qualquer momento para sair de frango terminar.

Explicação:

"*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
fonte
4

PHP, 52 bytes

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

Requer a -Fopção de linha de comando, contada como três. O gatilho é pressionado pressionando Enter.

Como -Fliteralmente executa o script novamente para todas as entradas (não é brincadeira), diee coisas do tipo não terminam, então saímos por um erro de tempo de execução suprimido @\n.

Uso da amostra

$ php -F primo-roulette.php

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

Perl 5, 43 bytes

Corra com perl -p. Variante de marcador estável - ou seja, a posição do marcador é decidida apenas uma vez no início.

$i//=0|rand 6;$_=$i--?'*click*':die'*BANG*'
— Oleg V. Volkov
fonte
Agradável! Eu mudaria o cabeçalho para "Perl 5.10+", já que você está usando //=. Além disso, não se esqueça de contar -pna sua pontuação .
— ThisSuitIsBlackNot
4

C, 110 74 72 bytes

Agradecemos a Dennis por se livrar das inclusões e muito 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.
fonte
3

Doces , 36 bytes

Cerca de metade do programa é o texto a ser impresso :(

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

forma longa:

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

Python 3, 95 bytes

Também minha primeira tentativa de golfe, também em Python 3. Juro que Bruce e não somos a mesma pessoa.

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

Ungolfed:

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

Gere um número aleatório entre 0 e 5, inclusive, imprima o clique várias vezes e imprima bang . Pressione Enter / Return para puxar o gatilho.

— Steve Eckert
fonte
Seguindo o exemplo de Bruce, você pode salvar alguns bytes comfrom random import*
— wnnmaw
A menos que algo esteja faltando, é um byte de economia. Mas eu aceito! Obrigado!
— Steve Eckert
Bom tentativa, eu usei a sua solução como uma inspiração para a minha solução python 2 ^^
— Basile-henry
3

PlatyPar , 26 25 bytes

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

Explicação:

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

Experimente online !

— Cyoce
fonte
2

Emacs Lisp, 94 89 bytes

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

Ungolfed:

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

R, 86 80 77 bytes

Como de costume, o R possui recursos impressionantes para codificar golfe, mas também inclui nomes de funções.

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

Python 2, 108 104 102 100 98 bytes

Minha primeira tentativa no golfe:

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

Talvez eu deva acrescentar que o programa não é encerrado corretamente quando você perde, apenas gera uma exceção (que resulta em encerramento):

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
— ბიმო
fonte
Bem-vindo à programação de quebra-cabeças e código de golfe! Quando você postar uma resposta de código de golfe, inclua o nome do idioma e a contagem de bytes (editei aqui para você). Obrigado!
— precisa
Sim, muito obrigado! Na verdade, eu estava tentando resolver esse problema, não consegui editá-lo corretamente antes de você.
— ბიმო
Recebo sua contagem de bytes como 112, o que você usou?
— wnnmaw
Além disso, você pode salvar 2 bytes fazendo #a=shuffle([1,0,0,0,0,0])
— wnnmaw
11
Até onde eu sei, o shuffle altera a estrutura de dados subjacente e não retorna nada. Eu tentei isso, obrigado de qualquer maneira. O título (idioma e contagem de bytes) foi escrito pelo ProgramFOX. Mas quando eu uso wc, dá-me 109 qual deles, então está certo. Como você conta?
— ბიმო
2

Perl 5, 40 bytes

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

Executar sem opções de linha de comando, o gatilho é pressionado pressionando Enter.

— primo
fonte
2

Python, 81 bytes

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

inspirado nas soluções Ruby (51) e Python

— Lars
fonte
1

Lisp comum, 109

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

Não é muito competitivo, mas eu gosto de 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*")))
— coredump
fonte
1

Perl 5, 43 bytes

42 bytes + -popção de linha de comando. Basta pressionar enterpara disparar.

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

Obrigado a Dom Hastings por sua ajuda! A resposta original era 67 bytes:

$i++;$a=$i>=int(rand(6));print$_=$a?'*BANG!*':'*click*';last if($a)
— Codefun64
fonte
Na verdade, o problema -pera que ele sairia antes de chamar a última printdeclaração, sem saber por quê. Eu tentei. Fora isso, sugestões incríveis, obrigado! Meu conhecimento continua a crescer ...
— Codefun64
@DomHastings Além disso, infelizmente, por algum motivo, o 0|truque não funcionou como o esperado, mas eu raspei alguns bytes dele, a declaração de impressão e a última declaração, como você sugeriu. Como isso parece agora?
— Codefun64
@DomHastings Porra, você é bom. Eu recomendo colocar isso como a sua própria resposta, desde que você definitivamente escreveu um programa menor do que eu (você tem 40 bytes em comparação com o meu original 67!)
— Codefun64
Agradeço a explicação! Sempre feliz em aprender mais da minha linguagem de script favorita! Eu nunca soube do incremento do prefex, isso é incrível. Obrigado :)
— Codefun64
Você é muito bem-vindo, feliz por ter ajudado!
— Dom Hastings
1

MATL , 41 bytes

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

Para puxar o gatilho, insira uma string não vazia (como 'try').

Para finalizar, insira uma sequência vazia

Exemplos

Nesse caso, o gatilho foi acionado uma vez e ... azar:

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

Nesse caso, o usuário parou (observe a entrada final vazia) após duas tentativas de sorte:

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

Explicação

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

Pressione enter para puxar o gatilho ou ctrl + c para pressioná-lo.

— Brad Gilbert b2gills
fonte
1

Python 2, 88 84 bytes

Esta solução é inspirada nas soluções python 3 já fornecidas. Eu escolhi o python 2 para remover os parênteses de impressão, mesmo que isso mude o comportamento de input ().

import time
for i in[0]*int(time.time()%6)+[1]:input();print("*click*","*BANG!*")[i]
  • Estou usando o módulo do tempo como uma função aleatória (boa o suficiente para roleta russa)
  • a entrada do player deve ser "i" e depois Enter (caso contrário, input () lançará um erro), esse truque se baseia no fato de que a entrada pode ser "qualquer que seja".
— basile-henry
fonte
1

Ruby, 45 + 1 = 46

Não é tão inteligente quanto o lado D, mas é um pouco mais curto.

Com sinalizador de linha de comando p, execute

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

O usuário pode puxar o gatilho com retorno e sair com control-c. pfaz com que o programa seja executado em um loop, lendo as linhas de STDIN e produzindo $_. Cada vez que é executado, ele aumenta $.. Portanto, na primeira execução, ele escolhe um número inteiro positivo aleatório menor que 6, depois 5, depois 4 e assim por diante. No primeiro 0, saímos manualmente e saímos, até então saímos implicitamente.

(e agora percebo que já existe um Perl muito semelhante. Oh, bem.)

— histocrata
fonte
1

Perl 5, 69 51 49 bytes

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

Provavelmente existe um pouco mais de potencial de golfe, vou analisar isso.

Alterar:

  • Economizou 8 bytes removendo $le alguns pontos e vírgulas e 10 bytes alterando <STDIN>para<>
  • Guardado 2 bytes graças a Oleg V. Volkov
— ASCIIThenANSI
fonte
11
49:map{<>;print"*click*"}1..rand 6;<>;print"*BANG!*"
— Oleg V. Volkov
@ OlegV.Volkov Obrigado! Vou editá-lo agora.
— ASCIIThenANSI
0

VBA, 126 bytes

Versão 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

Versão divertida que torna os botões mais claros para maior aceitação do usuário.

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

Um pouco de diversão com formulários personalizados e você pode criar um belo jogo liso no VBA.

— JimmyJazzx
fonte
0

APL, 39/65 bytes

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

Resposta bastante direta.

— Oberon
fonte
O que significam as contagens de dois 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--;}}

Minha primeira tentativa no código de golfe, provavelmente há muito espaço para melhorias :)

— Ryan Fitzpatrick
fonte
0

Julia, 71 bytes

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

Pressione Enterpara disparar ou Ctrl+ Cpara sair. O último termina com um InterruptException.

Ungolfed:

# 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.
fonte
0

Lua, 73 bytes

q=io.read q()for i=2,math.random(6)do print"*click*"q()end print"*BANG!*"
— Oleg V. Volkov
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.