Rock-paper-scissors: Difference between revisions

{{trans|Python}}

V previous = [‘rock’, ‘paper’, ‘scissors’]

E

{{out}}

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

echo "What will you choose? [rock/paper/scissors]"

read response

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

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

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

setlocal enabledelayedexpansion

set /a "freq%choice%+=1"

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:

Version using Additional Weapons

#include <windows.h>

#include <iostream>

}

//-------------------------------------------------------------------------------

Sample output:

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>

=={{header|Forth}}==

include random.fs

2dup update-log 2dup print-throws

determine-winner rps ;

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

{{trans|Yabasic}}

Dim Shared As String word(10, 3)

For n As Byte = 0 To 9

Data "Paper","disproves","Spock"

Data "Spock","vaporizes","Rock"

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

=={{header|JavaScript}}==

const logic = {

rock: { w: 'scissor', l: 'paper'},

p1.challengeOther(p2); //true (Win)

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

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

type

echo "You win."

inc yourWins

{{out}}

=={{header|NS-HUBASIC}}==

20 COMPUTER$="ROCK"

30 IF COMPUTER=2 THEN COMPUTER$="PAPER"

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

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

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

=={{header|Phixmonti}}==

0 var wh

"Your punctuation: " print wh ?

"Mi punctuation: " print wc ?

{{out}}

<pre>'Rock, Paper, Scissors, Lizard, Spock!' rules are:

<?php

echo "<br>" . $results;

?>

=={{header|Picat}}==

(Some part is from the Prolog version.)

println("\nEnd terms with '.'.\n'quit.' ends the session.\n"),

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

beats(paper, rock).

beats(rock, scissors).

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

{

bias <- c(r = 1, p = 1, s = 1)

}

}

=={{header|Racket}}==

#lang racket

(require math)

(game-loop)

=={{header|Raku}}==

Here is standard Rock-Paper-Scissors.

options => [<Rock Paper Scissors>],

ro => {

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.

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

options => [<Rock Paper Scissors Lizard Spock>],

ro => {

sp => [ 2, '' ]

}

<pre>Round 1: [Ro]ck [Pa]per [Sc]issors [Li]zard [Sp]ock? li

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

Red [Purpose: "Implement a rock-paper-scissors game with weighted probability"]

remove find prior close ;removes what would have lost to player

]

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

!= '────────'; err=! "***error***"; @.=0 /*some constants for this program. */

prompt= ! 'Please enter one of: Rock Paper Scissors (or Quit)'

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>

!= '────────'; err=! "***error***"; @.=0 /*some constants for this REXX program.*/

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

end /*j*/

end /*who*/

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

=={{header|Ring}}==

# Project : Rock-paper-scissors

app.quit()

[https://github.com/ring-lang/ring/tree/master/applications/rockpaperscissors Rock Paper Scissors - image]

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

{{incorrect|Seed7|This example does not seem to use the weighted average AI from the task description.}}

$ include "keybd.s7i";

until command = 'q';

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

Sample run:

=={{header|Sidef}}==

const msg = [

default { aChoice = 0 }

}

'''Sample run:'''

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

=={{header|TI-83 BASIC}}==

:{0,0,0}→L1

:{0,0,0}→L2

:Disp L2(3)

:Disp "BYE"

{{omit from|GUISS}}

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!

{{incorrect|uBasic/4tH|This example does not seem to use the weighted average AI from the task description.}}

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

Semi-translation of Go version:

import os

}

}

{{out}}

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

{{libheader|Wren-str}}

{{libheader|Wren-ioutil}}

import "/str" for Str

import "/ioutil" for Input

games = games + 1

System.print()

{{out}}

=={{header|Yabasic}}==

WINNER = 1 : ACTION = 2 : LOSSER = 3

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

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