Roulette russe, rechargée

32

Jouons à la roulette russe!

Normalement, ce serait une course pour écrire le programme MOD 6 le plus court, mais ce n'est pas très réaliste, car les chances de gagner diminuent à chaque clic. Voici les règles:

  1. Émulez un vrai six tireurs :
    • Une seule balle est placée dans l'une des six chambres, et le canon est tourné une fois, seulement avant de jouer.
    • Le risque de perdre sur la n ième essai est 1/6.
    • La chance de perdre après n essais est de 1 / (6-n)
    • Vous êtes assuré de perdre en 6 essais au maximum.
  2. Perdant:
    • Afficher le texte *BANG!*
    • Arrêtez le programme.
  3. Gagnant:
    • "Gagner" signifie que l'arme ne tire pas, mais la balle est une chambre plus proche du marteau.
    • Afficher le texte *click*
    • Présentez un "déclencheur" à l'utilisateur, ainsi que la possibilité de terminer le programme (par exemple "ctrl + c", voir ci-dessous).
  4. Spécifique au programme:
    • Tirer sur la gâchette est une forme d'entrée utilisateur, y compris le premier essai. (Cela peut être une frappe, un clic de souris, peu importe; les invites de texte ne sont pas nécessaires.)
    • Une seule instance du programme est autorisée jusqu'à ce qu'elle soit terminée. (L'exécution d'une nouvelle instance du programme revient à donner au baril une bonne rotation, c'est-à-dire que la probabilité de perdre au prochain clic est réinitialisée à 1/6.)

Le code le plus court gagne!

Classement

Afficher l'extrait de code

code-golf  game  random 
— ayane
source
3
Vos hypothèses sont erronées - la chance de perdre au cinquième essai n'est que ⅙ si vous réorganisez les balles après chaque tir. Sans respiner, la chance de perdre est de ⅙ au premier coup, ⅕ au deuxième, ¼ au troisième ... se terminant par 1 au 6. Vous le reconnaissez avec "Vous êtes assuré de perdre au maximum en 6 essais".
— rhialto
2
@ user2956063 vous oubliez qu'il y a une chance (n-1) / 6 que vous n'atteigniez jamais le n: e essai et que vous ne puissiez donc pas perdre. Ils équilibrent à un 1/6 uniforme.
— Jacob Raihle
2
c'est peut-être une différence dans la façon dont les informaticiens et les statisticiens expriment la probabilité alors - pour moi "La chance de perdre au nième essai est ⅙" disons que c'est constant - que n soit 1 ou 100.
— rhialto
3
Pourquoi n'était-ce pas intitulé "Roulette russe, rechargée"?
— Hand-E-Food
1
@ user2956063: Vos probabilités sont conditionnelles . P (perdre sur le coup 2) = ⅙, mais P (perdre sur le coup 2 | n'a pas perdu sur le coup 1) = ⅕. En outre, nest (implicitement, je vous l'accorde) limité à [1,6], donc 100 est sorti.
— Tim Pederick

Réponses:

3

Pyth, 23 octets

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

Vraiment simple. Un nombre aléatoire d'itérations de 0 à 5 affiche le clic et demande une ligne d'entrée, suivie d'un coup à la fin.

— isaacg
source
1
bon sang, pyth!
— Cyoce
+3 octets: la dernière chaîne devrait être *BANG!*, pasBANG
— ayane
14

Rubis, 51 octets

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

Ungolfing est parti pour les lecteurs. Pas si difficile

  • Encore une fois, bravo à Martin, cette fois pour un tour avec $><<comme putsremplaçant.
  • N'affiche pas de nouvelles lignes, mais cela n'était pas obligatoire.
  • Le plus court, le plus simple. L'essentiel du comportement requis consiste à effectuer 0 à 5 clics, puis à tirer. Pour cela, les sorties sont accumulées à l'intérieur du tableau.
  • 2 octets supplémentaires peuvent être rasés si les sorties comme "*click*"sont correctes (ce qui est requis est imprimé à la fin), en remplaçant $><<par p . Je ne savais pas si cela respecterait toujours les règles.

68 64 octets

(une autre approche)

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

Je n'ai pas beaucoup réfléchi à l'algorithme (il peut être encore plus compact, mais pas si clair), mais j'aime vraiment le modèle qu'il contient:

  • Un tableau émule un baril avec ses éléments constituant le contenu des chambres. Comme un seul élément est une balle, la faire tourner et la mélanger sont équivalentes.
  • 0est une balle. D'autres chiffres ne le sont pas.
  • findtrouve une première valeur de retour pour laquelle le bloc n'est ni falseni nil.
  • ||-expression est implicitement renvoyée par le bloc. C'est un court-circuit: il retourne son premier opérande (sauf si c'est nilou false) ou un second (sinon). Il renvoie donc true(si x<1ou, plus clair mais plus long x == 0) ou la valeur de retour de puts, tandis que ...
  • putsrevient toujours nil. Oui.
  • getsdemande une entrée. Il Entersuffit de frapper .
  • Ctrl+ Ctermine le programme
