I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Two bullet roulette

Two bullet roulette
You are encouraged to solve this task according to the task description, using any language you may know.

The following is supposedly a question given to mathematics graduates seeking jobs on Wall Street:

``` A revolver handgun has a revolving cylinder with six chambers for bullets.

It is loaded with the following procedure:
1. Check the first chamber to the right of the trigger for a bullet.  If a bullet
is seen, the cylinder is rotated one chamber clockwise and the next chamber
checked until an empty chamber is found.
2. A cartridge containing a bullet is placed in the empty chamber.
3. The cylinder is then rotated one chamber clockwise.

To randomize the cylinder's position, the cylinder is spun, which causes the cylinder to take
a random position from 1 to 6 chamber rotations clockwise from its starting position.

When the trigger is pulled the gun will fire if there is a bullet in position 0, which is just

The gun is unloaded by removing all cartridges from the cylinder.

According to the legend, a suicidal Russian imperial military officer plays a game of Russian
roulette by putting two bullets in a six-chamber cylinder and pulls the trigger twice.
If the gun fires with a trigger pull, this is considered a successful suicide.

The cylinder is always spun before the first shot, but it may or may not be spun after putting
in the first bullet and may or may not be spun after taking the first shot.

Which of the following situations produces the highest probability of suicide?

A. Spinning the cylinder after loading the first bullet, and spinning again after the first shot.
C. Spinning the cylinder after firing the first shot only.
D. Not spinning the cylinder either after loading the first bullet or after the first shot.
E. The probability is the same for all cases.
```

1. Run a repeated simulation of each of the above scenario, calculating the percentage of suicide with a randomization of the four spinning, loading and firing order scenarios.
2. Show the results as a percentage of deaths for each type of scenario.
3. The hand calculated probabilities are 5/9, 7/12, 5/9, and 1/2. A correct program should produce results close enough to those to allow a correct response to the interview question.

Reference

Youtube video on the Russian 1895 Nagant revolver []

## 11l

Translation of: Go
`UInt32 seed = 0F nonrandom(n)   :seed = 1664525 * :seed + 1013904223   R Int(:seed >> 16) % n V cylinder = [0B] * 6 F rshift()   V t = :cylinder   L(i) (4..0).step(-1)      :cylinder[i + 1] = :cylinder[i]   :cylinder = t F unload()   L(i) 6      :cylinder[i] = 0B F load()   L :cylinder      rshift()   :cylinder = 1B   rshift() F spin()   L 1..nonrandom(6)      rshift() F fire()   V shot = :cylinder   rshift()   R shot F method(s)   unload()   L(c) s      S c         ‘L’            load()         ‘S’            spin()         ‘F’            I fire()               R 1   R 0 F mstring(s)   [String] l   L(c) s      S c         ‘L’            l [+]= ‘load’         ‘S’            l [+]= ‘spin’         ‘F’            l [+]= ‘fire’   R l.join(‘, ’) V tests = 100000L(m) [‘LSLSFSF’, ‘LSLSFF’, ‘LLSFSF’, ‘LLSFF’]   V sum = 0   L 0 .< tests      sum += method(m)   V pc = Float(sum) * 100 / tests   print(‘#<40 produces #2.3% deaths.’.format(mstring(m), pc))`
Output:
```load, spin, load, spin, fire, spin, fire produces 55.434% deaths.
```

## AutoHotkey

