100 prisoners: Difference between revisions

{{trans|Python}}

 

V pardoned = 0

V in_drawer = Array(0.<100)

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program prisonniex64.s */

</pre>

 

=={{header|Ada}}==

package Prisoners is

 

end Prisoners;

</syntaxhighlight>

pragma Ada_2012;

with Ada.Numerics.Discrete_Random;

end Prisoners;

</syntaxhighlight>

with Prisoners; use Prisoners;

with Ada.Text_IO; use Ada.Text_IO;

Random Strategy = 0.00%

</pre>

=={{header|APL}}==

{{works with|GNU APL|1.8}}

 

∇ R ← random Nnc; N; n; c

(N n c) ← Nnc

∇

 

 

</syntaxhighlight>

 

=={{header|Applesoft BASIC}}==

Actual test of 4000 trials for each method were run on the KEGSMAC emulator with MHz set to No Limit.

 

 

1 FOR X = 0 TO N:J(X) = X: NEXT: FOR I = 0 TO N:FOR X = 0 TO N:T = J(X):NP = INT ( RND (1) * H):J(X) = J(NP):J(NP) = T: NEXT :FOR G = 1 TO W:IF D(J(G)) = I THEN IP = IP + 1: NEXT I: RETURN

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program prisonniers.s */

Optimal strategie : 303 sur 1000

</pre>

=={{header|AutoHotkey}}==

randomFailTotal := 0, strategyFailTotal := 0

prisoners := [], drawers := [], Cards := []

Random Trials : 0.000000 % success rate</pre>

 

{{works with|BASIC256|2.0.0.11}}

O = 50

N = 2*O

Observed ratio: 0.3052, expected ratio with N=2*O: greater than about 0.30685

</pre>

 

=={{header|BCPL}}==

 

