15 puzzle game: Difference between revisions

:*   [[16 Puzzle Game]]

<br><br>

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program puzzle15_64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

 

=={{header|Ada}}==

We fist define a generic package Generic_Puzzle. Upon instantiation, it can take any number of rows, any number of columns for a rows*columns-1 game. Instead of plain numbers, the tiles on the board can have arbitrary names (but they should all be of the same length). The package user can request the name for the tile at a certain (row,column)-point, and the set of possible moves. The user can move the empty space up, down, left and right (if possible). If the user makes the attempt to perform an impossible move, a Constraint_Error is raised.

 

Rows, Cols: Positive;

with function Name(N: Natural) return String; -- with Pre => (N < Rows*Cols);

procedure Move(The_Move: Moves);

 

 

The package implementation is as follows.

 

Field: array(Row_Type, Col_Type) of Natural;

end loop;

end;

 

The main program reads the level from the command line. A larger level implies a more difficult instance. The default level is 10, which is fairly simple. After randomizing the board, the user can move the tiles.

 

Ada.Numerics.Discrete_Random, Ada.Command_Line;

 

end;

end loop;

 

{{out}}

4 moves!</pre>

 

 

=={{header|APL}}==

{{works with|Dyalog APL|16.0}}

⍺←4 4

(s∨.<0)∨2≠⍴s←⍺:'invalid shape:'s

(1↓⍺)∇ n

}z

{{out}}

<pre> fpg 10

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

bx lr @return

 

 

=={{header|Astro}}==

 

fun mainframe(puz):

print 'You WON'

break

 

=={{header|AutoHotkey}}==

Grid := [], Deltas := ["-1,0","1,0","0,-1","0,1"], Width := Size * 2.5

Gui, font, S%Size%

if (Trim(gridCont, ",") = "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16")

MsgBox, 262208, 15 Puzzle, You solved 15 Puzzle

 

=={{header|BASIC}}==

 

==={{header|Commodore BASIC}}===

20 REM COMMODORE BASIC 2.0

30 REM ********************************

1130 FOR T=0 TO 400

1140 NEXT

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}{{works with|ARM BBC BASIC}}{{works with|Brandy BASIC|Matrix Brandy}}

 

SIZE=4 : DIFFICULTY=3

COLOUR 0 : COLOUR 143

PRINT

 

=={{header|C}}==

===C89, 22 lines version===

The task, as you can see, can be resolved in 22 lines of no more than 80 characters. Of course, the source code in C is not very readable. The second example works exactly the same way, but it was written in much more human readable way. The program also works correctly for non-standard number of rows and/or columns.

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

RIGHT;}}}void pause(void){getchar();}int main(void){srand((unsigned)time(NULL));

do setup();while(isEnd());show();while(!isEnd()){update(get());show();}disp(

 

===C89, short version, TTY mode===

* RosettaCode: Fifteen puzle game, C89, plain vanillia TTY, MVC

*/

}

 

{{Out}}

<pre>

 

===C89, long version, TTY/Winapi/ncurses modes===

* RosettaCode: Fifteen puzle game, C89, MS Windows Console API, MVC

*

return EXIT_SUCCESS;

}

 

{{libheader|System.Windows.Forms}}

{{libheader|System.Drawing}}

using System.Drawing;

using System.Windows.Forms;

 

public class FifteenPuzzle

{

 

{

}

 

{

}

 

{

 

}

}

 

{

}

}

}

 

}

 

{

}

 

}

 

{

}

}

}

 

{

 

 

}

 

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

#include <time.h>

#include <stdlib.h>

p15 p; p.play(); return 0;

}

<pre>

+----+----+----+----+

Tested with GnuCOBOL

 

*> This code is dedicated to the public domain

*> This is GNUCOBOL 2.0

end-evaluate

.

 

{{out}}

Credit to this post for help with the inversions-counting function: [http://www.lispforum.com/viewtopic.php?f=2&t=3422]

 

 

(:use :common-lisp))

(in-package :15)

(rotatef (aref *board* (first pos) (second pos))

(aref *board* (first zpos) (second zpos))))))

 

=={{header|EasyLang}}==

 

 

len f[] 16

.

.

global done .

.

.

