21 game: Difference between revisions

{{trans|Python: Original, with output}}

 

‘selects a random number if the game_count is less than 18. otherwise chooses the winning number’

Int t

V t = input(‘Another game?(press y to continue):’)

I t != ‘y’

 

{{out}}

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program game21_64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

 

 

=={{header|Ada}}==

with Ada.Numerics.Discrete_Random;

 

when Human => Computer);

end loop Play_Loop;

 

=={{header|Applesoft BASIC}}==

WAIT instead of GET in a loop.

 

9 FOR PLAY = 0 TO 1

10 REM SET SCREEN COLORS HERE

240 END

1000 Z$ = " PRESS A KEY TO CONTINUE. ": PRINT SPC( 20 - INT ( LEN (Z$) / 2));: INVERSE : PRINT Z$;: NORMAL : WAIT 49152,128:K = PEEK (49168): RETURN

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program game21.s */

/***************************************************/

.include "../affichage.inc"

<pre>

The first move is human move.

=={{header|Arturo}}==

 

print " Welcome to 21 Game"

print "-----------------------------"

]

]

 

{{out}}

 

=={{header|AutoHotkey}}==

Gui, add, Radio, vRadioC , Cake

Gui, add, Radio, vRadioE x+0 Checked, Easy

Loop 3

GuiControl, Enable, % "Player1_" A_Index

 

=={{header|AWK}}==

 

BEGIN {

newgame();

}

{{Output}}

<pre>

 

=={{header|bash}}==

alias bind_variables='

{

fi

21_Game

 

=={{header|C}}==

* Game 21 - an example in C language for Rosseta Code.

*

}

}

{{out}}

<pre>21 Game

=={{header|C++}}==

===Model View Controller===

* Game 21 - an example in C++ language for Rosseta Code.

*

}

return EXIT_SUCCESS; // dead code

 

===Model View Presenter===

* Game 21 - an example in C++ language for Rosseta Code.

*

return EXIT_SUCCESS; // dead code

}

{{out}}

<pre>

 

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

 

using System;

 

 

=={{header|Commodore BASIC}}==

 

Written for BASIC v2 on the Commodore 64, this should be mostly compatible with all Commodore machines running any version of BASIC v2 and above. This implementation allows for one or both players to be either human or computer players. Also note that the computer player's "Thinking..." routine is a purely random delay meant to allow any human user time to process the flow of the game.

 

2 rem for rosetta code

 

2000 rem some computer names to pick from

2010 data "Commodore 64","VIC-20","Commodore 128","PET"

 

{{output}}

print "Sorry, you lost"

.

 

=={{header|Factor}}==

A difficulty system has been implemented. The player chooses a difficulty from 1-10. There is a <code>difficulty in 10</code> chance that the computer opponent gets to move first. There is a <code>difficulty in 10</code> chance each turn that the computer opponent will make the optimal move (i.e. setting the total to a number of the form <code>4n+1</code>) as opposed to a random move. At difficulty level 10, it is impossible for the human player to win the game.

{{works with|Factor|0.99 2020-07-03}}

kernel math math.functions math.parser multiline qw random

sequences ;

.welcome nl [ <game> do-turns ] with-return ;

 

{{out}}

<pre>

 

