15 puzzle game: Difference between revisions

{{trans|Python: Original, with output}}

 

position = 0

[Int = String] items

I g.game_over()

print(‘You WON’)

 

{{out}}

The same as in Python.

 

=={{header|68000 Assembly}}==

This is an entire Sega Genesis game, tested in the Fusion emulator. Thanks to Keith S. of Chibiakumas for the cartridge header, font routines, and printing logic. I programmed the actual game logic. This code can be copied and pasted into a text file and assembled as-is using vasmm68k_mot_win32.exe, no includes or incbins necessary (even the bitmap font is here too.)

 

;Ram Variables

Cursor_X equ $00FF0000 ;Ram for Cursor Xpos

Cursor_Y equ $00FF0000+1 ;Ram for Cursor Ypos

joypad1 equ $00FF0002

 

GameRam equ $00FF1000 ;Ram for where the pieces are

DC.B $80 ;23 DMA source address high (C=CMD) CCHHHHHH

VDPSettingsEnd:

 

{{out}}[https://ibb.co/4MZpL4W Screenshot of emulator]

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

DEFINE X0="13"

DEFINE Y0="6"

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/15_puzzle_game.png Screenshot from Atari 8-bit computer]

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;

}

 

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

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

 

 

textsize 13

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|Mathematica}} / {{header|Wolfram Language}}==

 

Move[x_] := (empty = Select[grid, #[[1]]==16 &][[1,2]];

CButton[{x_,loc_}] := If[x==16, Null, Button[x,Move @ loc]]

 

 

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

=== console only ===

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

{{out}}

<pre>

solved!

</pre>

=== GUI version ===

{{libheader|Phix/pGUI}}

{{libheader|Phix/online}}

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

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

-- demo\rosetta\15_puzzle_game.exw

<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

 

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

 

?></p>

</body>

 

=={{header|Picat}}==

import util.

 

Board[R0,C0] := S,

Board[R,C] := 0.

 

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

}

}

 

