Tic-tac-toe: Difference between revisions

 

''Tic-tac-toe''   is also known as:

::*   ''tic tac toe''

::*   ''tick tack toe''

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

 

 

This game has a simple AI.

place2 = 2

place3 = 3

Else

Goto reset

 

 

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

 

You win!</pre>

 

=={{header|EasyLang}}==

It uses minimax with alpha-beta pruning. Therefore, the computer never loses.

 

 

state = 0

textsize 14

.

.

.

.

.

.

.

.

.

on timer

.

on mouse_down

.

 

=={{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 over. I have won.

</pre>

 

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

Game over. Computer wins!

</pre>

 

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

In some ways easier to read, but because Pascal lack return/break/continue

functions a little long and different style. Tested with FreePascal on macOS.

 

 

type

var

 

end;

 

 

end;

 

 

 

if computer can win save it, otherwise block if need be, else do deeper.

At each level modify the board for the next call, but clean up as go back up,

end;

end;

end;

end;