Rock-paper-scissors: Difference between revisions

Support additional choices   [[wp:Rock-paper-scissors#Additional_weapons|additional weapons]].

<br><br>

 

=={{header|Ada}}==

 

 

procedure Rock_Paper_Scissors is

Ada.Text_IO.Put_Line(Result'Image(R) & Natural'Image(Score(R)));

end loop;

 

First and last few lines of the output of a game, where the human did permanently choose Rock:

 

=={{header|Aime}}==

computer_play(record plays, record beats)

{

 

return 0;

 

=={{header|ALGOL 68}}==

# rock/paper/scissors game #

# counts of the number of times the player has chosen each move #

OD;

print( ( "Thanks for a most enjoyable game", newline ) )

 

=={{header|AutoHotkey}}==

Write("Welcome to Rock-Paper-Scissors`nMake a choice: ")

 

Write(txt){

FileAppend, % txt, CONOUT$

 

=={{header|AutoIt}}==

I´ve created a GUI to play and show results, no Console Input

 

RPS()

 

EndFunc ;==>_RPS_Eval

 

 

=={{header|BASIC}}==

{{works with|QBasic}}

 

DIM choices(1 TO 3) AS STRING

DIM playerwins(1 TO 3) AS INTEGER

PRINT , choices(1), choices(2), choices(3)

PRINT "You chose:", pPLchoice(1), pPLchoice(2), pPLchoice(3)

 

A sample game:

You chose: 60 0 1

I chose: 2 55 4

 

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

setlocal enabledelayedexpansion

 

 

: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%

set compchoice=2

if %randchoice% geq %scissorslimit% set compchoice=3

goto %compchoice%

 

if %choice%==1 goto tie

if %choice%==2 goto win

 

:2

if %choice%==1 goto loss

if %choice%==2 goto tie

if %choice%==3 goto win

 

if %choice%==1 goto win

if %choice%==2 goto loss

 

:win

echo Player wins^!

goto end

 

:loss

echo Computer Wins^!

goto end

 

:tie

echo Tie^!

goto end

 

:end

pause

 

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

IF r%<=p%(0) THEN =1

IF r%<=p%(0)+p%(1) THEN =2

 

Sample output:

 

=={{header|C}}==

#include <stdio.h>

#include <stdlib.h>

}

}

 

Here's another code: (Does it using a while loop)

#include <stdio.h> // Standard IO

#include <stdlib.h> // other stuff

}

}

 

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

using System.Collections.Generic;

using System.Linq;

}

}

 

Sample output of first 2 and last 2 rounds when player chooses rock every turn:

Losses: 60

Draws: 1

</pre>

 

Code:

 

(:require [clojure.data.generators :refer [weighted]])

(:import jline.Terminal)

"Rock, Paper, Scissors!"

[& args]

 

{{out}}

=={{header|Crystal}}==

Inspired by [[#Ruby]] solution, but improved to allow additional weapons

# conventional weapons

enum Choice

loop do

break unless game.round

 

=={{header|D}}==

{{trans|Python}}

 

enum Choice { rock, paper, scissors }

}

}

{{out}}

<pre>rock, paper or scissors? paper

=={{header|Elixir}}==

{{trans|Erlang}}

def play, do: loop([1,1,1])

end

 

 

'''Sample output:'''

 

=={{header|Erlang}}==

-module(rps).

-compile(export_all).

true -> $R

end.

 

=={{header|Euphoria}}==

{{trans|C}}

integer sum,r

sum = 0

printf(1,"\nScore %d:%d\n",score)

user_rec[user_action] += 1

 

=={{header|F Sharp|F#}}==

 

let random = Random ()

 

game(1.0, 1.0, 1.0)

 

=={{header|Factor}}==

random sequences ;

IN: rosetta-code.rock-paper-scissors

: main ( -- ) { 0 0 0 1 1 1 } clone game drop ;

 

{{out}}

<pre>

</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.

! compilation

! gfortran -std=f2008 -Wall -ffree-form -fall-intrinsics -fimplicit-none f.f08 -o f

if (score(COMPUTER) .lt. score(HAPLESSUSER)) print*,'you won!'

end program rpsgame

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)

26.5 3.5

$

 

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

endif

endif

 

=={{header|Go}}==

 

import (

}

}

{{out|Sample output}}

<pre>

</pre>

Additional weapons:

 

import (

aw = form[ax]

}