'''It can be played on line''' :<BR> [https://www.openprocessing.org/sketch/863055/ here.]

==={{header|Processing Python mode}}===

{{trans|Processing}}

num_grid_cells = 16

piece_color = color(255, 175, 0)

# Upper bright

line(self.x + 2, self.y + 1, self.x +

 

=={{header|PureBasic}}==

Numbers are displayed in Hexadecimal (ie 1 to F)

Default controls are u,d,l,r

#difficulty=10 ;higher is harder

#up="u"

Print("Won !")

CloseConsole()

<pre>

1234

{{works with|Python|3.X}}

'''unoptimized'''

''' Structural Game for 15 - Puzzle with different difficulty levels'''

from random import randint

print('You WON')

break

<pre>

Enter the difficulty : 0 1 2

 

===Python: using tkinter===

''' Python 3.6.5 code using Tkinter graphical user interface.'''

 

g = Game(root)

root.mainloop()

 

=={{header|QB64}}==

_TITLE "GUI Sliding Blocks Game "

RANDOMIZE TIMER

END IF

LOOP

 

=={{header|Quackery}}==

The inputs are w,s,a,d and they refer to the direction in which the empty place "moves". After every prompt you can input a string of characters and submit them by pressing enter. Any characters other than w,s,a,d will be ignored, and moves will be performed according to the correct commands. Commands that would "move" the empty space off the edge of the puzzle are also ignored. For example, on a solved puzzle "asgw" would move 15 to the right, ignore 's' and 'g' and move 11 down.

( moves: 0 - up, 1 - down, 2 - left, 3 - right )

 

 

15-puzzle

 

=={{header|R}}==

The inputs are w,a,s,d and they refer to the direction in which the adjacent piece moves into the empty space. For example, on a solved puzzle, "d" would move the 15 to the right.

puz15<-function(scramble.length=100){

m=matrix(c(1:15,0),byrow=T,ncol=4)

}

}

 

Sample output:

It uses the <code>2htdp/universe</code> package.

 

(require 2htdp/universe 2htdp/image racket/list racket/match)

 

(to-draw (fifteen->pict))

(stop-when solved-world? (fifteen->pict #t))

 

=={{header|Raku}}==

{{works with|Rakudo|2018.06}}

Most of this is interface code. Reused substantial portions from the [[2048#Raku|2048]] task. Use the arrow keys to slide tiles, press 'q' to quit or 'n' for a new puzzle. Requires a POSIX termios aware terminal. Ensures that the puzzle is solvable by shuffling the board with an even number of swaps, then checking for even taxicab parity for the empty space.

 

constant $saved = Term::termios.new(fd => 1).getattr;

last if $key eq 'q'; # (q)uit

new() if $key eq 'n';

Sample screen shot:

<pre>

 

=={{header|Rebol}}==

if not find [0x108 108x0 0x-108 -108x0] face/offset - e/offset [exit]

x: face/offset face/offset: e/offset e/offset: x] across

] x: random repeat i 15 [append x:[] i] repeat i 15 [

repend g ['t mold x/:i random white] if find [4 8 12] i [append g 'return]

 

=={{header|Red}}==

Red [Needs: 'view]

system/view/screens/1/pane/-1/visible?: false ;; suppress console window

view lay

 

 

=={{header|REXX}}==

 

Over half of the REXX program has to do with input validation and presentation of the puzzle (grid).

parse arg N seed . /*obtain optional arguments from the CL*/

if N=='' | N=="," then N=4 /*Not specified? Then use the default.*/

rm=holeRow-1; rp=holeRow+1; cm=holeCol-1; cp=holeCol+1 /*possible moves.*/

!=!.rm.holeCol !.rp.holeCol !.holeRow.cm !.holeRow.cp /* legal moves.*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

=={{header|Ring}}==

 

# Project : CalmoSoft Fifteen Puzzle Game

# Date : 2018/12/01

return

 

 

'''Output:'''

 

[https://youtu.be/IZqpYctv8Zs CalmoSoft Fifteen Puzzle Game in Ring - video]

 

=={{header|Ruby}}==

 

class Board

end

 

 

{{out}}

{{libheader|JRubyArt}}

Gui Version:-

SOLUTION = %w[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0].freeze

 

end

 

 

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

' ---- fill 15 squares with 1 to 15

dim sq(16)

Text-Align:Center;Font-Size:24pt;Font-Weight:Bold;Font-Family:Arial;

}"

Output:

[[File:KokengeGame15.jpg]]

=={{header|Rust}}==

{{libheader|rand}}

use std::collections::HashMap;

use std::fmt;

use rand::Rng;

#[derive(Copy, Clone, PartialEq, Debug)]

enum Cell {

Empty,

}

#[derive(Eq, PartialEq, Hash, Debug)]

enum Direction {

Right,

}

enum Action {

Move(Direction),

Quit,

}

type Board = [Cell; 16];

const EMPTY: Board = [Cell::Empty; 16];

struct P15 {

board: Board,

}

impl P15 {

fn new() -> Self {

*cell = Cell::Card(i);

}

let mut rng = rand::thread_rng();

board.shuffle(&mut rng);

if !Self::is_valid(board) {

// random swap

while j == i {

}

board.swap(i, j);

}

Self { board }

}

fn is_valid(mut board: Board) -> bool {

// TODO: optimize

let mut permutations = 0;

let pos = board.iter().position(|&cell| cell == Cell::Empty).unwrap();

if pos != 15 {

board.swap(pos, 15);

permutations += 1;

}

for i in 1..16 {

let pos = board

.iter()

.unwrap();

if pos + 1 != i {

board.swap(pos, i - 1);

}

}

permutations % 2 == 0

}

fn get_empty_position(&self) -> usize {

self.board.iter().position(|&c| c == Cell::Empty).unwrap()

}

fn get_moves(&self) -> HashMap<Direction, Cell> {

let mut moves = HashMap::new();

let i = self.get_empty_position();

if i > 3 {

moves.insert(Direction::Up, self.board[i - 4]);

moves

}

fn play(&mut self, direction: &Direction) {

let i = self.get_empty_position();

};

}

fn is_complete(&self) -> bool {

self.board.iter().enumerate().all(|(i, &cell)| match cell {

}

}

impl fmt::Display for P15 {

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

for (i, &cell) in self.board.iter().enumerate() {

match cell {

}

if i % 4 == 3 {

}

}

}

}

fn main() {

let mut p15 = P15::new();

for turns in 1.. {

Action::Move(direction) => {

p15.play(&direction);

}

Action::Quit => {

break;

}

}

if p15.is_complete() {

break;

}

}

}

use Action::*;

use Direction::*;

}

let mut action = String::new();

io::stdin().read_line(&mut action).expect("read error");

"Q" => Quit,

_ => {

}

}

 

=={{header|Scala}}==

 

import jline.console._

.foldLeft(Board.solveState) { case (state, mv) => state.move(mv) }

}

 

=={{header|Scheme}}==

 

(import (scheme base)

(scheme read)

 

(play-game)

 

{{out}}

=={{header|Scilab}}==

 

solution=[tiles(1:4);...

tiles(5:8);...

end

 

 

{{out}}

 

=={{header|Simula}}==

BEGIN

CLASS FIFTEENPUZZLE(NUMTILES, SIDE, WIDTH, SEED);

P.REQUEST;

P.PRINTBOARD;

{{out}}

<pre>INPUT RANDOM SEED:

{{works with|SML/NJ}}

{{works with|Moscow ML}}

(* Load required Modules for Moscow ML *)

load "Int";

 

val () = Console.start()

 

<b>Note:</b>

The window-title is used to show messages.

 

# http://wiki.tcl.tk/14403

 

 

# For some more versions, see: http://wiki.tcl.tk/15067 : Classic 15 Puzzle and http://wiki.tcl.tk/15085 : N-Puzzle

 

=={{header|VBA}}==

The last move is displayed on the input box, or an error message if an invalid move is attempted. When the puzzle is solved, the move count is displayed.

 

Public iSide As Integer

Public iSize As Integer

ShowGrid = s

End Function

 

Sample output:

 

=={{header|Visual Basic .NET}}==

Inherits System.Windows.Forms.Form

 

End Function

 

 

=={{header|Visual Prolog}}==

[https://youtu.be/rWy3AX5HjXM 15 Puzzle in Visual Prolog - video]

 

/* ------------------------------------------------------------------------------------------------------

 

% end of automatic code

end implement playDialog

 

=={{header|VBScript}}==

'----------------15 game-------------------------------------

'WARNING: this script uses ANSI escape codes to position items on console so

usr= move(d)

end function

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-ioutil}}

{{libheader|Wren-fmt}}

 

var Move = Enum.create("Move", ["up", "down", "right", "left"])

 

var p = Puzzle.new()

 

{{out}}

 

=={{header|x86-64 Assembly}}==

; How to play ?.. Just press one of the arrow keys then [enter] to valid

; ( press [Ctrl+C] to escape )

xchg ax,word[puzzle+4+rbx*4]

mov word[puzzle+4+rdx*4],ax

 

=={{header|XBasic}}==

{{trans|Liberty BASIC}}

{{works with|Windows XBasic}}

PROGRAM "fifteenpuzzlegame"

VERSION "0.0001"

 

END PROGRAM

 

=={{header|XPL0}}==

[Box:= [^ ,^F,^E,^D, \starting configuration

^C,^B,^A,^9, \slide digits into ascending order

other []; \ignore 0 scan code prefix etc.

];