=={{header|F sharp|F#}}==

type Player =

| Computer

let run () = looper Start

{{out}}

<pre>

 

=={{header|Fortran}}==

 

subroutine ai

end do

end do

{{out}}

<pre>game 21 - an example in fortran language for rosseta code.

 

=={{Header|FreeBASIC}}==

#define COMP 0

randomize timer

else

print "Bad luck. The computer wins."

 

=={{header|Gambas}}==

' Gambas module file

 

Endif

 

 

<pre>

 

To give the human player a reasonable chance whoever goes first, the computer always chooses randomly when the running total is below 18 but otherwise chooses the exact number needed to win the game.

 

import (

}

}

 

{{out}}

=={{header|Haskell}}==

The computer chooses values randomly.

import System.IO

import System.Exit

putStrLn $ (fst names) ++ " has won the game"

when (y == 1) $ do

=={{header|J}}==

The main definition <tt>g21</tt> starts the game. J doesn't support niladic verbs. Although the <tt>y</tt> argument has no effect, it must be given. The empty literal vector <nowiki>''</nowiki> types quickly, hence often used to trigger niladic verbs. g21 does not superfluously penalize final sums exceeding 21.

g21=: summarize@play@setup ::('g21: error termination'"_)

 

write=: 1!:2 4: NB. unused

format=: ''&$: :([: ; (a: , [: ":&.> [) ,. '{}' ([ (E. <@}.;._1 ]) ,) ])

<pre>

g21''

The computer strategy is to see if a valid value will win the game. If so, that value is selected. Otherwise, a random value among the valid values is selected.

 

import java.util.Random;

import java.util.Scanner;

 

}

 

{{out}}

=={{header|Javascript}}==

The solution as a Javascript script inside a page written in HTML5. It should work with all modern browsers.

 

<head>

 

</body>

 

=={{header|Julia}}==

The computer or player can always win if they go first and choose a number that brings the total to one of the following: 1, 5, 9, 13, or 17. To make things vary more, there is a choice of computer play level at the start. The computer will randomly respond with level 1 and choose a random response 1/4 of the time at level 2.

function trytowin(n)

if 21 - n < 4

 

play21game()

 

=={{header|Lua}}==

gamewon = false

running_total = 0

 

end

 

 

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

ClearAll[ComputerChoose, HumanChoose]

ComputerChoose[n_] := If[n < 18, RandomChoice[{1, 2, 3}], 21 - n]

If[runningtotal == 21, Print["You won!"]; Break[]];

];

{{out}}

<pre>You choose = 2

There is a simple strategy which allows the first player to win in any case. It consists to choose a value which gives

a running total equal to 1, 5, 9, 13 or 17. So never let the computer starts as the program uses this strategy.

# 21 game.

 

echo "Quitting game."

break

 

{{out}}

 

=={{header|Objeck}}==

@quit : Bool;

@player_total : Int;

return 0;

}

 

=={{header|Pascal|Delphi}}==

program Game21;

 

end;

end.

 

=={{header|Perl}}==

{{trans|Raku}}

The 21 game. Each player chooses to add 1, 2, or 3 to a running total.

The player whose turn it is when the total reaches 21 wins. Enter q to quit.

my $i = $insults[1+int rand($#insults)];

print "$i, $g is not an integer between 1 and 3...\n"

{{out}}

<pre>The 21 game. Each player chooses to add 1, 2, or 3 to a running total.

If the computer goes first you cannot win, it will say "(you've already lost)" as soon as you have.<br>

You can run this online [http://phix.x10.mx/p2js/21Game.htm here]. (As noted below, a few improvements are in order.)

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\21_Game.exw

<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

 

=={{header|PHP}}==

The solution as a server-side PHP7 script and HTML5.

<html lang="en">

 

?>

 

 

=={{header|Picat}}==

{{trans|Julia}}

 

main =>

NextN = playermove(N)

end.

 

=={{header|Python}}==

 

{{works with|Python 2.X and 3.X}}

from random import randint

def start():

print("Computer wins {0} game, human wins {1} games".format(c,m))

t = raw_input("Another game?(press y to continue):")

 

{{out}}

 

===Python: using tkinter===

''' Python 3.6.5 code using Tkinter graphical user interface.

Starting player chosen randomly. '''

g = Game(root)

root.mainloop()

 

=={{header|Quackery}}==

 

"Who goes first: Computer, Player"

say " or Random?" cr

[ say "The computer won!" ]

else [ say "You won! Well done!" ]

 

{{out}}

 

=={{header|R}}==

state = 0

finished = F

turn = turn + 1

}

 

{{out}}

<pre>The total is now 0

You win!</pre>

 

{{out}}

<pre>The total is now 0

=={{header|Racket}}==

 

 

(define limit 21)

[(= new-total limit) (win human-turn?)]

[(> new-total limit) (win (not human-turn?))]

 

{{out}}

{{works with|Rakudo|2018.09}}

Since there is no requirement that the computer play sensibly, it always plays a random guess so the player has some chance to win.

The 21 game. Each player chooses to add 1, 2, or 3 to a running total.

The player whose turn it is when the total reaches 21 wins. Enter q to quit.

print ('Yo mama,', 'Jeez,', 'Ummmm,', 'Grow up,', 'Did you even READ the instructions?').roll;

say " $g is not an integer between 1 & 3..."

{{out|Sample game}}

<pre>The 21 game. Each player chooses to add 1, 2, or 3 to a running total.

 

This REXX version allows the user to choose if the computer should go first.

/*──────────── is added to the current sum, the first player to reach 21 exactly wins.*/

sep= copies('─', 8); sep2= " "copies('═', 8)" " /*construct an eye─catching msg fences.*/

if bad then iterate /*Had an error? Then get another number*/

x= x/1; if $+x>goal then call ser "Number will cause the sum to exceed " goal': ' x

{{out|output|text=''':'''}}

<pre>

 

=={{header|Ring}}==

# Project : 21 Game

 

}

}

Output:<br>

[http://kepkezelo.com/images/1hyutakip6vo1t1rpypy.jpg 21 Game]

 

=={{header|Ruby}}==

# 21 Game - an example in Ruby for Rosetta Code.

 

end

puts 'Good bye!'

 

=={{header|rust}}==

use std::io;

 

println!("player: {} win: {}", players[1].get_name(), players[1].wins);

}

 

=={{header|Scala}}==

object Game21 {

 

}

}

 

=={{header|uBasic/4tH}}==

else

print "Bad luck. The computer wins."

=={{header|Visual Basic .NET}}==

 

<p>

The file MainWindow.xaml.vb with Visual Basic source code.

 

Class MainWindow

End If

End Sub

<p>

The file MainWindow.xaml with GUI source code written in XAML.

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

</Grid>

</Window>

 

=={{header|Vlang}}==

{{trans|Go}}

import rand

import rand.seed

}

}

 

{{out}}

{{libheader|Wren-fmt}}

{{libheader|Wren-ioutil}}

import "/ioutil" for Input

import "random" for Random

}

round = round + 1

 

{{out}}