— Côté D
source
Barré 64 est normal 64?
— Cyoce
@Cyoce uhm ... oui. Ça devrait être, probablement. Il a été remplacé par l'entrée ci-dessus, mais il est basé sur une idée différente, alors je les ai laissés barrés.
— D-side
ce fut un jeu de mots sur ce
— Cyoce
@Cyoce oh, pardonnez-moi, premier post et tout ça, pas au courant de la tradition locale :)
— D-side
9

JavaScript, 64 octets

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

Explication

Pour tirer sur la gâchette, entrez n'importe quel texte dans l'invite. N'entrez rien ou cliquez sur Annuler pour terminer.

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
  )
— utilisateur81655
source
"*Bang!*"n'est pas supérieur à 7. Mais NaNn'est pas inférieur à 7.
— Bergi
@Bergi C'est vrai. J'ai reformulé l'explication pour la rendre un peu plus claire.
— user81655
6
@Bergi uniquement en Javascript, cette affirmation est-elle encore presque logique.
— MikeTheLiar
7

Lua, 82 75 octets

Assez long, mais il y a beaucoup de verbeux dans lua.

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

LabVIEW, 46 primitives LabVIEW

Crée un tableau de 0 et un 1, a une boucle pour attendre les clics et sort la chaîne. Il indique initialement que BANG parce que j'ai oublié de réinitialiser l'indicateur avant de le démarrer.

Notez également que c'est un gif, si si ne joue pas / charge pour vous, veuillez rouvrir la page.

— Eumel
source
Je ne vois pas où vous "*click*"sortez au cas où l'arme ne tirerait pas. De plus, est-ce que ça sort "bang"ou "*BANG!*"?
— Katenkyo
ça devrait être un gif mais pour moi ça ne joue pas, ça pourrait être le problème. Et oui ça ne fait que bang, c'est moi qui ne lis pas correctement je change ça en une seconde
— Eumel
stupide m'a oublié de réinitialiser la chaîne pour la vider avant de commencer donc c'est pourquoi elle affiche BANG au début ...
— Eumel
Pas de problème, j'ai vu le gif maintenant, on dirait que ça marche plutôt bien :)
— Katenkyo
5

Pyth, 31 30 28 octets

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

Peut presque certainement être amélioré. Entrez un nombre quelconque pour tirer sur la gâchette, une entrée vide pour terminer plus tôt (avec une erreur).

Explication:

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
— Poignée de porte
source
Votre premier est en fait plus court, vous n'avez pas besoin du suivi ".
— FryAmTheEggman
@FryAmTheEggman Oh, c'est vrai, j'ai oublié ça. Merci!
— Poignée de porte
De plus, je viens de remarquer quelque chose de stupide, qui FN<any>est toujours entièrement identique V<any>, qui devrait probablement être changé pour ne pas confondre les nouveaux golfeurs ...: P
— FryAmTheEggman
1
Vous pouvez simplement supprimer les caractères .?. Il n'y a pas besoin d'un else.
— Jakube
@FryAmTheEggman confondre les gens est génial. Il peut être incroyable de filtrer les gommages .
— Cyoce
5

Sérieusement, 27 25 octets

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

Pas de lien en ligne car il n'y a aucun moyen de faire une invite avec une entrée canalisée. Le programme peut être CTRL-C'D à tout moment de poulet fin.

Explication:

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

PHP, 52 octets

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

Nécessite l' -Foption de ligne de commande, comptée comme trois. La gâchette est tirée en appuyant sur Enter.

