Tic-tac-toe: Difference between revisions

{{trans|Python}}

 

F nonrandom_choice(lst)

:seed = 1664525 * :seed + 1013904223

L.break

L.was_no_break

 

{{out}}

 

=={{header|Ada}}==

-- can play human-human, human-computer, computer-human or computer-computer

-- the computer isn't very clever: it just chooses a legal random move

Ada.Text_IO.Put_Line("The winner is: " & Find_Winner(The_Board));

end if;

 

{{out}}

=={{header|ALGOL W}}==

The user can play O, X, both or neither. O goes first whether user or computer controlled.

 

string(10) board;

do begin end

 

{{out}}

<pre>

 

=={{header|AppleScript}}==

property XMask : missing value

property winningNumbers : {7, 56, 73, 84, 146, 273, 292, 448}

end repeat

return theResult as integer

 

=={{header|AutoHotkey}}==

This program uses a Gui with 9 buttons. Clicking on one will place an X there, disable the button, and cause the program to go somewhere.

It plays logically, trying to win, trying to block, or playing randomly in that order.

Gui, Add, Button, x52 y12 w30 h30 vB2 gButtonHandler,

Gui, Add, Button, x92 y12 w30 h30 vB3 gButtonHandler,

GuiClose:

ExitApp

 

=={{header|AWK}}==

# syntax: GAWK -f TIC-TAC-TOE.AWK

BEGIN {

}

function abs(x) { if (x >= 0) { return x } else { return -x } }

 

=={{header|Bash}}==

#encourage use of bash for more interesting tasks.

 

#!/bin/bash

declare -a B=( e e e e e e e e e ) # Board

show; [[ RANDOM%2 -eq 0 ]] && { turn O X; exit $?; } || turn X O

 

{{out}} (nice ANSI formatting is not shown)

<pre>

=={{header|BASIC}}==

==={{header|BASIC256}}===

# basado en código de Antonio Rodrigo dos Santos Silva (gracias):

# http://statusgear.freeforums.net/thread/17/basic-256-tic-tac-toe

call gameMenu()

end

 

 

===Microsoft Small Basic===

This game has a simple AI.

place2 = 2

place3 = 3

Else

Goto reset

 

===ZX Spectrum Basic===

 

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

This is just a game between two human players.

setlocal enabledelayedexpansion

:newgame

pause

goto newgame

===Advanced===

This code makes a version of Tic Tac Toe with more features:

:BEGIN

REM Skill level

set t7=

set t8=

 

=={{header|Befunge}}==

Plays reasonably well, but not perfectly, so can be beaten.

 

>9>066+0p076+0p^ ^,," |"_v#%3:- <

:,,0537051v>:#,_$#^5#,5#+<>:#v_55+

>"yM">:#,_$ :. 1234+++, 789*+ \0^<

"a s't"98:*+>:#,_$@>365*+"ward"48*

 

{{out}}

=={{header|C}}==

Opening alternates between human and computer. Computer never loses.

#include <stdlib.h>

 

while (1) printf("%s", game(first = !first));

return 0;

 

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

It tries to show a number of C# code features while still keeping each function small and understandable.

 

using System.Collections.Generic;

using System.Linq;

}

 

 

{{out}}

 

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

#include <windows.h>

#include <iostream>

}

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

{{out}} Computer plays 'X' and human plays 'O'

<pre>

 

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

(defun generate-board ()

(loop repeat 9 collect nil))

(format t "The winner is ~a!" (find-winner board))

(format t "It's a tie.")))))

 

{{out}}

 

=={{header|D}}==

std.ascii, std.array, std.range, std.math;

 

break;

}

{{out}}

<pre>Tic-tac-toe game player.