manifest $(

 

=={{header|C}}==

#include<stdbool.h>

#include<stdlib.h>

=={{header|C sharp|C#}}==

{{trans|D}}

using System.Linq;

 

 

=={{header|C++}}==

#include <algorithm> // for random_shuffle

#include <iostream> // for output

 

=={{header|Clojure}}==

 

(defn random-drawers []

 

=={{header|CLU}}==

% to use the random number generator.

%

The key here is avoiding the use of GOTO as a means of exiting a loop early.

 

10 rem 100 prisoners

20 rem set arrays

{{trans|Racket}}

 

(defparameter *samples* 10000)

(defparameter *prisoners* 100)

=={{header|Cowgol}}==

 

include "argv.coh";

 

Based on the Ruby implementation

 

N = 100_000

generate_rooms = ->{ (1..100).to_a.shuffle }

=={{header|D}}==

{{trans|Kotlin}}

import std.random;

import std.range;

Optimal play success rate: 31.16100000%

Random play success rate: 0.00000000%</pre>

=={{header|Delphi}}==

See [[#Pascal]].

=={{header|EasyLang}}==

.

subr shuffle_drawer

.

subr play_random

.

.

subr play_optimal

.

.

n = 10000

.

.

{{out}}

<pre>

random: 0.000%

optimal: 30.800%

</pre>

 

=={{header|Elixir}}==

{{trans|Ruby}}

def optimal_room(_, _, _, []), do: []

def optimal_room(prisoner, current_room, rooms, [_ | tail]) do

 

=={{header|F sharp|F#}}==

let shuffled min max =

[|min..max|] |> Array.sortBy (fun _ -> rnd.Next(min,max+1))

 

=={{header|Factor}}==

 

: setup ( -- seq seq ) 100 <iota> dup >array randomize ;

=={{header|FOCAL}}==

 

01.20 F Z=1,2000;D 5;S CU=CU+SU

01.30 T CU/20,!,"OPTIMAL";S CU=0

Run the two strategies (random and follow the card number) 10,000 times each, and show number or successes.

 

 

100 CONSTANT #drawers

 

=={{header|Fortran}}==

! Takes an input array and shuffles the elements by swapping them

! in pairs in turn 10 times

 

=={{header|FreeBASIC}}==

 

function gus( i as long, strat as boolean ) as long

 

print using "For prisoners using the strategy we had ####### successes and ####### failures.";c_success;c_fail</syntaxhighlight>

 

=={{header|Gambas}}==

Implementation of the '100 Prisoners' program written in VBA. Tested in Gambas 3.15.2

 

Public DrawerArray As Long[]

Trials/sec: 114.9</pre>

 

 

=={{header|Go}}==

 

import (

=={{header|Groovy}}==

{{trans|Java}}

import java.util.stream.Collectors

import java.util.stream.IntStream

 

=={{header|Haskell}}==

import Control.Monad.State

 

 

=={{header|J}}==

NB. game is solvable by optimal strategy when the length (#) of the

NB. longest (>./) cycle (C.) is at most 50.

 

=={{header|Janet}}==

(math/seedrandom (os/cryptorand 8))

 

=={{header|Java}}==

{{trans|Kotlin}}

import java.util.List;

import java.util.Objects;

{{trans|C#}}

{{Works with|Node.js}}

const _ = require('lodash');

 

{{works with|JavaScript|Node.js 16.13.0 (LTS)}}

 

 

// Simulate several thousand instances of the game:

 

jq does not have a built-in PRNG and so the jq program used here presupposes an external source of entropy such as /dev/urandom. The output shown below was obtained by invoking jq as follows:

< /dev/urandom tr -cd '0-9' | fold -w 1 | jq -MRcnr -f 100-prisoners.jq</syntaxhighlight>

 

 

'''Preliminaries'''

 

# Output: a PRN in range(0;$n) where $n is .

 

'''np Prisoners'''

def optimalStrategy($drawers; np):

# Does prisoner $p succeed?

=={{header|Julia}}==

{{trans|Python}}

 

function randomplay(n, numprisoners=100)

Random play wins: 0.00000000% of simulations.

Optimal play wins: 31.18100000% of simulations.

</pre>

 

=={{header|Kotlin}}==

val secrets = (0..99).toMutableList()

var ret = true

=={{header|Lua}}==

{{trans|lang}}

for i = #tbl, 2, -1 do

local j = math.random(i)

 

Don"t bother to simulate the random method: each prisoner has a probability p to win with:

# p=1/2</syntaxhighlight>

 

Since all prisoners' attempts are independent, the probability that they all win is:

 

evalf(%);

 

Here is a simulation based on this, assuming that the permutation of numbers in boxes is random:

 

nops(select(n->n<=50,a))/nops(a);

evalf(%);

It can be [https://en.wikipedia.org/wiki/Random_permutation_statistics#One_hundred_prisoners proved] that the probability with the second strategy is in fact:

 

evalf(%);

 

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

PlayRandom[n_] :=

Module[{pardoned = 0, sampler, indrawer, found, reveal},

 

=={{header|MATLAB}}==

%numP is the number of prisoners

%numG is the number of guesses

=={{header|MiniScript}}==

{{trans|Python}}

// using 0-99 instead of 1-100

pardoned = 0

=={{header|Nim}}==

Imperative style.

 

type

{{works with|Free Pascal}}

searching the longest cycle length as stated on talk page and increment an counter for that cycle length.

 

const

Randomly 0.00% get pardoned out of 100000 checking max 0</pre>

=== Alternative for optimized ===

{$IFDEF FPC}

{$MODE DELPHI}{$OPTIMIZATION ON,ALL}

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

Built so you could easily build and test your own strategies.

 

(by '(NIL (rand)) sort Lst) )

 

 

Then run

(test-strategy-n-times '+Optimal 10000)</syntaxhighlight>

 

 

=={{header|Phix}}==

{{out}}

<pre>

=={{header|Phixmonti}}==

{{trans|Yabasic}}

by Galileo, 05/2022 #/

 

 

=={{header|PL/M}}==

/* PARAMETERS */

DECLARE N$DRAWERS LITERALLY '100'; /* AMOUNT OF DRAWERS */

 

=={{header|Pointless}}==

iterate(ind => drawers[ind - 1], n)

|> takeUntil(ind => drawers[ind - 1] == n)

=={{header|PowerShell}}==

{{trans|Chris}}

### Clear Screen from old Output

Clear-Host

 

=={{header|Processing}}==

int trials = 100000;

int succes_count;

 

=={{header|PureBasic}}==

#DRAWERS =100

#LOOPS = 50

=={{header|Python}}==

===Procedural===

 

def play_random(n):

 

Or, an alternative procedural approach:

 

import random

 

{{Works with|Python|3.7}}

 

from random import randint, sample

 

=={{header|R}}==

success.r = rep(0,t) #this will keep track of how many prisoners find their ticket on each trial for the random method

success.o = rep(0,t) #this will keep track of how many prisoners find their ticket on each trial for the optimal method

 

=={{header|QB64}}==

Const Found = -1, Searching = 0, Status = 1, Tries = 2

Const Attempt = 1, Victories = 2, RandomW = 1, ChainW = 2

 

=={{header|Quackery}}==

 

[ dup size 2 / split ] is halve ( [ --> [ [ )

 

'''Output:'''

... simulate

...

 

=={{header|Racket}}==

(require srfi/1)

 

Also test with 10 prisoners to verify that the logic is correct for random selection. Random selection should succeed with 10 prisoners at a probability of (1/2)**10, so in 100_000 simulations, should get pardons about .0977 percent of the time.

 

my @prisoners = ^$prisoners;

my $half = floor +@prisoners / 2;

</pre>

=={{header|Red}}==

Red []

 

 

=={{header|REXX}}==

parse arg men trials seed . /*obtain optional arguments from the CL*/

if men=='' | men=="," then men= 100 /*number of prisoners for this run.*/

 

=={{header|Ruby}}==

N = 10_000

generate_rooms = ->{ [nil]+[*1..100].shuffle }

 

Cargo.toml

rand = '0.7.2'</syntaxhighlight>

 

src/main.rs

 

use rand::prelude::*;

 

=={{header|Sather}}==

shuffle (a: ARRAY{INT}) is

ARR_PERMUTE_ALG{INT, ARRAY{INT}}::shuffle(a);

=={{header|Scala}}==

{{trans|Java}}

import scala.util.control.Breaks._

 

Optimal play success rate: 31.201000%

Random play success rate: 0.000000%</pre>

 

=={{header|Swift}}==

 

 

struct PrisonersGame {

=={{header|Tcl}}==

{{trans|Common Lisp}}

set Prisoners 100

set MaxGuesses 50

{{works with|Transact-SQL|SQL Server 2017}}

 

GO

 

Probability of success with "random" strategy: 0.00

Probability of success with "optimal" strategy: 31.00</pre>

 

=={{header|VBA}}/{{header|Visual Basic}}==

 

 

NumberOfPrisoners = Int(InputBox("Number of Prisoners", "Prisoners", 100))

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Function PlayOptimal() As Boolean

 

=={{header|VBScript}}==

option explicit

const npris=100

</pre>

 

{{trans|Wren}}

import rand.seed

// Uses 0-based numbering rather than 1-based numbering throughout.

{{trans|Go}}

{{libheader|Wren-fmt}}

 

var rand = Random.new()

}

if (!nextPrisoner) {

}

}

 

=={{header|XPL0}}==

 

proc KShuffle; \Randomly rearrange the cards in the drawers

=={{header|Yabasic}}==

{{trans|Phix}}

// by Galileo, 05/2022

 

Prisoners: 100, random: 0, optimal: 31.2

---Program done, press RETURN---</pre>

 

=={{header|zkl}}==

fcn oneHundredJDI{ // just do it strategy

cupboard,picks := [0..SLOTS-1].walk().shuffle(), cupboard.copy();

True // all found their number

}</syntaxhighlight>

println("Just do it strategy (%,d simulatations): %.2f%%".fmt(N,s));

 

</pre>

And a sanity check (from the Raku entry):

{{out}}

<pre>