Nim game: Difference between revisions

{{trans|Python}}

F getTokens(curTokens) -> N

compTurn(tokens)

{{out}}

It may not be a very interesting game, but it assembles to only 222 bytes.

puts: equ 9

putch: equ 2

lose: db 13,10,'You lose!$'

nl: db 13,10,'$'

=={{header|8086 Assembly}}==

bits 16

cpu 8086

tokens: db 13,10,13,10,'Tokens: $'

lose: db 13,10,'You lose!$'

=={{header|Action!}}==

BYTE t,max

player=1-player

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Nim_game.png Screenshot from Atari 8-bit computer]

{{works with|Ada|Ada|2012}}

procedure Nim is

TIO.Put_Line("Computer won!");

{{out}}

<pre> 12 tokens remain.

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

# gets a single character answer from standin and returns it #

PROC answer = ( STRING prompt )CHAR:

DO SKIP OD;

print( ( "I win!", newline ) )

{{out}}

<pre>

=={{header|ALGOL-M}}==

BEGIN

WRITE("THANKS FOR PLAYING!");

{{out}}

<pre>

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

This one-liner demonstrates the 240 character line limit. The program has been crafted to be exactly 244 characters long. The last 4 characters HEAP will be truncated from the last statement in the line. The HEAP variable is optional in the out-most NEXT statement so the program still runs correctly.

=={{header|Arturo}}==

while ø [

tk: 0

break

]

{{out}}

=={{header|AsciiDots}}==

%$LMRTX

.-$"Nim Dots"-$""-

L-------------*---*>$_#-$" dots remaining."-$""

T

{{out}}

=={{header|AutoHotkey}}==

tokens := 12

while tokens {

else

ExitApp

=={{header|AWK}}==

# syntax: GAWK -f NIM_GAME.AWK

BEGIN {

printf("%s takes %d token%s; there are %d remaining\n",who,ans,(ans==1)?"":"s",tokens)

}

{{out}}

<pre>

=={{header|BlooP}}==

Bloop has no input capabilites, so the game is defined as a procedure, called with 3 numbers (since the game will last only 3 rounds anyhow). The procedure can be called with more numbers - extra parameters are ignored in most implementations I have found. Since there is no easy way to get more inputs, any incorrect values are converted to correct ones.

DEFINE PROCEDURE ''DIVIDE'' [A,B]:

BLOCK 0: BEGIN

PLAY_GAME [1,4,3];

{{out}}

=={{header|C}}==

#include <stdio.h>

return remainingTokens;

}

{{Out}}

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

{{trans|Go}}

#include <limits>

}

}

{{out}}

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

using System;

}

}

{{out}}

Sample game:

=={{header|Common Lisp}}==

(defun pturn (curTokens)

(write-string "How many tokens would you like to take?: ")

(return)))

(write-string "Computer wins!")

{{out}}

=={{header|Crystal}}==

until tokens <= 0

end

=={{header|Dyalect}}==

print("You can take 1, 2, or 3 on your turn.")

print("Whoever takes the last token wins.\n")

}

=={{header|Factor}}==

IN: rosetta-code.nim-game

: nim-game ( -- ) 12 round drop "Computer wins!" print ;

{{out}}

<pre>

=={{header|Fermat}}==

while heap>0 do

!!('There are ',heap,' tokens left. How many do you want to take?');

od;

{{out}}<pre>There are 12 tokens left. How many do you want to take?

>take := 4

=={{header|FreeBASIC}}==

while heap > 0

wend

=={{header|Go}}==

import (

}

}

{{out}}

=={{header|GW-BASIC}}==

20 WHILE HEAP>0

30 TAKE = 0

130 END

140 PRINT "You got the last token. Congratulations!"

=={{header|Haskell}}==

import System.IO

main :: IO ()

{{out}}

<pre>

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

110 RANDOMIZE

120 CLEAR SCREEN

310 ELSE

320 PRINT "You win!"

=={{header|J}}==

Implementation:

prompt tokens=: 12

}}

echo 'I take ',(":t=. 4-y),' tokens'

prompt tokens=:tokens-t

Sample session:

tokens: 12

take 1, 2 or 3 tokens

I take 2 tokens

tokens: 0

=={{header|Java}}==

import java.util.Scanner;

}

{{out}}

=== Browser Version ===

This is the easy but dirty way - with prompt for input, and console.log for output. The Nim class was structured so that input and output could be customized, for example to use HTML DOM elements for in and out, instead of the terminal.

class Nim {

constructor(tokens, printFun) {

}

}

{{out}}

=={{header|Julia}}==

{{trans|Raku}}

tcount = 12

takenum = 0

nimgame()

<pre>

12 tokens remain.

=={{header|Kotlin}}==

{{trans|Go}}

fun showTokens(tokens: Int) {

}

}

{{output}}

=={{header|Lua}}==

tokens = 12

print ("Computer wins.")