[https://easylang.online/apps/tictactoe.html Run it]

 

state = 0

textsize 14

.

.

 

=={{header|Erlang}}==

The program will randomly chose if the computer ("X") or the user ("O") starts. The computer look ahead is only one level. Perhaps the computer might lose?

-module(tic_tac_toe).

 

turn_next_move_ok( true, _Prompt, _Ns, N ) -> N;

turn_next_move_ok( false, Prompt, Ns, _N ) -> turn_next_move( Prompt, Ns ).

{{out}}

<pre>

{{works with|OpenEuphoria}}

No computer AI

include std/console.e

include std/text.e

 

end while

{{out}}

<pre>

A purely-functional solution with a naive (but perfect) computer player implementation. The first move is played randomly by the computer.

 

| Empty

| Computer

let b = set Computer emptyBoard (choose (freeSpace emptyBoard))

printBoard b

 

Example game:

Game between two humans.

 

 

\ board: 0=empty, 1=player X, 2=player O

 

game

 

{{out}}

=={{header|Fortran}}==

Objective: write program in less than 100 lines, not using semicolons. Computer never loses, but plays as random as possible. Player gets first move of first game. Afterwards, first move alternates between computer and player.

! This is a fortran95 implementation of the game of tic-tac-toe.

! - Objective was to use less than 100 lines.

enddo mainloop

end program

=={{header|FreeBASIC}}==

===graphics mode===

 

'About 400 lines of code, but it is a graphical (GUI ish) i.e. mouse driven.

End

End Sub

 

 

===text mode===

Screenres 320,240,32

 

Loop Until Multikey(&H01)

End

 

 

=={{header|Go}}==

Intermediate, like Python's "Better skilled player." Computer wins and blocks where it can, but otherwise plays randomly. Plays multiple games and keeps score. Player gets first move of first game. Afterwards, loser gets to go first, or after cat games, first move alternates.

 

import (

{0, 4, 8}, // diagonals

{2, 4, 6},

 

=={{header|Groovy}}==

Simplified version of Tic Tac Toe for player vs. player (no AI computer-controlled option).

 

def input = new Scanner(System.in)

return builder.toString();

}

 

=={{header|Haskell}}==

Computer player has three strategies: 1. Try to block the opponent first, 2. Try to guess a good position for the next move, 3. Place a piece randomly.

There are lots of comments throughout the code.

module Main where

 

putStrLn "3 : player X is human and player O is computer"

putStrLn "Player X always begins."

{{out}}

Player X is computer, O is human.

The following works in both Icon and Unicon. The computer plays randomly against a human player, with legal moves enforced and wins/draws notified.

 

# Play TicTacToe

 

play_game ()

end

 

=={{header|J}}==

To subsequent j poster: replacing this entry is fine by me.

Note 'ttt adjudicates or plays'

 

nor=: 8 b.

infix_pairs_agree=: 2&(=/\)

 

=={{header|Java}}==

This version works in the terminal itself, and uses the numpad for data entry. The computer is unbeatable, but some lines can be removed to avoid that. There's also an override that thrown in, just for fun.

import java.io.BufferedReader;

import java.io.InputStreamReader;

}

}

 

<pre>

 

This version uses javax.swing.

import java.awt.*;

import java.awt.event.*;

}

}

 

Graphical Java Example

import javax.swing.*;

import java.awt.event.*;

}

}

The following program may be executed for a player-against-player game.

import javax.swing.*;

import javax.swing.border.Border;

}

}

 

=={{header|Javascript}}==

HTML5 Canvas implementation. Should play perfectly or near-perfectly.

<!DOCTYPE html>

 

 

</html>

 

 

Human is X and goes first.

 

// Board

const topLeft = 1;

}

});

 

{{out}}

=={{header|Julia}}==

One move look-ahead algorithm. Computer plays to win or at least draw.

[2, 5, 8], [3, 6, 9],[1, 5, 9], [7, 5, 3]]

 

 

tictactoe()

Board move grid:

1 2 3

=={{header|Kotlin}}==

{{trans|C}}

 

import java.util.Random

println()

}

 

Sample game:

 