Parce que -Fcourt littéralement le script à nouveau pour chaque entrée (enfant , je vous pas), dieet autres ne se terminera pas en fait, donc nous sortir par erreur d'exécution supprimée à la place, @\n.

Exemple d'utilisation

$ php -F primo-roulette.php

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

Perl 5, 43 octets

Courez avec perl -p. Variante de balle stable - c'est-à-dire que la position de la balle n'est décidée qu'une seule fois au tout début.

$i//=0|rand 6;$_=$i--?'*click*':die'*BANG*'
— Oleg V. Volkov
source
Agréable! Je changerais l'en-tête en "Perl 5.10+", puisque vous utilisez //=. N'oubliez pas non plus de compter -pdans votre score .
— ThisSuitIsBlackNot
4

C, 110 74 72 octets

Merci à Dennis de se débarrasser des inclusions et de beaucoup moins d'octets.

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.
source
3

Candy , 36 octets

Environ la moitié du programme est le texte à imprimer :(

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

forme longue:

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

Python 3, 95 octets

Aussi ma première tentative de golf, également en Python 3. Je jure que Bruce et moi ne sommes pas la même personne.

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

Générez un nombre aléatoire entre 0 et 5 inclus, imprimez le clic autant de fois, puis imprimez le bang . Appuyez sur entrée / retour pour tirer sur la gâchette.

— Steve Eckert
source
En suivant l'exemple de Bruce, vous pouvez enregistrer quelques octets avecfrom random import*
— wnnmaw
À moins qu'il ne manque quelque chose d'autre, c'est un octet d'économies. Mais je vais le prendre! Merci!
— Steve Eckert
Belle tentative, j'ai utilisé votre solution comme source d'inspiration pour ma solution python 2 ^^
— basile-henry
3

PlatyPar , 26 25 octets

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

Explication:

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

Essayez-le en ligne !

— Cyoce
source
2

Emacs Lisp, 94 89 octets

(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
source
2

R, 86 80 77 octets

Comme d'habitude, R a des fonctionnalités impressionnantes pour coder le golf mais des noms de fonction looooooong.

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

Python 2, 108 104 102 100 98 bytes

Ma première tentative de golf:

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

Je devrais peut-être ajouter que le programme ne se termine pas correctement lorsque vous perdez, il lève juste une exception (ce qui entraîne la résiliation):

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
— ბიმო
source
Bienvenue dans Programming Puzzles & Code Golf! Lorsque vous postez une réponse de code de golf, veuillez inclure le nom de la langue et le nombre d'octets (je l'ai édité pour vous ici). Merci!
— ProgramFOX
Oui, merci beaucoup! J'essayais en fait de résoudre ce problème, je n'ai pas pu le modifier correctement avant vous.
— ბიმო
J'ai 112 octets , qu'avez-vous utilisé?
— wnnmaw
En outre, vous pouvez enregistrer 2 octets en faisanta=shuffle([1,0,0,0,0,0])
— wnnmaw
1
Autant que je sache, le shuffle modifie la structure des données sous-jacentes et ne renvoie rien. J'ai essayé ça, merci quand même. Le titre (langue et nombre d'octets) a été écrit par ProgramFOX. Mais quand je l'utilise, wccela me donne 109 qui de trop, donc c'est vrai. Comment comptez-vous?
— ბიმო
2

Perl 5, 40 octets

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

Exécuter sans options de ligne de commande, le déclencheur est tiré en appuyant sur Enter.

— primo
source
2

Python, 81 octets

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

inspiré des solutions Ruby (51) et Python

— Lars
source
1

Lisp commun, 109

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

Pas très compétitif, mais j'aime les listes circulaires:

