Rock-paper-scissors: Difference between revisions
m
→{{header|Wren}}: Minor tidy
m (→{{header|Wren}}: Minor tidy) |
|||
| (116 intermediate revisions by 44 users not shown) | |||
Line 1:
{{task|Games}}
;Task:
Implement the classic children's game [[wp:Rock-paper-scissors|Rock-paper-scissors]], as well as a simple predictive '''AI''' (<u>a</u>rtificial <u>i</u>ntelligence) player.
Rock Paper Scissors is a two player game.
Each player chooses one of rock, paper or scissors, without knowing the other player's choice.
The winner is decided by a set of rules:
:::* Rock beats scissors
:::* Scissors beat paper
:::* Paper beats rock
<br>
If both players choose the same thing, there is no winner for that round.
For this task, the computer will be one of the players.
The operator will select Rock, Paper or Scissors and the computer will keep a record of the choice frequency, and use that information to make a [[Probabilistic choice|weighted random choice]] in an attempt to defeat its opponent.
;Extra credit:
Support additional choices [[wp:Rock-paper-scissors#Additional_weapons|additional weapons]].
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">V rules = [‘rock’ = ‘paper’, ‘scissors’ = ‘rock’, ‘paper’ = ‘scissors’]
V previous = [‘rock’, ‘paper’, ‘scissors’]
L
V human = input("\nchoose your weapon: ")
V computer = rules[random:choice(previous)]
I human C (‘quit’, ‘exit’)
L.break
E I human C rules
previous.append(human)
print(‘the computer played ’computer, end' ‘; ’)
I rules[computer] == human
print(‘yay you win!’)
E I rules[human] == computer
print(‘the computer beat you... :(’)
E
print(‘it's a tie!’)
E
print(‘that's not a valid choice’)</syntaxhighlight>
{{out}}
<pre>
choose your weapon: rock
the computer played paper; the computer beat you... :(
choose your weapon: rock
the computer played scissors; yay you win!
choose your weapon: rock
the computer played paper; the computer beat you... :(
choose your weapon: rock
the computer played paper; the computer beat you... :(
choose your weapon: rock
the computer played rock; it's a tie!
</pre>
=={{header|Ada}}==
<
procedure Rock_Paper_Scissors is
Line 120 ⟶ 180:
Ada.Text_IO.Put_Line(Result'Image(R) & Natural'Image(Score(R)));
end loop;
end Rock_Paper_Scissors;</
First and last few lines of the output of a game, where the human did permanently choose Rock:
Line 168 ⟶ 228:
=={{header|Aime}}==
<
computer_play(record plays, record beats)
{
integer a, c, total;
text s;
total =
a = drand(total - 1);
break;
}
a -=
}
}
Line 196 ⟶ 254:
text s;
computer = human = 0;
while (1) {
o_text("Your choice [rock/paper/scissors]:\n");
if
break;
}
if (!
o_text("Invalid choice, try again\n");
} else {
Line 224 ⟶ 281:
o_form("Human: ~, Computer: ~\n", s, c);
if
o_text("Draw\n");
} elif
computer += 1;
o_text("Computer wins\n");
Line 234 ⟶ 291:
}
o_form("Score: Human: ~, Computer: ~\n", human, computer);
Line 241 ⟶ 298:
return 0;
}</
=={{header|ALGOL 68}}==
<syntaxhighlight lang="algol68">BEGIN
# rock/paper/scissors game #
# counts of the number of times the player has chosen each move #
# we initialise each to 1 so that the total isn't zero when we are #
# choosing the computer's first move (as in the Ada version) #
INT r count := 1;
INT p count := 1;
INT s count := 1;
# counts of how many games the player and computer have won #
INT
INT
print( ( "rock/paper/scissors", newline, newline ) );
WHILE
# get the players move - r => rock, p => paper, s => scissors #
# q => quit #
WHILE
print( ( "Please
AND player move /= "
AND player move /= "q"
)
DO
print( ( "Unrecognised move", newline ) )
OD;
# continue playing until the player chooses quit #
player move /= "q"
DO
CHAR computer move;
INT move count = r count + p count + s count;
# is in the range 0 .. rock / total #
# predict player will play paper if the random number #
# is in the range rock / total .. ( rock + paper ) / total #
# predict player will play scissors otherwise #
REAL r limit = r count / move count;
REAL p limit = r limit + ( p count / move count );
IF random move < r limit THEN
computer move := "p"
ELSE
#
computer move := "r"
FI;
print( ( "You chose: " + player move, newline ) );
print( ( "I chose: " + computer move, newline ) );
IF player move = computer move THEN
# both players chose the same - draw #
print( ( "
ELSE
# players chose different moves - there is a winner #
OR ( player move = "p" AND computer move = "r" )
OR ( player move = "s" AND computer move = "p" )
THEN
player count +:= 1;
print( ( "You win", newline ) )
ELSE
computer count +:= 1;
print( ( "I win", newline ) )
FI;
print( ( "You won: "
, whole( player count , 0 )
, ", I won: "
, whole( computer count, 0 )
, newline
)
)
FI;
IF player move = "r" THEN
# player chose rock #
r count +:= 1
ELIF player move = "p" THEN
# player chose paper #
p count +:= 1
ELSE
# player chose scissors #
s count +:= 1
FI
OD;
print( ( "Thanks for a most enjoyable game", newline ) )
END</syntaxhighlight>
=={{header|AutoHotkey}}==
<
Write("Welcome to Rock-Paper-Scissors`nMake a choice: ")
Line 444 ⟶ 436:
Write(txt){
FileAppend, % txt, CONOUT$
}</
=={{header|AutoIt}}==
Line 450 ⟶ 442:
I´ve created a GUI to play and show results, no Console Input
<
RPS()
Line 544 ⟶ 536:
EndFunc ;==>_RPS_Eval
</syntaxhighlight>
=={{header|Bash}}==
<syntaxhighlight lang="bash">#!/bin/bash
echo "What will you choose? [rock/paper/scissors]"
read response
aiThought=$(echo $[ 1 + $[ RANDOM % 3 ]])
case $aiThought in
1) aiResponse="rock" ;;
2) aiResponse="paper" ;;
3) aiResponse="scissors" ;;
esac
echo "AI - $aiResponse"
responses="$response$aiResponse"
case $responses in
rockrock) isTie=1 ;;
rockpaper) playerWon=0 ;;
rockscissors) playerWon=1 ;;
paperrock) playerWon=1 ;;
paperpaper) isTie=1 ;;
paperscissors) playerWon=0 ;;
scissorsrock) playerWon=0 ;;
scissorspaper) playerWon=1 ;;
scissorsscissors) isTie=1 ;;
esac
if [[ $isTie == 1 ]] ; then echo "It's a tie!" && exit 1 ; fi
if [[ $playerWon == 0 ]] ; then echo "Sorry, $aiResponse beats $response , try again.." && exit 1 ; fi
if [[ $playerWon == 1 ]] ; then echo "Good job, $response beats $aiResponse!" && exit 1 ; fi</syntaxhighlight>
=={{header|BASIC}}==
{{works with|QBasic}}
<
DIM choices(1 TO 3) AS STRING
DIM playerwins(1 TO 3) AS INTEGER
Line 610 ⟶ 629:
PRINT , choices(1), choices(2), choices(3)
PRINT "You chose:", pPLchoice(1), pPLchoice(2), pPLchoice(3)
PRINT " I chose:", pCMchoice(1), pCMchoice(2), pCMchoice(3)</
A sample game:
Line 633 ⟶ 652:
You chose: 60 0 1
I chose: 2 55 4
=={{header|Batch File}}==
<syntaxhighlight lang="dos">@echo off
setlocal enabledelayedexpansion
set choice1=rock
set choice2=paper
set choice3=scissors
set freq1=0
set freq2=0
set freq3=0
set games=0
set won=0
set lost=0
set tie=0
:start
cls
echo Games - %games% : Won - %won% : Lost - %lost% : Ties - %tie%
choice /c RPS /n /m "[R]ock, [P]aper or [S]cissors? "
set choice=%errorlevel%
rem used [1,1000] as interval for random
if %games% equ 0 (
rem at the beginning, there's no bias for each choice
set /a "rocklimit=1000 / 3"
set /a "scissorslimit=1000 * 2 / 3"
) else (
set /a "rocklimit=1000 * %freq3% / %games%"
set /a "scissorslimit=1000 * (%freq1% + %freq3%) / %games%"
)
set /a "randchoice=%random% %% 1000 + 1"
set compchoice=2
if %randchoice% geq %scissorslimit% set compchoice=3
if %randchoice% leq %rocklimit% set compchoice=1
cls
echo Player: !choice%choice%! ^|vs^| Computer: !choice%compchoice%!
goto %compchoice%
:1
if %choice%==1 goto tie
if %choice%==2 goto win
if %choice%==3 goto loss
:2
if %choice%==1 goto loss
if %choice%==2 goto tie
if %choice%==3 goto win
:3
if %choice%==1 goto win
if %choice%==2 goto loss
if %choice%==3 goto tie
:win
set /a "won+=1"
echo Player wins^!
goto end
:loss
set /a "lost+=1"
echo Computer Wins^!
goto end
:tie
set /a "tie+=1"
echo Tie^!
goto end
:end
set /a "games+=1"
set /a "freq%choice%+=1"
pause
goto start</syntaxhighlight>
=={{header|BBC BASIC}}==
<
PRINT "Each player guesses one of these three, and reveals it at the same time."
PRINT "Rock blunts scissors, which cut paper, which wraps stone."
Line 680 ⟶ 774:
IF r%<=p%(0) THEN =1
IF r%<=p%(0)+p%(1) THEN =2
=0</
Sample output:
Line 710 ⟶ 804:
=={{header|C}}==
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#define LEN 3
/* pick a random index from 0 to n-1, according to probablities listed
in p[] which is assumed to have a sum of 1. The values in the probablity
list matters up to the point where the sum goes over 1 */
int rand_idx(double *p, int n)
{
int
return i;
}
Line 739 ⟶ 827:
char str[2];
const char *winner[] = { "We tied.", "Meself winned.", "You win." };
double p[LEN] = { 1./3, 1./3, 1./3 };
while (1) {
my_action = rand_idx(
printf("\nYour choice [1-3]:\n"
" 1. Rock\n 2. Paper\n 3. Scissors\n> ");
/* scanf is a terrible way to do input. should use stty and keystrokes */
if (!scanf("%d", &user_action)) {
scanf("%1s", str);
if (*str == 'q')
printf("Your choices [rock : %d , paper : %d , scissors %d] ",user_rec[0],user_rec[1], user_rec[2]);
return 0;
}
continue;
}
Line 760 ⟶ 852:
names[user_action], names[my_action],
winner[(my_action - user_action + 3) % 3]);
user_rec[user_action]++;
}
}
</syntaxhighlight>
Here's another code: (Does it using a while loop)
<syntaxhighlight lang="c">
#include <stdio.h> // Standard IO
#include <stdlib.h> // other stuff
Line 870 ⟶ 963:
}
}
</syntaxhighlight>
=={{header|C sharp}}==
<
using System.Collections.Generic;
using System.Linq;
Line 1,246 ⟶ 1,139:
}
}
}</
Sample output of first 2 and last 2 rounds when player chooses rock every turn:
Line 1,279 ⟶ 1,172:
Losses: 60
Draws: 1
</pre>
=={{header|C++}}==
Version using Additional Weapons
<syntaxhighlight lang="cpp">
#include <windows.h>
#include <iostream>
#include <string>
//-------------------------------------------------------------------------------
using namespace std;
//-------------------------------------------------------------------------------
enum choices { ROCK, SPOCK, PAPER, LIZARD, SCISSORS, MX_C };
enum indexes { PLAYER, COMPUTER, DRAW };
//-------------------------------------------------------------------------------
class stats
{
public:
stats() : _draw( 0 )
{
ZeroMemory( _moves, sizeof( _moves ) );
ZeroMemory( _win, sizeof( _win ) );
}
void draw() { _draw++; }
void win( int p ) { _win[p]++; }
void move( int p, int m ) { _moves[p][m]++; }
int getMove( int p, int m ) { return _moves[p][m]; }
string format( int a )
{
char t[32];
wsprintf( t, "%.3d", a );
string d( t );
return d;
}
void print()
{
string d = format( _draw ),
pw = format( _win[PLAYER] ), cw = format( _win[COMPUTER] ),
pr = format( _moves[PLAYER][ROCK] ), cr = format( _moves[COMPUTER][ROCK] ),
pp = format( _moves[PLAYER][PAPER] ), cp = format( _moves[COMPUTER][PAPER] ),
ps = format( _moves[PLAYER][SCISSORS] ), cs = format( _moves[COMPUTER][SCISSORS] ),
pl = format( _moves[PLAYER][LIZARD] ), cl = format( _moves[COMPUTER][LIZARD] ),
pk = format( _moves[PLAYER][SPOCK] ), ck = format( _moves[COMPUTER][SPOCK] );
system( "cls" );
cout << endl;
cout << "+----------+-------+--------+--------+---------+----------+--------+---------+" << endl;
cout << "| | WON | DRAW | ROCK | PAPER | SCISSORS | LIZARD | SPOCK |" << endl;
cout << "+----------+-------+--------+--------+---------+----------+--------+---------+" << endl;
cout << "| PLAYER | " << pw << " | | " << pr << " | " << pp << " | " << ps << " | " << pl << " | " << pk << " |" << endl;
cout << "+----------+-------+ " << d << " +--------+---------+----------+--------+---------+" << endl;
cout << "| COMPUTER | " << cw << " | | " << cr << " | " << cp << " | " << cs << " | " << cl << " | " << ck << " |" << endl;
cout << "+----------+-------+--------+--------+---------+----------+--------+---------+" << endl;
cout << endl << endl;
system( "pause" );
}
private:
int _moves[2][MX_C], _win[2], _draw;
};
//-------------------------------------------------------------------------------
class rps
{
private:
int makeMove()
{
int total = 0, r, s;
for( int i = 0; i < MX_C; total += statistics.getMove( PLAYER, i++ ) );
r = rand() % total;
for( int i = ROCK; i < SCISSORS; i++ )
{
s = statistics.getMove( PLAYER, i );
if( r < s ) return ( i + 1 );
r -= s;
}
return ROCK;
}
void printMove( int p, int m )
{
if( p == COMPUTER ) cout << "My move: ";
else cout << "Your move: ";
switch( m )
{
case ROCK: cout << "ROCK\n"; break;
case PAPER: cout << "PAPER\n"; break;
case SCISSORS: cout << "SCISSORS\n"; break;
case LIZARD: cout << "LIZARD\n"; break;
case SPOCK: cout << "SPOCK\n";
}
}
public:
rps()
{
checker[ROCK][ROCK] = 2; checker[ROCK][PAPER] = 1; checker[ROCK][SCISSORS] = 0; checker[ROCK][LIZARD] = 0; checker[ROCK][SPOCK] = 1;
checker[PAPER][ROCK] = 0; checker[PAPER][PAPER] = 2; checker[PAPER][SCISSORS] = 1; checker[PAPER][LIZARD] = 1; checker[PAPER][SPOCK] = 0;
checker[SCISSORS][ROCK] = 1; checker[SCISSORS][PAPER] = 0; checker[SCISSORS][SCISSORS] = 2; checker[SCISSORS][LIZARD] = 0; checker[SCISSORS][SPOCK] = 1;
checker[LIZARD][ROCK] = 1; checker[LIZARD][PAPER] = 0; checker[LIZARD][SCISSORS] = 1; checker[LIZARD][LIZARD] = 2; checker[LIZARD][SPOCK] = 0;
checker[SPOCK][ROCK] = 0; checker[SPOCK][PAPER] = 1; checker[SPOCK][SCISSORS] = 0; checker[SPOCK][LIZARD] = 1; checker[SPOCK][SPOCK] = 2;
}
void play()
{
int p, r, m;
while( true )
{
cout << "What is your move (1)ROCK (2)SPOCK (3)PAPER (4)LIZARD (5)SCISSORS (0)Quit ? ";
cin >> p;
if( !p || p < 0 ) break;
if( p > 0 && p < 6 )
{
p--;
cout << endl;
printMove( PLAYER, p );
statistics.move( PLAYER, p );
m = makeMove();
statistics.move( COMPUTER, m );
printMove( COMPUTER, m );
r = checker[p][m];
switch( r )
{
case DRAW:
cout << endl << "DRAW!" << endl << endl;
statistics.draw();
break;
case COMPUTER:
cout << endl << "I WIN!" << endl << endl;
statistics.win( COMPUTER );
break;
case PLAYER:
cout << endl << "YOU WIN!" << endl << endl;
statistics.win( PLAYER );
}
system( "pause" );
}
system( "cls" );
}
statistics.print();
}
private:
stats statistics;
int checker[MX_C][MX_C];
};
//-------------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
srand( GetTickCount() );
rps game;
game.play();
return 0;
}
//-------------------------------------------------------------------------------
</syntaxhighlight>
Sample output:
<pre>
What is your move (1)ROCK (2)SPOCK (3)PAPER (4)LIZARD (5)SCISSORS (0)Quit ? 1
Your move: ROCK
My move: PAPER
I WIN!
What is your move (1)ROCK (2)SPOCK (3)PAPER (4)LIZARD (5)SCISSORS (0)Quit ? 3
Your move: PAPER
My move: SPOCK
YOU WIN!
What is your move (1)ROCK (2)SPOCK (3)PAPER (4)LIZARD (5)SCISSORS (0)Quit ? 1
Your move: SPOCK
My move: LIZARD
I WIN!
[...]
+----------+-------+--------+--------+---------+----------+--------+---------+
| | WON | DRAW | ROCK | PAPER | SCISSORS | LIZARD | SPOCK |
+----------+-------+--------+--------+---------+----------+--------+---------+
| PLAYER | 001 | | 003 | 002 | 000 | 000 | 009 |
+----------+-------+ 005 +--------+---------+----------+--------+---------+
| COMPUTER | 008 | | 000 | 005 | 000 | 001 | 008 |
+----------+-------+--------+--------+---------+----------+--------+---------+
</pre>
Line 1,291 ⟶ 1,384:
Code:
<
(:require [clojure.data.generators :refer [weighted]])
(:import jline.Terminal)
Line 1,329 ⟶ 1,422:
"Rock, Paper, Scissors!"
[& args]
(play-game {:rock 1, :paper 1, :scissors 1}))</
{{out}}
Line 1,340 ⟶ 1,433:
(R)ock, (P)aper, (S)cissors?
We both picked scissors. DRAW!</pre>
=={{header|Crystal}}==
Inspired by [[#Ruby]] solution, but improved to allow additional weapons
<syntaxhighlight lang="ruby">
# conventional weapons
enum Choice
Rock
Paper
Scissors
end
BEATS = {
Choice::Rock => [Choice::Paper],
Choice::Paper => [Choice::Scissors],
Choice::Scissors => [Choice::Rock],
}
# uncomment to use additional weapons
# enum Choice
# Rock
# Paper
# Scissors
# Lizard
# Spock
# end
# BEATS = {
# Choice::Rock => [Choice::Paper, Choice::Spock],
# Choice::Paper => [Choice::Scissors, Choice::Lizard],
# Choice::Scissors => [Choice::Rock, Choice::Spock],
# Choice::Lizard => [Choice::Rock, Choice::Scissors],
# Choice::Spock => [Choice::Paper, Choice::Lizard],
# }
class RPSAI
@stats = {} of Choice => Int32
def initialize
Choice.values.each do |c|
@stats[c] = 1
end
end
def choose
v = rand(@stats.values.sum)
@stats.each do |choice, rate|
v -= rate
return choice if v < 0
end
raise ""
end
def train(selected)
BEATS[selected].each do |c|
@stats[c] += 1
end
end
end
enum GameResult
HumanWin
ComputerWin
Draw
def to_s
case self
when .draw?
"Draw"
when .human_win?
"You win!"
when .computer_win?
"I win!"
end
end
end
class RPSGame
@score = Hash(GameResult, Int32).new(0)
@ai = RPSAI.new
def check(player, computer)
return GameResult::ComputerWin if BEATS[player].includes? computer
return GameResult::HumanWin if BEATS[computer].includes? player
return GameResult::Draw
end
def round
puts ""
print "Your choice (#{Choice.values.join(", ")}):"
s = gets.not_nil!.strip.downcase
return false if "quit".starts_with? s
player_turn = Choice.values.find { |choice| choice.to_s.downcase.starts_with? s }
unless player_turn
puts "Invalid choice"
return true
end
ai_turn = @ai.choose
result = check(player_turn, ai_turn)
puts "H: #{player_turn}, C: #{ai_turn} => #{result}"
@score[result] += 1
puts "score: human=%d, computer=%d, draw=%d" % GameResult.values.map { |r| @score[r] }
@ai.train player_turn
true
end
end
game = RPSGame.new
loop do
break unless game.round
end</syntaxhighlight>
=={{header|D}}==
{{trans|Python}}
<
enum Choice { rock, paper, scissors }
Line 1,399 ⟶ 1,602:
}
}
}</
{{out}}
<pre>rock, paper or scissors? paper
Line 1,418 ⟶ 1,621:
rock, paper or scissors?
</pre>
=={{header|Elixir}}==
{{trans|Erlang}}
<syntaxhighlight lang="elixir">defmodule Rock_paper_scissors do
def play, do: loop([1,1,1])
defp loop([r,p,s]=odds) do
IO.gets("What is your move? (R,P,S,Q) ") |> String.upcase |> String.first
|> case do
"Q" -> IO.puts "Good bye!"
human when human in ["R","P","S"] ->
IO.puts "Your move is #{play_to_string(human)}."
computer = select_play(odds)
IO.puts "My move is #{play_to_string(computer)}"
case beats(human,computer) do
true -> IO.puts "You win!"
false -> IO.puts "I win!"
_ -> IO.puts "Draw"
end
case human do
"R" -> loop([r+1,p,s])
"P" -> loop([r,p+1,s])
"S" -> loop([r,p,s+1])
end
_ ->
IO.puts "Invalid play"
loop(odds)
end
end
defp beats("R","S"), do: true
defp beats("P","R"), do: true
defp beats("S","P"), do: true
defp beats(x,x), do: :draw
defp beats(_,_), do: false
defp play_to_string("R"), do: "Rock"
defp play_to_string("P"), do: "Paper"
defp play_to_string("S"), do: "Scissors"
defp select_play([r,p,s]) do
n = :rand.uniform(r+p+s)
cond do
n <= r -> "P"
n <= r+p -> "S"
true -> "R"
end
end
end
Rock_paper_scissors.play</syntaxhighlight>
'''Sample output:'''
<pre>
What is your move? (R,P,S,Q) r
Your move is Rock.
My move is Scissors
You win!
What is your move? (R,P,S,Q) p
Your move is Paper.
My move is Paper
Draw
What is your move? (R,P,S,Q) s
Your move is Scissors.
My move is Scissors
Draw
What is your move? (R,P,S,Q) q
Good bye!
</pre>
=={{header|Erlang}}==
<
-module(rps).
-compile(export_all).
Line 1,468 ⟶ 1,740:
true -> $R
end.
</syntaxhighlight>
=={{header|Euphoria}}==
{{trans|C}}
<
integer sum,r
sum = 0
Line 1,521 ⟶ 1,793:
printf(1,"\nScore %d:%d\n",score)
user_rec[user_action] += 1
end while</
=={{header|F Sharp|F#}}==
<
let random = Random ()
Line 1,585 ⟶ 1,857:
game(1.0, 1.0, 1.0)
</syntaxhighlight>
=={{header|Factor}}==
<syntaxhighlight lang="factor">USING: combinators formatting io kernel math math.ranges qw
random sequences ;
IN: rosetta-code.rock-paper-scissors
CONSTANT: thing qw{ rock paper scissors }
CONSTANT: msg { "I win." "Tie!" "You win." }
: ai-choice ( r p s -- n )
3dup + + nip [1,b] random {
{ [ 3dup nip >= ] [ 3drop 1 ] }
{ [ 3dup [ + ] dip >= ] [ 3drop 2 ] }
[ 3drop 0 ]
} cond ;
: player-choice ( -- n )
"r/p/s/q? " write readln qw{ r p s q } index dup
[ drop player-choice ] unless ;
! return:
! -1 for n1 loses to n2.
! 0 for n1 ties n2.
! 1 for n1 beats n2.
: outcome ( n1 n2 -- n3 ) - dup abs 1 > [ neg ] when sgn ;
: status. ( seq -- )
"My wins: %d Ties: %d Your wins: %d\n" vprintf ;
: choices. ( n1 n2 -- )
[ thing nth ] bi@ "You chose: %s\nI chose: %s\n" printf ;
: tally ( seq n -- seq' ) over [ 1 + ] change-nth ;
: game ( seq -- seq' )
dup status. player-choice dup 3 = [ drop ] [
[ 3 + tally ] keep over 3 tail* first3 ai-choice 2dup
choices. outcome 1 + dup [ tally ] dip msg nth print nl
game
] if ;
! The game state is a sequence where the members are:
! losses, ties, wins, #rock, #paper, #scissors
: main ( -- ) { 0 0 0 1 1 1 } clone game drop ;
MAIN: main</syntaxhighlight>
{{out}}
<pre>
My wins: 0 Ties: 0 Your wins: 0
r/p/s/q? r
You chose: rock
I chose: paper
I win.
My wins: 1 Ties: 0 Your wins: 0
r/p/s/q? r
You chose: rock
I chose: scissors
You win.
My wins: 1 Ties: 0 Your wins: 1
r/p/s/q? r
You chose: rock
I chose: paper
I win.
My wins: 2 Ties: 0 Your wins: 1
r/p/s/q? r
You chose: rock
I chose: rock
Tie!
My wins: 2 Ties: 1 Your wins: 1
r/p/s/q? r
You chose: rock
I chose: rock
Tie!
My wins: 2 Ties: 2 Your wins: 1
r/p/s/q? r
You chose: rock
I chose: paper
I win.
My wins: 3 Ties: 2 Your wins: 1
r/p/s/q? r
You chose: rock
I chose: paper
I win.
My wins: 4 Ties: 2 Your wins: 1
r/p/s/q? q
</pre>
=={{header|Forth}}==
<syntaxhighlight lang="forth">
include random.fs
0 value aiwins
0 value plwins
10 constant inlim
0 constant rock
1 constant paper
2 constant scissors
create rpshistory 0 , 0 , 0 ,
create inversemove 1 , 2 , 0 ,
3 constant historylen
: @a ( n array -- )
swap cells + @ ;
: sum-history ( -- n )
0 historylen 0 ?do
i rpshistory @a 1+ + loop ;
: probable-choice ( -- n ) \ Simple linear search
sum-history random
historylen 0 ?do
i rpshistory @a -
dup 0< if drop i leave then
loop inversemove @a ;
: rps-print ( addr u -- )
cr type ;
: rpslog. ( -- )
s" ROCK PAPER SCISSORS AI/W PL/W" rps-print cr
3 0 do i cells rpshistory + @ 9 u.r loop aiwins 7 u.r plwins 6 u.r cr ;
create rpswords ' rock , ' paper , ' scissors , ' quit ,
: update-history! ( n -- )
cells rpshistory + 1 swap +! ;
: thrown. ( n -- addr u )
cells rpswords + @ name>string ;
: throws. ( n n -- )
thrown. s" AI threw: " 2swap s+ rps-print
thrown. s" You threw: " 2swap s+ rps-print ;
: print-throws ( n n -- )
rpslog. throws. ;
: tie. ( n n -- )
s" Tie. " rps-print ;
: plwin ( n n -- )
1 +to plwins s" You win. " rps-print ;
: aiwin ( n n -- )
1 +to aiwins s" AI wins. " rps-print ;
create rpsstates ' tie. , ' plwin , ' aiwin ,
: determine-winner ( n n -- )
>r abs r> abs - 3 + 3 mod
cells rpsstates + @ execute ;
: rps-validate ( name -- ) ( Rude way of checking for only valid commands )
4 0 do i cells rpswords + @ over = swap loop drop or or or ;
: rps-prompt. ( -- )
s" Enter choice (rock, paper, scissors or quit): " rps-print ;
: player-choice ( -- n ) recursive
pad inlim accept pad swap find-name
dup rps-validate if execute
else drop rps-prompt. player-choice then ;
: update-log ( n n -- )
update-history! update-history! ;
: rps ( -- ) recursive
rps-prompt. player-choice probable-choice
2dup update-log 2dup print-throws
determine-winner rps ;
</syntaxhighlight>
<pre>
Enter choice (rock, paper, scissors): rock
rock
ROCK PAPER SCISSORS AI/W PL/W
34 12 8 12 8
AI threw: rock
You threw: rock
Tie.
</pre>
=={{header|Fortran}}==
Please find an example run in a GNU/linux system along with compilation instructions at the beginning of the FORTRAN 2008 source code. Following the source are examples demonstrating the effectiveness of the built in simple predictive artificial intelligence. It uses the yes utility for a constant data source.
<syntaxhighlight lang="fortran">
! compilation
! gfortran -std=f2008 -Wall -ffree-form -fall-intrinsics -fimplicit-none f.f08 -o f
Line 1,652 ⟶ 2,115:
if (score(COMPUTER) .lt. score(HAPLESSUSER)) print*,'you won!'
end program rpsgame
</syntaxhighlight>
rpsgame won't play more than 30 games at a time.
<
$ yes r | ./f # rock
rock, paper, scissors? scoring computer choice (r) and your choice (r)
Line 1,685 ⟶ 2,148:
26.5 3.5
$
</syntaxhighlight>
=={{header|FreeBASIC}}==
{{trans|Yabasic}}
<syntaxhighlight lang="freebasic">Dim Shared As Byte ganador = 1, accion = 2, perdedor = 3, wp, wc
Dim Shared As String word(10, 3)
For n As Byte = 0 To 9
Read word(n, ganador), word(n, accion), word(n, perdedor)
Next n
Sub SimonSay(n As Byte)
Print Using "\ \ \ \ "; word(n, ganador); word(n, accion); word(n, perdedor)
End Sub
Sub Puntuacion()
Print !"\nPlayer = "; wp; !"\tComputer = "; wc; !"\n"
End Sub
Dim As Byte n
Dim As String*1 k
Dim As String eleccionCPU, eleccionJUG
Randomize Timer
Do
Cls
eleccionCPU = word(Rnd *10, ganador)
Print !"'Rock, Paper, Scissors, Lizard, Spock!' rules are:\n"
For n = 0 To 9
SimonSay(n)
Next n
Print !"\nType your choice letter:"
Input !"(R)ock, (P)aper, (S)cissors, (L)izard, Spoc(K), (Q)uit ", k
k = Ucase(k)
Select Case k
Case "Q"
Exit Do
Case "R"
eleccionJUG = "Rock"
Case "P"
eleccionJUG = "Paper"
Case "S"
eleccionJUG = "Scissors"
Case "L"
eleccionJUG = "Lizard"
Case "K"
eleccionJUG = "Spock"
End Select
Print !"\nPlayer chose "; eleccionJUG; " and Computer chose "; eleccionCPU
For n = 0 To 9
If word(n, ganador) = eleccionJUG And word(n, perdedor) = eleccionCPU Then
SimonSay(n)
Print !"\nWinner was Player"
wp += 1
Exit For
Elseif word(n, ganador) = eleccionCPU And word(n, perdedor) = eleccionJUG Then
SimonSay(n)
Print !"\nWinner was Computer"
wc += 1
Exit For
End If
Next n
If n = 10 Then Print !"\nOuch!"
Puntuacion()
Print "Press <SPACE> to continue"
Sleep
Loop Until(k = "Q")
Cls
Puntuacion()
If wp > wc Then
Print "Player win"
Elseif wc > wp Then
Print "Computer win"
Else
Print "Tie"
End If
Sleep
End
Data "Scissors","cuts","Paper"
Data "Paper","covers","Rock"
Data "Rock","crushes","Lizard"
Data "Lizard","poisons","Spock"
Data "Spock","smashes","Scissors"
Data "Scissors","decapites","Lizard"
Data "Lizard","eats","Paper"
Data "Paper","disproves","Spock"
Data "Spock","vaporizes","Rock"
Data "Rock","blunts","Scissors"</syntaxhighlight>
=={{header|GlovePIE}}==
You can only press the R, P or S key to advance.
<syntaxhighlight lang="glovepie">if var.end=0 then
var.end=0
var.computerchoice=random(3) // 1 is rock, 2 is paper, and 3 is scissors.
debug="Press the R key for rock, the P key for paper, or the S key for scissors:"
endif
if pressed(Key.R)and var.end=0 then
var.end=1
if var.computerchoice=1 then
debug="You chose rock, which the computer also chose, so it's a tie!"
else
if var.computerchoice=2 then
debug="The computer chose paper, covering your choice of rock, so you lose!"
else
debug="You chose rock, smashing the computer's choice of scissors, so you win!"
endif
endif
endif
if pressed(Key.P)and var.end=0 then
var.end=1
if var.computerchoice=1 then
debug="You chose paper, covering the computer's choice of rock, so you win!"
else
if var.computerchoice=2 then
debug="You chose paper, which the computer also chose, so it's a tie!"
else
debug="The computer chose scissors, cutting your choice of paper, so you lose!"
endif
endif
endif
if pressed(Key.S)and var.end=0 then
var.end=1
if var.computerchoice=1 then
debug="The computer chose rock, smashing your choice of scissors, so you lose!"
else
if var.computerchoice=2 then
debug="You chose scissors, cutting the computer's choice of paper, so you win!"
else
debug="You chose scissors, which the computer also chose, so it's a tie!"
endif
endif
endif</syntaxhighlight>
=={{header|Go}}==
<
import (
Line 1,756 ⟶ 2,357:
}
}
}</
{{out|Sample output}}
<pre>
Line 1,777 ⟶ 2,378:
</pre>
Additional weapons:
<
import (
Line 2,033 ⟶ 2,634:
aw = form[ax]
}
}</
Example game files:
<pre>
Line 2,127 ⟶ 2,728:
=={{header|Haskell}}==
<
data Choice
= Rock
| Paper
| Scissors
deriving (Show, Eq)
beats :: Choice -> Choice -> Bool
beats Paper Rock = True
beats Scissors Paper = True
Line 2,138 ⟶ 2,742:
beats _ _ = False
genrps :: (
genrps (r, p, s) = rps <$> rand
where
rps x
| x
| x <= s + r = Paper
| otherwise = Scissors
rand = randomRIO (1, r + p + s) :: IO Int
getrps
getrps = rps <$> getLine
where
rps "paper" = Paper
rps _ = error "invalid input"
game :: (Int, Int, Int) -> IO a
game (r, p, s) = do
putStrLn "rock, paper or scissors?"
h <- getrps
c <- genrps (r, p, s)
putStrLn ("Player: " ++ show h ++ " Computer: " ++ show c)
putStrLn
(if beats h c
else if beats c h
then "player
else "draw\n")
let rr =
if h == Rock
then r + 1
else r
pp =
if h == Paper
then p + 1
else p
ss =
if h == Scissors
then s + 1
else s
game (rr, pp, ss)
main
main = game (1, 1, 1)</syntaxhighlight>
=={{header|Icon}} and {{header|Unicon}}==
The key to this comes down to two structures and two lines of code. The player history ''historyP'' is just an ordered list of every player turn and provides the weight for the random selection. The ''beats'' list is used to rank moves and to choose the move that would beat the randomly selected move.
<
procedure main()
Line 2,206 ⟶ 2,830:
printf("\nResults:\n %d rounds\n %d Draws\n %d Computer wins\n %d Player wins\n",
winP+winC+draws,draws,winC,winP)
end</
{{libheader|Icon Programming Library}}
Line 2,237 ⟶ 2,861:
1 Computer wins
1 Player wins</pre>
=={{header|IS-BASIC}}==
<syntaxhighlight lang="is-basic">100 PROGRAM "Rock.bas"
110 RANDOMIZE
120 STRING CH$(1 TO 3)*8,K$*1
130 NUMERIC PLWINS(1 TO 3),SCORE(1 TO 3),PLSTAT(1 TO 3),CMSTAT(1 TO 3),PLCHOICE,CMCHOICE
140 CALL INIC
150 DO
160 CALL GUESS
170 PRINT :PRINT "Rock, paper, or scissors (1 = rock, 2 = paper, 3 = scissors, ESC = quit)"
180 DO
190 LET K$=INKEY$
200 LOOP UNTIL K$>="1" AND K$<="3" OR K$=CHR$(27)
210 IF K$=CHR$(27) THEN EXIT DO
220 LET PLCHOICE=VAL(K$)
230 LET CMSTAT(CMCHOICE)=CMSTAT(CMCHOICE)+1:LET PLSTAT(PLCHOICE)=PLSTAT(PLCHOICE)+1
240 PRINT "You chose ";CH$(PLCHOICE);" and I chose ";CH$(CMCHOICE);"."
250 SET #102:INK 3
260 IF PLCHOICE=CMCHOICE THEN
270 PRINT "Tie!"
280 LET SCORE(3)=SCORE(3)+1
290 ELSE IF CMCHOICE=PLWINS(PLCHOICE) THEN
300 PRINT "You won!"
310 LET SCORE(1)=SCORE(1)+1
320 ELSE
330 PRINT "I won!"
340 LET SCORE(2)=SCORE(2)+1
350 END IF
360 SET #102:INK 1
370 LOOP
380 PRINT :PRINT "Some useless statistics:"
390 PRINT "You won";SCORE(1);"times, and I won";SCORE(2);"times;";SCORE(3);"ties."
400 PRINT :PRINT ,,CH$(1),CH$(2),CH$(3)
410 PRINT "You chose:",PLSTAT(1),PLSTAT(2),PLSTAT(3)
420 PRINT " I chose:",CMSTAT(1),CMSTAT(2),CMSTAT(3)
430 END
440 DEF INIC
450 LET CH$(1)="rock":LET CH$(2)="paper":LET CH$(3)="scissors"
460 LET PLWINS(1)=3:LET PLWINS(2)=1:LET PLWINS(3)=2
470 FOR I=1 TO 3
480 LET PLSTAT(I),CMSTAT(I),SCORE(I)=0
490 NEXT
500 TEXT 80
510 END DEF
520 DEF GUESS
530 LET CMCHOICE=INT(RND*(PLSTAT(1)+PLSTAT(2)+PLSTAT(3)+3))
540 SELECT CASE CMCHOICE
550 CASE 0 TO PLSTAT(1)
560 LET CMCHOICE=2
570 CASE PLSTAT(1)+1 TO PLSTAT(1)+PLSTAT(2)+1
580 LET CMCHOICE=3
590 CASE ELSE
600 LET CMCHOICE=1
610 END SELECT
620 END DEF</syntaxhighlight>
=={{header|J}}==
<
game=:3 :0
outcomes=. rps=. 0 0 0
Line 2,258 ⟶ 2,937:
end.
('Draws:','My wins:',:'Your wins: '),.":,.outcomes
)</
Example use (playing to give the computer implementation the advantage):
<
Choose Rock, Paper or Scissors: rock
I choose Scissors
Line 2,281 ⟶ 2,960:
Draws: 0
My wins: 4
Your wins: 1</
=={{header|Java}}==
{{works with|Java|1.5+}}
This could probably be made simpler, but some more complexity is necessary so that other items besides rock, paper, and scissors can be added (as school children and nerds like to do [setup for rock-paper-scissors-lizard-spock is in multi-line comments]). The method <code>getAIChoice()</code> borrows from [[#Ada|the Ada example]] in spirit, but is more generic to additional items.
<
import java.util.EnumMap;
import java.util.List;
Line 2,364 ⟶ 3,043:
return null;
}
}</
Sample output:
<pre>Make your choice: rock
Line 2,403 ⟶ 3,082:
You chose...wisely. You win!
...</pre>
=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">
const logic = {
rock: { w: 'scissor', l: 'paper'},
paper: {w:'rock', l:'scissor'},
scissor: {w:'paper', l:'rock'},
}
class Player {
constructor(name){
this.name = name;
}
setChoice(choice){
this.choice = choice;
}
challengeOther(PlayerTwo){
return logic[this.choice].w === PlayerTwo.choice;
}
}
const p1 = new Player('Chris');
const p2 = new Player('John');
p1.setChoice('rock');
p2.setChoice('scissor');
p1.challengeOther(p2); //true (Win)
</syntaxhighlight>
=={{header|jq}}==
'''Adapted from [[#Wren|Wren]]'''
<syntaxhighlight lang=jq>
# To quit, enter a blank line or type "q" or "quit"
def choices: ["r", "p", "s", "q"];
# The main source of entropy for this pseudo pseudo random number generator is the player :-)
# PRN in range(0;3)
def rand: now * 100 | floor | tostring[-2:] | tonumber % 3;
def tallies:
{pWins: 0, # player wins
cWins: 0, # computer wins
draws: 0, # neither wins
games: 0, # games played
pFreqs: [0, 0, 0] # player frequencies for each choice (rps)
};
# Update the tallies and populate .emit
def update($pChoice; $cChoice):
if $pChoice == "r" and $cChoice == "s"
then .emit += "Rock breaks scissors - You win!"
| .pWins += 1
elif $pChoice == "p" and $cChoice == "r"
then .emit += "Paper covers rock - You win!"
| .pWins += 1
elif $pChoice == "s" and $cChoice == "p"
then .emit += "Scissors cut paper - You win!"
| .pWins += 1
elif $pChoice == "s" and $cChoice == "r"
then .emit += "Rock breaks scissors - Computer wins!"
| .cWins += 1
elif $pChoice == "r" and $cChoice == "p"
then .emit += "Paper covers rock - Computer wins!"
| .cWins += 1
elif $pChoice == "p" and $cChoice == "s"
then .emit += "Scissors cut paper - Computer wins!"
| .cWins += 1
else .emit += "It's a draw!"
| .draws += 1
end
| .pFreqs[choices|index($pChoice)] += 1
| .games += 1 ;
def printScore:
"Wins: You \(.pWins), Computer \(.cWins), Neither \(.draws)\n";
def getComputerChoice:
# make a completely random choice until 3 games have been played
if .games < 3 then choices[rand]
else .games as $games
| (.pFreqs | map(3 * . / $games)) as $pFreqs
| rand as $num
| if $num < $pFreqs[0] then "p"
elif $num < $pFreqs[0] + $pFreqs[1] then "s"
else "r"
end
end ;
# Get player's choice (empty line or q or quit to quit).
# Return false if the choice is not recognized.
def pChoice:
(first(inputs) // null) as $in
| if $in == null or $in == "q" or $in == "quit" then null
else ($in|ascii_downcase) as $in
| if any(choices[]; . == $in) then $in
else false
end
end;
# Solicit input
def prompt:
if .games == 0
then "Enter: (r)ock, (p)aper, (s)cissors or (q)uit"
else printScore + "---\n\nYour choice r/p/s/q : "
end;
def play:
label $out
| foreach range(1; infinite) as $i (tallies ;
# if .prompt then it is time to get input:
if .prompt
then pChoice as $pChoice
| if $pChoice == null
then .prompt = false
| .emit = "OK, quitting", break $out
elif $pChoice == false
then .emit = "Valid responses are one of r p s q\nPlease try again."
else getComputerChoice as $cChoice
| .prompt = false
| .emit = "Computer's choice : \($cChoice)\n"
| update($pChoice; $cChoice)
end
else .prompt = prompt
| .emit = null
end )
| select(.emit).emit,
select(.prompt).prompt ;
play
</syntaxhighlight>
'''Invocation:''' jq -nrR -f rock-paper-scissors.jq
'''Sample game'''
<pre>
Enter: (r)ock, (p)aper, (s)cissors or (q)uit
?
Valid responses are one of r p s q
Please try again.
Enter: (r)ock, (p)aper, (s)cissors or (q)uit
r
Computer's choice : r
It's a draw!
Wins: You 0, Computer 0, Neither 1
---
Your choice r/p/s/q :
p
Computer's choice : s
Scissors cut paper - Computer wins!
Wins: You 0, Computer 1, Neither 1
---
Your choice r/p/s/q :
s
Computer's choice : s
It's a draw!
Wins: You 0, Computer 1, Neither 2
---
Your choice r/p/s/q :
OK, quitting
</pre>
=={{header|Julia}}==
<
print("Welcome to Rock, paper, scissors! Go ahead and type your pick.\n
r(ock), p(aper), or s(cissors)\n
Line 2,427 ⟶ 3,272:
end
end
end</
<pre>julia> rps()
Welcome to Rock, paper, scissors! Go ahead and type your pick.
Line 2,450 ⟶ 3,295:
you 2
me 1</pre>
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.2.10
import java.util.Random
const val choices = "rpsq"
val rand = Random()
var pWins = 0 // player wins
var cWins = 0 // computer wins
var draws = 0 // neither wins
var games = 0 // games played
val pFreqs = arrayOf(0, 0, 0) // player frequencies for each choice (rps)
fun printScore() = println("Wins: You $pWins, Computer $cWins, Neither $draws\n")
fun getComputerChoice(): Char {
// make a completely random choice until 3 games have been played
if (games < 3) return choices[rand.nextInt(3)]
val num = rand.nextInt(games)
return when {
num < pFreqs[0] -> 'p'
num < pFreqs[0] + pFreqs[1] -> 's'
else -> 'r'
}
}
fun main(args: Array<String>) {
println("Enter: (r)ock, (p)aper, (s)cissors or (q)uit\n")
while (true) {
printScore()
var pChoice: Char
while (true) {
print("Your choice r/p/s/q : ")
val input = readLine()!!.toLowerCase()
if (input.length == 1) {
pChoice = input[0]
if (pChoice in choices) break
}
println("Invalid choice, try again")
}
if (pChoice == 'q') {
println("OK, quitting")
return
}
val cChoice = getComputerChoice()
println("Computer's choice : $cChoice")
if (pChoice == 'r' && cChoice == 's') {
println("Rock breaks scissors - You win!")
pWins++
}
else if (pChoice == 'p' && cChoice == 'r') {
println("Paper covers rock - You win!")
pWins++
}
else if (pChoice == 's' && cChoice == 'p') {
println("Scissors cut paper - You win!")
pWins++
}
else if (pChoice == 's' && cChoice == 'r') {
println("Rock breaks scissors - Computer wins!")
cWins++
}
else if (pChoice == 'r' && cChoice == 'p') {
println("Paper covers rock - Computer wins!")
cWins++
}
else if (pChoice == 'p' && cChoice == 's') {
println("Scissors cut paper - Computer wins!")
cWins++
}
else {
println("It's a draw!")
draws++
}
pFreqs[choices.indexOf(pChoice)]++
games++
println()
}
}</syntaxhighlight>
Sample session:
<pre>
Enter: (r)ock, (p)aper, (s)cissors or (q)uit
Wins: You 0, Computer 0, Neither 0
Your choice r/p/s/q : r
Computer's choice : r
It's a draw!
Wins: You 0, Computer 0, Neither 1
Your choice r/p/s/q : p
Computer's choice : s
Scissors cut paper - Computer wins!
Wins: You 0, Computer 1, Neither 1
Your choice r/p/s/q : p
Computer's choice : r
Paper covers rock - You win!
Wins: You 1, Computer 1, Neither 1
Your choice r/p/s/q : s
Computer's choice : s
It's a draw!
Wins: You 1, Computer 1, Neither 2
Your choice r/p/s/q : p
Computer's choice : p
It's a draw!
Wins: You 1, Computer 1, Neither 3
Your choice r/p/s/q : q
OK, quitting
</pre>
=={{header|Lasso}}==
Notes: This implementation uses the default session handling in Lasso, and assumes it's running on a web server. User choices are passed in via HTTP as GET query parameters.
<
session_addvar('user', 'historic_choices')
session_addvar('user', 'win_record')
Line 2,521 ⟶ 3,487:
'User: '+($win_record->find('user')->size)+br
'Tie: '+($win_record->find('tie')->size)+br
^}</
{{out}}
<pre>Rock Paper Scissors Quit (<- as links)
Line 2,534 ⟶ 3,500:
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
dim rps( 2), g$( 3)
Line 2,623 ⟶ 3,589:
print " Thanks for playing!"
end
</syntaxhighlight>
You won 3204, and I won 3669. There were 3128 draws.
I AM THE CHAMPION!!
Line 2,647 ⟶ 3,613:
Can you see what will happen if, say, the 'human' is set to give 'Rock' EVERY time?
Try different %ages by altering the marked code lines.
=={{header|Locomotive Basic}}==
Line 2,653 ⟶ 3,618:
{{trans|Go}}
<
20 rps$="rps"
30 msg$(1)="Rock breaks scissors"
Line 2,675 ⟶ 3,640:
210 rn=rnd*plays
220 if rn<pcf(1) then achoice=2 else if rn<pcf(1)+pcf(2) then achoice=3 else achoice=1
230 goto 110</
=={{header|Lua}}==
<syntaxhighlight lang="lua">function cpuMove()
local totalChance = record.R + record.P + record.S
if totalChance == 0 then -- First game, unweighted random
local choice = math.random(1, 3)
if choice == 1 then return "R" end
if choice == 2 then return "P" end
if choice == 3 then return "S" end
end
local choice = math.random(1, totalChance) -- Weighted random bit
if choice <= record.R then return "P" end
if choice <= record.R + record.P then return "S" end
return "R"
end
function playerMove() -- Get user input for choice of 'weapon'
local choice
repeat
os.execute("cls") -- Windows specific command, change per OS
print("\nRock, Paper, Scissors")
print("=====================\n")
print("Scores -\tPlayer:", score.player)
print("\t\tCPU:", score.cpu .. "\n\t\tDraws:", score.draws)
io.write("\nChoose [R]ock [P]aper or [S]cissors: ")
choice = io.read():upper():sub(1, 1)
until choice == "R" or choice == "P" or choice == "S"
return choice
end
-- Decide who won, increment scores
function checkWinner (c, p)
io.write("I chose ")
if c == "R" then print("rock...") end
if c == "P" then print("paper...") end
if c == "S" then print("scissors...") end
if c == p then
print("\nDraw!")
score.draws = score.draws + 1
elseif (c == "R" and p == "P") or
(c == "P" and p == "S") or
(c == "S" and p == "R") then
print("\nYou win!")
score.player = score.player + 1
else
print("\nYou lose!")
score.cpu = score.cpu + 1
end
end
-- Main procedure
math.randomseed(os.time())
score = {player = 0, cpu = 0, draws = 0}
record = {R = 0, P = 0, S = 0}
local playerChoice, cpuChoice
repeat
cpuChoice = cpuMove()
playerChoice = playerMove()
record[playerChoice] = record[playerChoice] + 1
checkWinner(cpuChoice, playerChoice)
io.write("\nPress ENTER to continue or enter 'Q' to quit . . . ")
until io.read():upper():sub(1, 1) == "Q"</syntaxhighlight>
Session in which I chose nothing but rock:
<pre>
Rock, Paper, Scissors
=====================
Scores - Player: 1
CPU: 25
Draws: 0
Choose [R]ock [P]aper or [S]cissors: r
I chose paper...
You lose!
Press ENTER to continue or enter 'Q' to quit . . .
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
choices = {"Rock", "Paper", "Scissors"}},
Evaluate[record /@ choices] = {1, 1, 1};
Line 2,689 ⟶ 3,732:
Alternatives @@ Reverse /@ Partition[choices, 2, 1, 1],
"You win.", _, "Draw."]];
Column@{Dynamic[text], ButtonBar[# :> play[#] & /@ choices]}]</
=={{header|Mercury}}==
{{trans|Prolog}}
<syntaxhighlight lang="mercury">:- module rps.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
:- use_module random, exception.
:- import_module list, string.
:- type play
---> rock
; paper
; scissors.
:- pred beats(play, play).
:- mode beats(in, in) is semidet.
beats(rock, scissors).
beats(paper, rock).
beats(scissors, paper).
:- pred random(play::out, random.supply::mdi, random.supply::muo) is det.
random(Play, !RS) :-
random.random(1, 3, N, !RS),
( if N = 1 then
Play = rock
else if N = 2 then
Play = paper
else
Play = scissors
).
main(!IO) :-
seed(Seed, !IO),
random.init(Seed, RS),
play(RS, !IO).
:- pred play(random.supply::mdi, io::di, io::uo) is det.
play(!.RS, !IO) :-
io.write_string("Your choice? ", !IO),
io.read(Res, !IO),
(
Res = ok(Play),
random(Counter, !RS),
io.format("The computer chose %s\n", [s(string(Counter))], !IO),
( if beats(Counter, Play) then
io.write_string("Computer wins.\n", !IO)
else if beats(Play, Counter) then
io.write_string("You win!\n", !IO)
else
io.write_string("It is a draw\n", !IO)
),
play(!.RS, !IO)
;
Res = eof
;
Res = error(_, _),
exception.throw(Res)
).
:- pragma foreign_decl("C", "#include <time.h>").
:- pred seed(int::out, io::di, io::uo) is det.
:- pragma foreign_proc("C",
seed(Seed::out, _IO0::di, _IO::uo),
[promise_pure, will_not_call_mercury],
"
Seed = time(NULL);
").</syntaxhighlight>
=={{header|Nim}}==
<syntaxhighlight lang="nim">import random, strutils, tables
type
Choice {.pure.} = enum Rock, Paper, Scissors
History = tuple[total: int; counts: CountTable[Choice]]
const Successor: array[Choice, Choice] = [Paper, Scissors, Rock]
func `>`(a, b: Choice): bool =
## By construction, only the successor is greater than the choice.
a == Successor[b]
proc choose(history: History): Choice =
## Make a weighted random choice using the player counts
## then select the choice likely to beat it.
var value = rand(1..history.total)
for choice, count in history.counts.pairs:
if value <= count:
return Successor[choice]
dec value, count
randomize()
# Initialize history with one for each choice in order to avoid special case.
var history: History = (3, [Rock, Paper, Scissors].toCountTable)
echo "To quit game, type 'q' when asked for your choice."
var myChoice, yourChoice: Choice
var myWins, yourWins = 0
while true:
# Get player choice.
try:
stdout.write "Rock(1), paper(2), scissors(3). Your choice? "
let answer = stdin.readLine().strip()
if answer == "q":
quit "Quitting game.", QuitSuccess
if answer notin ["1", "2", "3"]:
echo "Invalid choice."
continue
yourChoice = Choice(ord(answer[0]) - ord('1'))
except EOFError:
quit "Quitting game.", QuitFailure
# Make my choice.
myChoice = history.choose()
echo "I choosed ", myChoice, '.'
history.counts.inc yourChoice
inc history.total
# Display result of round.
if myChoice == yourChoice:
echo "It’s a tie."
elif myChoice > yourChoice:
echo "I win."
inc myWins
else:
echo "You win."
inc yourWins
echo "Total wins. You: ", yourWins, " Me: ", myWins</syntaxhighlight>
{{out}}
<pre>To quit game, type 'q' when asked for your choice.
Rock(1), paper(2), scissors(3). Your choice? 1
I choosed Rock.
It’s a tie.
Total wins. You: 0 Me: 0
Rock(1), paper(2), scissors(3). Your choice? 1
I choosed Rock.
It’s a tie.
Total wins. You: 0 Me: 0
Rock(1), paper(2), scissors(3). Your choice? 1
I choosed Paper.
I win.
Total wins. You: 0 Me: 1
Rock(1), paper(2), scissors(3). Your choice? 1
I choosed Rock.
It’s a tie.
Total wins. You: 0 Me: 1
Rock(1), paper(2), scissors(3). Your choice? 1
I choosed Paper.
I win.
Total wins. You: 0 Me: 2
Rock(1), paper(2), scissors(3). Your choice? 1
I choosed Paper.
I win.
Total wins. You: 0 Me: 3
Rock(1), paper(2), scissors(3). Your choice? 1
I choosed Paper.
I win.
Total wins. You: 0 Me: 4
Rock(1), paper(2), scissors(3). Your choice? 1
I choosed Paper.
I win.
Total wins. You: 0 Me: 5
Rock(1), paper(2), scissors(3). Your choice? 1
I choosed Paper.
I win.
Total wins. You: 0 Me: 6
Rock(1), paper(2), scissors(3). Your choice? q
Quitting game.</pre>
=={{header|NS-HUBASIC}}==
<syntaxhighlight lang="ns-hubasic">10 COMPUTER=RND(3)+1
20 COMPUTER$="ROCK"
30 IF COMPUTER=2 THEN COMPUTER$="PAPER"
40 IF COMPUTER=3 THEN COMPUTER$="SCISSORS"
50 INPUT "ROCK, PAPER OR SCISSORS? ",HUMAN$
60 IF HUMAN$="ROCK" THEN GOTO 100
70 IF HUMAN$="PAPER" THEN GOTO 100
80 IF HUMAN$="SCISSORS" THEN GOTO 100
90 PRINT "INVALID GUESS. TRY AGAIN.": GOTO 50
100 PRINT "YOU CHOSE "HUMAN$" AND THE COMPUTER CHOSE "COMPUTER$"."
110 IF HUMAN$=COMPUTER$ THEN PRINT "THOSE ARE THE SAME CHOICES";", SO YOU TIED."
120 IF HUMAN$="ROCK" AND COMPUTER=2 THEN PRINT "PAPER COVERS ROCK, SO YOU LOSE."
130 IF HUMAN$="ROCK" AND COMPUTER=3 THEN PRINT "ROCK BLUNTS SCISSORS";", SO YOU WIN."
140 IF HUMAN$="PAPER" AND COMPUTER=1 THEN PRINT "PAPER COVERS ROCK, SO YOU WIN."
150 IF HUMAN$="PAPER" AND COMPUTER=3 THEN PRINT "SCISSORS CUT PAPER";", SO YOU LOSE."
160 IF HUMAN$="SCISSORS" AND COMPUTER=1 THEN PRINT "ROCK BLUNTS SCISSORS";", SO YOU LOSE."
170 IF HUMAN$="SCISSORS" AND COMPUTER=2 THEN PRINT "SCISSORS CUT PAPER, SO YOU WIN."10 COMPUTER=RND(3)+1</syntaxhighlight>
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">
let pf = Printf.printf ;;
Line 2,746 ⟶ 3,983:
make_moves 1. 1. 1. ;;
</syntaxhighlight>
=={{header|PARI/GP}}==
<
my(v=[1,1,1],wins,losses); \\ Laplace rule
for(i=1,rounds,
Line 2,783 ⟶ 4,020:
[wins,losses]
};
contest(10)</
=={{header|Perl}}==
The program supports "--quiet" option, which makes it suppress all in-game output (useful for batch testing). At the end of a game it displays detailed statistics.
<
use 5.012;
use warnings;
Line 2,909 ⟶ 4,146:
main();
</syntaxhighlight>
Example input can be generated as follows:
<
perl -e '@c=qw(r p s); for(1..10000){ print $c[ rand() < 0.75 ? 0 : int rand(2) + 1 ], "\n" }' | perl rps.pl --quiet
</syntaxhighlight>
Output:
<pre>
Line 2,960 ⟶ 4,197:
</pre>
=={{header|
<syntaxhighlight lang="phix">--standard game
constant rule3 = {"rock blunts scissors",
"paper wraps rock",
"scissors cut paper"}
--extended version
constant rule5 = {"rock blunts scissors",
"rock crushes lizard",
"paper wraps rock",
"paper disproves spock",
"scissors cut paper",
"scissors decapitate lizard",
"lizard eats paper",
"lizard poisons spock",
"spock smashes scissors",
"spock vaporizes rock"}
constant rules = iff(rand(2)=1?rule3:rule5)
sequence what = {}
sequence beats = {}
string
string question = "What is your move "
integer choices, hsum
sequence history, cplays, pplays
object x, verb, y
for i=1 to length(rules) do
{x} = split(rules[i])
if not find(x,what) then
what = append(what,x)
if find(x[1],wkeys) then
wkeys = append(wkeys,x[$])
question &= x[1..-2]&"("&x[$]&"), "
else
wkeys = append(wkeys,x[1])
question &= "("&x[1]&")"&x[2..$]&", "
end if
end if
end for
choices = length(wkeys)
history = repeat(1,choices)
hsum = 3
cplays = repeat(0,choices)
pplays = repeat(0,choices)
beats = repeat(repeat(0,choices),choices)
question[-2] = '?'
for i=1 to length(rules) do
{x,verb,y} = split(rules[i])
beats[find(x,what)][find(y,what)] = verb
end for
integer cmove, pmove, draws = 0, pwins = 0, cwins = 0
while 1 do
cmove = rand(hsum)
for i=1 to choices do
cmove -= history[i]
if cmove<=0 then
-- predicted user choice of i, find whatever beats it
for j=1 to choices do
if string(beats[j][i]) then
cmove = j
exit
end if
end for
exit
end if
end for
puts(1,question)
while 1 do
pmove = lower(wait_key())
if pmove='q' then exit end if
pmove = find(pmove,wkeys)
if pmove!=0 then exit end if
end while
if pmove='q' then exit end if
printf(1,"you: %s, me: %s, ",{what[pmove],what[cmove]})
cplays[cmove] += 1
pplays[pmove] += 1
if cmove=pmove then
printf(1,"a draw.\n")
draws += 1
else
if string(beats[cmove][pmove]) then
printf(1,"%s %s %s. I win.\n",{what[cmove],beats[cmove][pmove],what[pmove]})
cwins += 1
elsif string(beats[pmove][cmove]) then
printf(1,"%s %s %s. You win.\n",{what[pmove],beats[pmove][cmove],what[cmove]})
pwins += 1
else
?9/0 -- sanity check
end if
end if
history[pmove] += 1
hsum += 1
end while
printf(1,"\n\nYour wins:%d, My wins:%d, Draws:%d\n",{pwins,cwins,draws})
printf(1,"\n\nYour wins:%d, My wins:%d, Draws:%d\n",{pwins,cwins,draws})
printf(1," ") for i=1 to choices do printf(1,"%9s",what[i]) end for
printf(1,"\nyou: ") for i=1 to choices do printf(1,"%9d",pplays[i]) end for
printf(1,"\n me: ") for i=1 to choices do printf(1,"%9d",cplays[i]) end for</syntaxhighlight>
{{out}}
<pre style="font-size: 8px">
What is your move (r)ock, (p)aper, (s)cissors? you: rock, me: scissors, rock blunts scissors. You win.
What is your move (r)ock, (p)aper, (s)cissors? you: rock, me: rock, a draw.
What is your move (r)ock, (p)aper, (s)cissors? you: rock, me: paper, paper wraps rock. I win.
What is your move (r)ock, (p)aper, (s)cissors? you: rock, me: rock, a draw.
What is your move (r)ock, (p)aper, (s)cissors? you: rock, me: paper, paper wraps rock. I win.
What is your move (r)ock, (p)aper, (s)cissors? you: rock, me: paper, paper wraps rock. I win.
What is your move (r)ock, (p)aper, (s)cissors? you: rock, me: paper, paper wraps rock. I win.
What is your move (r)ock, (p)aper, (s)cissors? you: rock, me: paper, paper wraps rock. I win.
What is your move (r)ock, (p)aper, (s)cissors? you: rock, me: paper, paper wraps rock. I win.
What is your move (r)ock, (p)aper, (s)cissors? you: rock, me: paper, paper wraps rock. I win.
What is your move (r)ock, (p)aper, (s)cissors?
Your wins:1, My wins:7, Draws:2
rock paper scissors
you: 10 0 0
me: 2 7 1
</pre>
=={{header|Phixmonti}}==
<syntaxhighlight lang="phixmonti">include ..\Utilitys.pmt
0 var wh
0 var wc
( "Scissors cuts Paper"
"Paper covers Rock"
"Rock crushes Lizard"
"Lizard poisons Spock"
"Spock smashes Scissors"
"Scissors decapites Lizard"
"Lizard eats Paper"
"Paper disproves Spock"
"Spock vaporizes Rock"
"Rock blunts Scissors" )
"'Rock, Paper, Scissors, Lizard, Spock!' rules are: " ? nl
len for
get ?
endfor
nl
( ( "S" "Scissors" ) ( "P" "Paper" ) ( "R" "Rock" ) ( "L" "Lizard" ) ( "K" "Spock" ) )
true while
"Choose (S)cissors, (P)paper, (R)ock, (L)izard, Spoc(K) or (Q)uit: " input nl upper
dup "Q" == if
nl drop false
else
getd if
dup "You choose " print ? var he
rand 5 * int 1 + 2 2 tolist sget
dup "I choose " print ? var ce
he ce == if
"Draw" ?
else
swap len for
get dup
split 2 del
he ce 2 tolist
over over == rot rot reverse == or if exitfor else drop endif
endfor
dup ?
he find 1 == if wh 1 + var wh "You win!" else wc 1 + var wc "I win!" endif ? drop
swap
endif
else
print " is a invalid input!" ?
endif
true
endif
endwhile
drop drop
"Your punctuation: " print wh ?
"Mi punctuation: " print wc ?
wh wc > if "You win!" else wh wc < if "I win!" else "Draw!" endif endif ?</syntaxhighlight>
{{out}}
<pre>'Rock, Paper, Scissors, Lizard, Spock!' rules are:
Scissors cuts Paper
Paper covers Rock
Rock crushes Lizard
Lizard poisons Spock
Spock smashes Scissors
Scissors decapites Lizard
Lizard eats Paper
Paper disproves Spock
Spock vaporizes Rock
Rock blunts Scissors
Choose (S)cissors, (P)paper, (R)ock, (L)izard, Spoc(K) or (Q)uit: k
You choose Spock
I choose Rock
Spock vaporizes Rock
You win!
Choose (S)cissors, (P)paper, (R)ock, (L)izard, Spoc(K) or (Q)uit: q
Your punctuation: 1
Mi punctuation: 0
You win!
=== Press any key to exit ===</pre>
=={{header|PHP}}==
'''Use the url bar to play'''
e.g: www.example.com/rockpaper.php?moves=paper
<br>
www.example.com/rockpaper.php?moves=rock
----
<syntaxhighlight lang="php">
<?php
echo "<h1>" . "Choose: ROCK - PAPER - SCISSORS" . "</h1>";
echo "<h2>";
echo "";
$player = strtoupper( $_GET["moves"] );
$wins = [
'ROCK' => 'SCISSORS',
'PAPER' => 'ROCK',
'SCISSORS' => 'PAPER'
];
$a_i = array_rand($wins);
echo "<br>";
echo "Player chooses " . "<i style=\"color:blue\">" . $player . "</i>";
echo "<br>";
echo "<br>" . "A.I chooses " . "<i style=\"color:red\">" . $a_i . "</i>";
$results = "";
if ($player == $a_i){
$results = "Draw";
} else if($wins[$a_i] == $player ){
$results = "A.I wins";
} else {
$results = "Player wins";
}
echo "<br>" . $results;
?>
</syntaxhighlight>
=={{header|Picat}}==
{{trans|Prolog}}
(Some part is from the Prolog version.)
<syntaxhighlight lang="picat">go ?=>
println("\nEnd terms with '.'.\n'quit.' ends the session.\n"),
Prev = findall(P,beats(P,_)),
ChoiceMap = new_map([P=0 : P in Prev]),
ResultMap = new_map([computer_wins=0,user_wins=0,draw=0]),
play(Prev,ChoiceMap,ResultMap),
nl,
println("Summary:"),
println(choiceMap=ChoiceMap),
println(resultMap=ResultMap),
nl.
go => true.
%
% Play an interactive game.
%
play(Prev,ChoiceMap,ResultMap) =>
print("Your choice? "),
P = read_term(),
if P == quit then
nl,
print_result(ResultMap)
else
C = choice(ChoiceMap),
printf("The computer chose %w%n", C),
result(C,P,Prev,Next,Result),
ChoiceMap.put(P,ChoiceMap.get(P)+1),
ResultMap.put(Result,ResultMap.get(Result,0)+1),
play(Next,ChoiceMap,ResultMap)
end.
%
% Do a weighted random choice based on the user's previous choices.
%
weighted_choice(Map) = Choice =>
Map2 = [(V+1)=K : K=V in Map].sort, % ensure that all choices can be made
% Prepare the probability matrix M
Total = sum([P : P=_ in Map2]),
Len = Map2.len,
M = new_array(Len,2),
T = new_list(Len),
foreach({I,P=C} in zip(1..Len,Map2))
if I == 1 then
M[I,1] := 1,
M[I,2] := P
else
M[I,1] := M[I-1,2]+1,
M[I,2] := M[I,1]+P-1
end,
T[I] := C
end,
M[Len,2] := Total,
% Pick a random number in 1..Total
R = random(1,Total),
Choice = _,
% Check were R match
foreach(I in 1..Len, var(Choice))
if M[I,1] <= R, M[I,2] >= R then
Choice := T[I]
end
end.
%
% Check probably best counter choice.
%
choice(Map) = Choice =>
% what is the Player's probably choice
PlayersProbablyMove = weighted_choice(Map),
% select the choice that beats it
beats(Choice,PlayersProbablyMove).
print_result(ResultMap) =>
foreach(C in ResultMap.keys)
println(C=ResultMap.get(C))
end,
nl.
% This part is from the Prolog version.
result(C,P,R,[C|R],Result) :-
beats(C,P),
Result = computer_wins,
printf("Computer wins.\n").
result(C,P,R,[B|R],Result) :-
beats(P,C),
beats(B,P),
Result=user_wins,
printf("You win!%n").
result(C,C,R,[B|R],Result) :-
beats(B,C),
Result=draw,
printf("It is a draw\n").
beats(paper, rock).
beats(rock, scissors).
beats(scissors, paper).</syntaxhighlight>
Sample result when user only plays rock.
{{out}}
<pre>End terms with '.'.
'quit.' ends the session.
Your choice? rock.
The computer chose paper
Computer wins.
Your choice? rock.
The computer chose paper
Computer wins.
Your choice? rock.
The computer chose paper
Computer wins.
Your choice? rock.
The computer chose rock
It is a draw
Your choice? rock.
The computer chose rock
It is a draw
Your choice? quit.
computer_wins = 3
user_wins = 0
draw = 2
Summary:
choiceMap = (map)[rock = 5,paper = 0,scissors = 0]
resultMap = (map)[computer_wins = 3,user_wins = 0,draw = 2]</pre>
=={{header|PicoLisp}}==
<
(let (Rock 0 Paper 0 Scissors 0)
(loop
Line 3,108 ⟶ 4,603:
((== Your (car Mine)) "I win")
(T "You win") ) )
(inc Your) ) ) )</
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
rock: procedure options (main); /* 30 October 2013 */
declare move character (1), cm fixed binary;
Line 3,143 ⟶ 4,638:
end;
end rock;
</syntaxhighlight>
=={{header|Prolog}}==
<syntaxhighlight lang="prolog">play :-
findall(P,beats(P,_),Prev),
play(Prev).
play(Prev) :-
write('your choice? '),
read(P),
random_member(C, Prev),
format('The computer chose ~p~n', C),
result(C,P,Prev,Next),
!,
play(Next).
result(C,P,R,[C|R]) :-
beats(C,P),
format('Computer wins.~n').
result(C,P,R,[B|R]) :-
beats(P,C),
beats(B,P),
format('You win!~n').
result(C,C,R,[B|R]) :-
beats(B,C),
format('It is a draw~n').
beats(paper, rock).
beats(rock, scissors).
beats(scissors, paper).</syntaxhighlight>
=={{header|PureBasic}}==
<
;choices are in listed according to their cycle, weaker followed by stronger
#rock
Line 3,229 ⟶ 4,753:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</
Sample output:
<pre style="height:40ex;overflow:scroll">Welcome to the game of rock-paper-scissors
Line 3,281 ⟶ 4,805:
The <code>rules</code> dictionary is of the form <code>'this': beaten by 'that', etc</code> as opposed to <code>'this': beats 'that'</code>.
<
rules = {'rock': 'paper', 'scissors': 'rock', 'paper': 'scissors'}
Line 3,288 ⟶ 4,812:
while True:
human = input('\nchoose your weapon: ')
computer = rules[choice(previous)] # choose the weapon which beats a randomly chosen weapon from "previous"
if human in ('quit', 'exit'): break
elif human in rules:
previous.append(human)
print('the computer played', computer, end='; ')
if rules[computer] == human: # if what beats the computer's choice is the human's choice...
print('yay you win!')
elif rules[human] == computer: # if what beats the human's choice is the computer's choice...
print('the computer beat you... :(')
else: print("it's a tie!")
else: print("that's not a valid choice")</
Output, where player always chooses Rock:
Line 3,321 ⟶ 4,844:
choose your weapon: rock
the computer played paper; the computer beat you... :(</pre>
This is another code. Output is as same as the above output.
<syntaxhighlight lang="python">from random import randint
hands = ['rock', 'scissors', 'paper']; judge = ['its a tie!', 'the computer beat you... :(', 'yay you win!']
while True:
try:
YOU = hands.index(input('Choose your weapon: ')) # YOU = hands.index(raw_input('Choose your weapon: ')) If you use Python2.7
except ValueError:
break
NPC = randint(0, 2)
print('The computer played ' + hands[NPC] + '; ' + judge[YOU-NPC])</syntaxhighlight>
=={{header|Quackery}}==
<syntaxhighlight lang="Quackery">
[ 0 ] is rock ( --> n )
[ 1 ] is paper ( --> n )
[ 2 ] is scissor ( --> n )
[ $ "Choose rock, paper or scissors: "
input cr
trim reverse trim reverse
$ "" swap witheach [ lower join ]
dup $ "rock" = iff
[ drop rock ] done
dup $ "paper" = iff
[ drop paper ] done
$ "scissors" = iff
scissor done
again ] is player ( --> n )
[ stack 1 ] is rocks ( --> s )
[ stack 1 ] is papers ( --> s )
[ stack 1 ] is scissors ( --> s )
[ 1 swap
[ table rocks papers scissors ]
do tally ] is notechoice ( n --> )
[ 0 ' [ rocks papers scissors ]
witheach [ share + ]
random
dup rocks share < iff
[ drop paper ] done
rocks share -
papers share < iff
scissor done
rock ] is computer ( --> n )
[ say "Computer chose "
[ table rock paper scissors ]
echo say "." cr ] is echomove ( n --> )
[ [ table
[ table 0 1 2 ]
[ table 2 0 1 ]
[ table 1 2 0 ] ] do ] is result ( n n --> n )
[ [ table
$ "It's a draw."
$ "Computer wins."
$ "Player wins." ]
do echo$ cr cr ] is announce ( n --> )
[ stack 0 ] is draws ( --> s )
[ stack 0 ] is cwins ( --> s )
[ stack 0 ] is pwins ( --> s )
[ [ table draws cwins pwins ]
1 swap tally ] is keepscore ( n --> )
[ say "Computer: " cwins share echo
say " Player: " pwins share echo
say " Draws: " draws share echo
cr cr ] is scoreboard ( --> )
[ ' [ rocks papers scissors ]
witheach [ 1 swap replace ]
' [ draws cwins pwins ]
witheach [ 0 swap replace ] ] is initialise ( --> )
[ 0
[ drop
$ "How many games? " input
trim reverse trim reverse
$->n until ]
cr ] is games ( --> n )
[ initialise
games times
[ computer
player dup notechoice
over echomove
result dup announce
keepscore
scoreboard ] ] is play ( --> )</syntaxhighlight>
{{out}}
As a dialogue in the Quackery shell.
<pre>/O> play
...
How many games? 3
Choose rock, paper or scissors: rock
Computer chose rock.
It's a draw.
Computer: 0 Player: 0 Draws: 1
Choose rock, paper or scissors: paper
Computer chose scissors.
Computer wins.
Computer: 1 Player: 0 Draws: 1
Choose rock, paper or scissors: scissors
Computer chose paper.
Player wins.
Computer: 1 Player: 1 Draws: 1
Stack empty.
/O></pre>
=={{header|R}}==
This milks R's vectorisation quite heavily. However, this approach doesn't generalise well to the extra credit task. In particular, the last two lines of the loop would need a lot of work to be both non-ugly and working.
<syntaxhighlight lang="rsplus">play <- function()
{
bias <- c(r = 1, p = 1, s = 1)
repeat
{
playerChoice <- readline(prompt = "Rock (r), Paper (p), Scissors (s), or Quit (q)? ")
if(playerChoice == "q") break
rps <- c(Rock = "r", Paper = "p", Scissors = "s")
if(!playerChoice %in% rps) next
compChoice <- sample(rps, 1, prob = bias / sum(bias))
cat("I choose", names(compChoice), "\n",
c("We draw!", "I win!", "I lose!")[1 + (which(compChoice == rps) - which(playerChoice == rps)) %% 3], "\n")
bias <- bias + (playerChoice == c("s", "r", "p"))
}
}
play()</syntaxhighlight>
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
(require math)
(define history (make-hash '((paper . 1) (scissors . 1) (rock . 1))))
(define total 3)
(define (update-history! human-choice)
(set! total (+ total 1))
(hash-update! history human-choice add1 0))
(define (pick-one)
(sample
(discrete-dist '(paper scissors rock)
(map (λ (x) (hash-ref history x))
'(scissors paper rock)))))
(define (find-winner computer human)
(define order '(scissors paper rock scissors))
(cond
[(eq? computer human) 'none]
[(eq? (second (member computer order)) human) 'computer]
[ 'human]))
(define (game-loop)
(define computer-choice (pick-one))
(define human-choice (read))
(define winner (find-winner computer-choice human-choice))
(update-history! human-choice)
(displayln (~a "Computer picked " computer-choice ", "
"human picked " human-choice ", "
winner " wins."))
(game-loop))
(game-loop)
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
This is slightly more complicated than it could be; it is a general case framework with input filtering. It weights the computers choices based on your previous choices. Type in at least the first two characters of your choice, or just hit enter to quit. Customize it by supplying your own <tt>%vs</tt> options/outcomes.
Here is standard Rock-Paper-Scissors.
<syntaxhighlight lang="raku" line>my %vs = (
options => [<Rock Paper Scissors>],
ro => {
ro => [ 2, '' ],
pa => [ 1, 'Paper covers Rock: ' ],
sc => [ 0, 'Rock smashes Scissors: ' ]
},
pa => {
ro => [ 0, 'Paper covers Rock: ' ],
pa => [ 2, '' ],
sc => [ 1, 'Scissors cut Paper: ' ]
},
sc => {
ro => [ 1, 'Rock smashes Scissors: '],
pa => [ 0, 'Scissors cut Paper: ' ],
sc => [ 2, '' ]
}
);
my %choices = %vs<options>.map({; $_.substr(0,2).lc => $_ });
my $keys = %choices.keys.join('|');
my $prompt = %vs<options>.map({$_.subst(/(\w\w)/, -> $/ {"[$0]"})}).join(' ')~"? ";
my %weight = %choices.keys »=>» 1;
my @stats = 0,0,0;
my $round;
while my $player = (prompt "Round {++$round}: " ~ $prompt).lc {
$player.=substr(0,2);
say 'Invalid choice, try again.' and $round-- and next
unless $player.chars == 2 and $player ~~ /<$keys>/;
my $computer = (flat %weight.keys.map( { $_ xx %weight{$_} } )).pick;
%weight{$_.key}++ for %vs{$player}.grep( { $_.value[0] == 1 } );
my $result = %vs{$player}{$computer}[0];
@stats[$result]++;
say "You chose %choices{$player}, Computer chose %choices{$computer}.";
print %vs{$player}{$computer}[1];
print ( 'You win!', 'You Lose!','Tie.' )[$result];
say " - (W:{@stats[0]} L:{@stats[1]} T:{@stats[2]})\n",
};</syntaxhighlight>Example output:
<pre>Round 1: [Ro]ck [Pa]per [Sc]issors? ro
You chose Rock, Computer chose Paper.
Paper covers Rock: You Lose! - (W:0 L:1 T:0)
Round 2: [Ro]ck [Pa]per [Sc]issors? pa
You chose Paper, Computer chose Scissors.
Scissors cut Paper: You Lose! - (W:0 L:2 T:0)
Round 3: [Ro]ck [Pa]per [Sc]issors? pa
You chose Paper, Computer chose Scissors.
Scissors cut Paper: You Lose! - (W:0 L:3 T:0)
Round 4: [Ro]ck [Pa]per [Sc]issors? ro
You chose Rock, Computer chose Rock.
Tie. - (W:0 L:3 T:1)
Round 5: [Ro]ck [Pa]per [Sc]issors? sc
You chose Scissors, Computer chose Scissors.
Tie. - (W:0 L:3 T:2)
...</pre>
Here is example output from the same code only with a different %vs data structure implementing [http://en.wikipedia.org/wiki/Rock-paper-scissors-lizard-Spock Rock-Paper-Scissors-Lizard-Spock].
<syntaxhighlight lang="raku" line>my %vs = (
options => [<Rock Paper Scissors Lizard Spock>],
ro => {
ro => [ 2, '' ],
pa => [ 1, 'Paper covers Rock: ' ],
sc => [ 0, 'Rock smashes Scissors: ' ],
li => [ 0, 'Rock crushes Lizard: ' ],
sp => [ 1, 'Spock vaporizes Rock: ' ]
},
pa => {
ro => [ 0, 'Paper covers Rock: ' ],
pa => [ 2, '' ],
sc => [ 1, 'Scissors cut Paper: ' ],
li => [ 1, 'Lizard eats Paper: ' ],
sp => [ 0, 'Paper disproves Spock: ' ]
},
sc => {
ro => [ 1, 'Rock smashes Scissors: ' ],
pa => [ 0, 'Scissors cut Paper: ' ],
sc => [ 2, '' ],
li => [ 0, 'Scissors decapitate Lizard: '],
sp => [ 1, 'Spock smashes Scissors: ' ]
},
li => {
ro => [ 1, 'Rock crushes Lizard: ' ],
pa => [ 0, 'Lizard eats Paper: ' ],
sc => [ 1, 'Scissors decapitate Lizard: '],
li => [ 2, '' ],
sp => [ 0, 'Lizard poisons Spock: ' ]
},
sp => {
ro => [ 0, 'Spock vaporizes Rock: ' ],
pa => [ 1, 'Paper disproves Spock: ' ],
sc => [ 0, 'Spock smashes Scissors: ' ],
li => [ 1, 'Lizard poisons Spock: ' ],
sp => [ 2, '' ]
}
);</syntaxhighlight>
<pre>Round 1: [Ro]ck [Pa]per [Sc]issors [Li]zard [Sp]ock? li
You chose Lizard, Computer chose Scissors.
Scissors decapitate Lizard: You Lose! - (W:0 L:1 T:0)
Round 2: [Ro]ck [Pa]per [Sc]issors [Li]zard [Sp]ock? sp
You chose Spock, Computer chose Paper.
Paper disproves Spock: You Lose! - (W:0 L:2 T:0)
Round 3: [Ro]ck [Pa]per [Sc]issors [Li]zard [Sp]ock? ro
You chose Rock, Computer chose Lizard.
Rock crushes Lizard: You Win! - (W:1 L:2 T:0)
Round 4: [Ro]ck [Pa]per [Sc]issors [Li]zard [Sp]ock? ro
You chose Rock, Computer chose Scissors.
Rock smashes Scissors: You win! - (W:2 L:2 T:0)
Round 5: [Ro]ck [Pa]per [Sc]issors [Li]zard [Sp]ock? li
You chose Lizard, Computer chose Paper.
Lizard eats Paper: You win! - (W:3 L:2 T:0)
...</pre>
=={{header|Rascal}}==
<
rel[str, str] whatbeats = {<"Rock", "Scissors">, <"Scissors", "Paper">, <"Paper", "Rock">};
Line 3,342 ⟶ 5,182:
ComputerChoices += x;
return "Computer played <computer>. <CheckWinner(human, computer)> wins!";
}</
Sample output:
<
str: "Computer played Rock. Nobody wins!"
Line 3,372 ⟶ 5,212:
rascal>RPS("Rock")
str: "Computer played Paper. Paper wins!"</
=={{header|
<syntaxhighlight lang="rebol">
Red [Purpose: "Implement a rock-paper-scissors game with weighted probability"]
prior: rejoin choices: ["r" "p" "s"]
while [
find choices pchoice: ask "choose rock: r, paper: p, or scissors: s^/"
] [
print ["AI Draws:" cchoice: random/only prior]
cwin: select "rpsr" pchoice
close: select "rspr" pchoice
print case [
pchoice = cchoice ["tie"]
cchoice = cwin ["you lose"]
'else ["you win"]
]
append prior cwin ;adds what would have beaten player
remove find prior close ;removes what would have lost to player
]
</syntaxhighlight>
=={{header|REXX}}==
===traditional, 3 choices===
This REXX program version:
::* allows the human player to
::* issues appropriate error messages for an incorrect (or no) choice(s)
::*
::* keeps track of the human player's responses (to hopefully make future computer winning choices)
::* uses better "English"/grammer, i.e.: ''rock breaks scissors'', and ''paper covers rock''.
<syntaxhighlight lang="rexx">/*REXX program plays rock─paper─scissors with a human; tracks what human tends to use. */
prompt= ! 'Please enter one of: Rock Paper Scissors (or Quit)'
$.p= 'paper' ; $.s= "scissors"; $.r= 'rock' /*list of the choices in this program. */
t.p= $.r ; t.s= $.p ; t.r= $.s /*thingys that beats stuff. */
w.p= $.s ; w.s= $.r ; w.r= $.p /*stuff " " thingys. */
b.p= 'covers'; b.s= "cuts" ; b.r= 'breaks' /*verbs: how the choice wins. */
do forever; say; say
c= word(
m= max(@.r, @.p, @.s);
if @.p==m then
if @.s==m then
when words(u)
when
when abbrev('
abbrev('
otherwise
end /*select*/
if \ok then iterate /*answer ¬
@.a1
say ! 'computer chose: ' c
if a1==
if $.a1==t.c1 then say ! 'the computer wins. ' ! $.c1 b.c1 $.a1
else say ! 'you win! ' ! $.a1 b.a1 $.c1
end
{{out|output|text= with various responses from the user (output shown is a screen scraping):}}
<pre>
──────── Please enter one of: Rock Paper Scissors (or Quit)
s ◄■■■■■■■■■■■■■■■ human input.
──────── computer chose: rock
──────── the computer wins. ──────── rock
──────── Please enter one of: Rock Paper Scissors (or Quit)
s ◄■■■■■■■■■■■■■■■ human input.
──────── computer chose: rock
──────── the computer wins. ──────── rock
──────── Please enter one of: Rock Paper Scissors (or Quit)
s ◄■■■■■■■■■■■■■■■ human input.
──────── computer chose: rock
──────── the computer wins. ──────── rock
──────── Please enter one of: Rock Paper Scissors (or Quit)
s ◄■■■■■■■■■■■■■■■ human input.
──────── computer chose: rock
──────── the computer wins. ──────── rock
──────── Please enter one of: Rock Paper Scissors (or Quit)
s ◄■■■■■■■■■■■■■■■ human input.
──────── computer chose: rock
──────── the computer wins. ──────── rock
──────── Please enter one of: Rock Paper Scissors (or Quit)
p ◄■■■■■■■■■■■■■■■ human input.
──────── computer chose: rock
──────── you win! ──────── paper
──────── Please enter one of: Rock Paper Scissors (or Quit)
q ◄■■■■■■■■■■■■■■■ human input.
──────── quitting.
</pre>
===extended, 5 choices===
This REXX version supports more choices: <big> rock paper scissors lizard Spock </big>
<syntaxhighlight lang="rexx">/*REXX pgm plays rock─paper─scissors─lizard─Spock with human; tracks human usage trend. */
!= '────────'; err=! "***error***"; @.=0 /*some constants for this REXX program.*/
prompt=! 'Please enter one of: Rock Paper SCissors Lizard SPock (Vulcan) (or Quit)'
$.p='paper' ; $.s="scissors" ; $.r='rock' ; $.L="lizard" ; $.v='Spock' /*names of the thingys*/
t.p= $.r $.v ; t.s= $.p $.L ; t.r= $.s $.L ; t.L= $.p $.v ; t.v= $.r $.s /*thingys beats stuff.*/
w.p= $.L $.s ; w.s= $.v $.r ; w.r= $.v $.p ; w.L= $.r $.s ; w.v= $.L $.p /*stuff beats thingys.*/
b.p='covers disproves'; b.s="cuts decapitates"; b.r='breaks crushes'; b.L="eats poisons"; b.v='vaporizes smashes' /*how the choice wins.*/
whom.1= ! 'the computer wins. ' !; whom.2= ! "you win! " !; win= words(t. p)
do forever; say; say prompt; say /*prompt CBLF; then get a response. */
c= word($.p $.s $.r $.L $.v, random(1, 5) ) /*the computer's first choice/pick. */
m= max(@.r, @.p, @.s, @.L, @.v) /*used in examining CBLF's history. */
if @.p==m then c= word(w.p, random(1, 2) ) /*emulate JC's The Amazing Karnac. */
if @.s==m then c= word(w.s, random(1, 2) ) /* " " " " " */
if @.r==m then c= word(w.r, random(1, 2) ) /* " " " " " */
if @.L==m then c= word(w.L, random(1, 2) ) /* " " " " " */
if @.v==m then c= word(w.v, random(1, 2) ) /* " " " " " */
c1= left(c, 1) /*C1 is used for faster comparing. */
parse pull u; a= strip(u) /*obtain the CBLF's choice/pick. */
upper a c1 ; a1= left(a, 1) /*uppercase the choices, get 1st char. */
ok=0 /*indicate answer isn't OK (so far). */
select /* [↓] process the CBLF's choice/pick.*/
when words(u)==0 then say err 'nothing entered.'
when words(u)>1 then say err 'too many choices: ' u
when abbrev('QUIT', a) then do; say ! 'quitting.'; exit; end
when abbrev('LIZARD', a) |,
abbrev('ROCK', a) |,
abbrev('PAPER', a) |,
abbrev('VULCAN', a) |,
abbrev('SPOCK', a,2) |,
abbrev('SCISSORS',a,2) then ok=1 /*it's a valid choice for the human. */
otherwise say err 'you entered a bad choice: ' u
end /*select*/
if \ok then iterate /*answer ¬OK? Then get another choice.*/
@.a1= @.a1 + 1 /*keep a history of the CBLF's choices.*/
say ! 'computer chose: ' c
if a1==c1 then say ! 'draw.' /*Oh rats! The contest ended up a draw*/
else do who=1 for 2 /*either the computer or the CBLF won. */
if who==2 then parse value a1 c1 with c1 a1
do j=1 for win /*see who won. */
if $.a1 \== word(t.c1, j) then iterate /*not this 'un. */
say whom.who $.c1 word(b.c1, j) $.a1 /*notify winner.*/
leave /*leave J loop.*/
end /*j*/
end /*who*/
end /*forever*/ /*stick a fork in it, we're all done. */</syntaxhighlight>
{{out|output|text= is similar to the 1<sup>st</sup> REXX version.}} <br><br>
=={{header|Ring}}==
<syntaxhighlight lang="ring">
# Project : Rock-paper-scissors
load "stdlib.ring"
load "guilib.ring"
width = 200
height = 200
myChose = 1
compChose = 1
nextPlayer = 1
myScore = 0
compScore = 0
C_FONTSIZE = 15
C_ROCK = "images/rock.jpg"
C_PAPER = "images/paper.jpg"
C_SCISSORS = "images/scissors.jpg"
ChoseList = [C_ROCK,C_PAPER,C_SCISSORS]
Button = list(len(ChoseList))
app = new QApp
{
StyleFusion()
win = new QWidget() {
setWindowTitle('Stone Paper Scissors Game')
setWinIcon(self,C_ROCK)
setStyleSheet("background-color:cyan;")
setWindowFlags(Qt_Window | Qt_WindowTitleHint | Qt_WindowCloseButtonHint | Qt_CustomizeWindowHint)
reSize(900,600)
winheight = height()
fontSize = 8 + (winheight / 100)
for Col = 1 to len(ChoseList)
Button[Col] = new QPushButton(win) {
x = 150+(Col-1)*height
setgeometry(x,35,width,height)
setStyleSheet("background-color:white;")
seticon(new qicon(new qpixmap(ChoseList[Col])))
setIconSize(new qSize(200,200))
setclickevent("ButtonPress(" + string(Col) + ")")
setSizePolicy(1,1)
}
next
labelMyChose = new QLabel(win) {
setgeometry(200,250,150,30)
setFont(new qFont("Verdana",C_FONTSIZE,50,0))
settext("My Chose:")
}
labelCompChose = new QLabel(win) {
setgeometry(580,250,150,30)
setFont(new qFont("Verdana",C_FONTSIZE,50,0))
settext("Comp Chose:")
}
labelScoreEnd = new QLabel(win) {
setgeometry(0,510,win.width(),30)
setAlignment(Qt_AlignHCenter | Qt_AlignVCenter)
setFont(new qFont("Verdana",C_FONTSIZE,50,0))
settext("")
}
btnMyChose = new QPushButton(win) {
setgeometry(150,300,width,height)
setStyleSheet("background-color:white;")
}
btnCompChose = new QPushButton(win) {
setgeometry(550,300,width,height)
setStyleSheet("background-color:white;")
}
btnNewGame = new QPushButton(win) {
setgeometry(170,550,150,40)
setFont(new qFont("Verdana",C_FONTSIZE,50,0))
setclickevent("NewGame()")
settext("New Game")
}
btnExit = new QPushButton(win) {
setgeometry(580,550,150,40)
setFont(new qFont("Verdana",C_FONTSIZE,50,0))
setclickevent("Close()")
settext("Exit")
}
labelMyScore = new QLabel(win) {
setgeometry(170,0,100,30)
setFont(new qFont("Verdana",C_FONTSIZE,50,0))
settext("My Score: ")
}
labelMyScoreSum = new QLabel(win) {
setgeometry(300,0,100,30)
setFont(new qFont("Verdana",C_FONTSIZE,50,0))
settext("")
}
labelCompScore = new QLabel(win) {
setgeometry(580,0,130,30)
setFont(new qFont("Verdana",C_FONTSIZE,50,0))
settext("Comp Score: ")
}
labelCompScoreSum = new QLabel(win) {
setgeometry(730,0,100,30)
setFont(new qFont("Verdana",C_FONTSIZE,50,0))
settext("")
}
show()
}
exec()
}
func ButtonPress Col
if nextPlayer = 1
myChose = Col
btnMyChose {
seticon(new qicon(new qpixmap(ChoseList[Col])))
setIconSize(new qSize(width,height))
}
nextPlayer = 2
compChose()
ok
func compChose
rndChose = random(len(ChoseList)-1) + 1
compChose = rndChose
btnCompChose {
seticon(new qicon(new qpixmap(ChoseList[compChose])))
setIconSize(new qSize(width,height))
}
nextPlayer = 1
Result()
func Result
if (myChose = compChose)
labelScoreEnd.settext("Draw!")
ok
if (myChose = 1) and (compChose = 2)
labelScoreEnd.settext("Computer Win!")
compScore = compScore + 1
labelCompScoreSum.settext(string(compScore))
ok
if (myChose = 1) and (compChose = 3)
labelScoreEnd.settext("I Win!")
myScore = myScore + 1
labelMyScoreSum.settext(string(myScore))
ok
if (myChose = 2) and (compChose = 3)
labelScoreEnd.settext("Computer Win!")
compScore = compScore + 1
labelCompScoreSum.settext(string(compScore))
ok
if (myChose = 2) and (compChose = 1)
labelScoreEnd.settext("I Win!")
myScore = myScore + 1
labelMyScoreSum.settext(string(myScore))
ok
if (myChose = 3) and (compChose = 1)
labelScoreEnd.settext("Computer Win!")
compScore = compScore + 1
labelCompScoreSum.settext(string(compScore))
ok
if (myChose = 3) and (compChose = 2)
labelScoreEnd.settext("I Win!")
myScore = myScore + 1
labelMyScoreSum.settext(string(myScore))
ok
func NewGame
nextPlayer = 1
myScore = 0
compScore = 0
btnMyChose {
seticon(new qicon(new qpixmap("")))
setIconSize(new qSize(200,200))
}
btnCompChose {
seticon(new qicon(new qpixmap("")))
setIconSize(new qSize(200,200))
}
labelScoreEnd.settext("")
labelMyScoreSum.settext("0")
labelCompScoreSum.settext("0")
func Close
win.close()
app.quit()
</syntaxhighlight>
[https://github.com/ring-lang/ring/tree/master/applications/rockpaperscissors Rock Paper Scissors - image]
=={{header|Ruby}}==
<
CHOICES = %w[rock paper scissors quit]
BEATS = {
Line 3,566 ⟶ 5,660:
end
RockPaperScissorsGame.new</
sample game where human always chooses rock:
Line 3,616 ⟶ 5,710:
=={{header|Run BASIC}}==
<
rps$ = "Rock,Paper,Sissors"
[loop]
Line 3,646 ⟶ 5,740:
print "Good Bye! I enjoyed the game"
end
</syntaxhighlight>
=={{header|Rust}}==
<syntaxhighlight lang="rust">extern crate rand;
#[macro_use]
extern crate rand_derive;
use std::io;
use rand::Rng;
use Choice::*;
#[derive(PartialEq, Clone, Copy, Rand, Debug)]
enum Choice {
Rock,
Paper,
Scissors,
}
fn beats(c1: Choice, c2: Choice) -> bool {
(c1 == Rock && c2 == Scissors) || (c1 == Scissors && c2 == Paper) || (c1 == Paper && c2 == Rock)
}
fn ai_move<R: Rng>(rng: &mut R, v: [usize; 3]) -> Choice {
// weighted random choice, a dynamic version of `rand::distributions::WeightedChoice`
let rand = rng.gen_range(0, v[0] + v[1] + v[2]);
if rand < v[0] {
Paper
} else if rand < v[0] + v[1] {
Scissors
} else {
Rock
}
}
fn main() {
let mut rng = rand::thread_rng();
println!("Rock, paper, scissors!");
let mut ai_choice: Choice = rng.gen();
let mut ucf = [0, 0, 0]; // user choice frequency
let mut score = [0, 0];
loop {
println!("Please input your move: 'r', 'p' or 's'. Type 'q' to quit");
let mut input = String::new();
io::stdin()
.read_line(&mut input)
.expect("failed to read line");
let u_choice = match input.to_lowercase().trim() {
s if s.starts_with('r') => {
ucf[0] += 1;
Rock
}
s if s.starts_with('p') => {
ucf[1] += 1;
Paper
}
s if s.starts_with('s') => {
ucf[2] += 1;
Scissors
}
s if s.starts_with('q') => break,
_ => {
println!("Please enter a correct choice!");
continue;
}
};
println!("You chose {:?}, I chose {:?}.", u_choice, ai_choice);
if beats(u_choice, ai_choice) {
score[0] += 1;
println!("You win!");
} else if u_choice == ai_choice {
println!("It's a tie!");
} else {
score[1] += 1;
println!("I win!");
}
println!("-Score: You {}, Me {}", score[0], score[1]);
// only after the 1st iteration the AI knows the stats and can make
// its weighted random move
ai_choice = ai_move(&mut rng, ucf);
}
println!("Thank you for the game!");
}</syntaxhighlight>
=={{header|Scala}}==
You can invoke this game with an arbitrary number of weapons:
<
import scala.collection.mutable.LinkedHashMap
def play(beats: LinkedHashMap[Symbol,Set[Symbol]], played: scala.collection.Map[Symbol,Int]) {
Line 3,691 ⟶ 5,871:
'spock -> Set('scissors, 'rock)
))
}</
{{out}}
<pre>Your move ('rock, 'paper, 'scissors, 'lizard, 'spock): paper
Line 3,717 ⟶ 5,897:
My move: 'paper
You lost</pre>
Here's another code: (I refactored the above code, it is more functional, more testable )
<syntaxhighlight lang="scala">object RockPaperScissors extends App {
def beats = Map(
'rock -> Set('lizard, 'scissors),
'paper -> Set('rock, 'spock),
'scissors -> Set('paper, 'lizard),
'lizard -> Set('spock, 'paper),
'spock -> Set('scissors, 'rock)
)
// init with uniform probabilities
def initPlayed = beats.mapValues(_ => 1)
def input = Symbol(readLine(s"""Your move (${beats.keys mkString ", "}): """))
def random(max: Int) = scala.util.Random.nextInt(max)
def display(text: String) = print(text)
def weighted(todo: Iterator[(Symbol,Int)], rand: Int, accum: Int = 0): Symbol = todo.next match {
case (s, i) if rand <= (accum + i) => s
case (_, i) => weighted(todo, rand, accum + i)
}
def calcMyMove(random: Int => Int, played: Map[Symbol,Int]) = {
weighted(played.toIterator, 1 + random(played.values.sum)) match {
// choose an opponent that would beat the player's anticipated move
case h => beats.find{case (s, l) => l contains h}.getOrElse(beats.head)._1
}
}
case class Result(text: String, won: Int, lost: Int, drew: Int) {
override def toString = s"$text. Won: $won, Lost: $lost, Drew: $drew"
}
def getResult(userWeapon: Symbol, myMove: Symbol, result: Result) = {
if (beats(userWeapon) contains myMove)
result.copy(text = "You won", won = result.won + 1)
else if (beats(myMove) contains userWeapon)
result.copy(text = "You lost", lost = result.lost + 1)
else result.copy(text = "We drew", drew = result.drew + 1)
}
def play(input: => Symbol, display: String => Unit, random: Int => Int)
(played: Map[Symbol,Int], result: Result): Result = {
val userWeapon = input
if (userWeapon != Symbol("")) {
val newResult = if (beats contains userWeapon) {
val myMove = calcMyMove(random, played)
display(s" My move: $myMove\n ")
getResult(userWeapon, myMove, result)
} else {
result.copy(text = " Unknown weapon, try again")
}
display(newResult + "\n")
play(input, display, random)(played get userWeapon match {
case None => played
case Some(count) => played.updated(userWeapon, count + 1)
}, newResult)
} else result
}
override def main(args: Array[String]): Unit =
play(input, display, random)(initPlayed, Result("Start", 0, 0, 0))
}</syntaxhighlight>
{{out}}
<pre>
Your move ('spock, 'rock, 'lizard, 'paper, 'scissors): rock
My move: 'rock
We drew. Won: 0, Lost: 0, Drew: 1
Your move ('spock, 'rock, 'lizard, 'paper, 'scissors): spock
My move: 'spock
We drew. Won: 0, Lost: 0, Drew: 2
Your move ('spock, 'rock, 'lizard, 'paper, 'scissors): lizard
My move: 'spock
You won. Won: 1, Lost: 0, Drew: 2
Your move ('spock, 'rock, 'lizard, 'paper, 'scissors): scissors
My move: 'spock
You lost. Won: 1, Lost: 1, Drew: 2
Your move ('spock, 'rock, 'lizard, 'paper, 'scissors): scissors
My move: 'spock
You lost. Won: 1, Lost: 2, Drew: 2
Your move ('spock, 'rock, 'lizard, 'paper, 'scissors): spock
My move: 'rock
You won. Won: 2, Lost: 2, Drew: 2</pre>
=={{header|Seed7}}==
Line 3,723 ⟶ 5,985:
[http://seed7.sourceforge.net/libraries/keybd.htm#getc%28in_console_keybd_file%29 getc].
It is also possible to quit the program with q.
{{incorrect|Seed7|This example does not seem to use the weighted average AI from the task description.}}
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";
$ include "keybd.s7i";
Line 3,757 ⟶ 6,022:
until command = 'q';
writeln("Goodbye! Thanks for playing!");
end func;</
Sample run:
Line 3,779 ⟶ 6,044:
=={{header|Sidef}}==
<
const msg = [
Line 3,785 ⟶ 6,050:
"Paper covers rock",
"Scissors cut paper",
]
say <<"EOT"
\n>> Rock Paper Scissors <<\n
** Enter 'r', 'p', or 's' as your play.
Line 3,794 ⟶ 6,059:
EOT
var plays = 0
var aScore = 0
var pScore = 0
var pcf = [0,0,0]
var aChoice =
loop {
var pi = Sys.scanln("Play: ")
pi == 'q' && break
var pChoice = rps.
if (pChoice == -1) {
STDERR.print("Invalid input!\n")
next
}
++pcf[pChoice]
# show result of play
">> My play:
given ((aChoice - pChoice + 3) % 3) {
when (0) { say "Tie." }
when (1) { "%-*s %s".printlnf(30, msg[aChoice], 'My point'); aScore++ }
when (2) { "%-*s %s".printlnf(30, msg[pChoice], 'Your point'); pScore++ }
# show score
"%-6s".printf("%d:%d" % (pScore, aScore))
# compute ai choice for next play
case (rn < pcf[0]) { aChoice = 1 }
case (pcf[0]+pcf[1] > rn) { aChoice =
default { aChoice = 0 }
}
}</syntaxhighlight>
'''Sample run:'''
Line 3,867 ⟶ 6,120:
>> My play: r Paper covers rock Your point
4:1 Play: q
</pre>
=={{header|SuperCollider}}==
<pre>
// play it in the REPL, evaluating line by line
a = RockPaperScissors.new;
a.next(Scissors);
a.next(Scissors);
a.next(Scissors);
a.next(Paper);
</pre>
An implementation using classes
<pre>
Rock {
*play { |other|
^other.rock + this + "against" + other
}
*rock {
^"tie"
}
*paper {
^"loses"
}
*scissors {
^"wins"
}
*losesAgainst {
^Paper
}
}
Paper {
*play { |other|
^other.paper + this + "against" + other
}
*paper {
^"tie"
}
*scissors {
^"loses"
}
*rock {
^"wins"
}
*losesAgainst {
^Scissors
}
}
Scissors {
*play { |other|
^other.scissors + this + "against" + other
}
*scissors {
^"tie"
}
*rock {
^"loses"
}
*paper {
^"wins"
}
*losesAgainst {
^Rock
}
}
RockPaperScissors {
var opponentMoves;
*new {
^super.new.init
}
init {
opponentMoves = Bag.new;
}
findBestMatch {
var typicalMove = opponentMoves.wchoose;
if(typicalMove.isNil) { ^[Rock, Paper, Scissors].choose };
^typicalMove.losesAgainst
}
next { |otherMove|
var myMove = this.findBestMatch;
opponentMoves.add(otherMove);
^play(otherMove, myMove)
}
}
</pre>
=={{header|Swift}}==
<syntaxhighlight lang="swift">enum Choice: CaseIterable {
case rock
case paper
case scissors
case lizard
case spock
}
extension Choice {
var weaknesses: Set<Choice> {
switch self {
case .rock:
return [.paper, .spock]
case .paper:
return [.scissors, .lizard]
case .scissors:
return [.rock, .spock]
case .lizard:
return [.rock, .scissors]
case .spock:
return [.paper, .lizard]
}
}
}
struct Game {
private(set) var history: [(Choice, Choice)] = []
private(set) var p1Score: Int = 0
private(set) var p2Score: Int = 0
mutating func play(_ p1Choice: Choice, against p2Choice: Choice) {
history.append((p1Choice, p2Choice))
if p2Choice.weaknesses.contains(p1Choice) {
p1Score += 1
} else if p1Choice.weaknesses.contains(p2Choice) {
p2Score += 1
}
}
}
func aiChoice(for game: Game) -> Choice {
if let weightedWeekness = game.history.flatMap({ $0.0.weaknesses }).randomElement() {
return weightedWeekness
} else {
// If history is empty, return random Choice
return Choice.allCases.randomElement()!
}
}
var game = Game()
print("Type your choice to play a round, or 'q' to quit")
loop: while true {
let choice: Choice
switch readLine().map({ $0.lowercased() }) {
case "r", "rock":
choice = .rock
case "p", "paper":
choice = .paper
case "scissors":
choice = .scissors
case "l", "lizard":
choice = .lizard
case "spock":
choice = .spock
case "q", "quit", "exit":
break loop
case "s":
print("Do you mean Spock, or scissors?")
continue
default:
print("Unknown choice. Type 'q' to quit")
continue
}
let p2Choice = aiChoice(for: game)
print("You played \(choice) against \(p2Choice)")
game.play(choice, against: p2Choice)
print("Current score: \(game.p1Score) : \(game.p2Score)")
}</syntaxhighlight>
'''Sample run:'''
<pre>
Type your choice to play a round, or 'q' to quit
r
You played rock against paper
Current score: 0 : 1
Paper
You played paper against paper
Current score: 0 : 1
spock
You played spock against lizard
Current score: 0 : 2
lizard
You played lizard against paper
Current score: 1 : 2
q
</pre>
=={{header|Tcl}}==
<
### Choices are represented by integers, which are indices into this list:
Line 3,933 ⟶ 6,396:
# Update the state of how the human has played in the past
lset states $humanMove [expr {[lindex $states $humanMove] + 1}]
}</
Sample run:
<pre>
Line 3,965 ⟶ 6,428:
Bye!
</pre>
=={{header|TI-83 BASIC}}==
<syntaxhighlight lang="ti83b">PROGRAM:RPS
:{0,0,0}→L1
:{0,0,0}→L2
:Lbl ST
:Disp "R/P/S"
:Disp "1/2/3"
:Lbl EC
:Input A
:If A>3 or A<1
:Then
:Goto NO
:End
:randInt(1,3+L1(1)+L1(2)+L1(3)→C
:If C≤1+L1(1)
:Then
:2→B
:Goto NS
:End
:If C>2+L1(2)
:Then
:1→B
:Else
:3→B
:End
:Lbl NS
:L1(A)+1→L1(A)
:If A=B
:Then
:Disp "TIE GAME"
:L2(3)+1→L2(3)
:Goto TG
:End
:If (A=1 and B=2) or (A=2 and B=3) or (A=3 and B=1)
:Then
:Disp "I WIN"
:L2(1)+1→L2(1)
:Else
:Disp "YOU WIN"
:L2(2)+1→L2(2)
:End
:Lbl TG
:Disp "PLAY AGAIN?"
:Input Str1
:If Str1="YES"
:Then
:ClrHome
:Goto ST
:Else
:Goto EN
:End
:Lbl NO
:ClrHome
:Pause "PICK 1,2, or 3"
:ClrHome
:Goto EC
:Lbl EN
:ClrHome
:Disp "I WON:"
:Disp L2(1)
:Disp "YOU WON:"
:Disp L2(2)
:Disp "WE TIED:"
:Disp L2(3)
:Disp "BYE"
</syntaxhighlight>
{{omit from|GUISS}}
=={{header|TorqueScript}}==
Line 3,970 ⟶ 6,502:
Rock Paper Scissors in TorqueScript:
<syntaxhighlight lang="torquescript">
while(isobject(RockPaperScissors))
RockPaperScissors.delete();
Line 4,111 ⟶ 6,643:
return %result;
}
</syntaxhighlight>
To begin do:
<syntaxhighlight lang="torquescript">
RockPaperScissors.startGame();
</syntaxhighlight>
Choose and play!
<syntaxhighlight lang="torquescript">
choose("Rock");
</syntaxhighlight>
=> You chose rock computer chose paper, you lose!
=={{header|uBasic/4tH}}==
This implementation uses a 6-bits binary scheme, where the lower three bits represent the choice of the user and the higher three bits the choice of the computer:
{{incorrect|uBasic/4tH|This example does not seem to use the weighted average AI from the task description.}}
<syntaxhighlight lang="text"> 20 LET P=0: LET Q=0: LET Z=0
30 INPUT "Rock, paper, or scissors (1 = rock, 2 = paper, 3 = scissors)? ", A
40 IF A>3 THEN GOTO 400
Line 4,214 ⟶ 6,679:
340 Q=Q+1 : PRINT "You chose 'paper', I chose 'scissors'. I win!" : GOTO 30
360 Z=Z+1 : PRINT "We both chose 'scissors'. It's a draw." : GOTO 30
400 PRINT "There were ";Z;" draws. I lost ";P;" times, you lost ";Q;" times." : END</
A sample game:
Line 4,234 ⟶ 6,699:
=={{header|UNIX Shell}}==
{{works with|Bourne Again Shell|4}}
<
choices=(rock paper scissors)
Line 4,296 ⟶ 6,761:
echo "You picked ${choices[i]} $(( human_counts[ (i+1)%3 ] - 1 )) times."
echo "I picked ${choices[i]} $(( computer_counts[i] )) times."
done</
=={{header|V (Vlang)}}==
Semi-translation of Go version:
<syntaxhighlight lang="v (vlang)">
import rand
import os
const (
rps = 'rps'
msg = [
'Rock breaks scissors',s
'Paper covers rock',
'Scissors cut paper'
]
)
fn main() {
println("Rock Paper Scissors")
println("Enter r, p, or s as your play. Anything else ends the game.")
println("Running score shown as <your wins>:<my wins>")
mut pi :='' // player input
mut a_score, mut p_score := 0, 0
mut pcf := []int{len: 2, init: 0} // pcf = player choice frequency
mut a_choice := rand.intn(3) or {0} // ai choice for first play is completely random
for _ in 0..6 {
// get player choice
pi = os.input('Play: ').str()
if typeof(pi).name != 'string' || pi.len != 1 {break}
p_choice := rps.index_any(pi)
if p_choice < 0 {break}
pcf << p_choice
// show result of play
println('My play: ' + rps[a_choice].ascii_str())
match (a_choice - p_choice + 3) % 3 {
0 {println("Tie.")}
1 {println('My point.\n' + msg[a_choice]) a_score++}
2 {println('Your point.\n' + msg[p_choice]) p_score++}
else {break}
}
// show score
println('$p_score : $a_score')
// compute ai choice for next play
rn := rand.intn(3) or {0}
match true {
rn < pcf[0] {a_choice = 2}
rn < pcf[0] + pcf[1] {a_choice = 0}
else {a_choice = rand.intn(3) or {0}}
}
}
}
</syntaxhighlight>
{{out}}
Sample game:
<pre>
Rock Paper Scissors
Enter r, p, or s as your play. Anything else ends the game.
Running score shown as <your wins>:<my wins>
Play: p
My play: s
My point.
Scissors cut paper
0 : 1
Play: r
My play: r
Tie.
0 : 1
Play: s
My play: p
Your point.
Scissors cut paper
1 : 1
Play: p
My play: p
Tie.
1 : 1
Play: r
My play: p
My point.
Paper covers rock
1 : 2
Play: s
My play: r
My point.
Rock breaks scissors
1 : 3
</pre>
=={{header|Wee Basic}}==
Due to how the code works, any key has to be entered for the computer's choice to be generated.
<syntaxhighlight lang="wee basic">let entered=0
let keycode=0
let rcounter=1
print 1 "Enter R for rock, P for paper, or S for scissors. (not case sensitive)"
while entered=0
input human$
if human=$="r"
let human$="rock"
let entered=1
elseif human=$="R"
let human$="rock"
let entered=1
elseif human=$="p"
let human$="paper"
let entered=1
elseif human=$="P"
let human$="paper"
let entered=1
elseif human=$="s"
let human$="scissors"
let entered=1
elseif human=$="S"
let human$="scissors"
let entered=1
elseif entered=0
print 1 "That choice is invalid."
endif
wend
print 1 "Press any key so the computer can make its choice."
while keycode=0
let rcounter=rcounter+1
let keycode=key()
if rcounter=4
let rcounter=1
endif
wend
if rcounter=1
let cpu$="rock"
elseif rcounter=2
let cpu$="paper"
elseif rcounter=3
let cpu$="scissors"
endif
print 1 "You chose"+human$+"."
print 1 "The computer chose"+cpu$+"."
if human$=cpu$
print 1 "You tied."
endif
if human$="rock"
if cpu$="paper"
print 1 "Paper covers rock, so you lose."
endif
if cpu$="scissors"
print 1 "Rock blunts scissors, so you win."
endif
endif
if human$="paper"
if cpu$="rock"
print 1 "Paper covers rock, so you win."
endif
if cpu$="scissors"
print 1 "Scissors cut paper, so you lose."
endif
endif
if human$="scissors"
if cpu$="rock"
print 1 "Rock blunts scissors, so you lose."
endif
if cpu$="paper"
print 1 "Scissors cut paper, so you win."
endif
endif
end</syntaxhighlight>
=={{header|Wren}}==
{{trans|Kotlin}}
{{libheader|Wren-str}}
{{libheader|Wren-ioutil}}
<syntaxhighlight lang="wren">import "random" for Random
import "./str" for Str
import "./ioutil" for Input
var choices = "rpsq"
var rand = Random.new()
var pWins = 0 // player wins
var cWins = 0 // computer wins
var draws = 0 // neither wins
var games = 0 // games played
var pFreqs = [0, 0, 0] // player frequencies for each choice (rps)
var printScore = Fn.new {
System.print("Wins: You %(pWins), Computer %(cWins), Neither %(draws)\n")
}
var getComputerChoice = Fn.new {
// make a completely random choice until 3 games have been played
if (games < 3) return choices[rand.int(3)]
var num = rand.int(games)
return (num < pFreqs[0]) ? "p" :
(num < pFreqs[0] + pFreqs[1]) ? "s" : "r"
}
System.print("Enter: (r)ock, (p)aper, (s)cissors or (q)uit\n")
while (true) {
printScore.call()
var pChoice = Str.lower(Input.option("Your choice r/p/s/q : ", "rpsqRPSQ"))
if (pChoice == "q") {
System.print("OK, quitting")
return
}
var cChoice = getComputerChoice.call()
System.print("Computer's choice : %(cChoice)")
if (pChoice == "r" && cChoice == "s") {
System.print("Rock breaks scissors - You win!")
pWins = pWins + 1
} else if (pChoice == "p" && cChoice == "r") {
System.print("Paper covers rock - You win!")
pWins = pWins + 1
} else if (pChoice == "s" && cChoice == "p") {
System.print("Scissors cut paper - You win!")
pWins = pWins + 1
} else if (pChoice == "s" && cChoice == "r") {
System.print("Rock breaks scissors - Computer wins!")
cWins = cWins + 1
} else if (pChoice == "r" && cChoice == "p") {
System.print("Paper covers rock - Computer wins!")
cWins = cWins + 1
} else if (pChoice == "p" && cChoice == "s") {
System.print("Scissors cut paper - Computer wins!")
cWins = cWins + 1
} else {
System.print("It's a draw!")
draws = draws + 1
}
var pf = pFreqs[choices.indexOf(pChoice)]
pFreqs[choices.indexOf(pChoice)] = pf + 1
games = games + 1
System.print()
}</syntaxhighlight>
{{out}}
Sample game:
<pre>
Enter: (r)ock, (p)aper, (s)cissors or (q)uit
Wins: You 0, Computer 0, Neither 0
Your choice r/p/s/q : r
Computer's choice : r
It's a draw!
Wins: You 0, Computer 0, Neither 1
Your choice r/p/s/q : p
Computer's choice : s
Scissors cut paper - Computer wins!
Wins: You 0, Computer 1, Neither 1
Your choice r/p/s/q : s
Computer's choice : p
Scissors cut paper - You win!
Wins: You 1, Computer 1, Neither 1
Your choice r/p/s/q : q
OK, quitting
</pre>
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">REM Yabasic 2.763 version
WINNER = 1 : ACTION = 2 : LOSSER = 3
dim word$(10, 3)
for n = 0 to 9
read word$(n, WINNER), word$(n, ACTION), word$(n, LOSSER)
next n
repeat
clear screen
computerChoice$ = word$(ran(10), WINNER)
print "'Rock, Paper, Scissors, Lizard, Spock!' rules are:\n"
for n = 0 to 9
SimonSay(n)
next n
print "\nType your choice letter:"
print "(R)ock, (P)aper, (S)cissors, (L)izard, Spoc(K), (Q)uit\n"
k$ = upper$(inkey$)
if k$ = "Q" break
switch k$
case "R": humanChoice$ = "Rock" : break
case "P": humanChoice$ = "Paper" : break
case "S": humanChoice$ = "Scissors" : break
case "L": humanChoice$ = "Lizard" : break
case "K": humanChoice$ = "Spock" : break
end switch
print "Player chose ", humanChoice$, " and Computer chose ", computerChoice$
for n = 0 to 9
if word$(n, WINNER) = humanChoice$ and word$(n, LOSSER) = computerChoice$ then
SimonSay(n)
print "Winner was Player"
wp = wp + 1
break
elseif word$(n, WINNER) = computerChoice$ and word$(n, LOSSER) = humanChoice$ then
SimonSay(n)
print "Winner was Computer"
wc = wc + 1
break
end if
next n
if n = 10 then
print "Ouch!"
end if
punctuation()
print "\nPress any key to continue"
inkey$
until(k$ = "Q")
punctuation()
if wp > wc then
print "Player win"
elseif wc > wp then
print "Computer win"
else
print "Tie"
end if
end
sub SimonSay(n)
print word$(n, WINNER), " ", word$(n, ACTION), " ", word$(n, LOSSER)
end sub
sub punctuation()
print "\nPlayer = ", wp, "\tComputer = ", wc, "\n"
end sub
data "Scissors","cuts","Paper"
data "Paper","covers","Rock"
data "Rock","crushes","Lizard"
data "Lizard","poisons","Spock"
data "Spock","smashes","Scissors"
data "Scissors","decapites","Lizard"
data "Lizard","eats","Paper"
data "Paper","disproves","Spock"
data "Spock","vaporizes","Rock"
data "Rock","blunts","Scissors"</syntaxhighlight>
| |||