As image uploads has been disabled, a live version can be viewed at: [http://jono.guthrie.net.nz/rosetta/Tic-tac-toe.lasso http://jono.guthrie.net.nz/rosetta/Tic-tac-toe.lasso]

session_start('user')

session_addvar('user', 'matrix')

$matrix = array('-','-','-','-','-','-','-','-','-')

$turn = 'x'

 

=={{header|Lingo}}==

Screenshot of application window: http://valentin.dasdeck.com/lingo/tic-tac-toe/tic-tac-toe-lingo.png<br />

"Human" cannot win this game.

global gBoard -- current board image

global gBoardTemplate -- empty board image

on sum (aLine)

return aLine[1]+aLine[2]+aLine[3]

 

=={{header|Lua}}==

Version for LuaJIT with or without ffi, negamax algorithm with alpha-beta pruning and caching of results. Human can't win.

ffi=require"ffi"

local function printf(fmt,...) io.write(string.format(fmt, ...)) end

draw(board)

until endgame()

 

{{out}}

=={{header|M2000 Interpreter}}==

Computer May loose;

Module Tic.Tac.Toe {

Dim Board$(1 to 3, 1 to 3)=" "

}

Tic.Tac.Toe

{{out}}

<pre style="height:30ex;overflow:scroll">

 

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

first, rows =

Join[#, Transpose@#, {Diagonal@#, Diagonal@Reverse@#}] &},

text = "Draw."]]]]], {i, 1, 3}, {j, 1, 3}], Thickness[.01],

Line[{{{1, 0}, {1, 3}}, {{2, 0}, {2, 3}}, {{0, 1}, {3, 1}}, {{0,

 

=={{header|MATLAB}}==

Allows for choice between any combination of human or computer players. Computer players are intelligent, but not perfect. It implements the "rules" used by the Newell and Simon's 1972 tic-tac-toe program (as explained by Wikipedia), but this implementation does not factor in the move before the move causing the fork (either for creation or prevention).

% Set up the board (one for each player)

% boards - 3x3x2 logical representation of all players' pieces

draw = all(all(boards(:, :, 1) | boards(:, :, 2)));

{{out}}

Computer goes first and plays perfectly:

 

=={{header|mIRC Scripting Language}}==

if ($2 isin %ttt) || (!%ttt) {

var %ttt~ = $remove($iif(%ttt,%ttt,1 2 3 4 5 6 7 8 9),$2,X,O)

echo -ag � $+ $iif($7 isnum,$chr(32),$7) $+ $chr(124) $+ $iif($8 isnum,$chr(32),$8) $+ $chr(124) $+ $iif($9 isnum, ,$9)

}

 

=={{header|МК-61/52}}==

ПП 28 1 - БП 51 ИП7 ПП 28 ИП7

ПП 28 КИП2 ИП2 ВП 4 4 С/П 1 -

x=0 33 8 П2 С/П П7 ИП2 4 - x#0

43 x<0 45 8 + П8 ИП7 - x#0 55

 

Cell numbering 1 to 9; starts from the upper left cell, then clockwise in a spiral. The first move is a calculator. Result: 44 - draw, 66 - victory of the calculator.

This is a translation of the second version with the better AI, but with some differences. For instance, we have chosen to display the board in the same way as the first version. All procedures have a parameter "board" rather accessing a global variable. We use also base 1-indexing for the board. Etc.

 

 

type

echo "Input the index of where you wish to place your mark at your turn."

randomize()

 

{{out}}

=={{header|Objeck}}==

Tic-tac-toe game using Minimax algorithm.

@board : Char[,];

@cpu_opening : Bool;

"===========\n"->PrintLine();

}

 

=={{header|Pascal}}==

I would expect this version should compile with most Pascal variants including Delphi, but YMMR.

 

 

type

player := swapPlayer(player);

end

 

=={{header|Perl}}==

the computer. Anyone who can identify the mistake, is welcome to fix it.

 

use strict;

 

$whose_turn = !$whose_turn;

}

 

{{out}}

</pre>

===Alternate with GUI===

 

use strict;

(sort {$a->[0] <=> $b->[0]} shuffle @moves)[ -($who eq 'X') ]

};

 

=={{header|Phix}}==

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/Tic_tac_toe.htm here].

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

