Morpion solitaire: Difference between revisions

=={{header|C}}==

Console play with ncurses. Length and touching rules can be changed at the begining of source code. 'q' key to quit, space key to toggle auto move, anykey for next move. Play is random. I got nowhere near the record 177 moves, but did approach the worst-possible (20) quite often.

#include <stdlib.h>

#include <unistd.h>

endwin();

return 0;

 

=={{header|Go}}==

{{libheader|goncurses}}

{{trans|C}}

 

import (

gc.CBreak(false)

gc.Echo(true)

 

=={{header|Icon}} and {{header|Unicon}}==

=={{header|J}}==

With this program as the file m.ijs

NB. turn will be a verb with GRID as y, returning GRID. Therefor:

NB. morpion is move to the power of infinity---convergence.

NB. example

smoutput play''

load the file into a j session to play an initial game and report the number of turns. We can play a game providing a vector of move numbers at which to report the output.

<pre>

{{libheader|nim-ncurses}}

 

import ncurses

 

endwin()

 

 

{{out}}

Picks a move at random from all possible moves at each step. A sample game is shown.

The largest score found so far (from just random play) is 92, also shown below.

use warnings;

use List::Util qw( none );

=~ s/.{60}\K /\n/gr, "\n";

tr/O/X/;

This runs on a 30x30 grid (as advised by Talk page).

Each move is shown as the end points of a line, startcolumn,startrow->endcolumn,endrow where row and column numbers

move count: 92

</pre>

A faster, shorter version without the single step display.

Uses the same kind of block shift/or technology I used in "Forest fire" and have used

for Conway's Life.

use warnings;

 

local $_ = <<END;

$_ = tr/X./ /r . tr/./ /r . tr/X./ /r; # expand to 30x30 and spaces

 

while( 1 )

{

for my $i ( 1, 30 .. 32 ) # directions 1 - 30 / 31 | 32 \

{

(substr $_, 4 * $i) =~ tr/X \n/P\0/r;

while( $combined =~ /[OW\[\]\^]/g ) # exactly four Xs and one space

print join(' ', map s/ .* /->/r =~ s!\d+! ($& % 31).','.int $& / 31 !ger,

@moves) =~ s/.{60}\K /\n/gr, "\n";

 

=={{header|Phix}}==

=={{header|Racket}}==

 

(module rules racket/base

(require racket/match)

p

(define bmp (pict->bitmap p))

 

 

'''Intermission:''' The <code>render</code> submodule just does drawing, and is not part of the solving. But the <code>main</code> module uses it, so we put it in here:

 

(require racket/match

racket/draw

[(hash-has-key? p# k) #\.]

[else #\space])))

{{out}}

 

<br>This program allows the <tt> D </tt> or <tt> T </tt> forms of the game, and allows any board size (grid size) of three or higher.

<br>The default games is <tt> 5T </tt>

signal on syntax; signal on noValue /*handle possible REXX program errors. */

/* [↓] handle the user options (if any)*/

x= xx

do y=yy-1 by -1; x=x+1; if @.x.y==empty then leave; z= z||@.x.y; end

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).

<br>The &nbsp; '''LINESIZE.REX''' &nbsp; REXX program is included here ──► [[LINESIZE.REX]].<br>

{{libheader|Wren-fmt}}

An embedded program so we can use the ncurses library.

 

import "random" for Random

Ncurses.nocbreak()

Ncurses.echo()

<br>

We now embed the above script in the following C program, build and run it.

 

#include <stdio.h>

int x = (int)wrenGetSlotDouble(vm, 2);

const char *str = wrenGetSlotString(vm, 3);

}

 

if (isStatic && strcmp(signature, "nocbreak()") == 0) return C_nocbreak;

if (isStatic && strcmp(signature, "echo()") == 0) return C_echo;

if (isStatic && strcmp(signature, "refresh()") == 0) return C_refresh;

if (isStatic && strcmp(signature, "getch()") == 0) return C_getch;

WrenVM* vm = wrenNewVM(&config);

const char* module = "main";

char *script = readFile(fileName);

WrenInterpretResult result = wrenInterpret(vm, module, script);

free(script);

return 0;