Rock-paper-scissors: Difference between revisions
m
→{{header|Wren}}: Minor tidy
m (Changed "Successors" to "Successor".) |
m (→{{header|Wren}}: Minor tidy) |
||
(19 intermediate revisions by 12 users not shown) | |||
Line 25:
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 134 ⟶ 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 182 ⟶ 228:
=={{header|Aime}}==
<
computer_play(record plays, record beats)
{
Line 252 ⟶ 298:
return 0;
}</
=={{header|ALGOL 68}}==
<
# rock/paper/scissors game #
# counts of the number of times the player has chosen each move #
Line 343 ⟶ 389:
OD;
print( ( "Thanks for a most enjoyable game", newline ) )
END</
=={{header|AutoHotkey}}==
<
Write("Welcome to Rock-Paper-Scissors`nMake a choice: ")
Line 390 ⟶ 436:
Write(txt){
FileAppend, % txt, CONOUT$
}</
=={{header|AutoIt}}==
Line 396 ⟶ 442:
I´ve created a GUI to play and show results, no Console Input
<
RPS()
Line 490 ⟶ 536:
EndFunc ;==>_RPS_Eval
</syntaxhighlight>
=={{header|Bash}}==
<
echo "What will you choose? [rock/paper/scissors]"
read response
Line 517 ⟶ 563:
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</
=={{header|BASIC}}==
{{works with|QBasic}}
<
DIM choices(1 TO 3) AS STRING
DIM playerwins(1 TO 3) AS INTEGER
Line 583 ⟶ 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 608 ⟶ 654:
=={{header|Batch File}}==
<
setlocal enabledelayedexpansion
Line 680 ⟶ 726:
set /a "freq%choice%+=1"
pause
goto start</
=={{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 728 ⟶ 774:
IF r%<=p%(0) THEN =1
IF r%<=p%(0)+p%(1) THEN =2
=0</
Sample output:
Line 758 ⟶ 804:
=={{header|C}}==
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
Line 810 ⟶ 856:
}
}
</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 917 ⟶ 963:
}
}
</syntaxhighlight>
=={{header|C sharp}}==
<
using System.Collections.Generic;
using System.Linq;
Line 1,093 ⟶ 1,139:
}
}
}</
Sample output of first 2 and last 2 rounds when player chooses rock every turn:
Line 1,131 ⟶ 1,177:
Version using Additional Weapons
<
#include <windows.h>
#include <iostream>
Line 1,291 ⟶ 1,337:
}
//-------------------------------------------------------------------------------
</syntaxhighlight>
Sample output:
Line 1,338 ⟶ 1,384:
Code:
<
(:require [clojure.data.generators :refer [weighted]])
(:import jline.Terminal)
Line 1,376 ⟶ 1,422:
"Rock, Paper, Scissors!"
[& args]
(play-game {:rock 1, :paper 1, :scissors 1}))</
{{out}}
Line 1,390 ⟶ 1,436:
=={{header|Crystal}}==
Inspired by [[#Ruby]] solution, but improved to allow additional weapons
<
# conventional weapons
enum Choice
Line 1,496 ⟶ 1,542:
loop do
break unless game.round
end</
=={{header|D}}==
{{trans|Python}}
<
enum Choice { rock, paper, scissors }
Line 1,556 ⟶ 1,602:
}
}
}</
{{out}}
<pre>rock, paper or scissors? paper
Line 1,579 ⟶ 1,625:
=={{header|Elixir}}==
{{trans|Erlang}}
<
def play, do: loop([1,1,1])
Line 1,626 ⟶ 1,672:
end
Rock_paper_scissors.play</
'''Sample output:'''
Line 1,647 ⟶ 1,693:
=={{header|Erlang}}==
<
-module(rps).
-compile(export_all).
Line 1,694 ⟶ 1,740:
true -> $R
end.
</syntaxhighlight>
=={{header|Euphoria}}==
{{trans|C}}
<
integer sum,r
sum = 0
Line 1,747 ⟶ 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,811 ⟶ 1,857:
game(1.0, 1.0, 1.0)
</syntaxhighlight>
=={{header|Factor}}==
<
random sequences ;
IN: rosetta-code.rock-paper-scissors
Line 1,857 ⟶ 1,903:
: main ( -- ) { 0 0 0 1 1 1 } clone game drop ;
MAIN: main</
{{out}}
<pre>
Line 1,907 ⟶ 1,953:
=={{header|Forth}}==
<
include random.fs
Line 1,991 ⟶ 2,037:
2dup update-log 2dup print-throws
determine-winner rps ;
</syntaxhighlight>
<pre>
Line 2,006 ⟶ 2,052:
=={{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 2,069 ⟶ 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 2,102 ⟶ 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.
<
var.end=0
var.computerchoice=random(3) // 1 is rock, 2 is paper, and 3 is scissors.
Line 2,146 ⟶ 2,286:
endif
endif
endif</
=={{header|Go}}==
<
import (
Line 2,217 ⟶ 2,357:
}
}
}</
{{out|Sample output}}
<pre>
Line 2,238 ⟶ 2,378:
</pre>
Additional weapons:
<
import (
Line 2,494 ⟶ 2,634:
aw = form[ax]
}
}</
Example game files:
<pre>
Line 2,588 ⟶ 2,728:
=={{header|Haskell}}==
<
data Choice
Line 2,646 ⟶ 2,786:
main :: IO a
main = game (1, 1, 1)</
=={{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,690 ⟶ 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,723 ⟶ 2,863:
=={{header|IS-BASIC}}==
<
110 RANDOMIZE
120 STRING CH$(1 TO 3)*8,K$*1
Line 2,775 ⟶ 2,915:
600 LET CMCHOICE=1
610 END SELECT
620 END DEF</
=={{header|J}}==
<
game=:3 :0
outcomes=. rps=. 0 0 0
Line 2,797 ⟶ 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,820 ⟶ 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,903 ⟶ 3,043:
return null;
}
}</
Sample output:
<pre>Make your choice: rock
Line 2,944 ⟶ 3,084:
=={{header|JavaScript}}==
<
const logic = {
rock: { w: 'scissor', l: 'paper'},
Line 2,970 ⟶ 3,110:
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,995 ⟶ 3,272:
end
end
end</
<pre>julia> rps()
Welcome to Rock, paper, scissors! Go ahead and type your pick.
Line 3,020 ⟶ 3,297:
=={{header|Kotlin}}==
<
import java.util.Random
Line 3,098 ⟶ 3,375:
println()
}
}</
Sample session:
Line 3,142 ⟶ 3,419:
=={{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 3,210 ⟶ 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 3,223 ⟶ 3,500:
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
dim rps( 2), g$( 3)
Line 3,312 ⟶ 3,589:
print " Thanks for playing!"
end
</syntaxhighlight>
You won 3204, and I won 3669. There were 3128 draws.
I AM THE CHAMPION!!
Line 3,341 ⟶ 3,618:
{{trans|Go}}
<
20 rps$="rps"
30 msg$(1)="Rock breaks scissors"
Line 3,363 ⟶ 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}}==
<
local totalChance = record.R + record.P + record.S
if totalChance == 0 then -- First game, unweighted random
Line 3,425 ⟶ 3,702:
checkWinner(cpuChoice, playerChoice)
io.write("\nPress ENTER to continue or enter 'Q' to quit . . . ")
until io.read():upper():sub(1, 1) == "Q"</
Session in which I chose nothing but rock:
<pre>
Line 3,443 ⟶ 3,720:
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
choices = {"Rock", "Paper", "Scissors"}},
Evaluate[record /@ choices] = {1, 1, 1};
Line 3,455 ⟶ 3,732:
Alternatives @@ Reverse /@ Partition[choices, 2, 1, 1],
"You win.", _, "Draw."]];
Column@{Dynamic[text], ButtonBar[# :> play[#] & /@ choices]}]</
=={{header|Mercury}}==
{{trans|Prolog}}
<
:- interface.
:- import_module io.
Line 3,524 ⟶ 3,801:
"
Seed = time(NULL);
").</
=={{header|Nim}}==
<
type
Line 3,589 ⟶ 3,866:
echo "You win."
inc yourWins
echo "Total wins. You: ", yourWins, " Me: ", myWins</
{{out}}
Line 3,633 ⟶ 3,910:
=={{header|NS-HUBASIC}}==
<
20 COMPUTER$="ROCK"
30 IF COMPUTER=2 THEN COMPUTER$="PAPER"
Line 3,649 ⟶ 3,926:
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</
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">
let pf = Printf.printf ;;
Line 3,706 ⟶ 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 3,743 ⟶ 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 3,869 ⟶ 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 3,921 ⟶ 4,198:
=={{header|Phix}}==
<
constant rule3 = {"rock blunts scissors",
"paper wraps rock",
Line 4,022 ⟶ 4,299:
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</
{{out}}
<pre style="font-size: 8px">
Line 4,044 ⟶ 4,321:
=={{header|Phixmonti}}==
<
0 var wh
Line 4,099 ⟶ 4,376:
"Your punctuation: " print wh ?
"Mi punctuation: " print wc ?
wh wc > if "You win!" else wh wc < if "I win!" else "Draw!" endif endif ?</
{{out}}
<pre>'Rock, Paper, Scissors, Lizard, Spock!' rules are:
Line 4,137 ⟶ 4,414:
<syntaxhighlight lang="php">
<?php
Line 4,167 ⟶ 4,444:
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 4,189 ⟶ 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 4,224 ⟶ 4,638:
end;
end rock;
</syntaxhighlight>
=={{header|Prolog}}==
<
findall(P,beats(P,_),Prev),
play(Prev).
Line 4,253 ⟶ 4,667:
beats(paper, rock).
beats(rock, scissors).
beats(scissors, paper).</
=={{header|PureBasic}}==
<
;choices are in listed according to their cycle, weaker followed by stronger
#rock
Line 4,339 ⟶ 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 4,391 ⟶ 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 4,412 ⟶ 4,826:
else: print("it's a tie!")
else: print("that's not a valid choice")</
Output, where player always chooses Rock:
Line 4,432 ⟶ 4,846:
This is another code. Output is as same as the above output.
<
hands = ['rock', 'scissors', 'paper']; judge = ['its a tie!', 'the computer beat you... :(', 'yay you win!']
Line 4,441 ⟶ 4,855:
break
NPC = randint(0, 2)
print('The computer played ' + hands[NPC] + '; ' + judge[YOU-NPC])</
=={{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}}==
<
#lang racket
(require math)
Line 4,479 ⟶ 5,031:
(game-loop)
</syntaxhighlight>
=={{header|Raku}}==
Line 4,487 ⟶ 5,039:
Here is standard Rock-Paper-Scissors.
<syntaxhighlight lang="raku"
options => [<Rock Paper Scissors>],
ro => {
Line 4,526 ⟶ 5,078:
print ( 'You win!', 'You Lose!','Tie.' )[$result];
say " - (W:{@stats[0]} L:{@stats[1]} T:{@stats[2]})\n",
};</
<pre>Round 1: [Ro]ck [Pa]per [Sc]issors? ro
You chose Rock, Computer chose Paper.
Line 4,550 ⟶ 5,102:
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"
options => [<Rock Paper Scissors Lizard Spock>],
ro => {
Line 4,587 ⟶ 5,139:
sp => [ 2, '' ]
}
);</
<pre>Round 1: [Ro]ck [Pa]per [Sc]issors [Li]zard [Sp]ock? li
Line 4,611 ⟶ 5,163:
=={{header|Rascal}}==
<
rel[str, str] whatbeats = {<"Rock", "Scissors">, <"Scissors", "Paper">, <"Paper", "Rock">};
Line 4,630 ⟶ 5,182:
ComputerChoices += x;
return "Computer played <computer>. <CheckWinner(human, computer)> wins!";
}</
Sample output:
<
str: "Computer played Rock. Nobody wins!"
Line 4,660 ⟶ 5,212:
rascal>RPS("Rock")
str: "Computer played Paper. Paper wins!"</
=={{header|Red}}==
<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}}==
Line 4,670 ⟶ 5,246:
::* 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''.
<
!= '────────'; err=! "***error***"; @.=0 /*some constants for this program. */
prompt= ! 'Please enter one of: Rock Paper Scissors (or Quit)'
Line 4,703 ⟶ 5,279:
if $.a1==t.c1 then say ! 'the computer wins. ' ! $.c1 b.c1 $.a1
else say ! 'you win! ' ! $.a1 b.a1 $.c1
end /*forever*/ /*stick a fork in it, we're all done. */</
{{out|output|text= with various responses from the user (output shown is a screen scraping):}}
<pre>
Line 4,750 ⟶ 5,326:
===extended, 5 choices===
This REXX version supports more choices: <big> rock paper scissors lizard Spock </big>
<
!= '────────'; err=! "***error***"; @.=0 /*some constants for this REXX program.*/
prompt=! 'Please enter one of: Rock Paper SCissors Lizard SPock (Vulcan) (or Quit)'
Line 4,796 ⟶ 5,372:
end /*j*/
end /*who*/
end /*forever*/ /*stick a fork in it, we're all done. */</
{{out|output|text= is similar to the 1<sup>st</sup> REXX version.}} <br><br>
=={{header|Ring}}==
<
# Project : Rock-paper-scissors
Line 5,012 ⟶ 5,588:
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 5,084 ⟶ 5,660:
end
RockPaperScissorsGame.new</
sample game where human always chooses rock:
Line 5,134 ⟶ 5,710:
=={{header|Run BASIC}}==
<
rps$ = "Rock,Paper,Sissors"
[loop]
Line 5,164 ⟶ 5,740:
print "Good Bye! I enjoyed the game"
end
</syntaxhighlight>
=={{header|Rust}}==
<
#[macro_use]
extern crate rand_derive;
Line 5,249 ⟶ 5,825:
}
println!("Thank you for the game!");
}</
=={{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 5,295 ⟶ 5,871:
'spock -> Set('scissors, 'rock)
))
}</
{{out}}
<pre>Your move ('rock, 'paper, 'scissors, 'lizard, 'spock): paper
Line 5,323 ⟶ 5,899:
Here's another code: (I refactored the above code, it is more functional, more testable )
<
def beats = Map(
'rock -> Set('lizard, 'scissors),
Line 5,382 ⟶ 5,958:
override def main(args: Array[String]): Unit =
play(input, display, random)(initPlayed, Result("Start", 0, 0, 0))
}</
{{out}}
<pre>
Line 5,412 ⟶ 5,988:
{{incorrect|Seed7|This example does not seem to use the weighted average AI from the task description.}}
<
$ include "keybd.s7i";
Line 5,446 ⟶ 6,022:
until command = 'q';
writeln("Goodbye! Thanks for playing!");
end func;</
Sample run:
Line 5,468 ⟶ 6,044:
=={{header|Sidef}}==
<
const msg = [
Line 5,521 ⟶ 6,097:
default { aChoice = 0 }
}
}</
'''Sample run:'''
Line 5,660 ⟶ 6,236:
=={{header|Swift}}==
<
case rock
case paper
Line 5,737 ⟶ 6,313:
game.play(choice, against: p2Choice)
print("Current score: \(game.p1Score) : \(game.p2Score)")
}</
'''Sample run:'''
<pre>
Line 5,757 ⟶ 6,333:
=={{header|Tcl}}==
<
### Choices are represented by integers, which are indices into this list:
Line 5,820 ⟶ 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 5,854 ⟶ 6,430:
=={{header|TI-83 BASIC}}==
<
:{0,0,0}→L1
:{0,0,0}→L2
Line 5,918 ⟶ 6,494:
:Disp L2(3)
:Disp "BYE"
</syntaxhighlight>
{{omit from|GUISS}}
Line 5,926 ⟶ 6,502:
Rock Paper Scissors in TorqueScript:
<syntaxhighlight lang="torquescript">
while(isobject(RockPaperScissors))
RockPaperScissors.delete();
Line 6,067 ⟶ 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!
Line 6,088 ⟶ 6,664:
{{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 6,103 ⟶ 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 6,123 ⟶ 6,699:
=={{header|UNIX Shell}}==
{{works with|Bourne Again Shell|4}}
<
choices=(rock paper scissors)
Line 6,185 ⟶ 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.
<
let keycode=0
let rcounter=1
Line 6,261 ⟶ 6,925:
endif
endif
end</
=={{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}}==
<
WINNER = 1 : ACTION = 2 : LOSSER = 3
Line 6,341 ⟶ 7,101:
data "Paper","disproves","Spock"
data "Spock","vaporizes","Rock"
data "Rock","blunts","Scissors"</
|