-- demo\rosetta\Tic_tac_toe.exw

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

 

=={{header|PHP}}==

NOTE: While PHP can considered a super-set of HTML/JS, usage has been kept to a minimum to focus on the more specific PHP parts.

 

<?php

const BOARD_NUM = 9;

echo '<a href="?b=', $EMPTY_BOARD_STR, '">Reset</a>';

if ($gameOver) echo '<h1>Game Over!</h1>';

 

=={{header|PicoLisp}}==

This solution doesn't bother about the game logic, but simply uses the alpha-beta-pruning 'game' function in the "simul" library.

 

(de display ()

((find3 T) "Congratulation, you won!")

((not (myMove)) "No moves")

{{out}}

<pre>: (main)

Uses a minimax algorithm with no Alpha-beta pruning, as the max depth of the recursion is 8. Computer never loses.<br>

A GUI interface written in XPCE is given.

 

:-dynamic box/2.

computer(o).

 

Module min-max.pl defines minimax algorithm.

 

% minimax(Player, Deep, MaxDeep, B, V-B)

lie(TTT, V-_, V-TTT).

 

 

=={{header|Python}}==

The computer enforces the rules but plays a random game.

'''

Tic-tac-toe game player.

else:

print('\nA draw')

 

'''Sample Game'''

In this version, The computer player will first complete a winning line of its own if it can, otherwise block a winning line of its opponent if they have two in a row, or then choose a random move.

 

'''

Tic-tac-toe game player.

break

else:

 

{{out}}

This program simulates a game of Tic-Tac-Toe inside of an interactive window. It includes three player modes, which are a two-player game, a human versus random AI, or human versus maximized AI. This implementation belongs to "X", and can also be found here.

 

rm(list=ls())

library(RColorBrewer)

#start("name", "mode" = 0 - 2, type = 0,1)

 

 

=={{header|Racket}}==

 

The <tt>minimax.rkt</tt> module:

#lang lazy

(provide minimax)

(next (cdr x)

(min β (minimax (car x) α β (not max-player))))))]))))

 

The <tt>game.rkt</tt> module:

 

#lang lazy

(require racket/class

(set-field! opponent p2 p1)

(send p1 your-turn initial-state))

 

The <tt>tick-tack.rkt</tt> module:

 

(require "game.rkt"

(new (interactive-player o%) [name "Dummy"] [look-ahead 0]))

 

 

Sample games:

As an example of another zero-sum game consider the classical [http://en.wikipedia.org/wiki/Nim Nim] game:

 

#lang racket

 

(define player-B

(new (interactive-player second%) [name "B"] [look-ahead 4]))

 

Computer plays with the computer:

The computer plays a random game.

 

my @winning-positions = [0..2], [3..5], [6..8], [0,3,6], [1,4,7], [2,5,8],

[0,4,8], [6,4,2];

} else {

say "How boring, a draw!";

 

=={{header|REXX}}==

<br>A fair amount of code was dedicated to error detection &nbsp; and &nbsp; the displaying of error messages, &nbsp; and

<br>also the presentation of the tic─tac─toe game boards (grids).

$= copies('─', 9) /*eyecatcher for error messages, prompt*/

oops = $ '***error*** ' /*literal for when an error happens. */

 

if _==N | (_>=w & ec\=='') then return 1==1 /*a winner has been determined.*/

This REXX program makes use of &nbsp; '''LINESIZE''' &nbsp; REXX program (or BIF) which is used to determine the screen width (or linesize) of the terminal (console); &nbsp; this is used to determine the amount of padding for a centered display of the two grids.

 

 

The tecTacToe.ring is provided [https://github.com/AbdelrahmanGIT/RingSamples/blob/master/src/TecTacToe.ring here]

Load "guilib.ring"

 

next

if tie=true return 3 ok return 0

 

{{out}}

This implementation stores the board as a one-dimensional array and hardcodes all possible straight lines in <code>LINES</code>, rather than storing the board as a two-dimensional matrix and identifying straight lines dynamically.

 

LINES = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7]]

