Russian Roulette, Reloaded

32

Giochiamo alla roulette russa!

Normalmente, questa sarebbe una corsa per scrivere il programma MOD 6 più breve, ma non è molto realistico, poiché la possibilità di vincere diminuisce ad ogni clic. Ecco le regole:

  1. Emula un vero tiratore a sei :
    • Un singolo proiettile viene posizionato in una delle sei camere e la canna viene fatta girare una volta, solo prima di giocare.
    • La possibilità di perdere il n ° prova è 1/6.
    • La possibilità di perdere dopo n tentativi è 1 / (6-n)
    • Sei garantito di perdere, al massimo, in 6 tentativi.
  2. perdere:
    • Visualizza il testo *BANG!*
    • Termina il programma.
  3. Vincente:
    • "Vincere" significa che la pistola non spara, ma il proiettile è una camera più vicino al martello.
    • Visualizza il testo *click*
    • Presenta un "trigger" per l'utente, insieme alla possibilità di terminare il programma (es. "Ctrl + c", vedi sotto).
  4. Programma specifico:
    • Premere il grilletto è una forma di input dell'utente, incluso il primo tentativo. (Questo può essere un tasto, un clic del mouse, qualunque cosa; i messaggi di testo non sono richiesti.)
    • È consentita solo un'istanza del programma fino alla sua conclusione. (Eseguire una nuova istanza del programma è simile a dare alla canna una buona rotazione, ovvero la probabilità di perdere al clic successivo viene ripristinata a 1/6.)

Vince il codice più corto!

Classifica

Mostra snippet di codice

code-golf  game  random 
— Ayane
fonte
3
I tuoi presupposti sono sbagliati: la possibilità di perdere all'ennesimo tentativo è solo ⅙ se rispondi ai proiettili dopo ogni tiro. Senza rischiare la possibilità di perdere è ⅙ al primo tiro, ⅕ al secondo, ¼ al terzo ... che termina con 1 al 6 °. Lo riconosci con "Sei sicuro di perdere, al massimo, in 6 tentativi".
— rhialto
2
@utente2956063 stai dimenticando che esiste una possibilità (n-1) / 6 che non raggiungi mai il tentativo n: th, e quindi non puoi perdere. Si bilanciano in uniforme 1/6.
— Jacob Raihle,
2
forse questa è una differenza nel modo in cui gli informatici e gli statistici esprimono probabilità allora - per me "La possibilità di perdere all'ennesimo tentativo è ⅙" dire che è costante - che n sia 1 o 100.
— rhialto
3
Perché questo non era intitolato "Russian Roulette, Reloaded"?
— Hand-E-Food,
1
@ user2956063: le tue probabilità sono condizionate . P (perdi nel tiro 2) = ⅙, ma P (perdi nel tiro 2 | non ha perso nel tiro 1) = ⅕. Inoltre, n(implicitamente, ti garantirò) limitato a [1,6], quindi 100 è uscito.
— Tim Pederick,

Risposte:

3

Pyth, 23 byte

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

Davvero semplice. Un numero casuale di iterazioni 0 - 5 visualizza il clic e richiede una riga di input, seguito da un botto alla fine.

— isaacg
fonte
1
accidenti a te, pit!
— Cyoce,
+3 byte: l'ultima stringa dovrebbe essere *BANG!*, nonBANG
— ayane il
14

Rubino, 51 byte

