Penney's game: Difference between revisions

{{trans|Python}}

V you = ‘’

print("\n I win!")

L.break

{{out}}

=={{header|AutoHotkey}}==

Gui, add, text, w90, Computer:

loop, 3

gosub, RandomStart

return

=={{header|BASIC}}==

==={{header|BASIC256}}===

{{trans|FreeBASIC}}

global jugador, computador, secuencia

jugador = "" : computador = ""

print "¡Gracias por jugar!"

end

==={{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>

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

{{works with|C sharp|7}}

using static System.Threading.Thread;

using System;

}

{{out}}

<pre style="height:30ex;overflow:scroll">

=={{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}}

=={{header|Common Lisp}}==

{{trans|UNIX Shell}}

(defparameter *heads* #\H)

(coerce my-list 'string)))

{{Out}}

=={{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>

=={{header|FreeBASIC}}==

{{trans|BBC BASIC}}

Sub Jugador_elige(secuencia As String)

Dim As String eleccion

Sleep

End

=={{header|Go}}==

package main

import "fmt"

}

}

Output:

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

=={{header|Nim}}==

{{trans|Python}}

randomize()

echo "\n I win!"

break

{{out}}

=={{header|Pascal}}==

TYPE

readln

{{out}}

=={{header|Perl}}==

#!usr/bin/perl

use 5.020;

}

}

{{out}}

<pre>

{{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>

=={{header|Prolog}}==

game(h) :-

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

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

Output:

=={{header|Python}}==

import random

from time import sleep

print('\n I win!')

break

{{out}}

=={{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}}

{{works with|Rakudo|2018.02}}

enum Yay <Yay Good Super Hah Ooh Yipee Sweet Cool Yes Haha>;

enum Boo <Drat Darn Crumb Oops Rats Bah Criminy Argh Shards>;

print "$_ ";

}

{{out}}

Note: the actual run displays a little coin-flipping animation, but that won't show up here:

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

__= copies('─', 9) /*literal for eye─catching fence. */

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

do until g\==@.CBLF!; g= r(#); end /*otherwise, generate a choice. */

@.comp= translate(g, 'HT', 10)

{{out|output|text=&nbsp; of a six-game session &nbsp; (ended by user entering a '''quit'''):}}

<pre>

=={{header|Ruby}}==

def yourChoice

print " #{seq[-1]}"

end

{{out}}

=={{header|Rust}}==

extern crate rand;

}

{{out}}

<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() {

printf $'Penney\'s Game\n\n'

main "$@"

{{Output}}

=={{header|VBA}}==

Option Explicit

End If

End If

{{out}}

<pre>You start

{{trans|Kotlin}}

{{libheader|Wren-str}}

import "io" for Stdin, Stdout

import "timer" for Timer

}

Timer.sleep(2000) // wait two seconds for next flip

{{out}}

=={{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>