Penney's game: Difference between revisions

* [https://www.youtube.com/watch?v=U9wak7g5yQA The Penney Ante Part 2] (Video).

<br><br>

 

=={{header|BASIC}}==

==={{header|Sinclair ZX81 BASIC}}===

Works with 1k of RAM.

20 PRINT "YOU PICK FIRST."

30 INPUT P$

290 PRINT "YOU WIN"

300 STOP

{{out}}

<pre>YOU PICK FIRST.

 

=={{header|Batch File}}==

::Penney's Game Task from Rosetta Code Wiki

::Batch File Implementation

if /i "!you_bet!"=="%cpu_bet%" (echo [Bet something different...]&echo.&goto %1)

for %%i in ("t=T" "h=H") do set "you_bet=!you_bet:%%~i!"

{{out}}

Note: The outputs of tosses are 'delayed' just to make the game a little more dramatic.

 

=={{header|BBC BASIC}}==

PRINT "*** Penney's Game ***"

REPEAT

ELSE

= "H" + LEFT$(sequence$, 2)

{{out}}

<pre>*** Penney's Game ***

=={{header|C}}==

This solution stores the sequences in bit-packed integers. With minor adjustments, this can be extended to allow larger sequence lengths beyond the required 3. However, the ai's algorithm for the perfect choice would need to be altered. More robust methods of input could be chosen, as scanf is generally fairly unsafe. A safer alternative would be to use something like fgets, and parse the input string ourselves.

#include <stdio.h>

#include <stdlib.h>

return 0;

}

{{out}}

<pre>

 

</pre>

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

#include <time.h>

#include <iostream>

return 0;

}

{{out}}

<pre>

 

=={{header|Clojure}}==

(:gen-class))

 

(println "Penney's Game.")

(play-game {:first-player (flip-coin)

 

{{out}}

Thanks for playing!

</pre>

 

=={{header|D}}==

{{trans|Python}}

import std.stdio, std.random, std.algorithm, std.string,

std.conv, std.range, core.thread;

Thread.sleep(1.seconds);

}

The output is the same as the Python entry.

 

=={{header|Elixir}}==

{{trans|Ruby}}

@toss [:Heads, :Tails]

end

 

 

{{out}}

 

=={{header|Factor}}==

strings ;

IN: rosetta-code.penneys-game

[ computer-first human-second ] if flip-coins ;

{{out}}

<pre>

The computer won.

</pre>

 

=={{header|Go}}==

package main

import "fmt"

}

}

Output:

<pre>

Do you want to continue(0/1):

</pre>

=={{header|Haskell}}==

import System.IO

import System.Random

stdgen <- getStdGen

let (cpuFirst, genA) = random stdgen

{{out}}

<pre>

=={{header|J}}==

'''Solution:'''

 

randomize '' NB. randomize seed for new session

'Toss sequence is %s' printf < (3 + <./ Result) {. Tosses

echo ('No result';'You win!';'Computer won!') {::~ *-/ Result

'''Usage:'''

Computer chose TTT

Choose a sequence of three coin tosses (H/T):

Computer chose HHT

Toss sequence is HTHTT

 

=={{header|Java}}==

 

public class PenneysGame {

return s;

}

 

<pre>Computer chooses HTH

=={{header|Julia}}==

'''Functions'''

const SLEN = 3

 

return b

end

 

'''Game Setup'''

println("Playing Penney's Game Against the computer.")

 

print(@sprintf "You bet %s " pgdecode(human))

println(@sprintf "and the computer bet %s." pgdecode(mach))

 

'''Game Play'''

pg = randbool(SLEN)

pgtail = copy(pg)

println("so you won.")

end

 

{{output}}

 

=={{header|Kotlin}}==

 

import java.util.Random

}

}

 

Sample game where computer goes first:

 

=={{header|Lua}}==

function penny_game()

local player, computer = "", ""

r = io.read()

until( r == "N" or r == "n" )

{{out}}

<pre>

 

=={{header|MiniScript}}==

if rnd < 0.5 then return "T" else return "H"

end function

end if

wait

 

{{out}}

H

I win!</pre>

 

=={{header|Pascal}}==

 

TYPE

readln

 

 

{{out}}

 

=={{header|Perl}}==

#!usr/bin/perl

use 5.020;

}

}