{{out}}

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

While[n > 0,

c = ChoiceDialog["Current amount = " <> ToString[n] <> "\nHow many do you want to pick?", {1 -> 1, 2 -> 2, 3 -> 3}];

n -= (4 - c);

]

=={{header|MiniScript}}==

{{trans|Lua}}

print "Nim Game"

end while

{{out}}

<pre>Nim Game

=={{header|Nim}}==

import terminal

computer()

{{out}}

=={{header|OCaml}}==

{{trans|Python|with plurals added, loops turned to recursion and string input handled}}

print_string "How many tokens would you like to take? ";

let n = read_int_opt () |> Option.value ~default:0 in

if tokens = 0 then print_endline "Computer wins!" else play_game tokens

{{out}}

<pre>

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

say "Computer wins." and last

if $tokens <= 0;

{{out}}

<pre>12 tokens remaining.

=={{header|Phix}}==

{{trans|Raku}}

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- getc</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">tokens</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">12</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">player</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>

<span style="color: #000000;">tokens</span> <span style="color: #0000FF;">-=</span> <span style="color: #000000;">4</span><span style="color: #0000FF;">;</span> <span style="color: #000000;">player</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>

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

{{out}}

<pre>

{{trans|Python}}

void get_tokens(int cur_tokens) {

write("Computer wins!\n");

return 0;

{{out}}

=={{header|Plain English}}==

Start up.

Play the game of Nim.

Format the count and "piece" or "pieces" into a string.

Write "The computer took " then the string then "." on the console.

{{out}}

<pre>

=={{header|Prolog}}==

next_turn(N) :-

-> format('Computer wins!')

; next_turn(N2)

{{out}}

<pre>

=={{header|Python}}==

Works on Python 3

print("Py Nim\n")

print("Computer wins!")

{{out}}

=={{header|R}}==

##

}

{{out}}

=={{header|Racket}}==

#lang racket

(pturn 12)

=={{header|Raku}}==

{{works with|Rakudo|2019.03}}

loop {

say "Computer takes {4 - $player}.\n$tokens tokens remaining.\n";

say "Computer wins." and last if $tokens <= 0;

{{out|Sample output}}

<pre>12 tokens remaining.

=={{header|Red}}==

date: 2021-10-24

version: 0.6.4

tokens: subtract tokens subtract 4 n

]

{{out}}

<pre>

=={{header|REXX}}==

Programming notes: &nbsp; extra error checking was done with specific informative error messages. &nbsp; Also included was a method of quitting the game. &nbsp; The number of (starting) tokens &nbsp; (the ''pot'') &nbsp; can be specified on the command line, &nbsp; the default is &nbsp; '''12'''.

parse arg pot _ . 1 __ /*obtain optional argument from the CL.*/

if pot=='' | pot=="," then pot= 12 /*Not specified? Then use the default.*/

show: say; say pad "Tokens remaining: " arg(1)' ' pad; say; return

s: if arg(1)==1 then return arg(3); return word(arg(2) 's',1)

{{out|output|text=&nbsp; when using the default input:}}

<pre>

=={{header|Ring}}==

# Project : CalmoSoft Nim Game

# Date : 16/04/2020-13:27:07

win.close()

app.Quit()

Necessary image files:

[http://www.mediafire.com/file/8z9tus0owwkv92q/Images.zip/file Images file]

=={{header|Ruby}}==

puts "There are #{remaining} dots.\nHow many dots would you like to take? "

unless (num=gets.to_i).between?(1, 3)

puts "Computer took the last and wins."

{{out}}

<pre>There are 12 dots.

=={{header|Rust}}==

fn main() {

let mut tokens = 12;

println!("");

}

{{out}}

sample game:

=={{header|S-Basic}}==

$constant maxtokens = 12

$constant machine = 0

print "Thanks for playing!"

{{out}}

<pre>

=={{header|Scala}}==

var tokens = 12

println("Computer wins!")

}

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

Object subclass: Nim [

| tokens |

g := Nim new.

g mainLoop.

{{out}}

sample game:

=={{header|SNOBOL4}}==

{{works with|CSNOBOL4}}

&DUMP = 1

&DUMP = 0

<pre>The mysterious game of Nim!

=={{header|Swift}}==

while tokens != 0 {

print()

{{out}}

=={{Header|Tiny BASIC}}==

20 PRINT "There are"

30 PRINT H

200 END

210 PRINT "I got the last token. I win. Better luck next time."

=={{header|True BASIC}}==

LET llevar = 0

SET COLOR 2

PRINT "Obtuve la última ficha. ¡Gané! Mejor suerte la próxima vez."

=={{header|Vlang}}==

{{trans|Go}}

fn show_tokens(tokens int) {

}

}

{{out}}

=={{header|Wren}}==

{{trans|Go}}

var showTokens = Fn.new { |tokens| System.print("Tokens remaining %(tokens)\n") }

break

}

{{out}}