Tic-tac-toe: Difference between revisions

 

;Task:

 

 

;See also

<br><br>

 

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

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

 

HUMAN, enter you move (number):</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|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|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.*;

}

}