`methods =(load, spin, load, spin, fire, spin, fireload, spin, load, spin, fire, fireload, load, spin, fire, spin, fireload, load, spin, fire, fire) for i, method in StrSplit(methods, "`n", "`r"){	death := 0	main:	loop 100000	{		sixGun := []		for i, v in StrSplit(StrReplace(method," "), ",")			if %v%()				continue, main	}	output .= Format("{1:0.3f}", death/1000) "% Deaths for : """ method """`n"}MsgBox % outputreturn load(){	global	if !sixGun.Count()		sixGun := [0,1,0,0,0,0]	else		if sixGun			sixGun := 1	sixGun := 1}fire(){	global	if bullet := sixGun		death++	temp := sixGun	loop, 5		sixGun[7-A_Index] := sixGun[6-A_Index]	sixGun := temp	return bullet}spin(){	global	Random, rnd, 1, 12	loop, % rnd	{		temp := sixGun		loop, 5			sixGun[7-A_Index] := sixGun[6-A_Index]		sixGun := temp	}}`
Output:
```55.478% Deaths for : "load, spin, load, spin, fire, spin, fire"

## C

Translation of: Go
`#include <stdbool.h>#include <stdio.h>#include <stdlib.h>#include <string.h>#include <time.h> static int nextInt(int size) {    return rand() % size;} static bool cylinder; static void rshift() {    bool t = cylinder;    int i;    for (i = 4; i >= 0; i--) {        cylinder[i + 1] = cylinder[i];    }    cylinder = t;} static void unload() {    int i;    for (i = 0; i < 6; i++) {        cylinder[i] = false;    }} static void load() {    while (cylinder) {        rshift();    }    cylinder = true;    rshift();} static void spin() {    int lim = nextInt(6) + 1;    int i;    for (i = 1; i < lim; i++) {        rshift();    }} static bool fire() {    bool shot = cylinder;    rshift();    return shot;} static int method(const char *s) {    unload();    for (; *s != '\0'; s++) {        switch (*s) {        case 'L':            load();            break;        case 'S':            spin();            break;        case 'F':            if (fire()) {                return 1;            }            break;        }    }    return 0;} static void append(char *out, const char *txt) {    if (*out != '\0') {        strcat(out, ", ");    }    strcat(out, txt);} static void mstring(const char *s, char *out) {    for (; *s != '\0'; s++) {        switch (*s) {        case 'L':            append(out, "load");            break;        case 'S':            append(out, "spin");            break;        case 'F':            append(out, "fire");            break;        }    }} static void test(char *src) {    char buffer = "";    const int tests = 100000;    int sum = 0;    int t;    double pc;     for (t = 0; t < tests; t++) {        sum += method(src);    }     mstring(src, buffer);    pc = 100.0 * sum / tests;     printf("%-40s produces %6.3f%% deaths.\n", buffer, pc);} int main() {    srand(time(0));     test("LSLSFSF");    test("LSLSFF");    test("LLSFSF");    test("LLSFF");     return 0;}`
Output:
```load, spin, load, spin, fire, spin, fire produces 55.456% deaths.

## C++

Translation of: C
`#include <array>#include <iomanip>#include <iostream>#include <random>#include <sstream> class Roulette {private:    std::array<bool, 6> cylinder;     std::mt19937 gen;    std::uniform_int_distribution<> distrib;     int next_int() {        return distrib(gen);    }     void rshift() {        std::rotate(cylinder.begin(), cylinder.begin() + 1, cylinder.end());    }     void unload() {        std::fill(cylinder.begin(), cylinder.end(), false);    }     void load() {        while (cylinder) {            rshift();        }        cylinder = true;        rshift();    }     void spin() {        int lim = next_int();        for (int i = 1; i < lim; i++) {            rshift();        }    }     bool fire() {        auto shot = cylinder;        rshift();        return shot;    } public:    Roulette() {        std::random_device rd;        gen = std::mt19937(rd());        distrib = std::uniform_int_distribution<>(1, 6);         unload();    }     int method(const std::string &s) {        unload();        for (auto c : s) {            switch (c) {            case 'L':                load();                break;            case 'S':                spin();                break;            case 'F':                if (fire()) {                    return 1;                }                break;            }        }        return 0;    }}; std::string mstring(const std::string &s) {    std::stringstream ss;    bool first = true;     auto append = [&ss, &first](const std::string s) {        if (first) {            first = false;        } else {            ss << ", ";        }        ss << s;    };     for (auto c : s) {        switch (c) {        case 'L':            append("load");            break;        case 'S':            append("spin");            break;        case 'F':            append("fire");            break;        }    }     return ss.str();} void test(const std::string &src) {    const int tests = 100000;    int sum = 0;     Roulette r;    for (int t = 0; t < tests; t++) {        sum += r.method(src);    }     double pc = 100.0 * sum / tests;     std::cout << std::left << std::setw(40) << mstring(src) << " produces " << pc << "% deaths.\n";} int main() {    test("LSLSFSF");    test("LSLSFF");    test("LLSFSF");    test("LLSFF");     return 0;}`
Output:
```load, spin, load, spin, fire, spin, fire produces 55.487% deaths.

## EasyLang

Translation of: C
`len cyl[] 6func rshift . .  h = cyl  for i = 5 downto 1    cyl[i] = cyl[i - 1]  .  cyl = h.func unload . .  for i range 6    cyl[i] = 0  ..func load . .  while cyl = 1    call rshift  .  cyl = 1  call rshift.func spin . .  lim = random 6 + 1  for i = 1 to lim - 1    call rshift  ..func fire . shot .  shot = cyl  call rshift.func method m[] . shot .  call unload  shot = 0  for m in m[]    if m = 0      call load    elif m = 1      call spin    elif m = 2      call fire shot      if shot = 1        break 1      .    .  ..method\$[] = [ "load" "spin" "fire" ]func test m[] . .  n = 100000  for i range n    call method m[] shot    sum += shot  .  for i range len m[]    write method\$[m[i]] & " "  .  print "-> " & 100 * sum / n & "% deaths".call test [ 0 1 0 1 2 1 2 ]call test [ 0 1 0 1 2 2 ]call test [ 0 0 1 2 1 2 ]call test [ 0 0 1 2 2 ]`

## Factor

Translation of: Julia
Translation of: Python
`USING: accessors assocs circular formatting fry kernel literalsmath random sequences ;IN: rosetta-code.roulette CONSTANT: cyl \$[ { f f f f f f } <circular> ] : cylinder ( -- seq ) cyl [ drop f ] map! ; : load ( seq -- seq' )    0 over nth [ dup rotate-circular ] when    t 0 rot [ set-nth ] [ rotate-circular ] [ ] tri ; : spin ( seq -- seq' ) [ 6 random 1 + + ] change-start ; : fire ( seq -- ? seq' )    [ 0 swap nth ] [ rotate-circular ] [ ] tri ; : LSLSFSF ( -- ? ) cylinder load spin load spin fire spin fire drop or ;: LSLSFF  ( -- ? ) cylinder load spin load spin fire fire drop or ;: LLSFSF  ( -- ? ) cylinder load load spin fire spin fire drop or ;: LLSFF   ( -- ? ) cylinder load load spin fire fire drop or ; : percent ( ... n quot: ( ... -- ... ? ) -- ... x )    0 -rot '[ _ call( -- ? ) 1 0 ? + ] [ times ] keepd /f 100 * ; inline : run-test ( description quot -- )    100,000 swap percent    "Method <%s> produces %.3f%% deaths.\n" printf ; : main ( -- )    {        { "load, spin, load, spin, fire, spin, fire" [ LSLSFSF ] }        { "load, spin, load, spin, fire, fire" [ LSLSFF ] }        { "load, load, spin, fire, spin, fire" [ LLSFSF ] }        { "load, load, spin, fire, fire" [ LLSFF ] }    } [ run-test ] assoc-each ; MAIN: main`
Output:
`"rosetta-code.roulette" run`
```Method <load, spin, load, spin, fire, spin, fire> produces 55.598% deaths.
```

## Go

Translation of: Wren

Though procedural rather than OO.

`package main import (    "fmt"    "math/rand"    "strings"    "time") var cylinder = bool{} func rshift() {    t := cylinder    for i := 4; i >= 0; i-- {        cylinder[i+1] = cylinder[i]    }    cylinder = t} func unload() {    for i := 0; i < 6; i++ {        cylinder[i] = false    }} func load() {    for cylinder {        rshift()    }    cylinder = true    rshift()} func spin() {    var lim = 1 + rand.Intn(6)    for i := 1; i < lim; i++ {        rshift()    }} func fire() bool {    shot := cylinder    rshift()    return shot} func method(s string) int {    unload()    for _, c := range s {        switch c {        case 'L':            load()        case 'S':            spin()        case 'F':            if fire() {                return 1            }        }    }    return 0} func mstring(s string) string {    var l []string    for _, c := range s {        switch c {        case 'L':            l = append(l, "load")        case 'S':            l = append(l, "spin")        case 'F':            l = append(l, "fire")        }    }    return strings.Join(l, ", ")} func main() {    rand.Seed(time.Now().UnixNano())    tests := 100000    for _, m := range []string{"LSLSFSF", "LSLSFF", "LLSFSF", "LLSFF"} {        sum := 0        for t := 1; t <= tests; t++ {            sum += method(m)        }        pc := float64(sum) * 100 / float64(tests)        fmt.Printf("%-40s produces %6.3f%% deaths.\n", mstring(m), pc)    }}`
Output:

Sample run:

```load, spin, load, spin, fire, spin, fire produces 55.267% deaths.
```

## JavaScript

` let Pistol = function(method) {  this.fired = false;  this.cylinder = new Array(6).fill(false);  this.trigger = 0;  this.rshift = function() {    this.trigger = this.trigger == 0 ? 5 : this.trigger-1;  }  this.load = function() {    while (this.cylinder[this.trigger]) this.rshift();    this.cylinder[this.trigger] = true;    this.rshift();  }  // actually we don't need this here: just for completeness  this.unload = function() { this.cylinder.fill(false); }   this.spin = function() { this.trigger = Math.floor(Math.random() * 6); }  this.fire = function() {    if (this.cylinder[this.trigger]) this.fired = true;    this.rshift();  }  this.exec = function() {    if (!method) console.error('No method provided');    else {      method = method.toUpperCase();      for (let x = 0; x < method.length; x++)        switch (method[x]) {          case 'F' : this.fire(); break;          case 'L' : this.load(); break;          case 'S' : this.spin(); break;          case 'U' : this.unload(); break;          default: console.error(`Unknown character in method: \${method[x]}`);        }      return this.fired;    }  }} // simulatingconst ITERATIONS = 25e4;let methods = 'lslsfsf lslsff llsfsf llsff'.split(' '),    bodyCount;console.log(`@ \${ITERATIONS.toLocaleString('en')} iterations:`);console.log();for (let x = 0; x < methods.length; x++) {  bodyCount = 0;  for (let y = 1; y <= ITERATIONS; y++)    if (new Pistol(methods[x]).exec()) bodyCount++;  console.log(`\${methods[x]}:`);  console.log(`deaths: \${bodyCount.toLocaleString('en')} (\${(bodyCount / ITERATIONS * 100).toPrecision(3)} %) `);  console.log();} `
Output:

Example:

```@ 250,000 iterations:

lslsfsf:
deaths: 139,030 (55.6 %)

lslsff:
deaths: 145,912 (58.4 %)

llsfsf:
deaths: 138,628 (55.5 %)

llsff:
deaths: 125,268 (50.1 %)
```

## Julia

Translation of: Python
`const cyl = zeros(Bool, 6) function load()    while cyl        cyl .= circshift(cyl, 1)    end    cyl = true    cyl .= circshift(cyl, 1)end spin() = (cyl .= circshift(cyl, rand(1:6))) fire() = (shot = cyl; cyl .= circshift(cyl, 1); shot) function LSLSFSF()    cyl .= 0    load(); spin(); load(); spin()    fire() && return true    spin(); return fire()end function LSLSFF()    cyl .= 0    load(); spin(); load(); spin()    fire() && return true    return fire()end function LLSFSF()    cyl .= 0    load(); load(); spin()    fire() && return true    spin(); return fire()end function LLSFF()    cyl .= 0    load(); load(); spin()    fire() && return true    return fire()end function testmethods(N = 10000000)    for (name, method) in [("load, spin, load, spin, fire, spin, fire", LSLSFSF),                           ("load, spin, load, spin, fire, fire", LSLSFF),                           ("load, load, spin, fire, spin, fire", LLSFSF),                           ("load, load, spin, fire, fire", LLSFF)]        percentage = 100 * sum([method() for _ in 1:N]) / N        println("Method \$name produces \$percentage per cent deaths.")    endend testmethods() `
Output:
```Method load, spin, load, spin, fire, spin, fire produces 55.54253 per cent deaths.
Method load, spin, load, spin, fire, fire produces 58.32598 per cent deaths.
Method load, load, spin, fire, spin, fire produces 55.54244 per cent deaths.
```

## Kotlin

Translation of: C
`import kotlin.random.Random val cylinder = Array(6) { false } fun rShift() {    val t = cylinder[cylinder.size - 1]    for (i in (0 until cylinder.size - 1).reversed()) {        cylinder[i + 1] = cylinder[i]    }    cylinder = t} fun unload() {    for (i in cylinder.indices) {        cylinder[i] = false    }} fun load() {    while (cylinder) {        rShift()    }    cylinder = true    rShift()} fun spin() {    val lim = Random.nextInt(0, 6) + 1    for (i in 1..lim) {        rShift()    }} fun fire(): Boolean {    val shot = cylinder    rShift()    return shot} fun method(s: String): Int {    unload()    for (c in s) {        when (c) {            'L' -> {                load()            }            'S' -> {                spin()            }            'F' -> {                if (fire()) {                    return 1                }            }        }    }    return 0} fun mString(s: String): String {    val buf = StringBuilder()    fun append(txt: String) {        if (buf.isNotEmpty()) {            buf.append(", ")        }        buf.append(txt)    }    for (c in s) {        when (c) {            'L' -> {                append("load")            }            'S' -> {                append("spin")            }            'F' -> {                append("fire")            }        }    }    return buf.toString()} fun test(src: String) {    val tests = 100000    var sum = 0     for (t in 0..tests) {        sum += method(src)    }     val str = mString(src)    val pc = 100.0 * sum / tests    println("%-40s produces %6.3f%% deaths.".format(str, pc))} fun main() {    test("LSLSFSF");    test("LSLSFF");    test("LLSFSF");    test("LLSFF");}`
Output:
```load, spin, load, spin, fire, spin, fire produces 55.638% deaths.

## Mathematica/Wolfram Language

`ClearAll[Unload, Load, Spin, Fire]Unload[] := ConstantArray[False, 6]Load[state_List] := Module[{s = state},  While[s[],   s = RotateRight[s, 1]   ];  s[] = True;  s  ]Spin[state_List] := RotateRight[state, RandomInteger[{1, 6}]]Fire[state_List] := Module[{shot},  shot = First[state];  {RotateRight[state, 1], shot}  ]ClearAll[LSLSFSF]LSLSFSF[] := Module[{state, shot},  state = Unload[];  state = Load[state];  state = Spin[state];  state = Load[state];  state = Spin[state];  {state, shot} = Fire[state];  If[shot,   Return[True]   ];  state = Spin[state];  {state, shot} = Fire[state];  If[shot,   Return[True]   ];  Return[False]  ]ClearAll[LSLSFF]LSLSFF[] := Module[{state, shot},  state = Unload[];  state = Load[state];  state = Spin[state];  state = Load[state];  state = Spin[state];  {state, shot} = Fire[state];  If[shot,   Return[True]   ];  {state, shot} = Fire[state];  If[shot,   Return[True]   ];  Return[False]  ]ClearAll[LLSFSF]LLSFSF[] := Module[{state, shot},  state = Unload[];  state = Load[state];  state = Load[state];  state = Spin[state];  {state, shot} = Fire[state];  If[shot,   Return[True]   ];  state = Spin[state];  {state, shot} = Fire[state];  If[shot,   Return[True]   ];  Return[False]  ]ClearAll[LLSFF]LLSFF[] := Module[{state, shot},  state = Unload[];  state = Load[state];  state = Load[state];  state = Spin[state];  {state, shot} = Fire[state];  If[shot,   Return[True]   ];  {state, shot} = Fire[state];  If[shot,   Return[True]   ];  Return[False]  ]n = 10^5;Count[Table[LSLSFSF[], n], True]/N[n]Count[Table[LSLSFF[], n], True]/N[n]Count[Table[LLSFSF[], n], True]/N[n]Count[Table[LLSFF[], n], True]/N[n]`
Output:
```0.55243
0.58272
0.55423
0.49975```

## Nim

`import algorithm, random, sequtils, strformat, strutils, tables type  Revolver = array[6, bool]  Action {.pure.} = enum Load, Spin, Fire, Error const Actions = {'L': Load, 'S': Spin, 'F': Fire}.toTable func spin(revolver: var Revolver; count: Positive) =  revolver.rotateLeft(-count) func load(revolver: var Revolver) =  while revolver:    revolver.spin(1)  revolver = true  revolver.spin(1) func fire(revolver: var Revolver): bool =  result = revolver  revolver.spin(1) proc test(scenario: string) =  let actions = scenario.mapIt(Actions.getOrDefault(it, Error))  var deaths = 0  var count = 100_000  for _ in 1..count:    var revolver: Revolver    for action in actions:      case action      of Load:        revolver.load()      of Spin:        revolver.spin(rand(1..6))      of Fire:        if revolver.fire():          inc deaths          break      of Error:        raise newException(ValueError, "encountered an unknown action.")  echo &"""{100 * deaths / count:5.2f}% deaths for scenario {actions.join(", ")}.""" randomize()for scenario in ["LSLSFSF", "LSLSFF", "LLSFSF", "LLSFF"]:  test(scenario)`
Output:
```55.73% deaths for scenario Load, Spin, Load, Spin, Fire, Spin, Fire.

## Perl

Translation of: Raku
`use strict;use warnings;use feature 'say'; my @cyl;my \$shots = 6; sub load  {    push @cyl, shift @cyl while \$cyl;    \$cyl = 1;    push @cyl, shift @cyl} sub spin  { push @cyl, shift @cyl for 0 .. int rand @cyl }sub fire  { push @cyl, shift @cyl; \$cyl } sub LSLSFSF {    @cyl = (0) x \$shots;    load, spin, load, spin;    return 1 if fire;    spin;    fire} sub LSLSFF {    @cyl = (0) x \$shots;    load, spin, load, spin;    fire or fire} sub LLSFSF {    @cyl = (0) x \$shots;    load, load, spin;    return 1 if fire;    spin;    fire} sub LLSFF {    @cyl = (0) x \$shots;    load, load, spin;    fire or fire} my \$trials = 10000; for my \$ref (<LSLSFSF LSLSFF LLSFSF LLSFF>) {    no strict 'refs';    my \$total = 0;    \$total += &\$ref for 1..\$trials;    printf "%7s %.2f%%\n", \$ref, \$total / \$trials * 100;}`
Output:
```LSLSFSF 55.04%
LSLSFF 58.77%
LLSFSF 55.09%
LLSFF 50.13%```

## Phix

`function spin(sequence revolver, integer count)    while count do        revolver = revolver[\$]&revolver[1..\$-1]        count -= 1    end while    return revolverend function function load(sequence revolver)    while revolver do        revolver = spin(revolver,1)     end while    revolver = true    revolver = spin(revolver,1)     return revolverend function bool dead = falsefunction fire(sequence revolver)    if revolver then dead = true end if    revolver = spin(revolver,1)     return revolverend function procedure test(string method)    integer deaths = 0,            limit = 100000    for n=1 to limit do        sequence revolver = repeat(false,6)        dead = false        for i=1 to length(method) do            integer ch = method[i]            switch ch              case 'L': revolver = load(revolver)              case 'S': revolver = spin(revolver,rand(6))              case 'F': revolver = fire(revolver)            end switch         end for        deaths += dead    end for    printf(1,"%s: %5.2f\n",{method,100*deaths/limit})end procedure printf(1,"Load/Spin/Fire method percentage fatalities:\n")papply({"LSLSFSF","LSLSFF","LLSFSF","LLSFF"},test)`
Output:
```Load/Spin/Fire method percentage fatalities:
LSLSFSF: 55.66
LSLSFF: 58.55
LLSFSF: 55.76
LLSFF: 49.97
```

## Python

`""" Russian roulette problem """import numpy as np class Revolver:    """ simulates 6-shot revolving cylinger pistol """     def __init__(self):        """ start unloaded """        self.cylinder = np.array([False] * 6)     def unload(self):        """ empty all chambers of cylinder """        self.cylinder[:] = False     def load(self):        """ load a chamber (advance til empty if full already), then advance once """        while self.cylinder:            self.cylinder[:] = np.roll(self.cylinder, 1)        self.cylinder = True     def spin(self):        """ spin cylinder, randomizing position of chamber to be fired """        self.cylinder[:] = np.roll(self.cylinder, np.random.randint(1, high=7))     def fire(self):        """ pull trigger of revolver, return True if fired, False if did not fire """        shot = self.cylinder        self.cylinder[:] = np.roll(self.cylinder, 1)        return shot     def LSLSFSF(self):        """ load, spin, load, spin, fire, spin, fire """        self.unload()        self.load()        self.spin()        self.load()        self.spin()        if self.fire():            return True        self.spin()        if self.fire():            return True        return False     def LSLSFF(self):        """ load, spin, load, spin, fire, fire """        self.unload()        self.load()        self.spin()        self.load()        self.spin()        if self.fire():            return True        if self.fire():            return True        return False     def LLSFSF(self):        """ load, load, spin, fire, spin, fire """        self.unload()        self.load()        self.load()        self.spin()        if self.fire():            return True        self.spin()        if self.fire():            return True        return False     def LLSFF(self):        """ load, load, spin, fire, fire """        self.unload()        self.load()        self.load()        self.spin()        if self.fire():            return True        if self.fire():            return True        return False  if __name__ == '__main__':     REV = Revolver()    TESTCOUNT = 100000    for (name, method) in [['load, spin, load, spin, fire, spin, fire', REV.LSLSFSF],                           ['load, spin, load, spin, fire, fire', REV.LSLSFF],                           ['load, load, spin, fire, spin, fire', REV.LLSFSF],                           ['load, load, spin, fire, fire', REV.LLSFF]]:         percentage = 100 * sum([method() for _ in range(TESTCOUNT)]) / TESTCOUNT        print("Method", name, "produces", percentage, "per cent deaths.") `
Output:
```Method load, spin, load, spin, fire, spin, fire produces 55.652 per cent deaths.
Method load, spin, load, spin, fire, fire produces 58.239 per cent deaths.
Method load, load, spin, fire, spin, fire produces 55.774 per cent deaths.
```

## Raku

`unit sub MAIN (\$shots = 6); my @cyl; sub load () {    @cyl.=rotate(-1) while @cyl;    @cyl = 1;    @cyl.=rotate(-1);} sub spin () { @cyl.=rotate: (^@cyl).pick } sub fire () { @cyl.=rotate; @cyl } sub LSLSFSF {    @cyl = 0 xx \$shots;    load, spin, load, spin;    return 1 if fire;    spin;    fire} sub LSLSFF {    @cyl = 0 xx \$shots;    load, spin, load, spin;    fire() || fire} sub LLSFSF {    @cyl = 0 xx \$shots;    load, load, spin;    return 1 if fire;    spin;    fire} sub LLSFF {    @cyl = 0 xx \$shots;    load, load, spin;    fire() || fire} my %revolver;my \$trials = 100000; for ^\$trials {    %revolver<LSLSFSF> += LSLSFSF;    %revolver<LSLSFF>  += LSLSFF;    %revolver<LLSFSF>  += LLSFSF;    %revolver<LLSFF>   += LLSFF;} say "{.fmt('%7s')}: %{(%revolver{\$_} / \$trials × 100).fmt('%.2f')}"  for <LSLSFSF LSLSFF LLSFSF LLSFF>`
Sample output (default; 6 shooter):
```LSLSFSF: %55.37
LSLSFF: %58.30
LLSFSF: %55.42
LLSFF: %50.29
```

Though if you go and look at the Wikipedia article for the 1895 Nagant revolver mentioned in the task reference section, you'll see it is actually a 7 shot revolver... so, run again with 7 chambers:

`raku roulette.raku 7`

Sample output (7 shooter):
```LSLSFSF: %49.29
LSLSFF: %51.14
LLSFSF: %48.74
LLSFF: %43.08```

Or, how about a Ruger GP100 10 round revolver?

`raku roulette.raku 10`

Sample output (10 shooter):
```LSLSFSF: %36.00
LSLSFF: %37.00
LLSFSF: %36.13
LLSFF: %29.77```

Doesn't change the answers, B (LSLSFF) is definitely the worst most likely choice in all cases.

## REXX

Translation of: GO

This REXX version eliminates the spinning of the bullet chamber if the random number for a spin is   6   (which would
normally just spin the bullet chamber around to its initial position,   thereby saving some busywork by the program).

Changing the cartridge chamber from an index array to a simple string made the program around   200%   faster.

`/*REXX pgm simulates scenarios for a two─bullet Russian roulette game with a 6 cyl. gun.*/parse arg cyls tests seed .                      /*obtain optional arguments from the CL*/if  cyls=='' |  cyls==","  then  cyls=      6    /*Not specified?  Then use the default.*/if tests=='' | tests==","  then tests= 100000    /* "      "         "   "   "     "    */if datatype(seed, 'W')  then call random ,,seed  /* "      "         "   "   "     "    */cyls_ = cyls - 1;          @0= copies(0, cyls)   /*shortcut placeholder for cylinders-1 */@abc= 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'               /*indices for the various options used.*/scenarios= 'LSLSFsF  LSLSFF  LLSFSF  LLSFF'      /*the list of scenarios to be tested.  */#= words(scenarios)                              /*the number of actions in a scenario. */                                                 /*The scenarios are case insensitive.  */        do m=1  for #;     q= word(scenarios, m) /*test each of the scenarios specified.*/                           sum= 0                /*initialize the  sum  to zero.        */           do tests;       sum= sum + method()   /*added the sums up for the percentages*/           end   /*tests*/                                    pc= left( (sum * 100 / tests)"%",  7)        say act()   '  (option'     substr(@abc, m, 1)")   produces  "    pc    ' deaths.'        end   /*m*/exit 0                                           /*stick a fork in it,  we're all done. *//*──────────────────────────────────────────────────────────────────────────────────────*/fire:   != left(@, 1);      @= right(@, cyls_)left(@, 1);   /* ◄──── next cyl.*/  return !load:   if left(@, 1)  then @= right(@, cyls_)left(@, 1);  @= 1||right(@, cyls_); returnspin:   ?= random(1, cyls);    if ?\==cyls  then @= substr(@ || @, ? + 1, cyls);  return/*──────────────────────────────────────────────────────────────────────────────────────*/method: @= @0;   do a=1  for length(q);          y= substr(q, a, 1)                 if y=='L'  then call load                            else if y=='S'  then call spin                                            else if y=='F'  then if fire()  then return 1                 end   /*a*/;                                                    return 0/*──────────────────────────────────────────────────────────────────────────────────────*/act:    \$=;      do a=1  for length(q);          y= substr(q, a, 1)                 if y=='L'  then \$= \$", load"                 if y=='S'  then \$= \$", spin"                 if y=='F'  then \$= \$", fire"                 end   /*a*/;                  return right( strip( strip(\$, , ",") ), 45)`
output   when using the default inputs,   showing that 2nd option   B   has the highest probability for a suicide:
```     load, spin, load, spin, fire, spin, fire   (option A)   produces   55.44%   deaths.
```

## Wren

Library: Wren-fmt
`import "random" for Randomimport "/fmt" for Fmt var Rand = Random.new() class Revolver {    construct new() {         _cylinder = List.filled(6, false)    }     rshift() {        var t = _cylinder[-1]        for (i in 4..0) _cylinder[i+1] = _cylinder[i]        _cylinder = t    }     unload() {        for (i in 0..5) _cylinder[i] = false    }     load() {        while (_cylinder) rshift()        _cylinder = true        rshift()    }     spin() {        for (i in 1..Rand.int(1, 7)) rshift()    }     fire() {        var shot = _cylinder        rshift()        return shot    }     method(s) {        unload()        for (c in s) {            if (c == "L") {                load()            } else if (c == "S") {                spin()            } else if (c == "F") {                if (fire()) return 1            }        }        return 0    }     static mstring(s) {        var l = []        for (c in s) {            if (c == "L") {                l.add("load")            } else if (c == "S") {                l.add("spin")            } else if (c == "F") {                l.add("fire")            }        }        return l.join(", ")    }} var rev = Revolver.new()var tests = 100000for (m in ["LSLSFSF", "LSLSFF", "LLSFSF", "LLSFF"]) {    var sum = 0    for (t in 1..tests) sum = sum + rev.method(m)    Fmt.print("\$-40s produces \$6.3f\% deaths.", Revolver.mstring(m), sum * 100 / tests)}`
Output:

Sample run:

```load, spin, load, spin, fire, spin, fire produces 55.500% deaths.