Example game files:

<pre>

=={{header|Haskell}}==

 

 

data Choice

 

main :: IO a

 

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

printf("\nResults:\n %d rounds\n %d Draws\n %d Computer wins\n %d Player wins\n",

winP+winC+draws,draws,winC,winP)

 

{{libheader|Icon Programming Library}}

 

=={{header|IS-BASIC}}==

110 RANDOMIZE

120 STRING CH$(1 TO 3)*8,K$*1

600 LET CMCHOICE=1

610 END SELECT

 

=={{header|J}}==

 

game=:3 :0

outcomes=. rps=. 0 0 0

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

Draws: 0

My wins: 4

 

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

return null;

}

Sample output:

<pre>Make your choice: rock

You chose...wisely. You win!

...</pre>

 

=={{header|Julia}}==

print("Welcome to Rock, paper, scissors! Go ahead and type your pick.\n

r(ock), p(aper), or s(cissors)\n

end

end

<pre>julia> rps()

Welcome to Rock, paper, scissors! Go ahead and type your pick.

 

=={{header|Kotlin}}==

 

import java.util.Random

println()

}

 

Sample session:

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

'User: '+($win_record->find('user')->size)+br

'Tie: '+($win_record->find('tie')->size)+br

{{out}}

<pre>Rock Paper Scissors Quit (<- as links)

 

=={{header|Liberty BASIC}}==

dim rps( 2), g$( 3)

 

print " Thanks for playing!"

end

You won 3204, and I won 3669. There were 3128 draws.

I AM THE CHAMPION!!

{{trans|Go}}

 

20 rps$="rps"

30 msg$(1)="Rock breaks scissors"

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

 

=={{header|Lua}}==

local totalChance = record.R + record.P + record.S

if totalChance == 0 then -- First game, unweighted random

checkWinner(cpuChoice, playerChoice)

io.write("\nPress ENTER to continue or enter 'Q' to quit . . . ")

Session in which I chose nothing but rock:

<pre>

</pre>

 

choices = {"Rock", "Paper", "Scissors"}},

Evaluate[record /@ choices] = {1, 1, 1};

Alternatives @@ Reverse /@ Partition[choices, 2, 1, 1],

"You win.", _, "Draw."]];

 

=={{header|Mercury}}==

{{trans|Prolog}}

:- interface.

:- import_module io.

"

Seed = time(NULL);

 

=={{header|OCaml}}==

let pf = Printf.printf ;;

 

make_moves 1. 1. 1. ;;

 

 

=={{header|PARI/GP}}==

my(v=[1,1,1],wins,losses); \\ Laplace rule

for(i=1,rounds,

[wins,losses]

};

 

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

 

main();

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

Output:

<pre>

I won: 5, you won: 2, draws: 0

</pre>

 

=={{header|Phix}}==