puts

players_with_human = [HumanPlayer, ComputerPlayer].shuffle

 

{{out}}

 

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

' TIC TAC TOE

' ---------------------------

input "Play again (y/n)";p$

if upper$(p$) = "Y" then goto [newGame]

 

=={{header|Rust}}==

use GameState::{ComputerWin, Draw, PlayerWin, Playing};

 

}

 

{{out}}

<pre>

Computer vs. human. Human starts. Computer plays 'O' and human plays 'X'.

Computer moves are legal, but random.

val Human = 'X'

val Computer = 'O'

}

 

 

{{out}}(human is always first)

Can be a game of human v. human, human v. machine, or machine v. machine. Machine moves have a hierarchy: firstly, it looks for a winning move; secondly, it looks for a way to block the opponent's victory; lastly, it makes a random move.

 

//Board size and marks

N = 3;

endfunction

 

 

=={{header|SQL}}==

Basic playable TicTacToe in SQLite using only the sqlite3 CLI.

The CLI wasn't really designed for this, making the interactivity a little bit clunky. However, some of the higher-level constructs in SQL allow for some intriguingly elegant game logic.

--Setup

drop table if exists board;

.print "->update board set p = 'X' where rowid = ?; select * from ui; select * from msg;"'

 

{{out}}

<pre>

=={{header|Swift}}==

Some Basic AI for obvious losing and winning conditions

import Darwin

 

}

}

{{out}}

<pre>

 

=={{header|Tailspin}}==

processor Tic-Tac-Toe

@: [position´1..position´9];

end play

 

{{out}}

<pre>

=={{header|Tcl}}==

{{trans|Python}}

 

# This code splits the players from the core game engine

# Assemble the pieces

set ttt [TicTacToe new HumanPlayer RandomRoboPlayer]

Sample game:

<pre>

 

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

REM

REM Released as public domain by Damian Gareth Walker, 2019

IF M=8 THEN LET Y=P

IF M=9 THEN LET Z=P

 

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

The computer plays randomly.

 

# play tic-tac-toe

main() {

}

 

 

{{Out}}

=={{header|VBA}}==

Human play first with the "X". You must choose the row and the column you want to play...

Option Explicit

 

IsEnd = True

End Function

{{out}}

<pre>Loop 0

{{trans|Kotlin}}

{{libheader|Wren-ioutil}}

import "/ioutil" for Input

 

if (yn == "n" || yn == "N") return

System.print()

 

{{out}}

=={{header|XPL0}}==

[[File:TTTXPL0.GIF|right]]

\ numeric keypad is used to make the player's move.

\

[SetVid(3); exit]; \clear screen & restore normal text mode

];

 

=={{header|Yabasic}}==

In the classic style.

10 REM TICTAC

15 INPUT "English (0), Spanish (other key): " IDIOMA : IF NOT IDIOMA THEN RESTORE 2020 ELSE RESTORE 2010 END IF

2010 DATA "YO GANO,TU GANAS,ES SIMPLEMENTE UN DIBUJO,ESTA ES MI PRIORIDAD ACTUALIZADA,PULSE LA TECLA <RETURN> PARA CONTINUAR,REALICE SU MOVIMIENTO,MOVIMIENTO: "

2020 DATA "I WIN,YOU WIN,IT'S JUST A DRAWING,THIS IS MY PRIORITY UPDATE,PRESS <RETURN> TO CONTINUE,TO MAKE YOUR MOVE,MOVEMENT: "

 

{{omit from|GUISS}}