[*['*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.

o

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

Ungolfing è partito per i lettori. Non così difficile

  • Ancora complimenti a Martin, questa volta per un trucco con $><<come putssostituto.
  • Non genera nuove righe, ma ciò non era necessario.
  • Il più corto, il più semplice. L'essenza del comportamento richiesto è fare 0-5 clic e poi sparare. Per questo, gli output vengono accumulati all'interno dell'array.
  • Altri 2 byte possono essere eliminati se gli output come "*click*"sono a posto (ciò che è necessario è stampato alla fine), sostituendolo $><<con p . Non ero sicuro che questo avrebbe ancora seguito le regole.

68 64 byte

(un altro approccio)

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

Non ho pensato molto all'algoritmo (può essere forse ancora più compatto, ma non così chiaro), ma mi piace molto il modello al suo interno:

  • Un array emula un barile con i suoi elementi come contenuti delle camere. Poiché solo un elemento è un proiettile, ruotarlo e mescolarlo sono equivalenti.
  • 0è un proiettile. Altri numeri non lo sono.
  • findtrova un primo valore di ritorno per il quale il blocco non è né falsené nil.
  • ||-espressione viene restituita implicitamente dal blocco. È un corto circuito: restituisce il suo primo operando (a meno che non sia nilo false) o un secondo (altrimenti). Quindi restituisce true(se x<1o, più chiaro ma più a lungo x == 0) o il valore restituito di puts, mentre ...
  • putsritorna sempre nil. Sì.
  • getsrichiede input. Basta colpire Enter.
  • Ctrl+ Ctermina il programma
— D-side
fonte
Barrato 64 è normale 64?
— Cyoce,
@Cyoce uhm ... si. Dovrebbe essere, probabilmente. È stato sostituito dalla voce precedente, ma si basa su un'idea diversa, quindi li ho lasciati, cancellati.
— Lato D il
era un gioco di
— parole
@Cyoce oh, scusami, primo post e tutto il resto, non consapevole della tradizione locale :)
— D-side
9

JavaScript, 64 byte

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

Spiegazione

Per premere il grilletto, immettere qualsiasi testo nel prompt. Non inserire nulla o fare clic su Annulla per terminare.

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!*"non è maggiore di 7. Ma NaNnon è inferiore a 7.
— Bergi,
@Bergi È vero. Ho riformulato la spiegazione per renderla un po 'più chiara.
— user81655
6
@Bergi solo in Javascript quell'affermazione si avvicina persino al senso.
— MikeTheLiar,
7

Lua, 82 75 byte

Abbastanza a lungo, ma c'è molto prolisso in lua.

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

LabVIEW, 46 Primitive LabVIEW

Crea un array di 0 e uno 1, ha un loop per attendere i clic e genera la stringa. Inizialmente dice BANG perché ho dimenticato di resettare l'indicatore prima di avviarlo.

Nota anche che questa è una gif, se non viene riprodotta / caricata per te riaprire la pagina.

— Eumel
fonte
Non vedo dove esegui l'output "*click*"nel caso in cui la pistola non abbia sparato. Inoltre, produce "bang"o "*BANG!*"?
— Katenkyo,
questo dovrebbe essere una gif ma per me non funziona, questo potrebbe essere il problema. E sì, mi fa solo scoppiare, che non stavo leggendo bene, lo cambio in un secondo
— Eumel
stupido mi sono dimenticato di reinizializzare la stringa da svuotare prima di iniziare, ecco perché mostra BANG all'inizio ...
— Eumel,
Nessun problema, ho visto la gif ora, sembra che funzioni abbastanza bene :)
— Katenkyo,
5

Pyth, 31 30 28 byte

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

Quasi certamente può essere migliorato. Immettere un numero qualsiasi per premere il grilletto, input vuoto per terminare in anticipo (con un errore).

Spiegazione:

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
— Maniglia
fonte
Il tuo primo è in realtà più corto, non hai bisogno del finale ".
— FryAmTheEggman,
@FryAmTheEggman Oh, giusto, me ne sono dimenticato. Grazie!
— Maniglia della porta
Inoltre, ho appena notato qualcosa di stupido, FN<any>è ancora del tutto identico V<any>, che probabilmente dovrebbe essere cambiato per non confondere i nuovi giocatori di golf ...: P
— FryAmTheEggman
1
Puoi semplicemente rimuovere i caratteri .?. Non è necessario un else.
— Jakube,
@FryAmTheEggman confondere le persone è fantastico. Può essere sorprendente filtrare gli scrub .
— Cyoce,
5

Scherzi a parte, 27 25 byte

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

Nessun collegamento online perché non è possibile eseguire un prompt con input convogliato. Il programma può essere CTRL-C'D in qualsiasi momento per far finta di niente terminare.

Spiegazione:

"*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 byte

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

Richiede l' -Fopzione della riga di comando, conteggiata come tre. Il grilletto viene premuto premendo Enter.