constant rule3 = {"rock blunts scissors",

"paper wraps rock",

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

{{out}}

<pre style="font-size: 8px">

me: 2 7 1

</pre>

 

=={{header|PHP}}==

 

 

 

<?php

echo "<br>" . $results;

?>

 

=={{header|PicoLisp}}==

(let (Rock 0 Paper 0 Scissors 0)

(loop

((== Your (car Mine)) "I win")

(T "You win") ) )

 

=={{header|PL/I}}==

rock: procedure options (main); /* 30 October 2013 */

declare move character (1), cm fixed binary;

end;

end rock;

 

=={{header|Prolog}}==

findall(P,beats(P,_),Prev),

play(Prev).

beats(paper, rock).

beats(rock, scissors).

 

=={{header|PureBasic}}==

;choices are in listed according to their cycle, weaker followed by stronger

#rock

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre style="height:40ex;overflow:scroll">Welcome to the game of rock-paper-scissors

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

else: print("it's a tie!")

 

 

Output, where player always chooses Rock:

 

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!']

break

NPC = randint(0, 2)

 

=={{header|Rascal}}==

 

rel[str, str] whatbeats = {<"Rock", "Scissors">, <"Scissors", "Paper">, <"Paper", "Rock">};

ComputerChoices += x;

return "Computer played <computer>. <CheckWinner(human, computer)> wins!";

Sample output:

str: "Computer played Rock. Nobody wins!"

 

 

rascal>RPS("Rock")

 

 

 

 

=={{header|REXX}}==

::* &nbsp; keeps track of the human player's responses &nbsp; (to hopefully make future computer winning choices)

::* &nbsp; uses better "English"/grammer, &nbsp; &nbsp; i.e.: &nbsp; &nbsp; &nbsp; ''rock breaks scissors'', &nbsp; &nbsp; &nbsp; and &nbsp; &nbsp; &nbsp; ''paper covers rock''.

 

select /*process/verify the CBLF's choice. */

when words(u)==0 then say err 'nothing entered'

when words(u)>1 then say err 'too many choices: ' u

when abbrev('ROCK', a) |,

abbrev('PAPER', a) |,

 

if \ok then iterate /*answer ¬OK? Then get another choice.*/

say ! 'computer chose: ' c

if a1== c1 then do; say ! 'draw.'; iterate; end

if $.a1==t.c1 then say ! 'the computer wins. ' ! $.c1 b.c1 $.a1

else say ! 'you win! ' ! $.a1 b.a1 $.c1

{{out|output|text=&nbsp; with various responses from the user &nbsp; (output shown is a screen scraping):}}

<pre>

===extended, 5 choices===

This REXX version supports more choices: &nbsp; <big> rock &nbsp; paper &nbsp; scissors &nbsp; lizard &nbsp; Spock </big>

prompt=! 'Please enter one of: Rock Paper SCissors Lizard SPock (Vulcan) (or Quit)'

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.*/

 

ok=0 /*indicate answer isn't OK (so far). */

select /* [↓] process the CBLF's choice/pick.*/

end /*j*/

end /*who*/

{{out|output|text=&nbsp; is similar to the 1^st REXX version.}} <br><br>

 

=={{header|Ring}}==

# Project : Rock-paper-scissors

 

 

 

=={{header|Ruby}}==

CHOICES = %w[rock paper scissors quit]

BEATS = {

end

 

 

sample game where human always chooses rock:

 

=={{header|Run BASIC}}==

rps$ = "Rock,Paper,Sissors"

[loop]

print "Good Bye! I enjoyed the game"

end

 

=={{header|Rust}}==

#[macro_use]

extern crate rand_derive;

}

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

'spock -> Set('scissors, 'rock)

))

{{out}}

<pre>Your move ('rock, 'paper, 'scissors, 'lizard, 'spock): paper

 

Here's another code: (I refactored the above code, it is more functional, more testable )

def beats = Map(

'rock -> Set('lizard, 'scissors),

override def main(args: Array[String]): Unit =

play(input, display, random)(initPlayed, Result("Start", 0, 0, 0))

{{out}}

<pre>

It is also possible to quit the program with q.

 

 

$ include "keybd.s7i";

 

until command = 'q';

writeln("Goodbye! Thanks for playing!");

 

Sample run:

 

=={{header|Sidef}}==

 

const msg = [

default { aChoice = 0 }

}

 

'''Sample run:'''

4:1 Play: q

</pre>

 

=={{header|SuperCollider}}==

}

</pre>

=={{header|Swift}}==

case rock

case paper

game.play(choice, against: p2Choice)

print("Current score: \(game.p1Score) : \(game.p2Score)")

'''Sample run:'''

<pre>

 

=={{header|Tcl}}==

 

### Choices are represented by integers, which are indices into this list:

# Update the state of how the human has played in the past

lset states $humanMove [expr {[lindex $states $humanMove] + 1}]

Sample run:

<pre>

Bye!

</pre>

 

=={{header|TorqueScript}}==

Rock Paper Scissors in TorqueScript:

 

while(isobject(RockPaperScissors))

RockPaperScissors.delete();

return %result;

}

 

To begin do:

 

RockPaperScissors.startGame();

 

Choose and play!

 

choose("Rock");

 

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

 

 

30 INPUT "Rock, paper, or scissors (1 = rock, 2 = paper, 3 = scissors)? ", A

40 IF A>3 THEN GOTO 400

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

 

A sample game:

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

{{works with|Bourne Again Shell|4}}

choices=(rock paper scissors)

 

echo "You picked ${choices[i]} $(( human_counts[ (i+1)%3 ] - 1 )) times."

echo "I picked ${choices[i]} $(( computer_counts[i] )) times."

 

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

endif

endif

 

=={{header|Yabasic}}==

 

WINNER = 1 : ACTION = 2 : LOSSER = 3

data "Paper","disproves","Spock"

data "Spock","vaporizes","Rock"