Rock-paper-scissors: Difference between revisions
m
→{{header|Wren}}: Minor tidy
Simple9371 (talk | contribs) m (→{{header|Seed7}}: Changed 'C' to 'Seed7') |
m (→{{header|Wren}}: Minor tidy) |
||
| (24 intermediate revisions by 15 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}}==
<syntaxhighlight lang="dos">@echo off
setlocal enabledelayedexpansion
Line 624 ⟶ 669:
: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
Line 642 ⟶ 692:
goto %compchoice%
:1
if %choice%==1 goto tie
if %choice%==2 goto win
Line 649 ⟶ 698:
: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
Line 661 ⟶ 708:
: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 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,906 ⟶ 1,952:
</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,971 ⟶ 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,004 ⟶ 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,048 ⟶ 2,286:
endif
endif
endif</
=={{header|Go}}==
<
import (
Line 2,119 ⟶ 2,357:
}
}
}</
{{out|Sample output}}
<pre>
Line 2,140 ⟶ 2,378:
</pre>
Additional weapons:
<
import (
Line 2,396 ⟶ 2,634:
aw = form[ax]
}
}</
Example game files:
<pre>
Line 2,490 ⟶ 2,728:
=={{header|Haskell}}==
<
data Choice
Line 2,548 ⟶ 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,592 ⟶ 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,625 ⟶ 2,863:
=={{header|IS-BASIC}}==
<
110 RANDOMIZE
120 STRING CH$(1 TO 3)*8,K$*1
Line 2,677 ⟶ 2,915:
600 LET CMCHOICE=1
610 END SELECT
620 END DEF</
=={{header|J}}==
<
game=:3 :0
outcomes=. rps=. 0 0 0
Line 2,699 ⟶ 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,722 ⟶ 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,805 ⟶ 3,043:
return null;
}
}</
Sample output:
<pre>Make your choice: rock
Line 2,846 ⟶ 3,084:
=={{header|JavaScript}}==
<
const logic = {
rock: { w: 'scissor', l: 'paper'},
Line 2,872 ⟶ 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,897 ⟶ 3,272:
end
end
end</
<pre>julia> rps()
Welcome to Rock, paper, scissors! Go ahead and type your pick.
Line 2,922 ⟶ 3,297:
=={{header|Kotlin}}==
<
import java.util.Random
Line 3,000 ⟶ 3,375:
println()
}
}</
Sample session:
Line 3,044 ⟶ 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,112 ⟶ 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,125 ⟶ 3,500:
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
dim rps( 2), g$( 3)
Line 3,214 ⟶ 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,243 ⟶ 3,618:
{{trans|Go}}
<
20 rps$="rps"
30 msg$(1)="Rock breaks scissors"
Line 3,265 ⟶ 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,327 ⟶ 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,345 ⟶ 3,720:
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
choices = {"Rock", "Paper", "Scissors"}},
Evaluate[record /@ choices] = {1, 1, 1};
Line 3,357 ⟶ 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,426 ⟶ 3,801:
"
Seed = time(NULL);
").</
=={{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}}==
<
20 COMPUTER$="ROCK"
30 IF COMPUTER=2 THEN COMPUTER$="PAPER"
Line 3,445 ⟶ 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,502 ⟶ 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,539 ⟶ 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,665 ⟶ 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,717 ⟶ 4,198:
=={{header|Phix}}==
<
constant rule3 = {"rock blunts scissors",
"paper wraps rock",
Line 3,818 ⟶ 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 3,840 ⟶ 4,321:
=={{header|Phixmonti}}==
<
0 var wh
Line 3,895 ⟶ 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 3,933 ⟶ 4,414:
<syntaxhighlight lang="php">
<?php
Line 3,963 ⟶ 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 3,985 ⟶ 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,020 ⟶ 4,638:
end;
end rock;
</syntaxhighlight>
=={{header|Prolog}}==
<
findall(P,beats(P,_),Prev),
play(Prev).
Line 4,049 ⟶ 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,135 ⟶ 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,187 ⟶ 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,208 ⟶ 4,826:
else: print("it's a tie!")
else: print("that's not a valid choice")</
Output, where player always chooses Rock:
Line 4,228 ⟶ 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,237 ⟶ 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,275 ⟶ 5,031:
(game-loop)
</syntaxhighlight>
=={{header|Raku}}==
Line 4,283 ⟶ 5,039:
Here is standard Rock-Paper-Scissors.
<syntaxhighlight lang="raku"
options => [<Rock Paper Scissors>],
ro => {
Line 4,322 ⟶ 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,346 ⟶ 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,383 ⟶ 5,139:
sp => [ 2, '' ]
}
);</
<pre>Round 1: [Ro]ck [Pa]per [Sc]issors [Li]zard [Sp]ock? li
Line 4,407 ⟶ 5,163:
=={{header|Rascal}}==
<
rel[str, str] whatbeats = {<"Rock", "Scissors">, <"Scissors", "Paper">, <"Paper", "Rock">};
Line 4,426 ⟶ 5,182:
ComputerChoices += x;
return "Computer played <computer>. <CheckWinner(human, computer)> wins!";
}</
Sample output:
<
str: "Computer played Rock. Nobody wins!"
Line 4,456 ⟶ 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,466 ⟶ 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,499 ⟶ 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,546 ⟶ 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,592 ⟶ 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 4,808 ⟶ 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 4,880 ⟶ 5,660:
end
RockPaperScissorsGame.new</
sample game where human always chooses rock:
Line 4,930 ⟶ 5,710:
=={{header|Run BASIC}}==
<
rps$ = "Rock,Paper,Sissors"
[loop]
Line 4,960 ⟶ 5,740:
print "Good Bye! I enjoyed the game"
end
</syntaxhighlight>
=={{header|Rust}}==
<
#[macro_use]
extern crate rand_derive;
Line 5,045 ⟶ 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,091 ⟶ 5,871:
'spock -> Set('scissors, 'rock)
))
}</
{{out}}
<pre>Your move ('rock, 'paper, 'scissors, 'lizard, 'spock): paper
Line 5,119 ⟶ 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,178 ⟶ 5,958:
override def main(args: Array[String]): Unit =
play(input, display, random)(initPlayed, Result("Start", 0, 0, 0))
}</
{{out}}
<pre>
Line 5,208 ⟶ 5,988:
{{incorrect|Seed7|This example does not seem to use the weighted average AI from the task description.}}
<
$ include "keybd.s7i";
Line 5,242 ⟶ 6,022:
until command = 'q';
writeln("Goodbye! Thanks for playing!");
end func;</
Sample run:
Line 5,264 ⟶ 6,044:
=={{header|Sidef}}==
<
const msg = [
Line 5,317 ⟶ 6,097:
default { aChoice = 0 }
}
}</
'''Sample run:'''
Line 5,456 ⟶ 6,236:
=={{header|Swift}}==
<
case rock
case paper
Line 5,533 ⟶ 6,313:
game.play(choice, against: p2Choice)
print("Current score: \(game.p1Score) : \(game.p2Score)")
}</
'''Sample run:'''
<pre>
Line 5,553 ⟶ 6,333:
=={{header|Tcl}}==
<
### Choices are represented by integers, which are indices into this list:
Line 5,616 ⟶ 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,650 ⟶ 6,430:
=={{header|TI-83 BASIC}}==
<
:{0,0,0}→L1
:{0,0,0}→L2
Line 5,714 ⟶ 6,494:
:Disp L2(3)
:Disp "BYE"
</syntaxhighlight>
{{omit from|GUISS}}
Line 5,722 ⟶ 6,502:
Rock Paper Scissors in TorqueScript:
<syntaxhighlight lang="torquescript">
while(isobject(RockPaperScissors))
RockPaperScissors.delete();
Line 5,863 ⟶ 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 5,882 ⟶ 6,662:
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|
<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 5,899 ⟶ 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 5,919 ⟶ 6,699:
=={{header|UNIX Shell}}==
{{works with|Bourne Again Shell|4}}
<
choices=(rock paper scissors)
Line 5,981 ⟶ 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,057 ⟶ 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,137 ⟶ 7,101:
data "Paper","disproves","Spock"
data "Spock","vaporizes","Rock"
data "Rock","blunts","Scissors"</
| |||