(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
source
1

Perl 5, 43 octets

42 octets + -poption de ligne de commande. Appuyez simplement enterpour déclencher.

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

Merci à Dom Hastings pour son aide! La réponse d'origine était 67 octets:

$i++;$a=$i>=int(rand(6));print$_=$a?'*BANG!*':'*click*';last if($a)
— Codefun64
source
En fait, le problème -pétait qu'il se terminerait avant d'appeler la dernière printinstruction, sans savoir pourquoi. Je l'ai essayé. A part ça, de super suggestions, merci! Mes connaissances continuent de croître ...
— Codefun64
@DomHastings Aussi, malheureusement, pour une raison quelconque, l' 0|astuce n'a pas fonctionné comme prévu, mais j'en ai rasé quelques octets, l'instruction print et la dernière instruction comme vous l'avez suggéré. À quoi ça ressemble maintenant?
— Codefun64
@DomHastings Damn, vous êtes bon. Je recommande de mettre cela comme votre propre réponse, car vous avez certainement écrit un programme plus petit que moi (vous avez 40 octets par rapport à mon 67 d'origine!)
— Codefun64
J'apprécie l'explication! Toujours heureux d'en savoir plus sur mon langage de script préféré! Je ne connaissais même pas l'incrémentation du préfex, c'est assez génial. Merci :)
— Codefun64
Vous êtes les bienvenus, heureux d'avoir aidé!
— Dom Hastings
1

MATL , 41 octets

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

Pour tirer sur le déclencheur, saisissez une chaîne non vide (telle que 'try').

Pour terminer, entrez une chaîne vide

Exemples

Dans ce cas, la gâchette a été actionnée une fois et ... pas de chance:

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

Dans ce cas, l'utilisateur s'est arrêté (notez la dernière entrée vide) après deux tirages chanceux:

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

Explication

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
source
1

Perl 6 ,  58    53 octets

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

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

Appuyez sur Entrée pour tirer sur la gâchette, ou sur Ctrl + C pour la poser.

— Brad Gilbert b2gills
source
1

Python 2, 88 84 octets

Cette solution est inspirée des solutions python 3 déjà données. J'ai choisi python 2 pour supprimer la parenthèse d'impression même si cela change le comportement de input ().

import time
for i in[0]*int(time.time()%6)+[1]:input();print("*click*","*BANG!*")[i]
  • J'utilise le modulo du temps comme une fonction aléatoire (assez bon pour la roulette russe)
  • l'entrée du lecteur doit être "i" puis Enter (sinon input () générera une erreur), cette astuce repose sur le fait que l'entrée peut être "n'importe quoi".
— basile-henry
source
1

Rubis, 45 + 1 = 46

Pas aussi intelligent que le côté D mais légèrement plus court.

Avec l'indicateur de ligne de commande p, exécutez

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

L'utilisateur peut appuyer sur la gâchette avec retour et repartir avec control-c. pentraîne l'exécution du programme en boucle, la lecture des lignes depuis STDIN et la sortie $_. Chaque fois qu'il s'exécute, il s'incrémente $.. Ainsi, lors de la première exécution, il choisit un entier positif aléatoire inférieur à 6, puis 5, puis 4, etc. Sur le premier 0, nous sortons manuellement et quittons, jusque-là nous sortons implicitement.

(et maintenant je remarque qu'il y a déjà un Perl très similaire. Oh bien.)

— histocrate
source
1

Perl 5, 69 51 49 octets

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

Il y a probablement un peu plus de potentiel pour le golf, je vais y réfléchir.

Changements:

  • 8 octets enregistrés en supprimant $lcertains points-virgules et 10 octets en passant <STDIN>à<>
  • Enregistré 2 octets grâce à Oleg V. Volkov
— ASCIIThenANSI
source
1
49:map{<>;print"*click*"}1..rand 6;<>;print"*BANG!*"
— Oleg V. Volkov
@ OlegV.Volkov Merci! Je vais le modifier maintenant.
— ASCIIThenANSI
0

VBA, 126 octets

Version Golf pour octets minimaux

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

Version amusante qui rend les boutons plus clairs pour une meilleure acceptation des utilisateurs.

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

Du plaisir avec les formulaires personnalisés et vous pourriez faire un joli jeu Slick en VBA.

— JimmyJazzx
source
0

APL, 39/65 octets

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

Réponse assez simple.

— Oberon
source
Que signifient les deux nombres d'octets?
— Mego
0

C, 180 octets

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

Ma première tentative de golf de code, il y a probablement beaucoup de place pour l'amélioration :)

— Ryan Fitzpatrick
source
0

Julia, 71 octets

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

Appuyez sur Enterpour tirer ou sur Ctrl+ Cpour quitter. Ce dernier se termine par unInterruptException .

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.
source
0

Lua, 73 octets

q=io.read q()for i=2,math.random(6)do print"*click*"q()end print"*BANG!*"
— Oleg V. Volkov
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.