.

on mouse_down

.

 

=={{header|F_Sharp|F#}}==

// 15 Puzzle Game. Nigel Galloway: August 9th., 2020

let Nr,Nc,RA,rnd=[|3;0;0;0;0;1;1;1;1;2;2;2;2;3;3;3|],[|3;0;1;2;3;0;1;2;3;0;1;2;3;0;1;2|],[|for n in [1..16]->n%16|],System.Random()

[<EntryPoint>]

let main n = fL(match n with [|n|]->let g=[|let g=uint64 n in for n in 60..-4..0->int((g>>>n)&&&15UL)|] in (Array.findIndex((=)0)g,g) |_->fE()) 0

3 uses:

15 game with no parameters will generate a random game which may be solved.

</pre>

=={{header|Factor}}==

combinators.short-circuit grouping io kernel literals math

math.matrices math.order math.parser math.vectors prettyprint qw

drop ;

 

{{out}}

<pre>

See [[15_puzzle_solver#Forth]] for a solver based on the same code.

 

 

cell 8 <> [if] s" 64-bit system required" exception throw [then]

 

solution 1000 shuffle play

 

=={{header|Fortran}}==

The game plan is to start with an ordered array so that each cell definitely has a unique code, then jumble them via "random" swaps. Possible arrangements turn out to have either odd or even parity based on the number of out-of-sequence squares, and as the allowed transformations do not change the parity and the solution state has even parity, odd parity starting states should not be presented except by those following Franz Kafka. The calculation is simplified by always having the blank square in the last position, thus in the last row. Once an even-parity starting state is floundered upon, the blank square is re-positioned using allowable moves so that the parity is not altered thereby. Then the game begins: single-square moves only are considered, though in practice groups of squares could be moved horizontally or vertically rather than one-step-at-a-time - a possible extension.

 

INTEGER I,J,T !So, we're stuck with supplying the obvious.

T = I !And, only for one type at a go.

IF (ANY(BORED(1:N - 2) + 1 .NE. BORED(2:N - 1))) GO TO 20 !Are we there yet?

WRITE (MSG,*) TRY,"Steps to success!" !Yes!

 

Output: Not so good. As ever, the character cell sizes are not square so a square game board comes out as a rectangle. Similarly, underlining is unavailable (no overprints!) so the layout is not pleasing. There are special "box-drawing" glyphs available, but they are not standardised and there is still no overprinting so that a flabby waste of space results. Further, there is no ability to re-write the display, even though one could easily regard the output to the screen as a random-access file: <code>WRITE (MSG,REC = 6) STUFF</code> would rewrite the sixth line of the display. Instead, output relentlessly rolls forwards, starting as follows:

 

=={{header|FreeBASIC}}==

dim as string outstr = ""

for i as ubyte = 0 to 15

print "Congratulations! You win!"

print

 

=={{header|Gambas}}==

'Inspiration came from: -

''http://rosettacode.org/wiki/15_Puzzle_Game

 

End

 

[http://www.cogier.com/gambas/Copuzzle.png Click here for image of game in play]

 

=={{header|Go}}==

 

import (

return

}

 

=={{header|Harbour}}==

 

#include "inkey.ch"

SetColor(" W/N, BG+/B")

RETURN fim

 

=={{header|Haskell}}==

import System.Random

 

randomIndex <- randomRIO (0, length moves - 1)

let move = moves !! randomIndex

Output:

<pre>Please enter the difficulty level: 0, 1 or 2

Implementation:

 

 

genboard=:3 :0

showboard board

echo 'You win.'

 

Most of this is user interface code. We initially shuffle the numbers randomly, then check their parity and swap the first and last squares if needed. Then, for each move, we allow the user to pick one of the taxicab neighbors of the empty square.

A full game would be too big to be worth showing here, so for the purpose of giving a glimpse of what this looks like in action we replace the random number generator with a constant:

 

15 puzzle

h for help, q to quit

│13│14│15│ │

└──┴──┴──┴──┘

 

=={{header|Java}}==

{{works with|Java|8}}

 

import java.awt.*;

});

}

 

=={{header|Javascript}}==

Play it [http://paulo-jorente.de/webgames/15p/ here]

var board, zx, zy, clicks, possibles, clickCounter, oldzx = -1, oldzy = -1;

function getPossibles() {

restart();

}

Html to test

<pre>

 

=={{header|Julia}}==

using Random

 

 

puzzle15play()

This puzzle is solvable.

+----+----+----+----+

Possible moves are: ["13", "12", "9"], 0 to exit. Your move? =>

</pre>

 

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.awt.BorderLayout

}

}

 

=={{header|Liberty BASIC}}==

{{trans|Commodore BASIC}}

{{works with|Just BASIC}}

' 15-PUZZLE GAME

' ********************************

isPuzzleComplete = pc

end function

 

=={{header|LiveCode}}==

#Please note that all this code can be performed in livecode with just few mouse clicks

#This is just a pure script exampe

end if

end checkDistance

Screenshot:

[https://s24.postimg.org/uc6fx7kph/Livecode15_Puzzle_Game.png]

 

=={{header|Lua}}==

math.randomseed( os.time() )

local puz = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0 }

-- [ entry point ] --

beginGame()

{{out}}

<pre>

Also the code is not the best, because we can move from 4 position to 5 (we can't do that with real puzzle)

 

Module Puzzle15 {

}

Puzzle15

 

=={{header|Mercury}}==

The ideal in Mercury is to have a declarative module that encodes the game logic, and then separate modules to implement a human player with text commands (here), or keyed commands, or some kind of AI player, and so on. fifteen.print/3 is a arguably a smudge on fifteen's interface:

:- interface.

:- use_module random, io.

move(I, right, !B) :-

not (I = 3 ; I = 7 ; I = 11 ; I = 15),

 

As used:

 

:- interface.

:- import_module io.

"

Seed = time(NULL);

 

=={{header|MUMPS}}==

 

=={{header|Nim}}==

 

type

 

draw board

{{out}}

<pre>┌──┬──┬──┬──┐

 

=={{header|OCaml}}==

struct

type t = int array

print_string " > ";

Puzzle.move p (read_line () |> int_of_string)

 

To move, input the number to slide into the blank. If you accidentally make an impossible move you can undo it by repeating the last input. A nice self-checked puzzle, the same as if you were physically moving the pieces around.

=={{header|Pascal}}==

This is Free Pascal(version >= 3.0.4) text mode implementation. To make a move, the user needs to enter the number of the selected tile.

program fifteen;

{$mode objfpc}

Run;

end.

 

=={{header|Perl}}==

On verbosity shows how the solvability is calculated. The program has some extra feature like font size and color scheme but also the possibility to set the intial board disposition.

This program was originally posted by me at [http://www.perlmonks.org/?node_id=1192660 perlmonks]

 

use strict;

 

 

 

===console version===

This short console program just poses solvable puzzles: it achieves this shuffling a solved board n times, where n defaults to 1000 but can be passed as first argument of the program in the command line. It was originally posted by me at [http://www.perlmonks.org/?node_id=1192865 perlmonks] but here a little modification was inserted to prevent wrong numbers to make the board messy.

use strict;

use warnings;

[$$e[0]-1,$$e[1]],[$$e[0]+1,$$e[1]],[$$e[0],$$e[1]-1],[$$e[0],$$e[1]+1]

}

 

=={{header|Phix}}==

Kept simple. Obviously, increase the 5 random moves for more of a challenge.

{{out}}

<pre>

solved!

</pre>

 

=={{header|PHP}}==

OOP and MVC design pattern has been used to facilitate any improvements, e.g. tiles with graphics instead of just numbers.

// Puzzle 15 Game - Rosseta Code - PHP 7 as the server-side script language.

 

else

echo "<span class='puzzle'></span>";

echo "<br>";

}

?></p>

</body>

 

=={{header|Powershell}}==

Board is always scrambled from a solved board so it's always solvable.

Written in ISE with ISESteroids. I'm sure the code could be improved on.

#15 Puzzle Game

$Script:Neighbours = @{

# Show Window

$result = Show-WPFWindow -Window $window

 

=={{header|Processing}}==

int number_of_grid_cells = 16; // Set the number of cells of the board here 9, 16, 25 etc

color piece_color = color(255, 175, 0);

}

}