Perché -Fletteralmente corre di nuovo lo script per ogni ingresso (non scherzo), diee simili non sarà effettivamente terminare, così abbiamo uscita Via errore di runtime soppressa, invece, @\n.

Esempio di utilizzo

$ php -F primo-roulette.php

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

Perl 5, 43 byte

Corri con perl -p. Variante di proiettile stabile - ovvero la posizione del proiettile viene decisa solo una volta all'inizio.

$i//=0|rand 6;$_=$i--?'*click*':die'*BANG*'
— Oleg V. Volkov
fonte
Bello! Vorrei cambiare l'intestazione in "Perl 5.10+", poiché stai usando //=. Inoltre, non dimenticare di contare -pnel tuo punteggio .
— ThisSuitIsBlackNon
4

C, 110 74 72 byte

Grazie a Dennis per aver eliminato le inclusioni e molti meno byte.

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

Candy , 36 byte

Circa metà del programma è il testo da stampare :(

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

forma lunga:

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 byte

Anche il mio primo tentativo di golf, anche in Python 3. Giuro Bruce e non sono la stessa persona.

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*")

Genera un numero casuale compreso tra 0 e 5 inclusi, stampa quel clic più volte, quindi stampa bang . Premi Invio / Invio per premere il grilletto.

— Steve Eckert
fonte
Seguendo l'esempio di Bruce, puoi salvare alcuni byte confrom random import*
— wnnmaw il
A meno che non ci sia qualcos'altro che mi manca, è un byte di risparmio. Ma lo prenderò! Grazie!
— Steve Eckert,
Bel tentativo, ho usato la tua soluzione come fonte d'ispirazione per la mia soluzione python 2 ^^
— basile-henry
3

PlatyPar , 26 25 byte

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

Spiegazione:

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

Provalo online !

— Cyoce
fonte
2

Emacs Lisp, 94 89 byte

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

Come al solito, R ha fantastiche funzionalità per codificare il golf ma nomi di funzioni incredibilmente lunghi.

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

Python 2, 108 104 102 100 98 byte

Il mio primo tentativo di giocare a golf:

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

Forse dovrei aggiungere che il programma non si interrompe correttamente quando si perde, genera solo un'eccezione (che si traduce in interruzione):

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
Benvenuto in Programmazione di puzzle e codice golf! Quando pubblichi una risposta di golf del codice, includi il nome della lingua e il conteggio dei byte (l'ho modificato per te qui). Grazie!
— Programma FOX
Sì, grazie mille! In realtà stavo cercando di risolvere quel problema, non sono riuscito a modificarlo correttamente prima di te.
— ბიმო
Ottengo il conteggio dei byte come 112, che cosa hai usato?
— wnnmaw,
Inoltre, puoi salvare 2 byte facendoa=shuffle([1,0,0,0,0,0])
— wnnmaw il
1
Per quanto ne so shuffle cambia la struttura dei dati sottostanti e non restituisce nulla. Ci ho provato, grazie comunque. Il titolo (lingua e conteggio dei byte) è stato scritto da ProgramFOX. Ma quando lo uso wcmi dà 109 quale troppo, quindi è giusto. Come si conta?
— ბიმო
2

Perl 5, 40 byte

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

Esegui senza opzioni della riga di comando, il grilletto viene premuto premendo Enter.

— Primo
fonte
2

Python, 81 byte

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

ispirato alle soluzioni Ruby (51) e Python

— Lars
fonte
1

Lisp comune, 109

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

Non molto competitivo, ma mi piacciono gli elenchi circolari:

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

42 byte + -popzione della riga di comando. Basta premere enterper attivare.

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

Grazie a Dom Hastings per il suo aiuto! La risposta originale era di 67 byte:

$i++;$a=$i>=int(rand(6));print$_=$a?'*BANG!*':'*click*';last if($a)
— Codefun64
fonte
In realtà il problema -pera che sarebbe uscito prima di chiamare l'ultima printaffermazione, non so perché. L'ho provato A parte questo, fantastici suggerimenti, grazie! La mia conoscenza continua a crescere ...
— Codefun64,
@DomHastings Inoltre, sfortunatamente, per qualche ragione il 0|trucco non ha funzionato come previsto, ma ho eliminato alcuni byte da esso, la dichiarazione di stampa e l'ultima istruzione come hai suggerito. Com'è adesso?
— Codefun64
@DomHastings Accidenti, sei bravo. Ti consiglio di inserirlo come risposta personale, dato che hai sicuramente scritto un programma più piccolo di me (hai 40 byte rispetto al mio 67 originale!)
— Codefun64
Apprezzo la spiegazione! Sempre felice di saperne di più sul mio linguaggio di scripting preferito! Non ho mai nemmeno saputo dell'incremento prefex, è davvero fantastico. Grazie :)
— Codefun64
Sei il benvenuto, felice di averti aiutato!
— Dom Hastings,
1

MATL , 41 byte

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

Per premere il grilletto, inserisci una stringa non vuota (come 'try').

Per terminare, inserire una stringa vuota

Esempi

In questo caso il grilletto è stato premuto una volta e ... sfortuna:

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

In questo caso l'utente si è fermato (notare l'input vuoto finale) dopo due tiri fortunati:

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

Spiegazione

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 byte

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

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

Premi Invio per premere il grilletto o ctrl + c per metterlo giù.

— Brad Gilbert b2gills
fonte
1

Python 2, 88 84 byte

Questa soluzione si ispira alle soluzioni Python 3 già fornite. Ho scelto Python 2 per rimuovere la parentesi di stampa anche se questo cambia il comportamento di input ().

import time
for i in[0]*int(time.time()%6)+[1]:input();print("*click*","*BANG!*")[i]
  • Sto usando il modulo del tempo come una funzione casuale (abbastanza buono per la roulette russa)
  • l'input del giocatore dovrebbe essere "i" quindi Enter (altrimenti input () genererà un errore), questo trucco si basa sul fatto che l'input può essere "qualunque".
— Basile-henry
fonte
1

Rubino, 45 + 1 = 46

Non intelligente come il lato D ma leggermente più corto.

Con flag della riga di comando p, eseguire

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

L'utente può premere il grilletto con il ritorno e partire con control-c. pfa sì che il programma venga eseguito in un ciclo, leggendo le righe da STDIN e producendo $_. Ogni volta che viene eseguito, aumenta $.. Quindi al primo avvio, sceglie un numero intero positivo casuale inferiore a 6, quindi 5, quindi 4 e così via. Sul primo 0, eseguiamo l'output manuale e usciamo, fino ad allora abbiamo output implicito.

(e ora noto che esiste già un Perl molto simile. Vabbè.)

— histocrat
fonte
1

Perl 5, 69 51 49 byte

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

Probabilmente c'è un po 'più di potenziale per il golf, esaminerò questo.

I cambiamenti:

  • Salvato 8 byte rimuovendo $le alcuni punti e virgola e 10 byte cambiando <STDIN>in<>
  • Salvato 2 byte grazie a Oleg V. Volkov
— ASCIIThenANSI
fonte
1
49:map{<>;print"*click*"}1..rand 6;<>;print"*BANG!*"
— Oleg V. Volkov,
@ OlegV.Volkov Grazie! Lo modificherò ora.
— ASCIIThenANSI
0

VBA, 126 byte

Versione golf per byte minimi

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

Versione divertente che rende i pulsanti più chiari per una maggiore accettazione da parte dell'utente.

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 po 'di divertimento con moduli personalizzati e potresti creare un bel gioco Slick in VBA.

— JimmyJazzx
fonte
0

APL, 39/65 byte

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

Risposta piuttosto semplice.

— Oberon
fonte
Cosa significano i conteggi a due byte?
— Mego
0

C, 180 byte

#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--;}}

Il mio primo tentativo di code golf, probabilmente c'è molto margine di miglioramento :)

— Ryan Fitzpatrick
fonte
0

Julia, 71 byte

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

Premi Enterper sparare o Ctrl+ Cper uscire. Quest'ultimo termina con un 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 byte

q=io.read q()for i=2,math.random(6)do print"*click*"q()end print"*BANG!*"
— Oleg V. Volkov
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.