{{out}}

<pre>

The computer wins!

</pre>

 

=={{header|Phix}}==

{{trans|C}}

Robert's robot's name is Robort.

return substitute_all(sprintf("%03b",pick),"10","HT")

end function

end procedure

{{out}}

<pre>

 

=={{header|PicoLisp}}==

 

(setq *S (list 0 0))

(= "N" (uppc (in NIL (char)))) ) ) ) )

 

{{out}}

<pre>

</pre>

 

 

game(h) :-

coin(0,h). coin(1,t).

coin_s(h, 'H'). coin_s(t, 'T').

Output:

</pre>

 

import random

from time import sleep

print('\n I win!')

break

 

{{out}}

You win!

>>> </pre>

 

=={{header|R}}==

# Penney's Game Task from Rosetta Code Wiki

# R implementation

}

}

{{out}}

Human first.

This does what's required of it from the task... just don't input anything outside the alphabet "htHT" for the human move.

 

;; Penney's Game. Tim Brown 2014-10-15

(define (flip . _) (match (random 2) (0 "H") (1 "T")))

(printf "~a chooses: ~a~%" (car p1) (flips->string (cdr p1)))

(values p1 (cons 'Hom-Sap (get-human-sequence)))]))

 

{{out}}

</pre>

(Nail-biting stuff!)

 

=={{header|REXX}}==

 

A feature also added was to allow a seed for the &nbsp; '''random''' &nbsp; BIF to allow repeatability for a game.

signal on halt /*a clean way out if CLBF quits. */

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

if datatype(seed,'W') then call random ,,seed /*use seed for RANDOM #s repeatability.*/

wins=0; do games=1 /*simulate a number of Penney's games. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

halt: say; say __ "Penney's Game was halted."; say; exit 13

s: if arg(1)==1 then return arg(3); return word(arg(2) 's',1) /*pluralizer.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

game: @.=; tosses=@. /*the coin toss sequence so far. */

if \toss1 then call randComp /*maybe let the computer go first*/

if toss1 then say __ "You win the first toss, so you pick your sequence first."

say __ "computer's pick:" @.comp /* " comp.'s " " " */

say /* [↓] flip the coin 'til a win.*/

end /*flips*/ /* [↑] this is a flipping coin,*/

/* [↓] series of tosses*/

_=wins; if _==0 then _='no'

say __ "You've won" _ "game"s(wins) 'out of ' games"."

return

/*──────────────────────────────────────────────────────────────────────────────────────*/

p=__ 'Pick a sequence of' # "coin tosses of H or T (Heads or Tails) or Quit:"

do until ok; say; say p; pull a /*uppercase the answer. */

select /*verify the user response. */

end /*select*/

end /*until ok*/

return

/*──────────────────────────────────────────────────────────────────────────────────────*/

randComp: if @.comp\=='' then return /*the computer already has a pick*/

<pre>

───────── The computer won first toss, the pick was: HHH

</pre>

 

 

def yourChoice

print " #{seq[-1]}"

end

 

{{out}}

Heads Heads Tails Heads Tails Heads Tails Tails Tails Tails Tails Tails Tails Heads Heads

You win!

</pre>

 

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

 

oo::class create Player {

}

 

{{out|Sample Game}}

<!-- Huh! This was a long one… -->

=={{header|UNIX Shell}}==

{{works with|Bash}}

main() {

 

if [[ $(flip) == H ]]; then

p2=$(choose_sequence)

else

fi

 

while true; do

case "$p1" in

esac

done

 

p2=$(choose_sequence "$p1")

fi

 

 

while true; do

flip=$(flip)

flips+=$flip

case "$flips" in

esac

done

if (( $# )); then

case "$1" in

*) result=H;;

esac

result=$(flip)$(flip)$(flip)

fi

}

 

flip() {

else

fi

}

 

 

{{Output}}

 

Human first:

Flipping to see who goes first ... You do.

 

I win!</pre>

=={{header|VBA}}==

Option Explicit

 

End If

End If

{{out}}

<pre>You start

 

Game over</pre>

 

=={{header|zkl}}==

reg myBet, yourBet;

if(coinToss()=="H"){ // The toss says I go first

if(Void!=coins.find(myBet)) { println(" I win!"); break; }

// ignore we both won

{{out}}

<pre>